+ if (i == n_cfg)
+ n = set_Block_dead(n);
+ }
+
+ return n;
+}
+
+/**
+ * Returns a equivalent node for a Jmp, a Bad :-)
+ * Of course this only happens if the Block of the Jmp is Bad.
+ */
+static ir_node *equivalent_node_Jmp(ir_node *n)
+{
+ /* GL: Why not same for op_Raise?? */
+ /* unreachable code elimination */
+ if (is_Block_dead(get_nodes_block(n)))
+ n = new_Bad();
+
+ return n;
+}
+
+static ir_node *equivalent_node_Cond(ir_node *n)
+{
+ /* We do not evaluate Cond here as we replace it by a new node, a Jmp.
+ See cases for iro_Cond and iro_Proj in transform_node. */
+ return n;
+}
+
+/**
+ * optimize operations that are commutative and have neutral 0,
+ * so a op 0 = 0 op a = a.
+ */
+static ir_node *equivalent_node_neutral_zero(ir_node *n)
+{
+ ir_node *oldn = n;
+
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+
+ tarval *tv;
+ ir_node *on;
+
+ /* After running compute_node there is only one constant predecessor.
+ Find this predecessors value and remember the other node: */
+ if ((tv = value_of(a)) != tarval_bad) {
+ on = b;
+ } else if ((tv = value_of(b)) != tarval_bad) {
+ on = a;
+ } else
+ return n;
+
+ /* If this predecessors constant value is zero, the operation is
+ unnecessary. Remove it: */
+ if (classify_tarval (tv) == TV_CLASSIFY_NULL) {
+ n = on;
+
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ }
+
+ return n;
+}
+
+#define equivalent_node_Add equivalent_node_neutral_zero
+#define equivalent_node_Eor equivalent_node_neutral_zero
+
+/**
+ * optimize operations that are not commutative but have neutral 0 on left,
+ * so a op 0 = a.
+ */
+static ir_node *equivalent_node_left_zero(ir_node *n)
+{
+ ir_node *oldn = n;
+
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+
+ if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+ n = a;
+
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ }
+
+ return n;
+}
+
+#define equivalent_node_Sub equivalent_node_left_zero
+#define equivalent_node_Shl equivalent_node_left_zero
+#define equivalent_node_Shr equivalent_node_left_zero
+#define equivalent_node_Shrs equivalent_node_left_zero
+#define equivalent_node_Rot equivalent_node_left_zero
+
+/**
+ * Er, a "symmetic unop", ie op(op(n)) = n.
+ */
+static ir_node *equivalent_node_symmetric_unop(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_node *pred = get_unop_op(n);
+
+ /* optimize symmetric unop */
+ if (get_irn_op(pred) == get_irn_op(n)) {
+ n = get_unop_op(pred);
+ DBG_OPT_ALGSIM2(oldn, pred, n);
+ }
+ return n;
+}
+
+/* NotNot x == x */
+#define equivalent_node_Not equivalent_node_symmetric_unop
+
+/* --x == x */ /* ??? Is this possible or can --x raise an
+ out of bounds exception if min =! max? */
+#define equivalent_node_Minus equivalent_node_symmetric_unop
+
+/**
+ * Optimize a * 1 = 1 * a = a.
+ */
+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);
+
+ /* Mul is commutative and has again an other neutral element. */
+ if (classify_tarval(value_of(a)) == TV_CLASSIFY_ONE) {
+ n = b;
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ } else if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) {
+ n = a;
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ }
+ return n;
+}
+
+/**
+ * Optimize a / 1 = a.
+ */
+static ir_node *equivalent_node_Div(ir_node *n)
+{
+ ir_node *a = get_Div_left(n);
+ ir_node *b = get_Div_right(n);
+
+ /* Div is not commutative. */
+ 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);
+ turn_into_tuple(n, 3);
+ set_Tuple_pred(n, pn_Div_M, mem);
+ set_Tuple_pred(n, pn_Div_X_except, new_Bad()); /* no exception */
+ set_Tuple_pred(n, pn_Div_res, a);
+ }
+ return n;
+}
+
+/**
+ * Optimize a / 1 = a.
+ */
+static ir_node *equivalent_node_DivMod(ir_node *n)
+{
+ ir_node *a = get_DivMod_left(n);
+ ir_node *b = get_DivMod_right(n);
+
+ /* 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) */
+ ir_node *mem = get_Div_mem(n);
+ ir_mode *mode = get_irn_mode(b);
+
+ turn_into_tuple(n, 4);
+ set_Tuple_pred(n, pn_DivMod_M, mem);
+ set_Tuple_pred(n, pn_DivMod_X_except, new_Bad()); /* no exception */
+ set_Tuple_pred(n, pn_DivMod_res_div, a);
+ set_Tuple_pred(n, pn_DivMod_res_mod, new_Const(mode, get_mode_null(mode)));
+ }
+ return n;
+}
+
+/**
+ * Use algebraic simplification a | a = a | 0 = 0 | a = a.
+ */
+static ir_node *equivalent_node_Or(ir_node *n)
+{
+ ir_node *oldn = n;
+
+ ir_node *a = get_Or_left(n);
+ ir_node *b = get_Or_right(n);
+
+ if (a == b) {
+ n = a; /* Or has it's own neutral element */
+ } else if (classify_tarval(value_of(a)) == TV_CLASSIFY_NULL) {
+ n = b;
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ } else if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+ n = a;
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ }
+
+ return n;
+}
+
+/**
+ * Optimize a & 0b1...1 = 0b1...1 & a = a & a = a.
+ */
+static ir_node *equivalent_node_And(ir_node *n)
+{
+ ir_node *oldn = n;
+
+ ir_node *a = get_And_left(n);
+ ir_node *b = get_And_right(n);
+
+ if (a == b) {
+ n = a; /* And has it's own neutral element */
+ } else if (classify_tarval(value_of(a)) == TV_CLASSIFY_ALL_ONE) {
+ n = b;
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ } else if (classify_tarval(value_of(b)) == TV_CLASSIFY_ALL_ONE) {
+ n = a;
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ }
+ return n;
+}
+
+/**
+ * Try to remove useless conv's:
+ */
+static ir_node *equivalent_node_Conv(ir_node *n)
+{
+ ir_node *oldn = n;
+ ir_node *a = get_Conv_op(n);
+ ir_node *b;
+
+ ir_mode *n_mode = get_irn_mode(n);
+ ir_mode *a_mode = get_irn_mode(a);
+
+ if (n_mode == a_mode) { /* No Conv necessary */
+ n = a;
+ DBG_OPT_ALGSIM3(oldn, a, n);
+ } else if (get_irn_op(a) == op_Conv) { /* Conv(Conv(b)) */
+ ir_mode *b_mode;
+
+ b = get_Conv_op(a);
+ n_mode = get_irn_mode(n);
+ b_mode = get_irn_mode(b);
+
+ if (n_mode == b_mode) {
+ if (n_mode == mode_b) {
+ n = b; /* Convb(Conv*(xxxb(...))) == xxxb(...) */
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ }
+ else if (mode_is_int(n_mode) || mode_is_character(n_mode)) {
+ if (smaller_mode(b_mode, a_mode)){
+ n = b; /* ConvS(ConvL(xxxS(...))) == xxxS(...) */
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
+ }