+/**
+ * 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_node_And */
+
+/**
+ * Transform an Eor.
+ */
+static ir_node *transform_node_Eor(ir_node *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),
+ mode, get_mode_null(mode));
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_A_A);
+ } else if ((mode == mode_b)
+ && (get_irn_op(a) == op_Proj)
+ && (get_irn_mode(a) == mode_b)
+ && (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)
+ && (get_irn_op(get_Proj_pred(a)) == op_Cmp)) {
+ /* The Eor negates a Cmp. The Cmp has the negated result anyways! */
+ n = new_r_Proj(current_ir_graph, get_irn_n(n, -1), get_Proj_pred(a),
+ mode_b, get_negated_pnc(get_Proj_proj(a), mode));
+
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT_BOOL);
+ } else if ((mode == mode_b)
+ && (classify_tarval (value_of(b)) == TV_CLASSIFY_ONE)) {
+ /* The Eor is a Not. Replace it by a Not. */
+ /* ????!!!Extend to bitfield 1111111. */
+ n = new_r_Not(current_ir_graph, get_irn_n(n, -1), a, mode_b);
+
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
+ }
+
+ return n;
+} /* transform_node_Eor */
+
+/**
+ * Transform a Not.
+ */
+static ir_node *transform_node_Not(ir_node *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)
+ && (get_irn_op(get_Proj_pred(a)) == op_Cmp)) {
+ /* We negate a Cmp. The Cmp has the negated result anyways! */
+ n = new_r_Proj(current_ir_graph, get_irn_n(n, -1), get_Proj_pred(a),
+ mode_b, get_negated_pnc(get_Proj_proj(a), mode_b));
+ DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_CMP);
+ }
+ return n;
+} /* transform_node_Not */
+
+/**
+ * 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;
+} /* transform_node_Minus */
+
+/**
+ * Transform a Cast_type(Const) into a new Const_type
+ */
+static ir_node *transform_node_Cast(ir_node *n) {
+ ir_node *oldn = n;
+ ir_node *pred = get_Cast_op(n);
+ ir_type *tp = get_irn_type(n);
+
+ if (get_irn_op(pred) == op_Const && get_Const_type(pred) != tp) {
+ n = new_rd_Const_type(NULL, current_ir_graph, get_irn_n(pred, -1), get_irn_mode(pred),
+ get_Const_tarval(pred), tp);
+ DBG_OPT_CSTEVAL(oldn, n);
+ } else if ((get_irn_op(pred) == op_SymConst) && (get_SymConst_value_type(pred) != tp)) {
+ n = new_rd_SymConst_type(NULL, current_ir_graph, get_irn_n(pred, -1), get_SymConst_symbol(pred),
+ get_SymConst_kind(pred), tp);
+ DBG_OPT_CSTEVAL(oldn, n);
+ }
+
+ return n;
+} /* transform_node_Cast */
+
+/**
+ * Transform a Proj(Div) with a non-zero value.
+ * 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;
+ 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) {
+ /* 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);
+
+ 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);
+ /* this is a Div without exception, we can remove the memory edge */
+ set_Div_mem(n, new_mem);
+ return res;
+ }
+ }
+ return proj;
+} /* transform_node_Proj_Div */
+
+/**
+ * Transform a Proj(Mod) with a non-zero value.
+ * 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;
+ 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) {
+ /* 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);
+
+ 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);
+ /* 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);
+ return res;
+ }
+ }
+ return proj;
+} /* transform_node_Proj_Mod */
+
+/**
+ * Transform a Proj(DivMod) with a non-zero value.
+ * 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;
+ 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) {
+ /* 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);
+
+ 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);
+ /* this is a DivMod without exception, we can remove the memory edge */
+ set_DivMod_mem(n, 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;
+ }
+ }
+ return proj;
+} /* transform_node_Proj_DivMod */
+
+/**
+ * Optimizes jump tables (CondIs or CondIu) by removing all impossible cases.
+ */
+static ir_node *transform_node_Proj_Cond(ir_node *proj) {
+ if (get_opt_unreachable_code()) {
+ ir_node *n = get_Proj_pred(proj);
+ ir_node *b = get_Cond_selector(n);
+
+ if (mode_is_int(get_irn_mode(b))) {
+ tarval *tb = value_of(b);
+
+ if (tb != tarval_bad) {
+ /* 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 {
+ /* this case will NEVER be taken, kill it */
+ return new_Bad();
+ }
+ }
+ }
+ }
+ }
+ return proj;
+} /* transform_node_Proj_Cond */