Add get_opt_overflow_unsafe_transform() option.

Currently this option allows x-c -> x + (-c) for unsigned.
If this option is enabled, we cannot do liner function test replacement ...

So, enable it AFTER OSR has run...

[r17804]

diff --git a/ir/ir/irflag.c b/ir/ir/irflag.c
index 6d4a972..7123f5e 100644 (file)
--- a/ir/ir/irflag.c
+++ b/ir/ir/irflag.c
@@ -20,7 +20,7 @@
 /**
  * @file
  * @brief   Flags to control optimizations.
- * @author  Christian Schaefer, Goetz Lindenmaier
+ * @author  Michael Beck, Sebastian Hack
  * @version $Id$
  */
 #ifdef HAVE_CONFIG_H
@@ -99,53 +99,49 @@ void set_opt_##name##_verbose(int flag) { \
 
 /* for compatibility reasons */
 void set_optimize(int value) {
-  if (value) libFIRM_opt |= irf_optimize;
-  else       libFIRM_opt &= ~irf_optimize;
+       if (value) libFIRM_opt |= irf_optimize;
+       else       libFIRM_opt &= ~irf_optimize;
 }
 
 int (get_optimize)(void) {
-  return get_opt_optimize();
+       return get_opt_optimize();
 }
 
-void set_opt_control_flow(int value)
-{
-  set_opt_control_flow_straightening(value);
-  set_opt_control_flow_weak_simplification(value);
-  set_opt_control_flow_strong_simplification(value);
+void set_opt_control_flow(int value) {
+       set_opt_control_flow_straightening(value);
+       set_opt_control_flow_weak_simplification(value);
+       set_opt_control_flow_strong_simplification(value);
 }
 
 void set_firm_verbosity (int value) {
-  firm_verbosity_level = value;
+       firm_verbosity_level = value;
 }
 
-int  (get_firm_verbosity) (void) {
-  return _get_firm_verbosity();
+int (get_firm_verbosity) (void) {
+       return _get_firm_verbosity();
 }
 
 /* Save the current optimization state. */
-void save_optimization_state(optimization_state_t *state)
-{
-  *state = libFIRM_opt;
+void save_optimization_state(optimization_state_t *state) {
+       *state = libFIRM_opt;
 }
 
 /* Restore the current optimization state. */
-void restore_optimization_state(const optimization_state_t *state)
-{
-  libFIRM_opt = *state;
+void restore_optimization_state(const optimization_state_t *state) {
+       libFIRM_opt = *state;
 }
 
 /* Switches ALL optimizations off */
-void all_optimizations_off(void)
-{
-  libFIRM_opt = 0;
+void all_optimizations_off(void) {
+       libFIRM_opt = 0;
 }
 
 #ifdef _DEBUG
 /* only for debugging */
 void firm_show_flags(FILE *f) {
-  if (! f)
-    f = stdout;
-  printf("Firm optimization state:\n");
+       if (! f)
+               f = stdout;
+       printf("Firm optimization state:\n");
 #define E_FLAG(name, value, def) printf(" %-20s = %s\n", #name, get_opt_##name() ? "ON" : "OFF");
 #define I_FLAG(name, value, def) printf(" %-20s = %s\n", #name, get_opt_##name() ? "ON" : "OFF");
 #define R_FLAG(name, value)      printf(" %-20s = %s\n", #name, is_##name##_running() ? "is running" : "not running");
@@ -153,7 +149,7 @@ void firm_show_flags(FILE *f) {
 #undef I_FLAG
 #undef E_FLAG
 #undef R_FLAG
-  printf("\n");
+       printf("\n");
 }
 #endif
 
@@ -176,5 +172,5 @@ void firm_init_flags(void) {
 firm_verification_t opt_do_node_verification = FIRM_VERIFICATION_ON;
 
 void do_node_verification(firm_verification_t mode) {
-  opt_do_node_verification = mode;
+       opt_do_node_verification = mode;
 }

diff --git a/ir/ir/irflag_t.def b/ir/ir/irflag_t.def
index 7413984..38d0ead 100644 (file)
--- a/ir/ir/irflag_t.def
+++ b/ir/ir/irflag_t.def
@@ -20,7 +20,7 @@
 /**
  * @file
  * @brief     Definitions for optimisation flags
- * @author    Michael Beck
+ * @author    Michael Beck, Sebastian Hack
  * @version   $Id$
  */
 
@@ -58,6 +58,9 @@ I_FLAG(control_flow_weak_simplification   , 6, ON)
 /** */
 I_FLAG(control_flow_strong_simplification , 7, ON)
 
+/** If set, overflow unsafe transformations are allowed. */
+I_FLAG(overflow_unsafe_transform          , 8, OFF)
+
 /** Remove dynamic method dispatch. */
 E_FLAG(dyn_meth_dispatch                  , 11, ON)
 

diff --git a/ir/ir/irflag_t.h b/ir/ir/irflag_t.h
index f497a3a..478024f 100644 (file)
--- a/ir/ir/irflag_t.h
+++ b/ir/ir/irflag_t.h
@@ -20,7 +20,7 @@
 /**
  * @file
  * @brief    Flags to control optimizations, inline implementation.
- * @author   Michael Beck
+ * @author   Michael Beck, Sebastian Hack
  * @version  $Id$
  */
 #ifndef FIRM_IR_IRFLAG_T_H
@@ -102,17 +102,17 @@ static INLINE void set_##name##_running(int flag) {\
 #undef E_FLAG
 #undef R_FLAG
 
-static INLINE int _get_firm_verbosity (void) {
+static INLINE int _get_firm_verbosity(void) {
        return firm_verbosity_level;
 }
 
-static INLINE int _get_optimize (void) {
-  return get_opt_optimize();
+static INLINE int _get_optimize(void) {
+       return get_opt_optimize();
 }
 
 static INLINE firm_verification_t
 get_node_verification_mode(void) {
-  return opt_do_node_verification;
+       return opt_do_node_verification;
 }
 
 #define get_optimize()                           _get_optimize()

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index 53c4d9b..c2458ee 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -1257,7 +1257,7 @@ static ir_node *equivalent_node_Phi(ir_node *n) {
        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
                    && (! is_Bad(first_val))
 #endif
                   ) {        /* value not dead */
@@ -1276,7 +1276,7 @@ static ir_node *equivalent_node_Phi(ir_node *n) {
                ir_node *scnd_val = get_Phi_pred(n, i);
                if (   (scnd_val != n)
                    && (scnd_val != first_val)
-#if 1
+#if 0
                    && (! is_Bad(scnd_val))
 #endif
                        ) {
@@ -2098,17 +2098,27 @@ restart:
        if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
                return n;
 
-       if (is_Const(b) && get_irn_mode(b) != mode_P) {
-               /* a - C -> a + (-C) */
-               ir_node *cnst = const_negate(b);
-               if (cnst != NULL) {
-                       ir_node  *block = get_nodes_block(n);
-                       dbg_info *dbgi  = get_irn_dbg_info(n);
-                       ir_graph *irg   = get_irn_irg(n);
+       if (is_Const(b)) {
+               ir_mode *mode = get_irn_mode(b);
+               int allow;
 
-                       n = new_rd_Add(dbgi, irg, block, a, cnst, mode);
-                       DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_TO_ADD);
-                       return n;
+               if (get_opt_overflow_unsafe_transform())
+                       allow = mode != mode_P;
+               else
+                       allow = mode_is_signed(mode);
+
+               if (allow) {
+                       /* a - C -> a + (-C) */
+                       ir_node *cnst = const_negate(b);
+                       if (cnst != NULL) {
+                               ir_node  *block = get_nodes_block(n);
+                               dbg_info *dbgi  = get_irn_dbg_info(n);
+                               ir_graph *irg   = get_irn_irg(n);
+
+                               n = new_rd_Add(dbgi, irg, block, a, cnst, mode);
+                               DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_TO_ADD);
+                               return n;
+                       }
                }
        }
 

diff --git a/ir/opt/opt_osr.c b/ir/opt/opt_osr.c
index 689e4a5..2b91b9e 100644 (file)
--- a/ir/opt/opt_osr.c
+++ b/ir/opt/opt_osr.c
@@ -1087,6 +1087,14 @@ static void do_lftr(ir_node *cmp, void *ctx) {
  * @param env   the IV environment
  */
 static void lftr(ir_graph *irg, iv_env *env) {
+       if ((env->flags & osr_flag_lftr_with_ov_check)  &&
+               get_opt_overflow_unsafe_transform()) {
+               /*
+                * If overflow unsafe transformation are allowed, we cannot perform
+                * linear function test replacement with overflow checks.
+                */
+               return;
+       }
        irg_walk_graph(irg, NULL, do_lftr, env);
 }
 

diff --git a/ir/opt/reassoc.c b/ir/opt/reassoc.c
index 4eaedc7..b390e73 100644 (file)
--- a/ir/opt/reassoc.c
+++ b/ir/opt/reassoc.c
@@ -168,12 +168,18 @@ static int reassoc_Sub(ir_node **in)
                        /* already constant, nothing to do */
                        return 0;
                }
+
+               if (!get_opt_overflow_unsafe_transform() && !mode_is_signed(rmode)) {
+                       /* do not transform unsigned, overflow will occur */
+                       return 0;
+               }
+
                mode = get_irn_mode(n);
                dbi  = get_irn_dbg_info(n);
 
                /* Beware of SubP(P, Is) */
                irn = new_rd_Minus(dbi, current_ir_graph, block, right, rmode);
-               irn = new_rd_Add(dbi, current_ir_graph, block, left, irn, get_irn_mode(n));
+               irn = new_rd_Add(dbi, current_ir_graph, block, left, irn, mode);
 
                DBG((dbg, LEVEL_5, "Applied: %n - %n => %n + (-%n)\n",
                        get_Sub_left(n), right, get_Sub_left(n), right));