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]
/**
* @file
* @brief Flags to control optimizations.
- * @author Christian Schaefer, Goetz Lindenmaier
+ * @author Michael Beck, Sebastian Hack
* @version $Id$
*/
#ifdef HAVE_CONFIG_H
/* 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");
#undef I_FLAG
#undef E_FLAG
#undef R_FLAG
- printf("\n");
+ printf("\n");
}
#endif
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;
}
/**
* @file
* @brief Definitions for optimisation flags
- * @author Michael Beck
+ * @author Michael Beck, Sebastian Hack
* @version $Id$
*/
/** */
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)
/**
* @file
* @brief Flags to control optimizations, inline implementation.
- * @author Michael Beck
+ * @author Michael Beck, Sebastian Hack
* @version $Id$
*/
#ifndef FIRM_IR_IRFLAG_T_H
#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()
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 */
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
) {
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;
+ }
}
}
* @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);
}
/* 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));