#include "archop.h"
#include "opt_polymorphy.h"
#include "opt_confirms.h"
+#include "irtools.h"
/* Make types visible to allow most efficient access */
# include "entity_t.h"
*/
static tarval *computed_value_SymConst(ir_node *n)
{
- if ((get_SymConst_kind(n) == symconst_size) &&
- (get_type_state(get_SymConst_type(n))) == layout_fixed)
- return new_tarval_from_long(get_type_size_bytes(get_SymConst_type(n)), get_irn_mode(n));
+ ir_type *type;
+
+ switch (get_SymConst_kind(n)) {
+ case symconst_type_size:
+ type = get_SymConst_type(n);
+ if (get_type_state(type) == layout_fixed)
+ return new_tarval_from_long(get_type_size_bytes(type), get_irn_mode(n));
+ break;
+ case symconst_type_align:
+ type = get_SymConst_type(n);
+ if (get_type_state(type) == layout_fixed)
+ return new_tarval_from_long(get_type_alignment_bytes(type), get_irn_mode(n));
+ break;
+ default:
+ break;
+ }
return tarval_bad;
}
{
ir_node *oldn = n;
ir_node *left, *right;
+ 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;
n = equivalent_node_neutral_zero(n);
if (n != oldn)
/* (a - x) + x */
n = get_Sub_left(left);
- if (get_irn_mode(oldn) == get_irn_mode(n)) {
+ if (mode == get_irn_mode(n)) {
DBG_OPT_ALGSIM1(oldn, left, right, n, FS_OPT_ADD_SUB);
return n;
}
/* x + (a - x) */
n = get_Sub_left(right);
- if (get_irn_mode(oldn) == get_irn_mode(n)) {
+ if (mode == get_irn_mode(n)) {
DBG_OPT_ALGSIM1(oldn, left, right, n, FS_OPT_ADD_SUB);
return n;
}
static ir_node *equivalent_node_Sub(ir_node *n)
{
ir_node *oldn = n;
+ ir_node *a, *b;
+ ir_mode *mode = get_irn_mode(n);
- ir_node *a = get_Sub_left(n);
- ir_node *b = get_Sub_right(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) {
- if (get_irn_mode(n) == get_irn_mode(a)) {
+ 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) {
- ir_mode *mode = get_irn_mode(n);
-
if (mode_wrap_around(mode)) {
ir_node *left = get_Add_left(a);
ir_node *right = get_Add_right(a);
if (left == b) {
- if (get_irn_mode(n) == get_irn_mode(right)) {
+ if (mode == get_irn_mode(right)) {
n = right;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
}
}
else if (right == b) {
- if (get_irn_mode(n) == get_irn_mode(left)) {
+ if (mode == get_irn_mode(left)) {
n = left;
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
}
}
}
}
-
return n;
}
static ir_node *equivalent_node_Mul(ir_node *n)
{
ir_node *oldn = n;
-
ir_node *a = get_Mul_left(n);
ir_node *b = get_Mul_right(n);
return n;
}
+/**
+ * Optimize a / 1.0 = a.
+ */
+static ir_node *equivalent_node_Quot(ir_node *n) {
+ ir_node *a = get_Quot_left(n);
+ ir_node *b = get_Quot_right(n);
+
+ /* 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) */
+ ir_node *mem = get_Quot_mem(n);
+ turn_into_tuple(n, pn_Quot_max);
+ set_Tuple_pred(n, pn_Quot_M, mem);
+ set_Tuple_pred(n, pn_Quot_X_except, new_Bad()); /* no exception */
+ set_Tuple_pred(n, pn_Quot_res, a);
+ }
+ return n;
+}
+
/**
* Optimize a / 1 = a.
*/
ir_mode *a_mode = get_irn_mode(a);
if (n_mode == a_mode) { /* No Conv necessary */
+ /* leave strict floating point Conv's */
+ if (get_Conv_strict(n))
+ return n;
n = a;
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV);
} else if (get_irn_op(a) == op_Conv) { /* Conv(Conv(b)) */
- no Sync in start block.
- fold Sync-nodes, iff they have only one predecessor except
themselves.
- @fixme: are there loop's in Sync's
*/
static ir_node *equivalent_node_Sync(ir_node *n)
{
/* Turn Bound into a tuple (mem, bad, idx) */
ir_node *mem = get_Bound_mem(n);
turn_into_tuple(n, pn_Bound_max);
- set_Tuple_pred(n, pn_Bound_M_regular, mem);
- set_Tuple_pred(n, pn_Bound_X_except, new_Bad()); /* no exception */
- set_Tuple_pred(n, pn_Bound_res, idx);
- set_Tuple_pred(n, pn_Bound_M_except, mem);
+ set_Tuple_pred(n, pn_Bound_M, mem);
+ set_Tuple_pred(n, pn_Bound_X_except, new_Bad()); /* no exception */
+ set_Tuple_pred(n, pn_Bound_res, idx);
}
return n;
}
CASE(Minus);
CASE(Mul);
CASE(Div);
+ CASE(Quot);
CASE(DivMod);
CASE(And);
CASE(Conv);
} /* end switch */
}
+/**
+ * Returns non-zero if a node is a Phi node
+ * with all predecessors constant.
+ */
+static int is_const_Phi(ir_node *n) {
+ int i;
+
+ if (! is_Phi(n))
+ return 0;
+ for (i = get_irn_arity(n) - 1; i >= 0; --i)
+ if (! is_Const(get_irn_n(n, i)))
+ return 0;
+ return 1;
+}
+
+/**
+ * Apply an evaluator on a binop with a constant operators (and one Phi).
+ *
+ * @param phi the Phi node
+ * @param other the other operand
+ * @param eval an evaluator function
+ * @param left if non-zero, other is the left operand, else the right
+ *
+ * @return a new Phi node if the conversion was successful, NULL else
+ */
+static ir_node *apply_binop_on_phi(ir_node *phi, tarval *other, tarval *(*eval)(tarval *, tarval *), int left) {
+ tarval *tv;
+ void **res;
+ ir_node *pred;
+ ir_mode *mode;
+ ir_graph *irg;
+ int i, n = get_irn_arity(phi);
+
+ NEW_ARR_A(void *, res, n);
+ if (left) {
+ for (i = 0; i < n; ++i) {
+ pred = get_irn_n(phi, i);
+ tv = get_Const_tarval(pred);
+ tv = eval(other, tv);
+
+ if (tv == tarval_bad) {
+ /* folding failed, bad */
+ return NULL;
+ }
+ res[i] = tv;
+ }
+ }
+ else {
+ for (i = 0; i < n; ++i) {
+ pred = get_irn_n(phi, i);
+ tv = get_Const_tarval(pred);
+ tv = eval(tv, other);
+
+ if (tv == tarval_bad) {
+ /* folding failed, bad */
+ return 0;
+ }
+ res[i] = tv;
+ }
+ }
+ mode = get_irn_mode(phi);
+ irg = current_ir_graph;
+ for (i = 0; i < n; ++i) {
+ pred = get_irn_n(phi, i);
+ res[i] = new_r_Const_type(irg, get_nodes_block(pred),
+ mode, res[i], get_Const_type(pred));
+ }
+ return new_r_Phi(irg, get_nodes_block(phi), n, (ir_node **)res, mode);
+}
+
+/**
+ * Apply an evaluator on a unop with a constant operator (a Phi).
+ *
+ * @param phi the Phi node
+ * @param eval an evaluator function
+ *
+ * @return a new Phi node if the conversion was successful, NULL else
+ */
+static ir_node *apply_unop_on_phi(ir_node *phi, tarval *(*eval)(tarval *)) {
+ tarval *tv;
+ void **res;
+ ir_node *pred;
+ ir_mode *mode;
+ ir_graph *irg;
+ int i, n = get_irn_arity(phi);
+
+ NEW_ARR_A(void *, res, n);
+ for (i = 0; i < n; ++i) {
+ pred = get_irn_n(phi, i);
+ tv = get_Const_tarval(pred);
+ tv = eval(tv);
+
+ if (tv == tarval_bad) {
+ /* folding failed, bad */
+ return 0;
+ }
+ res[i] = tv;
+ }
+ mode = get_irn_mode(phi);
+ irg = current_ir_graph;
+ for (i = 0; i < n; ++i) {
+ pred = get_irn_n(phi, i);
+ res[i] = new_r_Const_type(irg, get_nodes_block(pred),
+ mode, res[i], get_Const_type(pred));
+ }
+ return new_r_Phi(irg, get_nodes_block(phi), n, (ir_node **)res, mode);
+}
+
/**
* Transform AddP(P, ConvIs(Iu)), AddP(P, ConvIu(Is)) and
* SubP(P, ConvIs(Iu)), SubP(P, ConvIu(Is)).
return n;
}
+#define HANDLE_BINOP_PHI(op,a,b,c) \
+ c = NULL; \
+ if (is_Const(b) && is_const_Phi(a)) { \
+ /* check for Op(Phi, Const) */ \
+ c = apply_binop_on_phi(a, get_Const_tarval(b), op, 0); \
+ } \
+ else if (is_Const(a) && is_const_Phi(b)) { \
+ /* check for Op(Const, Phi) */ \
+ c = apply_binop_on_phi(b, get_Const_tarval(a), op, 1); \
+ } \
+ if (c) { \
+ DBG_OPT_ALGSIM0(oldn, c, FS_OPT_CONST_PHI); \
+ return c; \
+ }
+
+#define HANDLE_UNOP_PHI(op,a,c) \
+ c = NULL; \
+ if (is_const_Phi(a)) { \
+ /* check for Op(Phi) */ \
+ c = apply_unop_on_phi(a, op); \
+ } \
+ if (c) { \
+ DBG_OPT_ALGSIM0(oldn, c, FS_OPT_CONST_PHI); \
+ return c; \
+ }
+
+
/**
* Do the AddSub optimization, then Transform
+ * Constant folding on Phi
* Add(a,a) -> Mul(a, 2)
* Add(Mul(a, x), a) -> Mul(a, x+1)
* if the mode is integer or float.
static ir_node *transform_node_Add(ir_node *n)
{
ir_mode *mode;
- ir_node *oldn = n;
+ ir_node *a, *b, *c, *oldn = n;
n = transform_node_AddSub(n);
+ a = get_Add_left(n);
+ b = get_Add_right(n);
+
+ HANDLE_BINOP_PHI(tarval_add, a,b,c);
+
mode = get_irn_mode(n);
- if (mode_is_num(mode)) {
- ir_node *a = get_Add_left(n);
- ir_node *b = get_Add_right(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;
+
+ if (mode_is_num(mode)) {
if (a == b) {
ir_node *block = get_irn_n(n, -1);
/**
* Do the AddSub optimization, then Transform
+ * Constant folding on Phi
* Sub(0,a) -> Minus(a)
* Sub(Mul(a, x), a) -> Mul(a, x-1)
+ * Sub(Sub(x, y), b) -> Sub(x, Add(y,b))
*/
static ir_node *transform_node_Sub(ir_node *n)
{
ir_mode *mode;
ir_node *oldn = n;
- ir_node *a, *b;
+ ir_node *a, *b, *c;
n = transform_node_AddSub(n);
+ a = get_Sub_left(n);
+ b = get_Sub_right(n);
+
+ HANDLE_BINOP_PHI(tarval_sub, a,b,c);
+
mode = get_irn_mode(n);
- a = get_Sub_left(n);
- b = get_Sub_right(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;
+
if (mode_is_num(mode) && (classify_Const(a) == CNST_NULL)) {
n = new_rd_Minus(
get_irn_dbg_info(n),
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_MUL_A_X_A);
}
}
+ else if (get_irn_op(a) == op_Sub) {
+ ir_node *x = get_Sub_left(a);
+ ir_node *y = get_Sub_right(a);
+ ir_node *blk = get_irn_n(n, -1);
+ ir_mode *m_b = get_irn_mode(b);
+ ir_mode *m_y = get_irn_mode(y);
+ ir_node *add;
+
+ /* Determine the right mode for the Add. */
+ if (m_b == m_y)
+ mode = m_b;
+ else if (mode_is_reference(m_b))
+ mode = m_b;
+ else if (mode_is_reference(m_y))
+ mode = m_y;
+ else {
+ /*
+ * Both modes are different but none is reference,
+ * happens for instance in SubP(SubP(P, Iu), Is).
+ * We have two possibilities here: Cast or ignore.
+ * Currently we ignore this case.
+ */
+ return n;
+ }
+
+ add = new_r_Add(current_ir_graph, blk, y, b, mode);
+
+ set_Sub_left(n, x);
+ set_Sub_right(n, add);
+ DBG_OPT_ALGSIM0(n, n, FS_OPT_SUB_SUB_X_Y_Z);
+ }
return n;
}
/**
* Transform Mul(a,-1) into -a.
+ * Do constant evaluation of Phi nodes.
* Do architecture dependent optimizations on Mul nodes
*/
static ir_node *transform_node_Mul(ir_node *n) {
- ir_node *oldn = n;
- ir_mode *mode = get_irn_mode(n);
+ ir_node *c, *oldn = n;
+ ir_node *a = get_Mul_left(n);
+ ir_node *b = get_Mul_right(n);
+ ir_mode *mode;
+
+ HANDLE_BINOP_PHI(tarval_mul, a,b,c);
+ mode = get_irn_mode(n);
if (mode_is_signed(mode)) {
ir_node *r = NULL;
- ir_node *a = get_Mul_left(n);
- ir_node *b = get_Mul_right(n);
if (value_of(a) == get_mode_minus_one(mode))
r = b;
}
/**
- * transform a Div Node
+ * Transform a Div Node.
*/
static ir_node *transform_node_Div(ir_node *n)
{
}
/**
- * transform a Mod node
+ * Transform a Mod node.
*/
static ir_node *transform_node_Mod(ir_node *n)
{
}
/**
- * transform a DivMod node
+ * Transform a DivMod node.
*/
static ir_node *transform_node_DivMod(ir_node *n)
{
}
/**
- * transform a Cond node
+ * Transform a Cond node.
*/
static ir_node *transform_node_Cond(ir_node *n)
{
return n;
}
+/**
+ * Transform an And.
+ */
+static ir_node *transform_node_And(ir_node *n)
+{
+ ir_node *c, *oldn = n;
+ ir_node *a = get_And_left(n);
+ ir_node *b = get_And_right(n);
+
+ HANDLE_BINOP_PHI(tarval_and, a,b,c);
+ return n;
+}
+
/**
* Transform an Eor.
*/
static ir_node *transform_node_Eor(ir_node *n)
{
- ir_node *oldn = n;
+ ir_node *c, *oldn = n;
ir_node *a = get_Eor_left(n);
ir_node *b = get_Eor_right(n);
ir_mode *mode = get_irn_mode(n);
+ HANDLE_BINOP_PHI(tarval_eor, a,b,c);
+
if (a == b) {
/* a ^ a = 0 */
n = new_rd_Const(get_irn_dbg_info(n), current_ir_graph, get_irn_n(n, -1),
}
/**
- * Transform a boolean Not.
+ * Transform a Not.
*/
static ir_node *transform_node_Not(ir_node *n)
{
- ir_node *oldn = n;
+ ir_node *c, *oldn = n;
ir_node *a = get_Not_op(n);
+ HANDLE_UNOP_PHI(tarval_not,a,c);
+
+ /* check for a boolean Not */
if ( (get_irn_mode(n) == mode_b)
&& (get_irn_op(a) == op_Proj)
&& (get_irn_mode(a) == mode_b)
mode_b, get_negated_pnc(get_Proj_proj(a), mode_b));
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_CMP);
}
+ return n;
+}
+
+/**
+ * Transform a Minus.
+ */
+static ir_node *transform_node_Minus(ir_node *n)
+{
+ ir_node *c, *oldn = n;
+ ir_node *a = get_Minus_op(n);
+ HANDLE_UNOP_PHI(tarval_neg,a,c);
return n;
}
}
}
+/**
+ * Move Confirms down through Phi nodes.
+ */
+static ir_node *transform_node_Phi(ir_node *phi) {
+ int i, n;
+ ir_mode *mode = get_irn_mode(phi);
+
+ if (mode_is_reference(mode)) {
+ n = get_irn_arity(phi);
+
+ /* Beware of Phi0 */
+ if (n > 0) {
+ ir_node *pred = get_irn_n(phi, 0);
+ ir_node *bound, *new_Phi, *block, **in;
+ pn_Cmp pnc;
+
+ if (! is_Confirm(pred))
+ return phi;
+
+ bound = get_Confirm_bound(pred);
+ pnc = get_Confirm_cmp(pred);
+
+ NEW_ARR_A(ir_node *, in, n);
+ in[0] = get_Confirm_value(pred);
+
+ for (i = 1; i < n; ++i) {
+ pred = get_irn_n(phi, i);
+
+ if (! is_Confirm(pred) ||
+ get_Confirm_bound(pred) != bound ||
+ get_Confirm_cmp(pred) != pnc)
+ return phi;
+ in[i] = get_Confirm_value(pred);
+ }
+ /* move the Confirm nodes "behind" the Phi */
+ block = get_irn_n(phi, -1);
+ new_Phi = new_r_Phi(current_ir_graph, block, n, in, get_irn_mode(phi));
+ return new_r_Confirm(current_ir_graph, block, new_Phi, bound, pnc);
+ }
+ }
+ return phi;
+}
+
/**
* returns the operands of a commutative bin-op, if one operand is
* a const, it is returned as the second one.
}
/**
- * Optimize an Or
+ * Transform an Or.
*/
-static ir_node *transform_node_Or(ir_node *or)
+static ir_node *transform_node_Or(ir_node *n)
{
- or = transform_node_Or_bf_store(or);
- or = transform_node_Or_Rot(or);
+ ir_node *c, *oldn = n;
+ ir_node *a = get_Or_left(n);
+ ir_node *b = get_Or_right(n);
- return or;
+ HANDLE_BINOP_PHI(tarval_or, a,b,c);
+
+ n = transform_node_Or_bf_store(n);
+ n = transform_node_Or_Rot(n);
+
+ return n;
}
+
/* forward */
static ir_node *transform_node(ir_node *n);
return n;
}
-#define transform_node_Shr transform_node_shift
-#define transform_node_Shrs transform_node_shift
-#define transform_node_Shl transform_node_shift
+/**
+ * Transform a Shr.
+ */
+static ir_node *transform_node_Shr(ir_node *n)
+{
+ ir_node *c, *oldn = n;
+ ir_node *a = get_Shr_left(n);
+ ir_node *b = get_Shr_right(n);
+
+ HANDLE_BINOP_PHI(tarval_shr, a, b, c);
+ return transform_node_shift(n);
+}
+
+/**
+ * Transform a Shrs.
+ */
+static ir_node *transform_node_Shrs(ir_node *n)
+{
+ ir_node *c, *oldn = n;
+ ir_node *a = get_Shrs_left(n);
+ ir_node *b = get_Shrs_right(n);
+
+ HANDLE_BINOP_PHI(tarval_shrs, a, b, c);
+ return transform_node_shift(n);
+}
+
+/**
+ * Transform a Shl.
+ */
+static ir_node *transform_node_Shl(ir_node *n)
+{
+ ir_node *c, *oldn = n;
+ ir_node *a = get_Shl_left(n);
+ ir_node *b = get_Shl_right(n);
+
+ HANDLE_BINOP_PHI(tarval_shl, a, b, c);
+ return transform_node_shift(n);
+}
/**
* Remove dead blocks and nodes in dead blocks
CASE(DivMod);
CASE(Abs);
CASE(Cond);
+ CASE(And);
+ CASE(Or);
CASE(Eor);
+ CASE(Minus);
CASE(Not);
CASE(Cast);
CASE(Proj);
+ CASE(Phi);
CASE(Sel);
- CASE(Or);
CASE(Shr);
CASE(Shrs);
CASE(Shl);
}
/** Compares the attributes of two Proj nodes. */
-static int node_cmp_attr_Proj(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Proj(ir_node *a, ir_node *b) {
return get_irn_proj_attr (a) != get_irn_proj_attr (b);
}
}
/** Compares the attributes of two Call nodes. */
-static int node_cmp_attr_Call(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Call(ir_node *a, ir_node *b) {
return (get_irn_call_attr(a) != get_irn_call_attr(b));
}
}
/** Compares the attributes of two Phi nodes. */
-static int node_cmp_attr_Phi(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Phi(ir_node *a, ir_node *b) {
return get_irn_phi_attr (a) != get_irn_phi_attr (b);
}
+/** Compares the attributes of two Conv nodes. */
+static int node_cmp_attr_Conv(ir_node *a, ir_node *b) {
+ return get_Conv_strict(a) != get_Conv_strict(b);
+}
+
/** Compares the attributes of two Cast nodes. */
-static int node_cmp_attr_Cast(ir_node *a, ir_node *b)
-{
+static int node_cmp_attr_Cast(ir_node *a, ir_node *b) {
return get_Cast_type(a) != get_Cast_type(b);
}
CASE(Call);
CASE(Sel);
CASE(Phi);
+ CASE(Conv);
CASE(Cast);
CASE(Load);
CASE(Store);
/*
* Calculate a hash value of a node.
*/
-unsigned
-ir_node_hash (ir_node *node)
+unsigned ir_node_hash(ir_node *node)
{
unsigned h;
int i, irn_arity;
h = 9*h + HASH_PTR(get_irn_mode(node));
} else if (node->op == op_SymConst) {
/* special value for const, as they only differ in their symbol. */
- h = HASH_PTR(node->attr.i.sym.type_p);
+ h = HASH_PTR(node->attr.symc.sym.type_p);
h = 9*h + HASH_PTR(get_irn_mode(node));
} else {
h = irn_arity = get_irn_intra_arity(node);
/* consider all in nodes... except the block if not a control flow. */
- for (i = is_cfop(node) ? -1 : 0; i < irn_arity; i++) {
+ for (i = is_cfop(node) ? -1 : 0; i < irn_arity; i++) {
h = 9*h + HASH_PTR(get_irn_intra_n(node, i));
}
return h;
}
-pset *
-new_identities(void) {
+pset *new_identities(void) {
return new_pset(identities_cmp, N_IR_NODES);
}
-void
-del_identities(pset *value_table) {
+void del_identities(pset *value_table) {
del_pset(value_table);
}
}
}
- o = pset_find(value_table, n, ir_node_hash (n));
+ o = pset_find(value_table, n, ir_node_hash(n));
if (!o) return n;
DBG_OPT_CSE(n, o);
}
/**
- * garbage in, garbage out. If a node has a dead input, i.e., the
+ * Garbage in, garbage out. If a node has a dead input, i.e., the
* Bad node is input to the node, return the Bad node.
*/
static INLINE ir_node *gigo(ir_node *node)
/* Blocks, Phis and Tuples may have dead inputs, e.g., if one of the
blocks predecessors is dead. */
- if ( op != op_Block && op != op_Phi && op != op_Tuple) {
+ if (op != op_Block && op != op_Phi && op != op_Tuple) {
irn_arity = get_irn_arity(node);
/*
/* Propagating Unknowns here seems to be a bad idea, because
sometimes we need a node as a input and did not want that
it kills it's user.
- However, i might be useful to move this into a later phase
- (it you thing optimizing such code is useful). */
+ However, it might be useful to move this into a later phase
+ (if you think that optimizing such code is useful). */
if (is_Unknown(pred) && mode_is_data(get_irn_mode(node)))
return new_Unknown(get_irn_mode(node));
#endif