*/
static ir_node *equivalent_node_Sub(ir_node *n) {
ir_node *oldn = n;
- ir_node *a, *b;
+ ir_node *b;
ir_mode *mode = get_irn_mode(n);
/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
return n;
- a = get_Sub_left(n);
b = get_Sub_right(n);
/* Beware: modes might be different */
if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+ ir_node *a = get_Sub_left(n);
if (mode == get_irn_mode(a)) {
n = a;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
}
- } else if (get_irn_op(a) == op_Add) {
- if (mode_wrap_around(mode)) {
- ir_node *left = get_Add_left(a);
- ir_node *right = get_Add_right(a);
-
- if (left == b) {
- if (mode == get_irn_mode(right)) {
- n = right;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
- }
- } else if (right == b) {
- if (mode == get_irn_mode(left)) {
- n = left;
- DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
- }
- }
- }
}
return n;
} /* equivalent_node_Sub */
if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
/* Turn Div into a tuple (mem, bad, a) */
ir_node *mem = get_Div_mem(n);
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_irn_n(n, -1);
turn_into_tuple(n, pn_Div_max);
set_Tuple_pred(n, pn_Div_M, mem);
set_Tuple_pred(n, pn_Div_X_regular, new_r_Jmp(current_ir_graph, blk));
/* Div is not commutative. */
if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* Quot(x, 1) == x */
- /* Turn Quot into a tuple (mem, bad, a) */
+ /* Turn Quot into a tuple (mem, jmp, bad, a) */
ir_node *mem = get_Quot_mem(n);
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_irn_n(n, -1);
turn_into_tuple(n, pn_Quot_max);
set_Tuple_pred(n, pn_Quot_M, mem);
set_Tuple_pred(n, pn_Quot_X_regular, new_r_Jmp(current_ir_graph, blk));
/* Div is not commutative. */
if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) { /* div(x, 1) == x */
- /* Turn DivMod into a tuple (mem, bad, a, 0) */
+ /* Turn DivMod into a tuple (mem, jmp, bad, a, 0) */
ir_node *a = get_DivMod_left(n);
ir_node *mem = get_Div_mem(n);
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_irn_n(n, -1);
ir_mode *mode = get_DivMod_resmode(n);
turn_into_tuple(n, pn_DivMod_max);
* Optimize Proj(Tuple) and gigo() for ProjX in Bad block,
* ProjX(Load) and ProjX(Store).
*/
-static ir_node *equivalent_node_Proj(ir_node *n) {
- ir_node *oldn = n;
- ir_node *a = get_Proj_pred(n);
+static ir_node *equivalent_node_Proj(ir_node *proj) {
+ ir_node *oldn = proj;
+ ir_node *a = get_Proj_pred(proj);
- if ( get_irn_op(a) == op_Tuple) {
+ if (get_irn_op(a) == op_Tuple) {
/* Remove the Tuple/Proj combination. */
- if ( get_Proj_proj(n) <= get_Tuple_n_preds(a) ) {
- n = get_Tuple_pred(a, get_Proj_proj(n));
- DBG_OPT_TUPLE(oldn, a, n);
+ if ( get_Proj_proj(proj) <= get_Tuple_n_preds(a) ) {
+ proj = get_Tuple_pred(a, get_Proj_proj(proj));
+ DBG_OPT_TUPLE(oldn, a, proj);
} else {
- assert(0); /* This should not happen! */
- n = new_Bad();
+ /* This should not happen! */
+ assert(! "found a Proj with higher number than Tuple predecessors");
+ proj = new_Bad();
}
- } else if (get_irn_mode(n) == mode_X) {
- if (is_Block_dead(get_nodes_block(skip_Proj(n)))) {
+ } else if (get_irn_mode(proj) == mode_X) {
+ if (is_Block_dead(get_nodes_block(skip_Proj(proj)))) {
/* Remove dead control flow -- early gigo(). */
- n = new_Bad();
+ proj = new_Bad();
} else if (get_opt_ldst_only_null_ptr_exceptions()) {
ir_op *op = get_irn_op(a);
- if (op == op_Load || op == op_Store) {
+ if (op == op_Load) {
+ /* get the Load address */
+ ir_node *addr = get_Load_ptr(a);
+ ir_node *blk = get_irn_n(a, -1);
+ ir_node *confirm;
+
+ if (value_not_null(addr, &confirm)) {
+ if (confirm == NULL) {
+ /* this node may float if it did not depend on a Confirm */
+ set_irn_pinned(a, op_pin_state_floats);
+ }
+ if (get_Proj_proj(proj) == pn_Load_X_except) {
+ DBG_OPT_EXC_REM(proj);
+ return new_Bad();
+ } else
+ return new_r_Jmp(current_ir_graph, blk);
+ }
+ } else if (op == op_Store) {
/* get the load/store address */
- ir_node *addr = get_irn_n(a, 1);
+ ir_node *addr = get_Store_ptr(a);
+ ir_node *blk = get_irn_n(a, -1);
ir_node *confirm;
if (value_not_null(addr, &confirm)) {
/* this node may float if it did not depend on a Confirm */
set_irn_pinned(a, op_pin_state_floats);
}
- DBG_OPT_EXC_REM(n);
- return new_Bad();
+ if (get_Proj_proj(proj) == pn_Store_X_except) {
+ DBG_OPT_EXC_REM(proj);
+ return new_Bad();
+ } else
+ return new_r_Jmp(current_ir_graph, blk);
}
}
}
}
- return n;
+ return proj;
} /* equivalent_node_Proj */
/**
ir_node *b = get_CopyB_src(n);
if (a == b) {
- /* Turn CopyB into a tuple (mem, bad, bad) */
+ /* Turn CopyB into a tuple (mem, jmp, bad, bad) */
ir_node *mem = get_CopyB_mem(n);
ir_node *blk = get_nodes_block(n);
turn_into_tuple(n, pn_CopyB_max);
- set_Tuple_pred(n, pn_CopyB_M, mem);
+ set_Tuple_pred(n, pn_CopyB_M, mem);
set_Tuple_pred(n, pn_CopyB_X_regular, new_r_Jmp(current_ir_graph, blk));
- set_Tuple_pred(n, pn_CopyB_X_except, new_Bad()); /* no exception */
- set_Tuple_pred(n, pn_CopyB_M_except, new_Bad());
+ set_Tuple_pred(n, pn_CopyB_X_except, new_Bad()); /* no exception */
+ set_Tuple_pred(n, pn_CopyB_M_except, new_Bad());
}
return n;
} /* equivalent_node_CopyB */
/* By definition lower < upper, so if idx == lower -->
lower <= idx && idx < upper */
if (idx == lower) {
- /* Turn Bound into a tuple (mem, bad, idx) */
+ /* Turn Bound into a tuple (mem, jmp, bad, idx) */
ret_tuple = 1;
} else {
ir_node *pred = skip_Proj(idx);
}
}
if (ret_tuple) {
- /* Turn Bound into a tuple (mem, bad, idx) */
+ /* Turn Bound into a tuple (mem, jmp, bad, idx) */
ir_node *mem = get_Bound_mem(n);
ir_node *blk = get_nodes_block(n);
turn_into_tuple(n, pn_Bound_max);
a = get_Sub_left(n);
b = get_Sub_right(n);
- HANDLE_BINOP_PHI(tarval_sub, a,b,c);
-
mode = get_irn_mode(n);
+restart:
+ HANDLE_BINOP_PHI(tarval_sub, a,b,c);
+
/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic))
return n;
+ if (is_Add(a)) {
+ if (mode_wrap_around(mode)) {
+ ir_node *left = get_Add_left(a);
+ ir_node *right = get_Add_right(a);
+
+ /* FIXME: Does the Conv's word only for two complement or generally? */
+ if (left == b) {
+ if (mode != get_irn_mode(right)) {
+ /* This Sub is an effective Cast */
+ right = new_r_Conv(get_irn_irg(n), get_irn_n(n, -1), right, mode);
+ }
+ n = right;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ } else if (right == b) {
+ if (mode != get_irn_mode(left)) {
+ /* This Sub is an effective Cast */
+ left = new_r_Conv(get_irn_irg(n), get_irn_n(n, -1), left, mode);
+ }
+ n = left;
+ DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
+ }
+ }
+ } else if (mode_is_int(mode) && is_Conv(a) && is_Conv(b)) {
+ ir_mode *mode = get_irn_mode(a);
+
+ if (mode == get_irn_mode(b)) {
+ ir_mode *ma, *mb;
+
+ a = get_Conv_op(a);
+ b = get_Conv_op(b);
+
+ /* check if it's allowed to skip the conv */
+ ma = get_irn_mode(a);
+ mb = get_irn_mode(b);
+
+ if (mode_is_reference(ma) && mode_is_reference(mb)) {
+ /* SubInt(ConvInt(aP), ConvInt(bP)) -> SubInt(aP,bP) */
+ set_Sub_left(n, a);
+ set_Sub_right(n, b);
+
+ goto restart;
+ }
+ }
+ }
/* Beware of Sub(P, P) which cannot be optimized into a simple Minus ... */
- if (mode_is_num(mode) && mode == get_irn_mode(a) && (classify_Const(a) == CNST_NULL)) {
+ else if (mode_is_num(mode) && mode == get_irn_mode(a) && (classify_Const(a) == CNST_NULL)) {
n = new_rd_Minus(
get_irn_dbg_info(n),
current_ir_graph,
set_Sub_right(n, add);
DBG_OPT_ALGSIM0(n, n, FS_OPT_SUB_SUB_X_Y_Z);
}
-
return n;
} /* transform_node_Sub */
value = arch_dep_replace_div_by_const(n);
if (value != n) {
- /* Turn Div into a tuple (mem, bad, value) */
+ /* Turn Div into a tuple (mem, jmp, bad, value) */
ir_node *mem = get_Div_mem(n);
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_irn_n(n, -1);
turn_into_tuple(n, pn_Div_max);
set_Tuple_pred(n, pn_Div_M, mem);
value = arch_dep_replace_mod_by_const(n);
if (value != n) {
- /* Turn Mod into a tuple (mem, bad, value) */
+ /* Turn Mod into a tuple (mem, jmp, bad, value) */
ir_node *mem = get_Mod_mem(n);
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_irn_n(n, -1);
turn_into_tuple(n, pn_Mod_max);
set_Tuple_pred(n, pn_Mod_M, mem);
if (evaluated) { /* replace by tuple */
ir_node *mem = get_DivMod_mem(n);
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_irn_n(n, -1);
turn_into_tuple(n, pn_DivMod_max);
set_Tuple_pred(n, pn_DivMod_M, mem);
set_Tuple_pred(n, pn_DivMod_X_regular, new_r_Jmp(current_ir_graph, blk));
* Removes the exceptions and routes the memory to the NoMem node.
*/
static ir_node *transform_node_Proj_Div(ir_node *proj) {
- ir_node *n = get_Proj_pred(proj);
- ir_node *b = get_Div_right(n);
- ir_node *confirm;
+ ir_node *div = get_Proj_pred(proj);
+ ir_node *b = get_Div_right(div);
+ ir_node *confirm, *res, *new_mem;
long proj_nr;
if (value_not_zero(b, &confirm)) {
/* div(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
- if (proj_nr == pn_Div_X_except) {
+ switch (proj_nr) {
+ case pn_Div_X_regular:
+ return new_r_Jmp(current_ir_graph, get_irn_n(div, -1));
+
+ case pn_Div_X_except:
/* we found an exception handler, remove it */
DBG_OPT_EXC_REM(proj);
return new_Bad();
- } else if (proj_nr == pn_Div_M) {
- ir_node *res = get_Div_mem(n);
- ir_node *new_mem = get_irg_no_mem(current_ir_graph);
+
+ case pn_Div_M:
+ res = get_Div_mem(div);
+ new_mem = get_irg_no_mem(current_ir_graph);
if (confirm) {
/* This node can only float up to the Confirm block */
new_mem = new_r_Pin(current_ir_graph, get_nodes_block(confirm), new_mem);
}
- set_irn_pinned(n, op_pin_state_floats);
+ set_irn_pinned(div, op_pin_state_floats);
/* this is a Div without exception, we can remove the memory edge */
- set_Div_mem(n, new_mem);
+ set_Div_mem(div, new_mem);
return res;
}
}
* Removes the exceptions and routes the memory to the NoMem node.
*/
static ir_node *transform_node_Proj_Mod(ir_node *proj) {
- ir_node *n = get_Proj_pred(proj);
- ir_node *b = get_Mod_right(n);
- ir_node *confirm;
+ ir_node *mod = get_Proj_pred(proj);
+ ir_node *b = get_Mod_right(mod);
+ ir_node *confirm, *res, *new_mem;
long proj_nr;
if (value_not_zero(b, &confirm)) {
/* mod(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
- if (proj_nr == pn_Mod_X_except) {
+ switch (proj_nr) {
+
+ case pn_Mod_X_regular:
+ return new_r_Jmp(current_ir_graph, get_irn_n(mod, -1));
+
+ case pn_Mod_X_except:
/* we found an exception handler, remove it */
DBG_OPT_EXC_REM(proj);
return new_Bad();
- } else if (proj_nr == pn_Mod_M) {
- ir_node *res = get_Mod_mem(n);
- ir_node *new_mem = get_irg_no_mem(current_ir_graph);
+
+ case pn_Mod_M:
+ res = get_Mod_mem(mod);
+ new_mem = get_irg_no_mem(current_ir_graph);
if (confirm) {
/* This node can only float up to the Confirm block */
new_mem = new_r_Pin(current_ir_graph, get_nodes_block(confirm), new_mem);
}
- set_irn_pinned(n, op_pin_state_floats);
+ set_irn_pinned(mod, op_pin_state_floats);
/* this is a Mod without exception, we can remove the memory edge */
- set_Mod_mem(n, get_irg_no_mem(current_ir_graph));
- return res;
- } else if (proj_nr == pn_Mod_res && get_Mod_left(n) == b) {
- /* a % a = 0 if a != 0 */
- ir_mode *mode = get_irn_mode(proj);
- ir_node *res = new_Const(mode, get_mode_null(mode));
-
- DBG_OPT_CSTEVAL(n, res);
+ set_Mod_mem(mod, get_irg_no_mem(current_ir_graph));
return res;
+ case pn_Mod_res:
+ if (get_Mod_left(mod) == b) {
+ /* a % a = 0 if a != 0 */
+ ir_mode *mode = get_irn_mode(proj);
+ ir_node *res = new_Const(mode, get_mode_null(mode));
+
+ DBG_OPT_CSTEVAL(mod, res);
+ return res;
+ }
}
}
return proj;
* Removes the exceptions and routes the memory to the NoMem node.
*/
static ir_node *transform_node_Proj_DivMod(ir_node *proj) {
- ir_node *n = get_Proj_pred(proj);
- ir_node *b = get_DivMod_right(n);
- ir_node *confirm;
+ ir_node *divmod = get_Proj_pred(proj);
+ ir_node *b = get_DivMod_right(divmod);
+ ir_node *confirm, *res, *new_mem;
long proj_nr;
if (value_not_zero(b, &confirm)) {
/* DivMod(x, y) && y != 0 */
proj_nr = get_Proj_proj(proj);
- if (proj_nr == pn_DivMod_X_except) {
+ switch (proj_nr) {
+
+ case pn_DivMod_X_regular:
+ return new_r_Jmp(current_ir_graph, get_irn_n(divmod, -1));
+
+ case pn_DivMod_X_except:
/* we found an exception handler, remove it */
DBG_OPT_EXC_REM(proj);
return new_Bad();
- } else if (proj_nr == pn_DivMod_M) {
- ir_node *res = get_DivMod_mem(n);
- ir_node *new_mem = get_irg_no_mem(current_ir_graph);
+
+ case pn_DivMod_M:
+ res = get_DivMod_mem(divmod);
+ new_mem = get_irg_no_mem(current_ir_graph);
if (confirm) {
/* This node can only float up to the Confirm block */
new_mem = new_r_Pin(current_ir_graph, get_nodes_block(confirm), new_mem);
}
- set_irn_pinned(n, op_pin_state_floats);
+ set_irn_pinned(divmod, op_pin_state_floats);
/* this is a DivMod without exception, we can remove the memory edge */
- set_DivMod_mem(n, get_irg_no_mem(current_ir_graph));
+ set_DivMod_mem(divmod, get_irg_no_mem(current_ir_graph));
return res;
- } else if (proj_nr == pn_DivMod_res_mod && get_DivMod_left(n) == b) {
- /* a % a = 0 if a != 0 */
- ir_mode *mode = get_irn_mode(proj);
- ir_node *res = new_Const(mode, get_mode_null(mode));
- DBG_OPT_CSTEVAL(n, res);
- return res;
+ case pn_DivMod_res_mod:
+ if (get_DivMod_left(divmod) == b) {
+ /* a % a = 0 if a != 0 */
+ ir_mode *mode = get_irn_mode(proj);
+ ir_node *res = new_Const(mode, get_mode_null(mode));
+
+ DBG_OPT_CSTEVAL(divmod, res);
+ return res;
+ }
}
}
return proj;
const ir_asm_constraint *cb;
ident **cla, **clb;
- if (get_ASM_text(a) != get_ASM_text(b));
+ if (get_ASM_text(a) != get_ASM_text(b))
return 1;
/* Should we really check the constraints here? Should be better, but is strange. */
projects / libfirm / blobdiff