size/aligment of types is now unsigned and in bytes, this fixes fehler095.c (array...

[libfirm] / ir / ir / iropt.c

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index 7a6321f..cdab35e 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -2815,6 +2815,7 @@ static ir_node *transform_node_Quot(ir_node *n) {
 /**
  * Optimize Abs(x) into  x if x is Confirmed >= 0
  * Optimize Abs(x) into -x if x is Confirmed <= 0
+ * Optimize Abs(-x) int Abs(x)
  */
 static ir_node *transform_node_Abs(ir_node *n) {
        ir_node *c, *oldn = n;
@@ -2835,7 +2836,7 @@ static ir_node *transform_node_Abs(ir_node *n) {
                 * not run it in the equivalent_node() context.
                 */
                n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph,
-                               get_irn_n(n, -1), a, mode);
+                               get_nodes_block(n), a, mode);
 
                DBG_OPT_CONFIRM(oldn, n);
                return n;
@@ -2846,8 +2847,17 @@ static ir_node *transform_node_Abs(ir_node *n) {
                DBG_OPT_CONFIRM(oldn, n);
                return n;
        default:
+               break;
+       }
+       if (is_Minus(a)) {
+               /* Abs(-x) = Abs(x) */
+               mode = get_irn_mode(n);
+               n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph,
+                               get_nodes_block(n), get_Minus_op(a), mode);
+               DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ABS_MINUS_X);
                return n;
        }
+       return n;
 }  /* transform_node_Abs */
 
 /**
@@ -2937,7 +2947,8 @@ static ir_node *transform_bitwise_distributive(ir_node *n,
                ir_node *b_left  = get_binop_left(b);
                ir_node *b_right = get_binop_right(b);
                ir_node *c       = NULL;
-               ir_node *op1, *op2;
+               ir_node *op1     = NULL;
+               ir_node *op2     = NULL;
 
                if (is_op_commutative(op)) {
                        if (a_left == b_left) {
@@ -3797,9 +3808,6 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
                }
        }
 
-       if (!get_opt_reassociation())
-               return proj;
-
        /*
         * First step: normalize the compare op
         * by placing the constant on the right side
@@ -5229,19 +5237,17 @@ void del_identities(pset *value_table) {
  * @param n   The node to normalize
  */
 static void normalize_node(ir_node *n) {
-       if (get_opt_reassociation()) {
-               if (is_op_commutative(get_irn_op(n))) {
-                       ir_node *l = get_binop_left(n);
-                       ir_node *r = get_binop_right(n);
-
-                       /* For commutative operators perform  a OP b == b OP a but keep
-                        * constants on the RIGHT side. This helps greatly in some
-                        * optimizations.  Moreover we use the idx number to make the form
-                        * deterministic. */
-                       if (!operands_are_normalized(l, r)) {
-                               set_binop_left(n, r);
-                               set_binop_right(n, l);
-                       }
+       if (is_op_commutative(get_irn_op(n))) {
+               ir_node *l = get_binop_left(n);
+               ir_node *r = get_binop_right(n);
+
+               /* For commutative operators perform  a OP b == b OP a but keep
+                * constants on the RIGHT side. This helps greatly in some
+                * optimizations.  Moreover we use the idx number to make the form
+                * deterministic. */
+               if (!operands_are_normalized(l, r)) {
+                       set_binop_left(n, r);
+                       set_binop_right(n, l);
                }
        }
 }  /* normalize_node */