cleanup space generation logic and make it more robust for union constructs

[libfirm] / ir / ir / iropt.c

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index a3bbb50..ff4a610 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -637,8 +637,16 @@ static tarval *computed_value_Psi(ir_node *n) {
  * if it has the form Confirm(x, '=', Const).
  */
 static tarval *computed_value_Confirm(ir_node *n) {
-       return get_Confirm_cmp(n) == pn_Cmp_Eq ?
-               value_of(get_Confirm_bound(n)) : tarval_bad;
+       /*
+        * Beware: we might produce Phi(Confirm(x == true), Confirm(x == false)).
+        * Do NOT optimize them away (CondEval wants them), so wait until
+        * remove_confirm is activated.
+        */
+       if (get_opt_remove_confirm()) {
+               return get_Confirm_cmp(n) == pn_Cmp_Eq ?
+                       value_of(get_Confirm_bound(n)) : tarval_bad;
+       }
+       return tarval_bad;
 }  /* computed_value_Confirm */
 
 /**
@@ -1592,19 +1600,9 @@ static ir_node *equivalent_node_Confirm(ir_node *n) {
                 */
                n = pred;
        }
-       if (pnc == pn_Cmp_Eq) {
-               ir_node *bound = get_Confirm_bound(n);
-
-               /*
-                * Optimize a rare case:
-                * Confirm(x, '=', Constlike) ==> Constlike
-                */
-               if (is_irn_constlike(bound)) {
-                       DBG_OPT_CONFIRM(n, bound);
-                       return bound;
-               }
-       }
-       return get_opt_remove_confirm() ? get_Confirm_value(n) : n;
+       if (get_opt_remove_confirm())
+               return get_Confirm_value(n);
+       return n;
 }
 
 /**
@@ -1992,6 +1990,7 @@ static ir_node *transform_node_AddSub(ir_node *n) {
                        }
                }
        }
+
        return n;
 }  /* transform_node_AddSub */
 
@@ -2044,6 +2043,17 @@ static ir_node *transform_node_Add(ir_node *n) {
        b = get_Add_right(n);
 
        mode = get_irn_mode(n);
+
+       if (mode_is_reference(mode)) {
+               ir_mode *lmode = get_irn_mode(a);
+
+               if (is_Const(b) && is_Const_null(b) && mode_is_int(lmode)) {
+                       /* an Add(a, NULL) is a hidden Conv */
+                       dbg_info *dbg = get_irn_dbg_info(n);
+                       return new_rd_Conv(dbg, current_ir_graph, get_nodes_block(n), a, mode);
+               }
+       }
+
        HANDLE_BINOP_PHI(tarval_add, a, b, c, mode);
 
        /* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
@@ -2053,7 +2063,7 @@ static ir_node *transform_node_Add(ir_node *n) {
        if (mode_is_num(mode)) {
                /* the following code leads to endless recursion when Mul are replaced by a simple instruction chain */
                if (!is_arch_dep_running() && a == b && mode_is_int(mode)) {
-                       ir_node *block = get_irn_n(n, -1);
+                       ir_node *block = get_nodes_block(n);
 
                        n = new_rd_Mul(
                                get_irn_dbg_info(n),
@@ -2158,6 +2168,16 @@ static ir_node *transform_node_Sub(ir_node *n) {
 
        mode = get_irn_mode(n);
 
+       if (mode_is_int(mode)) {
+               ir_mode *lmode = get_irn_mode(a);
+
+               if (is_Const(b) && is_Const_null(b) && mode_is_reference(lmode)) {
+                       /* a Sub(a, NULL) is a hidden Conv */
+                       dbg_info *dbg = get_irn_dbg_info(n);
+                       return new_rd_Conv(dbg, current_ir_graph, get_nodes_block(n), a, mode);
+               }
+       }
+
 restart:
        HANDLE_BINOP_PHI(tarval_sub, a, b, c, mode);