Remove be_abi_get_start_barrier(). Nobody calls it anymore.

[libfirm] / ir / opt / reassoc.c

diff --git a/ir/opt/reassoc.c b/ir/opt/reassoc.c
index 7ac6490..4606878 100644 (file)
--- a/ir/opt/reassoc.c
+++ b/ir/opt/reassoc.c
@@ -338,7 +338,6 @@ static int reassoc_Mul(ir_node **node)
                        in[0] = new_rd_Mul(NULL, current_ir_graph, block, c, t1, mode);
                        in[1] = new_rd_Mul(NULL, current_ir_graph, block, c, t2, mode);
 
-                       mode  = get_mode_from_ops(in[0], in[1]);
                        irn   = optimize_node(new_ir_node(NULL, current_ir_graph, block, op, mode, 2, in));
 
                        /* In some cases it might happen that the new irn is equal the old one, for
@@ -363,6 +362,40 @@ static int reassoc_Mul(ir_node **node)
        return 0;
 }  /* reassoc_Mul */
 
+/**
+ * Reassociate Shl. We transform Shl(x, const) into Mul's if possible.
+ */
+static int reassoc_Shl(ir_node **node) {
+       ir_node *n = *node;
+       ir_node *c = get_Shl_right(n);
+       ir_node *x, *blk, *irn;
+       ir_mode *mode;
+       tarval *tv;
+
+       if (! is_Const(c))
+               return 0;
+
+       x = get_Shl_left(n);
+       mode = get_irn_mode(x);
+
+       tv = get_mode_one(mode);
+       tv = tarval_shl(tv, get_Const_tarval(c));
+
+       if (tv == tarval_bad)
+               return 0;
+
+       blk = get_nodes_block(n);
+       c   = new_r_Const(current_ir_graph, blk, mode, tv);
+       irn = new_rd_Mul(get_irn_dbg_info(n), current_ir_graph, blk, x, c, mode);
+
+       if (irn != n) {
+               exchange(n, irn);
+               *node = irn;
+               return 1;
+       }
+       return 0;
+}  /* reassoc_Shl */
+
 /**
  * The walker for the reassociation.
  */
@@ -446,7 +479,7 @@ static void do_reassociation(walker_t *wenv)
 
 /**
  * Returns the earliest were a,b are available.
- * Note that we know that we know that a, b both dominate
+ * Note that we know that a, b both dominate
  * the block of the previous operation, so one must dominate the other.
  *
  * If the earliest block is the start block, return curr_blk instead
@@ -504,38 +537,51 @@ static int reverse_rule_distributive(ir_node **node) {
        ir_node *right = get_binop_right(n);
        ir_node *x, *blk, *curr_blk;
        ir_node *a, *b, *irn;
+       ir_op *op;
        ir_mode *mode;
        dbg_info *dbg;
 
-       if (! is_Mul(left) || !is_Mul(right))
+       op = get_irn_op(left);
+       if (op != get_irn_op(right))
                return 0;
 
-       x = get_Mul_left(left);
-
-       if (x == get_Mul_left(right)) {
-               /* (x * a) +/- (x * b) */
-               a = get_Mul_right(left);
-               b = get_Mul_right(right);
-               goto transform;
-       } else if (x == get_Mul_right(right)) {
-               /* (x * a) +/- (b * x) */
-               a = get_Mul_right(left);
-               b = get_Mul_left(right);
-               goto transform;
-       }
+       if (op == op_Shl) {
+               x = get_Shl_right(left);
+
+               if (x == get_Shl_right(right)) {
+                       /* (a << x) +/- (b << x) */
+                       a = get_Shl_left(left);
+                       b = get_Shl_left(right);
+                       goto transform;
+               }
+       } else if (op == op_Mul) {
+               x = get_Mul_left(left);
+
+               if (x == get_Mul_left(right)) {
+                       /* (x * a) +/- (x * b) */
+                       a = get_Mul_right(left);
+                       b = get_Mul_right(right);
+                       goto transform;
+               } else if (x == get_Mul_right(right)) {
+                       /* (x * a) +/- (b * x) */
+                       a = get_Mul_right(left);
+                       b = get_Mul_left(right);
+                       goto transform;
+               }
 
-       x = get_Mul_right(left);
-
-       if (x == get_Mul_right(right)) {
-               /* (a * x) +/- (b * x) */
-               a = get_Mul_left(left);
-               b = get_Mul_left(right);
-               goto transform;
-       } else if (x == get_Mul_left(right)) {
-               /* (a * x) +/- (x * b) */
-               a = get_Mul_left(left);
-               b = get_Mul_right(right);
-               goto transform;
+               x = get_Mul_right(left);
+
+               if (x == get_Mul_right(right)) {
+                       /* (a * x) +/- (b * x) */
+                       a = get_Mul_left(left);
+                       b = get_Mul_left(right);
+                       goto transform;
+               } else if (x == get_Mul_left(right)) {
+                       /* (a * x) +/- (x * b) */
+                       a = get_Mul_left(left);
+                       b = get_Mul_right(right);
+                       goto transform;
+               }
        }
        return 0;
 
@@ -553,7 +599,11 @@ transform:
                irn = new_rd_Sub(dbg, current_ir_graph, blk, a, b, mode);
 
        blk  = earliest_block(irn, x, curr_blk);
-       irn = new_rd_Mul(dbg, current_ir_graph, blk, irn, x, mode);
+
+       if (op == op_Mul)
+               irn = new_rd_Mul(dbg, current_ir_graph, blk, irn, x, mode);
+       else
+               irn = new_rd_Shl(dbg, current_ir_graph, blk, irn, x, mode);
 
        exchange(n, irn);
        *node = irn;
@@ -567,7 +617,7 @@ static int move_consts_up(ir_node **node) {
        ir_node *n = *node;
        ir_op *op;
        ir_node *l, *r, *a, *b, *c, *blk, *irn, *in[2];
-       ir_mode *mode;
+       ir_mode *mode, *ma, *mb;
        dbg_info *dbg;
 
        l = get_binop_left(n);
@@ -617,7 +667,18 @@ static int move_consts_up(ir_node **node) {
        return 0;
 
 transform:
-       /* check if a+b can be calculted in the same block is the old instruction */
+       /* In some cases a and b might be both of different integer mode, and c a SymConst.
+        * in that case we could either
+        * 1.) cast into unsigned mode
+        * 2.) ignore
+        * we implement the second here
+        */
+       ma = get_irn_mode(a);
+       mb = get_irn_mode(b);
+       if (ma != mb && mode_is_int(ma) && mode_is_int(mb))
+               return 0;
+
+       /* check if a+b can be calculated in the same block is the old instruction */
        if (! block_dominates(get_nodes_block(a), blk))
                return 0;
        if (! block_dominates(get_nodes_block(b), blk))
@@ -626,7 +687,7 @@ transform:
        in[0] = a;
        in[1] = b;
 
-       mode = get_mode_from_ops(in[0], in[1]);
+       mode = get_mode_from_ops(a, b);
        in[0] = optimize_node(new_ir_node(dbg, current_ir_graph, blk, op, mode, 2, in));
 
        if (op == op_Add || op == op_Sub) {
@@ -728,6 +789,7 @@ ir_op_ops *firm_set_default_reassoc(ir_opcode code, ir_op_ops *ops)
        CASE(And);
        CASE(Or);
        CASE(Eor);
+       CASE(Shl);
        default:
                /* leave NULL */;
        }