+/**
+ * Transform a Div/Mod/DivMod with a non-zero constant. Must be
+ * done here to avoid that this optimization runs more than once...
+ */
+static ir_node *transform_node_Proj(ir_node *proj)
+{
+ ir_node *n = get_Proj_pred(proj);
+ ir_node *b;
+ tarval *tb;
+
+ switch (get_irn_opcode(n)) {
+ case iro_Div:
+ b = get_Div_right(n);
+ tb = computed_value(b);
+
+ if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* div(x, c) && c != 0 */
+ ir_node *div, *proj;
+ ir_node *a = get_Div_left(n);
+ ir_node *mem = get_Div_mem(n);
+ int rem = get_optimize();
+
+ set_optimize(0);
+ {
+ div = new_rd_Div(get_irn_dbg_info(n), current_ir_graph,
+ get_nodes_block(n), get_irg_initial_mem(current_ir_graph), a, b);
+
+ proj = new_r_Proj(current_ir_graph, get_nodes_block(n), div, get_irn_mode(a), pn_Div_res);
+ }
+ set_optimize(rem);
+
+ turn_into_tuple(n, 3);
+ set_Tuple_pred(n, pn_Mod_M, mem);
+ set_Tuple_pred(n, pn_Mod_X_except, new_Bad());
+ set_Tuple_pred(n, pn_Mod_res, proj);
+ }
+ break;
+ case iro_Mod:
+ b = get_Mod_right(n);
+ tb = computed_value(b);
+
+ if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* mod(x, c) && c != 0 */
+ ir_node *mod, *proj;
+ ir_node *a = get_Mod_left(n);
+ ir_node *mem = get_Mod_mem(n);
+ int rem = get_optimize();
+
+ set_optimize(0);
+ {
+ mod = new_rd_Mod(get_irn_dbg_info(n), current_ir_graph,
+ get_nodes_block(n), get_irg_initial_mem(current_ir_graph), a, b);
+
+ proj = new_r_Proj(current_ir_graph, get_nodes_block(n), mod, get_irn_mode(a), pn_Mod_res);
+ }
+ set_optimize(rem);
+
+ turn_into_tuple(n, 3);
+ set_Tuple_pred(n, pn_Mod_M, mem);
+ set_Tuple_pred(n, pn_Mod_X_except, new_Bad());
+ set_Tuple_pred(n, pn_Mod_res, proj);
+ }
+ break;
+ case iro_DivMod:
+ b = get_DivMod_right(n);
+ tb = computed_value(b);
+
+ if (tb != tarval_bad && classify_tarval(tb) != TV_CLASSIFY_NULL) { /* DivMod(x, c) && c != 0 */
+ ir_node *div_mod, *proj_div, *proj_mod;
+ ir_node *a = get_Mod_left(n);
+ ir_node *mem = get_Mod_mem(n);
+ int rem = get_optimize();
+
+ set_optimize(0);
+ {
+ div_mod = new_rd_DivMod(get_irn_dbg_info(n), current_ir_graph,
+ get_nodes_block(n), get_irg_initial_mem(current_ir_graph), a, b);
+
+ proj_div = new_r_Proj(current_ir_graph, get_nodes_block(n), div_mod, get_irn_mode(a), pn_DivMod_res_div);
+ proj_mod = new_r_Proj(current_ir_graph, get_nodes_block(n), div_mod, get_irn_mode(a), pn_DivMod_res_mod);
+ }
+ set_optimize(rem);
+
+ turn_into_tuple(n, 4);
+ set_Tuple_pred(n, pn_DivMod_M, mem);
+ set_Tuple_pred(n, pn_DivMod_X_except, new_Bad());
+ set_Tuple_pred(n, pn_DivMod_res_div, proj_div);
+ set_Tuple_pred(n, pn_DivMod_res_mod, proj_mod);
+ }
+ break;
+
+ case iro_Cond:
+ if (get_opt_unreachable_code()) {
+ b = get_Cond_selector(n);
+ tb = computed_value(b);
+
+ if (tb != tarval_bad && mode_is_int(get_tarval_mode(tb))) {
+ /* we have a constant switch */
+ long num = get_Proj_proj(proj);
+
+ if (num != get_Cond_defaultProj(n)) { /* we cannot optimize default Proj's yet */
+ if (get_tarval_long(tb) == num) {
+ /* Do NOT create a jump here, or we will have 2 control flow ops
+ * in a block. This case is optimized away in optimize_cf(). */
+ return proj;
+ }
+ else
+ return new_Bad();
+ }
+ }
+ }
+ return proj;
+
+ default:
+ /* do nothing */
+ return proj;
+ }
+
+ /* we have added a Tuple, optimize it for the current Proj away */
+ return equivalent_node_Proj(proj);
+}
+
+/**
+ * Transform a Store before a Store to the same address...
+ * Both nodes must be in the same block.
+ *
+ * @todo Check for volatile! Moreover, what if the first store
+ * has a exception handler while the other has not?
+ */
+static ir_node *transform_node_Store(ir_node *store)
+{
+ ir_node *pred = skip_Proj(get_Store_mem(store));
+ ir_node *ptr = get_Store_ptr(store);
+
+ if (get_irn_op(pred) == op_Store &&
+ get_Store_ptr(pred) == ptr &&
+ get_nodes_block(pred) == get_nodes_block(store)) {
+ /* the Store n is useless, as it is overwritten by the store store */
+ ir_node *mem = get_Store_mem(pred);
+
+ turn_into_tuple(pred, 2);
+ set_Tuple_pred(pred, pn_Store_M, mem);
+ set_Tuple_pred(pred, pn_Store_X_except, new_Bad());
+ }
+ return store;
+}
+
+/**
+ * returns the operands of a commutative bin-op, if one operand is
+ * a const, it is returned as the second one.
+ */
+static void get_comm_Binop_Ops(ir_node *binop, ir_node **a, ir_node **c)
+{
+ ir_node *op_a = get_binop_left(binop);
+ ir_node *op_b = get_binop_right(binop);
+
+ assert(is_op_commutative(get_irn_op(binop)));
+
+ if (get_irn_op(op_a) == op_Const) {
+ *a = op_b;
+ *c = op_a;
+ }
+ else {
+ *a = op_a;
+ *c = op_b;
+ }
+}
+
+/**
+ * Optimize a Or(And(Or(And(v,c4),c3),c2),c1) pattern if possible.
+ * Such pattern may arise in bitfield stores.
+ *
+ * value c4 value c4 & c2
+ * AND c3 AND c1 | c3
+ * OR c2 ===> OR
+ * AND c1
+ * OR
+ */
+static ir_node *transform_node_Or(ir_node *or)
+{
+ ir_node *and, *c1;
+ ir_node *or_l, *c2;
+ ir_node *and_l, *c3;
+ ir_node *value, *c4;
+ ir_node *new_and, *new_const, *block;
+ ir_mode *mode = get_irn_mode(or);
+
+ tarval *tv1, *tv2, *tv3, *tv4, *tv, *n_tv4, *n_tv2;
+
+ get_comm_Binop_Ops(or, &and, &c1);
+ if ((get_irn_op(c1) != op_Const) || (get_irn_op(and) != op_And))
+ return or;
+
+ get_comm_Binop_Ops(and, &or_l, &c2);
+ if ((get_irn_op(c2) != op_Const) || (get_irn_op(or_l) != op_Or))
+ return or;
+
+ get_comm_Binop_Ops(or_l, &and_l, &c3);
+ if ((get_irn_op(c3) != op_Const) || (get_irn_op(and_l) != op_And))
+ return or;
+
+ get_comm_Binop_Ops(and_l, &value, &c4);
+ if (get_irn_op(c4) != op_Const)
+ return or;
+
+ /* ok, found the pattern, check for conditions */
+ assert(mode == get_irn_mode(and));
+ assert(mode == get_irn_mode(or_l));
+ assert(mode == get_irn_mode(and_l));
+
+ tv1 = get_Const_tarval(c1);
+ tv2 = get_Const_tarval(c2);
+ tv3 = get_Const_tarval(c3);
+ tv4 = get_Const_tarval(c4);
+
+ tv = tarval_or(tv4, tv2);
+ if (classify_tarval(tv) != TV_CLASSIFY_ALL_ONE) {
+ /* have at least one 0 at the same bit position */
+ return or;
+ }
+
+ n_tv4 = tarval_not(tv4);
+ if (tv3 != tarval_and(tv3, n_tv4)) {
+ /* bit in the or_mask is outside the and_mask */
+ return or;
+ }
+
+ n_tv2 = tarval_not(tv2);
+ if (tv1 != tarval_and(tv1, n_tv2)) {
+ /* bit in the or_mask is outside the and_mask */
+ return or;
+ }
+
+ /* ok, all conditions met */
+ block = get_nodes_block(or);
+
+ new_and = new_r_And(current_ir_graph, block,
+ value, new_r_Const(current_ir_graph, block, mode, tarval_and(tv4, tv2)), mode);
+
+ new_const = new_r_Const(current_ir_graph, block, mode, tarval_or(tv3, tv1));
+
+ set_Or_left(or, new_and);
+ set_Or_right(or, new_const);
+
+ /* check for more */
+ return transform_node_Or(or);
+}