/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-** All rights reserved.
-**
-** Authors: Christian Schaefer, Goetz Lindenmaier
-**
-** iropt --- optimizations intertwined with IR construction.
+* All rights reserved.
+*
+* Authors: Christian Schaefer, Goetz Lindenmaier
+*
+* iropt --- optimizations intertwined with IR construction.
*/
/* $Id$ */
case iro_SymConst:
if ((get_SymConst_kind(n) == size) &&
(get_type_state(get_SymConst_type(n))) == layout_fixed)
- res = tarval_from_long (mode_i, get_type_size(get_SymConst_type(n)));
+ res = tarval_from_long (mode_Is, get_type_size(get_SymConst_type(n)));
break;
case iro_Add:
if (ta && tb && (get_irn_mode(a) == get_irn_mode(b))
- && (get_irn_mode(a) != mode_p)) {
+ && (get_irn_mode(a) != mode_P)) {
res = tarval_add (ta, tb);
}
break;
case iro_Sub:
if (ta && tb && (get_irn_mode(a) == get_irn_mode(b))
- && (get_irn_mode(a) != mode_p)) {
+ && (get_irn_mode(a) != mode_P)) {
res = tarval_sub (ta, tb);
} else if (a == b) {
res = tarval_mode_null [get_irn_modecode (n)];
ir_node *aba = skip_nop(skip_Proj(ab));
if ( ( (/* aa is ProjP and aaa is Alloc */
(get_irn_op(aa) == op_Proj)
- && (get_irn_mode(aa) == mode_p)
+ && (get_irn_mode(aa) == mode_P)
&& (get_irn_op(aaa) == op_Alloc))
&& ( (/* ab is constant void */
(get_irn_op(ab) == op_Const)
- && (get_irn_mode(ab) == mode_p)
- && (get_Const_tarval(ab) == tarval_p_void))
+ && (get_irn_mode(ab) == mode_P)
+ && (get_Const_tarval(ab) == tarval_P_void))
|| (/* ab is other Alloc */
(get_irn_op(ab) == op_Proj)
- && (get_irn_mode(ab) == mode_p)
+ && (get_irn_mode(ab) == mode_P)
&& (get_irn_op(aba) == op_Alloc)
&& (aaa != aba))))
|| (/* aa is void and aba is Alloc */
(get_irn_op(aa) == op_Const)
- && (get_irn_mode(aa) == mode_p)
- && (get_Const_tarval(aa) == tarval_p_void)
+ && (get_irn_mode(aa) == mode_P)
+ && (get_Const_tarval(aa) == tarval_P_void)
&& (get_irn_op(ab) == op_Proj)
- && (get_irn_mode(ab) == mode_p)
+ && (get_irn_mode(ab) == mode_P)
&& (get_irn_op(aba) == op_Alloc)))
/* 3.: */
res = tarval_from_long (mode_b, get_Proj_proj(n) & irpn_Ne);
} /* compute node */
-
+#if 0
/* returns 1 if the a and b are pointers to different locations. */
-bool
+static bool
different_identity (ir_node *a, ir_node *b)
{
- assert (get_irn_mode (a) == mode_p
- && get_irn_mode (b) == mode_p);
+ assert (get_irn_mode (a) == mode_P
+ && get_irn_mode (b) == mode_P);
if (get_irn_op (a) == op_Proj && get_irn_op(b) == op_Proj) {
ir_node *a1 = get_Proj_pred (a);
}
return 0;
}
-
+#endif
/* equivalent_node returns a node equivalent to N. It skips all nodes that
perform no actual computation, as, e.g., the Id nodes. It does not create
Remaining Phi nodes are just Ids. */
if ((get_Block_n_cfgpreds(n) == 1) &&
(get_irn_op(get_Block_cfgpred(n, 0)) == op_Jmp) &&
- (get_opt_control_flow())) {
+ (get_opt_control_flow_straightening())) {
n = get_nodes_Block(get_Block_cfgpred(n, 0)); DBG_OPT_STG;
} else if ((get_Block_n_cfgpreds(n) == 2) &&
- (get_opt_control_flow())) {
+ (get_opt_control_flow_weak_simplification())) {
/* Test whether Cond jumps twice to this block
@@@ we could do this also with two loops finding two preds from several ones. */
a = get_Block_cfgpred(n, 0);
case iro_Minus: /* --x == x */ /* ??? Is this possible or can --x raise an
out of bounds exception if min =! max? */
if (get_irn_op(get_unop_op(n)) == get_irn_op(n)) {
- n = get_unop_op(get_unop_op(n)); DBG_OPT_ALGSIM2
+ n = get_unop_op(get_unop_op(n)); DBG_OPT_ALGSIM2;
}
break;
case iro_Mul:
/* Mul is commutative and has again an other neutral element. */
if (tarval_classify (computed_value (a)) == 1) {
- n = b; DBG_OPT_ALGSIM1
+ n = b; DBG_OPT_ALGSIM1;
} else if (tarval_classify (computed_value (b)) == 1) {
- n = a; DBG_OPT_ALGSIM1
+ n = a; DBG_OPT_ALGSIM1;
}
break;
case iro_Div:
ir_node *first_val = NULL; /* to shutup gcc */
ir_node *scnd_val = NULL; /* to shutup gcc */
+ if (!get_opt_normalize()) return;
+
n_preds = get_Phi_n_preds(n);
block = get_nodes_Block(n);
+ /* @@@ fliegt 'raus, sollte aber doch immer wahr sein!!!
+ assert(get_irn_arity(block) == n_preds && "phi in wrong block!"); */
if ((is_Bad(block)) || /* Control dead */
(block == current_ir_graph->start_block)) /* There should be no Phi nodes */
return new_Bad(); /* in the Start Block. */
/* We might generate an endless loop, so keep it alive. */
add_End_keepalive(get_irg_end(current_ir_graph), get_nodes_Block(n));
} else if (ta &&
- (get_irn_mode(a) == mode_I) &&
+ (get_irn_mode(a) == mode_Iu) &&
(get_Cond_kind(n) == dense) &&
(get_opt_unreachable_code())) {
/* I don't want to allow Tuples smaller than the biggest Proj.
else
set_Proj_proj(n, 0);
} else if ((get_irn_op(a) == op_Cond)
- && (get_irn_mode(get_Cond_selector(a)) == mode_I)
+ && (get_irn_mode(get_Cond_selector(a)) == mode_Iu)
&& value_of(a)
&& (get_Cond_kind(a) == dense)
&& (get_opt_unreachable_code())) {
/* The Cond is a Switch on a Constant */
- if (get_Proj_proj(n) == tv_val_CHIL(value_of(a))) {
+ if (get_Proj_proj(n) == tv_val_uInt(value_of(a))) {
/* The always taken branch, reuse the existing Jmp. */
if (!get_irn_link(a)) /* well, if it exists ;-> */
set_irn_link(a, new_r_Jmp(current_ir_graph, get_nodes_Block(n)));
It can only be called if it is guaranteed that no other nodes
reference this one, i.e., right after construction of a node. */
ir_node *
-optimize (ir_node *n)
+optimize_node (ir_node *n)
{
tarval *tv;
ir_node *old_n = n;
projects / libfirm / blobdiff