} /* computed_value_Shrs */
/**
- * Return the value of a Rot.
+ * Return the value of a Rotl.
*/
-static tarval *computed_value_Rot(ir_node *n) {
- ir_node *a = get_Rot_left(n);
- ir_node *b = get_Rot_right(n);
+static tarval *computed_value_Rotl(ir_node *n) {
+ ir_node *a = get_Rotl_left(n);
+ ir_node *b = get_Rotl_right(n);
tarval *ta = value_of(a);
tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
- return tarval_rot (ta, tb);
+ return tarval_rotl(ta, tb);
}
return tarval_bad;
-} /* computed_value_Rot */
+} /* computed_value_Rotl */
/**
* Return the value of a Conv.
CASE(Shl);
CASE(Shr);
CASE(Shrs);
- CASE(Rot);
+ CASE(Rotl);
CASE(Carry);
CASE(Borrow);
CASE(Conv);
ir_node *left, *right;
ir_mode *mode = get_irn_mode(n);
- /* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
- if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
- return n;
-
n = equivalent_node_neutral_zero(n);
if (n != oldn)
return n;
+ /* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
+ if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
+ return n;
+
left = get_Add_left(n);
right = get_Add_right(n);
#define equivalent_node_Shl equivalent_node_left_zero
#define equivalent_node_Shr equivalent_node_left_zero
#define equivalent_node_Shrs equivalent_node_left_zero
-#define equivalent_node_Rot equivalent_node_left_zero
+#define equivalent_node_Rotl equivalent_node_left_zero
/**
* Optimize a - 0 and (a + x) - x (for modes with wrap-around).
ir_mode *n_mode = get_irn_mode(n);
ir_mode *a_mode = get_irn_mode(a);
+restart:
if (n_mode == a_mode) { /* No Conv necessary */
if (get_Conv_strict(n)) {
/* special case: the predecessor might be a also a Conv */
if (is_Conv(a)) {
if (! get_Conv_strict(a)) {
/* first one is not strict, kick it */
- set_Conv_op(n, get_Conv_op(a));
- return n;
+ a = get_Conv_op(a);
+ a_mode = get_irn_mode(a);
+ set_Conv_op(n, a);
+ goto restart;
}
/* else both are strict conv, second is superfluous */
- } else if(is_Proj(a)) {
+ } else if (is_Proj(a)) {
ir_node *pred = get_Proj_pred(a);
- if(is_Load(pred)) {
+ if (is_Load(pred)) {
/* loads always return with the exact precision of n_mode */
assert(get_Load_mode(pred) == n_mode);
return a;
ir_node *b = get_Conv_op(a);
ir_mode *b_mode = get_irn_mode(b);
+ if (get_Conv_strict(n) && get_Conv_strict(a)) {
+ /* both are strict conv */
+ if (smaller_mode(a_mode, n_mode)) {
+ /* both are strict, but the first is smaller, so
+ the second cannot remove more precision, remove the
+ strict bit */
+ set_Conv_strict(n, 0);
+ }
+ }
if (n_mode == b_mode) {
- if (n_mode == mode_b) {
- n = b; /* Convb(Conv*(xxxb(...))) == xxxb(...) */
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
- } else if (mode_is_int(n_mode)) {
- if (get_mode_size_bits(b_mode) <= get_mode_size_bits(a_mode)) {
- n = b; /* ConvS(ConvL(xxxS(...))) == xxxS(...) */
+ if (! get_Conv_strict(n) && ! get_Conv_strict(a)) {
+ if (n_mode == mode_b) {
+ n = b; /* Convb(Conv*(xxxb(...))) == xxxb(...) */
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
+ } else if (get_mode_arithmetic(n_mode) == get_mode_arithmetic(a_mode)) {
+ if (smaller_mode(b_mode, a_mode)) {
+ n = b; /* ConvS(ConvL(xxxS(...))) == xxxS(...) */
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
+ }
+ }
+ }
+ if (is_Conv(b)) {
+ if (smaller_mode(b_mode, a_mode)) {
+ if (get_Conv_strict(n))
+ set_Conv_strict(b, 1);
+ n = b; /* ConvA(ConvB(ConvA(...))) == ConvA(...) */
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_CONV);
}
}
for (i = 0; i < n_preds; ++i) {
first_val = get_Phi_pred(n, i);
if ( (first_val != n) /* not self pointer */
-#if 1
+#if 0
+ /* BEWARE: when the if is changed to 1, Phi's will ignore it's Bad
+ * predecessors. Then, Phi nodes in dead code might be removed, causing
+ * nodes pointing to themself (Add's for instance).
+ * This is really bad and causes endless recursions in several
+ * code pathes, so we do NOT optimize such a code.
+ * This is not that bad as it sounds, optimize_cf() removes bad control flow
+ * (and bad Phi predecessors), so live code is optimized later.
+ */
&& (! is_Bad(first_val))
#endif
) { /* value not dead */
ir_node *scnd_val = get_Phi_pred(n, i);
if ( (scnd_val != n)
&& (scnd_val != first_val)
-#if 1
+#if 0
+ /* see above */
&& (! is_Bad(scnd_val))
#endif
) {
CASE(Shl);
CASE(Shr);
CASE(Shrs);
- CASE(Rot);
+ CASE(Rotl);
CASE(Not);
CASE(Minus);
CASE(Mul);
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
break;
- case iro_Rot:
- if (get_Rot_right(left) == get_Rot_right(right)) {
- /* a ROT X CMP b ROT X ==> a CMP b */
- left = get_Rot_left(left);
- right = get_Rot_left(right);
+ case iro_Rotl:
+ if (get_Rotl_right(left) == get_Rotl_right(right)) {
+ /* a ROTL X CMP b ROTL X ==> a CMP b */
+ left = get_Rotl_left(left);
+ right = get_Rotl_left(right);
changed |= 1;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
} /* transform_node_Or_bf_store */
/**
- * Optimize an Or(shl(x, c), shr(x, bits - c)) into a Rot
+ * Optimize an Or(shl(x, c), shr(x, bits - c)) into a Rotl
*/
-static ir_node *transform_node_Or_Rot(ir_node *or) {
+static ir_node *transform_node_Or_Rotl(ir_node *or) {
ir_mode *mode = get_irn_mode(or);
ir_node *shl, *shr, *block;
ir_node *irn, *x, *c1, *c2, *v, *sub, *n;
/* yet, condition met */
block = get_irn_n(or, -1);
- n = new_r_Rot(current_ir_graph, block, x, c1, mode);
+ n = new_r_Rotl(current_ir_graph, block, x, c1, mode);
- DBG_OPT_ALGSIM1(or, shl, shr, n, FS_OPT_OR_SHFT_TO_ROT);
+ DBG_OPT_ALGSIM1(or, shl, shr, n, FS_OPT_OR_SHFT_TO_ROTL);
return n;
} else if (is_Sub(c1)) {
v = c2;
block = get_nodes_block(or);
/* a Rot right is not supported, so use a rot left */
- n = new_r_Rot(current_ir_graph, block, x, sub, mode);
+ n = new_r_Rotl(current_ir_graph, block, x, sub, mode);
- DBG_OPT_ALGSIM0(or, n, FS_OPT_OR_SHFT_TO_ROT);
+ DBG_OPT_ALGSIM0(or, n, FS_OPT_OR_SHFT_TO_ROTL);
return n;
} else if (is_Sub(c2)) {
v = c1;
block = get_irn_n(or, -1);
/* a Rot Left */
- n = new_r_Rot(current_ir_graph, block, x, v, mode);
+ n = new_r_Rotl(current_ir_graph, block, x, v, mode);
- DBG_OPT_ALGSIM0(or, n, FS_OPT_OR_SHFT_TO_ROT);
+ DBG_OPT_ALGSIM0(or, n, FS_OPT_OR_SHFT_TO_ROTL);
return n;
}
return or;
-} /* transform_node_Or_Rot */
+} /* transform_node_Or_Rotl */
/**
* Transform an Or.
HANDLE_BINOP_PHI(tarval_or, a, b, c, mode);
n = transform_node_Or_bf_store(n);
- n = transform_node_Or_Rot(n);
+ n = transform_node_Or_Rotl(n);
if (n != oldn)
return n;
static ir_node *transform_node(ir_node *n);
/**
- * Optimize (a >> c1) >> c2), works for Shr, Shrs, Shl, Rot.
+ * Optimize (a >> c1) >> c2), works for Shr, Shrs, Shl, Rotl.
*
* Should be moved to reassociation?
*/
} /* transform_node_Shl */
/**
- * Transform a Rot.
+ * Transform a Rotl.
*/
-static ir_node *transform_node_Rot(ir_node *n) {
+static ir_node *transform_node_Rotl(ir_node *n) {
ir_node *c, *oldn = n;
- ir_node *a = get_Rot_left(n);
- ir_node *b = get_Rot_right(n);
+ ir_node *a = get_Rotl_left(n);
+ ir_node *b = get_Rotl_right(n);
ir_mode *mode = get_irn_mode(n);
- HANDLE_BINOP_PHI(tarval_rot, a, b, c, mode);
+ HANDLE_BINOP_PHI(tarval_rotl, a, b, c, mode);
return transform_node_shift(n);
-} /* transform_node_Rot */
+} /* transform_node_Rotl */
/**
* Transform a Conv.
CASE(Shr);
CASE(Shrs);
CASE(Shl);
- CASE(Rot);
+ CASE(Rotl);
CASE(Conv);
CASE(End);
CASE(Mux);
/*
* Calculate a hash value of a node.
*/
-unsigned ir_node_hash(ir_node *node) {
+unsigned ir_node_hash(const ir_node *node) {
unsigned h;
int i, irn_arity;
}
} /* update_value_table */
-/**
- * Return the canonical node computing the same value as n.
- *
- * @param value_table The value table
- * @param n The node to lookup
- *
- * Looks up the node in a hash table.
- *
- * For Const nodes this is performed in the constructor, too. Const
- * nodes are extremely time critical because of their frequent use in
- * constant string arrays.
- */
-static INLINE ir_node *identify(pset *value_table, ir_node *n) {
- ir_node *o = NULL;
-
- if (!value_table) return n;
-
- normalize_node(n);
-
- o = pset_find(value_table, n, ir_node_hash(n));
- if (o == NULL)
- return n;
-
- update_known_irn(o, n);
- DBG_OPT_CSE(n, o);
-
- return o;
-} /* identify */
-
-/**
- * During construction we set the op_pin_state_pinned flag in the graph right when the
- * optimization is performed. The flag turning on procedure global cse could
- * be changed between two allocations. This way we are safe.
- *
- * @param value_table The value table
- * @param n The node to lookup
- */
-static INLINE ir_node *identify_cons(pset *value_table, ir_node *n) {
- ir_node *old = n;
-
- n = identify(value_table, n);
- if (n != old && get_irn_MacroBlock(old) != get_irn_MacroBlock(n))
- set_irg_pinned(current_ir_graph, op_pin_state_floats);
- return n;
-} /* identify_cons */
-
/*
* Return the canonical node computing the same value as n.
* Looks up the node in a hash table, enters it in the table
return o;
} /* identify_remember */
+/**
+ * During construction we set the op_pin_state_pinned flag in the graph right when the
+ * optimization is performed. The flag turning on procedure global cse could
+ * be changed between two allocations. This way we are safe.
+ *
+ * @param value_table The value table
+ * @param n The node to lookup
+ */
+static INLINE ir_node *identify_cons(pset *value_table, ir_node *n) {
+ ir_node *old = n;
+
+ n = identify_remember(value_table, n);
+ if (n != old && get_irn_MacroBlock(old) != get_irn_MacroBlock(n))
+ set_irg_pinned(current_ir_graph, op_pin_state_floats);
+ return n;
+} /* identify_cons */
+
/* Add a node to the identities value table. */
void add_identities(pset *value_table, ir_node *node) {
if (get_opt_cse() && is_no_Block(node))
}
/* remove unnecessary nodes */
- if (get_opt_constant_folding() ||
+ if (get_opt_algebraic_simplification() ||
(iro == iro_Phi) || /* always optimize these nodes. */
(iro == iro_Id) ||
(iro == iro_Proj) ||
/* Some more constant expression evaluation that does not allow to
free the node. */
iro = get_irn_opcode(n);
- if (get_opt_constant_folding() ||
+ if (get_opt_algebraic_simplification() ||
(iro == iro_Cond) ||
(iro == iro_Proj)) /* Flags tested local. */
n = transform_node(n);
/* Remove nodes with dead (Bad) input.
Run always for transformation induced Bads. */
- n = gigo (n);
+ n = gigo(n);
/* Now we have a legal, useful node. Enter it in hash table for CSE */
if (get_opt_cse() && (get_irn_opcode(n) != iro_Block)) {
now all nodes are op_pin_state_pinned to blocks, i.e., the cse only finds common
subexpressions within a block. */
if (get_opt_cse()) {
- n = identify(current_ir_graph->value_table, n);
+ n = identify_remember(current_ir_graph->value_table, n);
}
/* Some more constant expression evaluation. */