X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firopt.c;h=947d676572110bbb273571cd4238be8ca38db749;hb=936044658c1ca3e0d50a82778e50fcccdb23043f;hp=39d587debd7f9710f1484df6e342789bdbdd8d88;hpb=8b897e0674eb0e6100a19c2674ca744d2c8246aa;p=libfirm

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index 39d587deb..947d67657 100644
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -145,8 +145,7 @@ static tarval *computed_value_Carry(ir_node *n) {
 		tarval_add(ta, tb);
 		return tarval_carry() ? get_mode_one(m) : get_mode_null(m);
 	} else {
-		if (   (classify_tarval(ta) == TV_CLASSIFY_NULL)
-			|| (classify_tarval(tb) == TV_CLASSIFY_NULL))
+		if (tarval_is_null(ta) || tarval_is_null(tb))
 			return get_mode_null(m);
 	}
 	return tarval_bad;
@@ -166,7 +165,7 @@ static tarval *computed_value_Borrow(ir_node *n) {
 
 	if ((ta != tarval_bad) && (tb != tarval_bad)) {
 		return tarval_cmp(ta, tb) == pn_Cmp_Lt ? get_mode_one(m) : get_mode_null(m);
-	} else if (classify_tarval(ta) == TV_CLASSIFY_NULL) {
+	} else if (tarval_is_null(ta)) {
 		return get_mode_null(m);
 	}
 	return tarval_bad;
@@ -310,12 +309,8 @@ static tarval *computed_value_And(ir_node *n) {
 	if ((ta != tarval_bad) && (tb != tarval_bad)) {
 		return tarval_and (ta, tb);
 	} else {
-		tarval *v;
-
-		if (   (classify_tarval ((v = ta)) == TV_CLASSIFY_NULL)
-			|| (classify_tarval ((v = tb)) == TV_CLASSIFY_NULL)) {
-			return v;
-		}
+		if (tarval_is_null(ta)) return ta;
+		if (tarval_is_null(tb)) return tb;
 	}
 	return tarval_bad;
 }  /* computed_value_And */
@@ -334,11 +329,8 @@ static tarval *computed_value_Or(ir_node *n) {
 	if ((ta != tarval_bad) && (tb != tarval_bad)) {
 		return tarval_or (ta, tb);
 	} else {
-		tarval *v;
-		if (   (classify_tarval ((v = ta)) == TV_CLASSIFY_ALL_ONE)
-			|| (classify_tarval ((v = tb)) == TV_CLASSIFY_ALL_ONE)) {
-			return v;
-		}
+		if (tarval_is_all_one(ta)) return ta;
+		if (tarval_is_all_one(tb)) return tb;
 	}
 	return tarval_bad;
 }  /* computed_value_Or */
@@ -542,25 +534,25 @@ static tarval *computed_value_Proj_Cmp(ir_node *n) {
 			ir_node *aba = skip_Id(skip_Proj(ab));
 
 			if (   (   (/* aa is ProjP and aaa is Alloc */
-			               (get_irn_op(aa) == op_Proj)
-			            && (mode_is_reference(get_irn_mode(aa)))
-			            && (get_irn_op(aaa) == op_Alloc))
+			               is_Proj(aa)
+			            && mode_is_reference(get_irn_mode(aa))
+			            && is_Alloc(aaa))
 			        && (   (/* ab is NULL */
-			                   (get_irn_op(ab) == op_Const)
-			                && (mode_is_reference(get_irn_mode(ab)))
-			                && (get_Const_tarval(ab) == get_mode_null(get_irn_mode(ab))))
+			                   is_Const(ab)
+			                && mode_is_reference(get_irn_mode(ab))
+			                && is_Const_null(ab))
 			            || (/* ab is other Alloc */
-			                   (get_irn_op(ab) == op_Proj)
-			                && (mode_is_reference(get_irn_mode(ab)))
-			                && (get_irn_op(aba) == op_Alloc)
+			                   is_Proj(ab)
+			                && mode_is_reference(get_irn_mode(ab))
+			                && is_Alloc(aba)
 			                && (aaa != aba))))
 			    || (/* aa is NULL and aba is Alloc */
-			           (get_irn_op(aa) == op_Const)
-			        && (mode_is_reference(get_irn_mode(aa)))
-			        && (get_Const_tarval(aa) == get_mode_null(get_irn_mode(aa)))
-			        && (get_irn_op(ab) == op_Proj)
-			        && (mode_is_reference(get_irn_mode(ab)))
-			        && (get_irn_op(aba) == op_Alloc)))
+			           is_Const(aa)
+			        && mode_is_reference(get_irn_mode(aa))
+			        && is_Const_null(aa)
+			        && is_Proj(ab)
+			        && mode_is_reference(get_irn_mode(ab))
+			        && is_Alloc(aba)))
 				/* 3.: */
 			return new_tarval_from_long(proj_nr & pn_Cmp_Ne, mode_b);
 		}
@@ -742,7 +734,7 @@ static ir_node *equivalent_node_Block(ir_node *n)
 	   This should be true, as the block is matured before optimize is called.
 	   But what about Phi-cycles with the Phi0/Id that could not be resolved?
 	   Remaining Phi nodes are just Ids. */
-	if ((n_preds == 1) && (get_irn_op(get_Block_cfgpred(n, 0)) == op_Jmp)) {
+	if (n_preds == 1 && is_Jmp(get_Block_cfgpred(n, 0))) {
 		ir_node *predblock = get_nodes_block(get_Block_cfgpred(n, 0));
 		if (predblock == oldn) {
 			/* Jmp jumps into the block it is in -- deal self cycle. */
@@ -752,8 +744,7 @@ static ir_node *equivalent_node_Block(ir_node *n)
 			n = predblock;
 			DBG_OPT_STG(oldn, n);
 		}
-	} else if ((n_preds == 1) &&
-	           (get_irn_op(skip_Proj(get_Block_cfgpred(n, 0))) == op_Cond)) {
+	} else if (n_preds == 1 && is_Cond(skip_Proj(get_Block_cfgpred(n, 0)))) {
 		ir_node *predblock = get_Block_cfgpred_block(n, 0);
 		if (predblock == oldn) {
 			/* Jmp jumps into the block it is in -- deal self cycle. */
@@ -769,10 +760,10 @@ static ir_node *equivalent_node_Block(ir_node *n)
 		ir_node *a = get_Block_cfgpred(n, 0);
 		ir_node *b = get_Block_cfgpred(n, 1);
 
-		if ((get_irn_op(a) == op_Proj) &&
-		    (get_irn_op(b) == op_Proj) &&
+		if (is_Proj(a) &&
+		    is_Proj(b) &&
 		    (get_Proj_pred(a) == get_Proj_pred(b)) &&
-		    (get_irn_op(get_Proj_pred(a)) == op_Cond) &&
+		    is_Cond(get_Proj_pred(a)) &&
 		    (get_irn_mode(get_Cond_selector(get_Proj_pred(a))) == mode_b)) {
 			/* Also a single entry Block following a single exit Block.  Phis have
 			   twice the same operand and will be optimized away. */
@@ -859,12 +850,10 @@ static ir_node *equivalent_node_neutral_zero(ir_node *n)
 	 * which happens in this rare construction: NULL + 3.
 	 * Then, a Conv would be needed which we cannot include here.
 	 */
-	if (classify_tarval (tv) == TV_CLASSIFY_NULL) {
-		if (get_irn_mode(on) == get_irn_mode(n)) {
-			n = on;
+	if (tarval_is_null(tv) && get_irn_mode(on) == get_irn_mode(n)) {
+		n = on;
 
-			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
-		}
+		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
 	}
 
 	return n;
@@ -900,7 +889,7 @@ static ir_node *equivalent_node_Add(ir_node *n) {
 	left  = get_Add_left(n);
 	right = get_Add_right(n);
 
-	if (get_irn_op(left) == op_Sub) {
+	if (is_Sub(left)) {
 		if (get_Sub_right(left) == right) {
 			/* (a - x) + x */
 
@@ -911,7 +900,7 @@ static ir_node *equivalent_node_Add(ir_node *n) {
 			}
 		}
 	}
-	if (get_irn_op(right) == op_Sub) {
+	if (is_Sub(right)) {
 		if (get_Sub_right(right) == left) {
 			/* x + (a - x) */
 
@@ -935,7 +924,7 @@ static ir_node *equivalent_node_left_zero(ir_node *n) {
 	ir_node *a = get_binop_left(n);
 	ir_node *b = get_binop_right(n);
 
-	if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+	if (is_Const(b) && is_Const_null(b)) {
 		n = a;
 
 		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_0);
@@ -969,7 +958,7 @@ static ir_node *equivalent_node_Sub(ir_node *n) {
 	b = get_Sub_right(n);
 
 	/* Beware: modes might be different */
-	if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+	if (is_Const(b) && is_Const_null(b)) {
 		ir_node *a = get_Sub_left(n);
 		if (mode == get_irn_mode(a)) {
 			n = a;
@@ -1020,10 +1009,10 @@ static ir_node *equivalent_node_Mul(ir_node *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) {
+		if (is_Const(a) && is_Const_one(a)) {
 			n = b;
 			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_1);
-		} else if (classify_tarval(value_of(b)) == TV_CLASSIFY_ONE) {
+		} else if (is_Const(b) && is_Const_one(b)) {
 			n = a;
 			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_NEUTRAL_1);
 		}
@@ -1039,7 +1028,7 @@ static ir_node *equivalent_node_Div(ir_node *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 */
+	if (is_Const(b) && is_Const_one(b)) { /* div(x, 1) == x */
 		/* Turn Div into a tuple (mem, bad, a) */
 		ir_node *mem = get_Div_mem(n);
 		ir_node *blk = get_irn_n(n, -1);
@@ -1060,7 +1049,7 @@ static ir_node *equivalent_node_Quot(ir_node *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 */
+	if (is_Const(b) && is_Const_one(b)) { /* Quot(x, 1) == x */
 		/* Turn Quot into a tuple (mem, jmp, bad, a) */
 		ir_node *mem = get_Quot_mem(n);
 		ir_node *blk = get_irn_n(n, -1);
@@ -1080,7 +1069,7 @@ static ir_node *equivalent_node_DivMod(ir_node *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 */
+	if (is_Const(b) && is_Const_one(b)) { /* div(x, 1) == x */
 		/* Turn DivMod into a tuple (mem, jmp, bad, a, 0) */
 		ir_node *a = get_DivMod_left(n);
 		ir_node *mem = get_Div_mem(n);
@@ -1109,10 +1098,10 @@ static ir_node *equivalent_node_Or(ir_node *n) {
 	if (a == b) {
 		n = a;    /* Or has it's own neutral element */
 		DBG_OPT_ALGSIM0(oldn, n, FS_OPT_OR);
-	} else if (classify_tarval(value_of(a)) == TV_CLASSIFY_NULL) {
+	} else if (is_Const(a) && is_Const_null(a)) {
 		n = b;
 		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_OR);
-	} else if (classify_tarval(value_of(b)) == TV_CLASSIFY_NULL) {
+	} else if (is_Const(b) && is_Const_null(b)) {
 		n = a;
 		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_OR);
 	}
@@ -1134,12 +1123,12 @@ static ir_node *equivalent_node_And(ir_node *n) {
 		DBG_OPT_ALGSIM0(oldn, n, FS_OPT_AND);
 		return n;
 	}
-	if (classify_tarval(value_of(a)) == TV_CLASSIFY_ALL_ONE) {
+	if (is_Const(a) && is_Const_all_one(a)) {
 		n = b;
 		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
 		return n;
 	}
-	if (classify_tarval(value_of(b)) == TV_CLASSIFY_ALL_ONE) {
+	if (is_Const(b) && is_Const_all_one(b)) {
 		n = a;
 		DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_AND);
 		return n;
@@ -1192,7 +1181,7 @@ static ir_node *equivalent_node_Conv(ir_node *n) {
 		}
 		n = a;
 		DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CONV);
-	} else if (get_irn_op(a) == op_Conv) { /* Conv(Conv(b)) */
+	} else if (is_Conv(a)) { /* Conv(Conv(b)) */
 		ir_mode *b_mode;
 
 		b = get_Conv_op(a);
@@ -1357,7 +1346,7 @@ 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 (is_Tuple(a)) {
 		/* Remove the Tuple/Proj combination. */
 		if ( get_Proj_proj(proj) <= get_Tuple_n_preds(a) ) {
 			proj = get_Tuple_pred(a, get_Proj_proj(proj));
@@ -1372,9 +1361,7 @@ static ir_node *equivalent_node_Proj(ir_node *proj) {
 			/* Remove dead control flow -- early gigo(). */
 			proj = new_Bad();
 		} else if (get_opt_ldst_only_null_ptr_exceptions()) {
-			ir_op *op = get_irn_op(a);
-
-			if (op == op_Load) {
+			if (is_Load(a)) {
 				/* get the Load address */
 				ir_node *addr = get_Load_ptr(a);
 				ir_node *blk  = get_irn_n(a, -1);
@@ -1391,7 +1378,7 @@ static ir_node *equivalent_node_Proj(ir_node *proj) {
 					} else
 						return new_r_Jmp(current_ir_graph, blk);
 				}
-			} else if (op == op_Store) {
+			} else if (is_Store(a)) {
 				/* get the load/store address */
 				ir_node *addr = get_Store_ptr(a);
 				ir_node *blk  = get_irn_n(a, -1);
@@ -1452,7 +1439,7 @@ static ir_node *equivalent_node_Mux(ir_node *n)
 		n = get_Mux_true(n);
 		DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_EQ);
 	}
-	else if (get_irn_op(sel) == op_Proj && !mode_honor_signed_zeros(get_irn_mode(n))) {
+	else if (is_Proj(sel) && !mode_honor_signed_zeros(get_irn_mode(n))) {
 		ir_node *cmp = get_Proj_pred(sel);
 		long proj_nr = get_Proj_proj(sel);
 		ir_node *b   = get_Mux_false(n);
@@ -1466,10 +1453,11 @@ static ir_node *equivalent_node_Mux(ir_node *n)
 		 * with NaN's because -NaN == NaN.
 		 * However, if +0 and -0 is handled differently, we cannot use the first one.
 		 */
-		if (get_irn_op(cmp) == op_Cmp && get_Cmp_left(cmp) == a) {
-			if (classify_Const(get_Cmp_right(cmp)) == CNST_NULL) {
+		if (is_Cmp(cmp) && get_Cmp_left(cmp) == a) {
+			ir_node *cmp_r = get_Cmp_right(cmp);
+			if (is_Const(cmp_r) && is_Const_null(cmp_r)) {
 				/* Mux(a CMP 0, X, a) */
-				if (get_irn_op(b) == op_Minus && get_Minus_op(b) == a) {
+				if (is_Minus(b) && get_Minus_op(b) == a) {
 					/* Mux(a CMP 0, -a, a) */
 					if (proj_nr == pn_Cmp_Eq) {
 						/* Mux(a == 0, -a, a)  ==>  -a */
@@ -1480,7 +1468,7 @@ static ir_node *equivalent_node_Mux(ir_node *n)
 						n = a;
 						DBG_OPT_ALGSIM0(oldn, n, FS_OPT_MUX_TRANSFORM);
 					}
-				} else if (classify_Const(b) == CNST_NULL) {
+				} else if (is_Const(b) && is_Const_null(b)) {
 					/* Mux(a CMP 0, 0, a) */
 					if (proj_nr == pn_Cmp_Lg || proj_nr == pn_Cmp_Ne) {
 						/* Mux(a != 0, 0, a) ==> a */
@@ -1540,7 +1528,7 @@ static ir_node *equivalent_node_Confirm(ir_node *n) {
 	ir_node *pred = get_Confirm_value(n);
 	pn_Cmp  pnc   = get_Confirm_cmp(n);
 
-	if (get_irn_op(pred) == op_Confirm && pnc == get_Confirm_cmp(pred)) {
+	if (is_Confirm(pred) && pnc == get_Confirm_cmp(pred)) {
 		/*
 		 * rare case: two identical Confirms one after another,
 		 * replace the second one with the first.
@@ -1817,7 +1805,7 @@ static ir_node *transform_node_AddSub(ir_node *n) {
 		ir_node *right = get_binop_right(n);
 		int ref_bits   = get_mode_size_bits(mode);
 
-		if (get_irn_op(left) == op_Conv) {
+		if (is_Conv(left)) {
 			ir_mode *mode = get_irn_mode(left);
 			int bits      = get_mode_size_bits(mode);
 
@@ -1840,7 +1828,7 @@ static ir_node *transform_node_AddSub(ir_node *n) {
 			}
 		}
 
-		if (get_irn_op(right) == op_Conv) {
+		if (is_Conv(right)) {
 			ir_mode *mode = get_irn_mode(right);
 			int bits      = get_mode_size_bits(mode);
 
@@ -1920,7 +1908,7 @@ static ir_node *transform_node_Add(ir_node *n) {
 
 	if (mode_is_num(mode)) {
 		/* the following code leads to endless recursion when Mul are replaced by a simple instruction chain */
-		if (!get_opt_arch_dep_running() && a == b && mode_is_int(mode)) {
+		if (!is_arch_dep_running() && a == b && mode_is_int(mode)) {
 			ir_node *block = get_irn_n(n, -1);
 
 			n = new_rd_Mul(
@@ -1955,7 +1943,7 @@ static ir_node *transform_node_Add(ir_node *n) {
 			DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_MINUS_B);
 			return n;
 		}
-		if (! get_opt_reassociation()) {
+		if (! is_reassoc_running()) {
 			/* do NOT execute this code if reassociation is enabled, it does the inverse! */
 			if (is_Mul(a)) {
 				ir_node *ma = get_Mul_left(a);
@@ -2028,7 +2016,7 @@ static ir_node *transform_node_Add(ir_node *n) {
 			if (is_Not(a)) {
 				ir_node *op = get_Not_op(a);
 
-				if (classify_Const(b) == CNST_ONE) {
+				if (is_Const(b) && is_Const_one(b)) {
 					/* ~x + 1 = -x */
 					ir_node *blk = get_irn_n(n, -1);
 					n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, blk, op, mode);
@@ -2047,7 +2035,7 @@ static ir_node *transform_node_Add(ir_node *n) {
 				ir_node *op = get_Not_op(b);
 
 				if (op == a) {
-					/* ~x + x = -1 */
+					/* x + ~x = -1 */
 					ir_node *blk = get_irn_n(n, -1);
 					n = new_r_Const(current_ir_graph, blk, mode, get_mode_minus_one(mode));
 					DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_X_NOT_X);
@@ -2172,7 +2160,7 @@ 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)) {
+	if (mode_is_num(mode) && mode == get_irn_mode(a) && is_Const(a) && is_Const_null(a)) {
 		n = new_rd_Minus(
 				get_irn_dbg_info(n),
 				current_ir_graph,
@@ -2259,7 +2247,7 @@ restart:
 		}
 	}
 	/* do NOT execute this code if reassociation is enabled, it does the inverse! */
-	if (get_opt_reassociation() && get_irn_op(a) == op_Mul) {
+	if (!is_reassoc_running() && is_Mul(a)) {
 		ir_node *ma = get_Mul_left(a);
 		ir_node *mb = get_Mul_right(a);
 
@@ -2295,21 +2283,22 @@ restart:
 			return n;
 		}
 	}
-	if (is_Sub(a)) {
-		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);
+	if (is_Sub(a)) { /* (x - y) - b -> x - (y + b) */
+		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_mode *add_mode;
 		ir_node *add;
 
 		/* Determine the right mode for the Add. */
 		if (m_b == m_y)
-			mode = m_b;
+			add_mode = m_b;
 		else if (mode_is_reference(m_b))
-			mode = m_b;
+			add_mode = m_b;
 		else if (mode_is_reference(m_y))
-			mode = m_y;
+			add_mode = m_y;
 		else {
 			/*
 			 * Both modes are different but none is reference,
@@ -2320,7 +2309,7 @@ restart:
 			return n;
 		}
 
-		add = new_r_Add(current_ir_graph, blk, y, b, mode);
+		add = new_r_Add(current_ir_graph, blk, y, b, add_mode);
 
 		n = new_rd_Sub(get_irn_dbg_info(n), current_ir_graph, blk, x, add, mode);
 		DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_SUB_X_Y_Z);
@@ -2422,24 +2411,24 @@ static ir_node *transform_node_Mul(ir_node *n) {
 		if (is_Const(b)) { /* (-a) * const -> a * -const */
 			ir_node *cnst = const_negate(b);
 			if (cnst != NULL) {
-				dbg_info *dbgi  = get_irn_dbg_info(b);
-				ir_node  *block = get_nodes_block(b);
+				dbg_info *dbgi  = get_irn_dbg_info(n);
+				ir_node  *block = get_nodes_block(n);
 				n = new_rd_Mul(dbgi, current_ir_graph, block, get_Minus_op(a), cnst, mode);
 				DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_MUL_MINUS_1);
 				return n;
 			}
 		} else if (is_Minus(b)) { /* (-a) * (-b) -> a * b */
-			dbg_info *dbgi  = get_irn_dbg_info(b);
-			ir_node  *block = get_nodes_block(b);
+			dbg_info *dbgi  = get_irn_dbg_info(n);
+			ir_node  *block = get_nodes_block(n);
 			n = new_rd_Mul(dbgi, current_ir_graph, block, get_Minus_op(a), get_Minus_op(b), mode);
 			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_MUL_MINUS_MINUS);
 			return n;
 		} else if (is_Sub(b)) { /* (-a) * (b - c) -> a * (c - b) */
 			ir_node  *sub_l = get_Sub_left(b);
 			ir_node  *sub_r = get_Sub_right(b);
-			dbg_info *dbgi  = get_irn_dbg_info(b);
+			dbg_info *dbgi  = get_irn_dbg_info(n);
 			ir_graph *irg   = current_ir_graph;
-			ir_node  *block = get_nodes_block(b);
+			ir_node  *block = get_nodes_block(n);
 			ir_node  *new_b = new_rd_Sub(dbgi, irg, block, sub_r, sub_l, mode);
 			n = new_rd_Mul(dbgi, irg, block, get_Minus_op(a), new_b, mode);
 			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_MUL_MINUS);
@@ -2449,9 +2438,9 @@ static ir_node *transform_node_Mul(ir_node *n) {
 		if (is_Sub(a)) { /* (a - b) * (-c) -> (b - a) * c */
 			ir_node  *sub_l = get_Sub_left(a);
 			ir_node  *sub_r = get_Sub_right(a);
-			dbg_info *dbgi  = get_irn_dbg_info(a);
+			dbg_info *dbgi  = get_irn_dbg_info(n);
 			ir_graph *irg   = current_ir_graph;
-			ir_node  *block = get_nodes_block(a);
+			ir_node  *block = get_nodes_block(n);
 			ir_node  *new_a = new_rd_Sub(dbgi, irg, block, sub_r, sub_l, mode);
 			n = new_rd_Mul(dbgi, irg, block, new_a, get_Minus_op(b), mode);
 			DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_MUL_MINUS);
@@ -2964,7 +2953,7 @@ static ir_node *transform_node_And(ir_node *n) {
 			dbg_info *dbg  = get_irn_dbg_info(n);
 			ir_node *block = get_nodes_block(n);
 
-			ar = new_rd_Minus(dbg, current_ir_graph, block, ar, mode);
+			ar = new_rd_Not(dbg, current_ir_graph, block, ar, mode);
 			n  = new_rd_And(dbg, current_ir_graph, block, ar, b, mode);
 			DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
 			return n;
@@ -2974,7 +2963,7 @@ static ir_node *transform_node_And(ir_node *n) {
 			dbg_info *dbg  = get_irn_dbg_info(n);
 			ir_node *block = get_nodes_block(n);
 
-			al = new_rd_Minus(dbg, current_ir_graph, block, al, mode);
+			al = new_rd_Not(dbg, current_ir_graph, block, al, mode);
 			n  = new_rd_And(dbg, current_ir_graph, block, al, b, mode);
 			DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
 			return n;
@@ -2989,7 +2978,7 @@ static ir_node *transform_node_And(ir_node *n) {
 			dbg_info *dbg  = get_irn_dbg_info(n);
 			ir_node *block = get_nodes_block(n);
 
-			br = new_rd_Minus(dbg, current_ir_graph, block, br, mode);
+			br = new_rd_Not(dbg, current_ir_graph, block, br, mode);
 			n  = new_rd_And(dbg, current_ir_graph, block, br, a, mode);
 			DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
 			return n;
@@ -2999,7 +2988,7 @@ static ir_node *transform_node_And(ir_node *n) {
 			dbg_info *dbg  = get_irn_dbg_info(n);
 			ir_node *block = get_nodes_block(n);
 
-			bl = new_rd_Minus(dbg, current_ir_graph, block, bl, mode);
+			bl = new_rd_Not(dbg, current_ir_graph, block, bl, mode);
 			n  = new_rd_And(dbg, current_ir_graph, block, bl, a, mode);
 			DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
 			return n;
@@ -3035,7 +3024,7 @@ static ir_node *transform_node_Eor(ir_node *n) {
 	HANDLE_BINOP_PHI(tarval_eor, a,b,c);
 
 	/* we can evaluate 2 Projs of the same Cmp */
-	if(get_irn_mode(n) == mode_b && is_Proj(a) && is_Proj(b)) {
+	if (mode == mode_b && is_Proj(a) && is_Proj(b)) {
 		ir_node *pred_a = get_Proj_pred(a);
 		ir_node *pred_b = get_Proj_pred(b);
 		if(pred_a == pred_b) {
@@ -3056,23 +3045,29 @@ static ir_node *transform_node_Eor(ir_node *n) {
 		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)) {
+	} else if (mode == mode_b &&
+			is_Proj(a) &&
+			is_Const(b) && is_Const_one(b) &&
+			is_Cmp(get_Proj_pred(a))) {
 		/* 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);
+	} else if (is_Const(b)) {
+		if (is_Not(a)) { /* ~x ^ const -> x ^ ~const */
+			ir_node  *cnst   = new_Const(mode, tarval_not(get_Const_tarval(b)));
+			ir_node  *not_op = get_Not_op(a);
+			dbg_info *dbg    = get_irn_dbg_info(n);
+			ir_graph *irg    = current_ir_graph;
+			ir_node  *block  = get_nodes_block(n);
+			ir_mode  *mode   = get_irn_mode(n);
+			n = new_rd_Eor(dbg, irg, block, not_op, cnst, mode);
+			return n;
+		} else if (is_Const_all_one(b)) { /* x ^ 1...1 -> ~1 */
+			n = new_r_Not(current_ir_graph, get_nodes_block(n), a, mode);
+			DBG_OPT_ALGSIM0(oldn, n, FS_OPT_EOR_TO_NOT);
+		}
 	} else {
 		n = transform_bitwise_distributive(n, transform_node_Eor);
 	}
@@ -3085,28 +3080,52 @@ static ir_node *transform_node_Eor(ir_node *n) {
  */
 static ir_node *transform_node_Not(ir_node *n) {
 	ir_node *c, *oldn = n;
-	ir_node *a = get_Not_op(n);
-	ir_op *op_a = get_irn_op(a);
+	ir_node *a    = get_Not_op(n);
+	ir_mode *mode = get_irn_mode(n);
 
 	HANDLE_UNOP_PHI(tarval_not,a,c);
 
 	/* check for a boolean Not */
-	if (   (get_irn_mode(n) == mode_b)
-	    && (op_a == op_Proj)
-	    && (get_irn_mode(a) == mode_b)
-	    && (get_irn_op(get_Proj_pred(a)) == op_Cmp)) {
+	if (mode == mode_b &&
+			is_Proj(a) &&
+			is_Cmp(get_Proj_pred(a))) {
 		/* 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;
+		return n;
 	}
-	if (op_a == op_Sub && classify_Const(get_Sub_right(a)) == CNST_ONE) {
-		/* ~(x-1) = -x */
-		ir_node *op = get_Sub_left(a);
-		ir_node *blk = get_irn_n(n, -1);
-		n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, blk, op, get_irn_mode(n));
-		DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_MINUS_1);
+	if  (is_Eor(a)) {
+		ir_node *eor_b = get_Eor_right(a);
+		if (is_Const(eor_b)) { /* ~(x ^ const) -> x ^ ~const */
+			ir_node  *cnst  = new_Const(mode, tarval_not(get_Const_tarval(eor_b)));
+			ir_node  *eor_a = get_Eor_left(a);
+			dbg_info *dbg   = get_irn_dbg_info(n);
+			ir_graph *irg   = current_ir_graph;
+			ir_node  *block = get_nodes_block(n);
+			ir_mode  *mode  = get_irn_mode(n);
+			n = new_rd_Eor(dbg, irg, block, eor_a, cnst, mode);
+			return n;
+		}
+	}
+	if (get_mode_arithmetic(mode) == irma_twos_complement) {
+		if (is_Minus(a)) { /* ~-x -> x + -1 */
+			dbg_info *dbg   = get_irn_dbg_info(n);
+			ir_graph *irg   = current_ir_graph;
+			ir_node  *block = get_nodes_block(n);
+			ir_node  *add_l = get_Minus_op(a);
+			ir_node  *add_r = new_rd_Const(dbg, irg, block, mode, get_mode_minus_one(mode));
+			n = new_rd_Add(dbg, irg, block, add_l, add_r, mode);
+		} else if (is_Add(a)) {
+			ir_node *add_r = get_Add_right(a);
+			if (is_Const(add_r) && is_Const_all_one(add_r)) {
+				/* ~(x + -1) = -x */
+				ir_node *op = get_Add_left(a);
+				ir_node *blk = get_irn_n(n, -1);
+				n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph, blk, op, get_irn_mode(n));
+				DBG_OPT_ALGSIM0(oldn, n, FS_OPT_NOT_MINUS_1);
+			}
+		}
 	}
 	return n;
 }  /* transform_node_Not */
@@ -3181,6 +3200,20 @@ static ir_node *transform_node_Minus(ir_node *n) {
 		return n;
 	}
 
+	if (is_Mul(a)) { /* -(a * const) -> a * -const */
+		ir_node *mul_l = get_Mul_left(a);
+		ir_node *mul_r = get_Mul_right(a);
+		if (is_Const(mul_r)) {
+			tarval   *tv    = tarval_neg(get_Const_tarval(mul_r));
+			ir_node  *cnst  = new_Const(mode, tv);
+			dbg_info *dbg   = get_irn_dbg_info(a);
+			ir_graph *irg   = current_ir_graph;
+			ir_node  *block = get_nodes_block(a);
+			n = new_rd_Mul(dbg, irg, block, mul_l, cnst, mode);
+			return n;
+		}
+	}
+
 	return n;
 }  /* transform_node_Minus */
 
@@ -3192,11 +3225,11 @@ static ir_node *transform_node_Cast(ir_node *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) {
+	if (is_Const(pred) && 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)) {
+	} else if (is_SymConst(pred) && 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);
@@ -3432,6 +3465,21 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 		}
 	}
 
+	/* TODO extend to arbitrary constants */
+	if (is_Conv(left) && is_Const(right) && is_Const_null(right)) {
+		ir_mode* mode    = get_irn_mode(left);
+		ir_node* op      = get_Conv_op(left);
+		ir_mode* op_mode = get_irn_mode(op);
+
+		if (get_mode_size_bits(mode) > get_mode_size_bits(op_mode) &&
+				(mode_is_signed(mode) || !mode_is_signed(op_mode))) {
+			ir_node  *null  = new_Const(op_mode, get_mode_null(op_mode));
+			set_Cmp_left( n, op);
+			set_Cmp_right(n, null);
+			return proj;
+		}
+	}
+
 	/* remove Casts */
 	if (is_Cast(left))
 		left = get_Cast_op(left);
@@ -3511,7 +3559,6 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 			default:
 				break;
 			}
-
 		}
 	}
 
@@ -3630,7 +3677,7 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 				if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
 
 					/* a-b == 0  ==>  a == b,  a-b != 0  ==>  a != b */
-					if (classify_tarval(tv) == TV_CLASSIFY_NULL && is_Sub(left)) {
+					if (tarval_is_null(tv) && is_Sub(left)) {
 						right =get_Sub_right(left);
 						left  = get_Sub_left(left);
 
@@ -3639,10 +3686,8 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 					}
 
 					if (tv != tarval_bad) {
-						ir_op *op = get_irn_op(left);
-
 						/* a-c1 == c2  ==>  a == c2+c1,  a-c1 != c2  ==>  a != c2+c1 */
-						if (op == op_Sub) {
+						if (is_Sub(left)) {
 							ir_node *c1 = get_Sub_right(left);
 							tarval *tv2 = value_of(c1);
 
@@ -3657,13 +3702,13 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 							}
 						}
 						/* a+c1 == c2  ==>  a == c2-c1,  a+c1 != c2  ==>  a != c2-c1 */
-						else if (op == op_Add) {
+						else if (is_Add(left)) {
 							ir_node *a_l = get_Add_left(left);
 							ir_node *a_r = get_Add_right(left);
 							ir_node *a;
 							tarval *tv2;
 
-							if (get_irn_op(a_l) == op_Const) {
+							if (is_Const(a_l)) {
 								a = a_r;
 								tv2 = value_of(a_l);
 							} else {
@@ -3682,7 +3727,7 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 							}
 						}
 						/* -a == c ==> a == -c, -a != c ==> a != -c */
-						else if (op == op_Minus) {
+						else if (is_Minus(left)) {
 							tarval *tv2 = tarval_sub(get_mode_null(mode), tv);
 
 							if (tv2 != tarval_bad) {
@@ -3696,10 +3741,8 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 				/* the following reassociations work only for <= */
 				else if (proj_nr == pn_Cmp_Le || proj_nr == pn_Cmp_Lt) {
 					if (tv != tarval_bad) {
-						ir_op *op = get_irn_op(left);
-
 						/* c >= 0 : Abs(a) <= c  ==>  (unsigned)(a + c) <= 2*c */
-						if (op == op_Abs) {
+						if (get_irn_op(left) == op_Abs) { // TODO something is missing here
 						}
 					}
 				}
@@ -3833,7 +3876,7 @@ static void get_comm_Binop_Ops(ir_node *binop, ir_node **a, ir_node **c) {
 
 	assert(is_op_commutative(get_irn_op(binop)));
 
-	if (get_irn_op(op_a) == op_Const) {
+	if (is_Const(op_a)) {
 		*a = op_b;
 		*c = op_a;
 	} else {
@@ -3880,8 +3923,8 @@ static ir_node *transform_node_Or_bf_store(ir_node *or) {
 		tv2 = get_Const_tarval(c2);
 
 		tv = tarval_or(tv1, tv2);
-		if (classify_tarval(tv) == TV_CLASSIFY_ALL_ONE) {
-			/* the AND does NOT clear a bit with isn't set be the OR */
+		if (tarval_is_all_one(tv)) {
+			/* the AND does NOT clear a bit with isn't set by the OR */
 			set_Or_left(or, or_l);
 			set_Or_right(or, c1);
 
@@ -3909,7 +3952,7 @@ static ir_node *transform_node_Or_bf_store(ir_node *or) {
 		tv4 = get_Const_tarval(c4);
 
 		tv = tarval_or(tv4, tv2);
-		if (classify_tarval(tv) != TV_CLASSIFY_ALL_ONE) {
+		if (!tarval_is_all_one(tv)) {
 			/* have at least one 0 at the same bit position */
 			return or;
 		}
@@ -3956,16 +3999,16 @@ static ir_node *transform_node_Or_Rot(ir_node *or) {
 	shl = get_binop_left(or);
 	shr = get_binop_right(or);
 
-	if (get_irn_op(shl) == op_Shr) {
-		if (get_irn_op(shr) != op_Shl)
+	if (is_Shr(shl)) {
+		if (!is_Shl(shr))
 			return or;
 
 		irn = shl;
 		shl = shr;
 		shr = irn;
-	} else if (get_irn_op(shl) != op_Shl) {
+	} else if (!is_Shl(shl)) {
 		return or;
-	} else if (get_irn_op(shr) != op_Shr) {
+	} else if (!is_Shr(shr)) {
 		return or;
 	}
 	x = get_Shl_left(shl);
@@ -3974,7 +4017,7 @@ static ir_node *transform_node_Or_Rot(ir_node *or) {
 
 	c1 = get_Shl_right(shl);
 	c2 = get_Shr_right(shr);
-	if (get_irn_op(c1) == op_Const && get_irn_op(c2) == op_Const) {
+	if (is_Const(c1) && is_Const(c2)) {
 		tv1 = get_Const_tarval(c1);
 		if (! tarval_is_long(tv1))
 			return or;
@@ -3994,7 +4037,7 @@ static ir_node *transform_node_Or_Rot(ir_node *or) {
 
 		DBG_OPT_ALGSIM1(or, shl, shr, n, FS_OPT_OR_SHFT_TO_ROT);
 		return n;
-	} else if (get_irn_op(c1) == op_Sub) {
+	} else if (is_Sub(c1)) {
 		v   = c2;
 		sub = c1;
 
@@ -4002,7 +4045,7 @@ static ir_node *transform_node_Or_Rot(ir_node *or) {
 			return or;
 
 		c1 = get_Sub_left(sub);
-		if (get_irn_op(c1) != op_Const)
+		if (!is_Const(c1))
 			return or;
 
 		tv1 = get_Const_tarval(c1);
@@ -4020,12 +4063,12 @@ static ir_node *transform_node_Or_Rot(ir_node *or) {
 
 		DBG_OPT_ALGSIM0(or, n, FS_OPT_OR_SHFT_TO_ROT);
 		return n;
-	} else if (get_irn_op(c2) == op_Sub) {
+	} else if (is_Sub(c2)) {
 		v   = c1;
 		sub = c2;
 
 		c1 = get_Sub_left(sub);
-		if (get_irn_op(c1) != op_Const)
+		if (!is_Const(c1))
 			return or;
 
 		tv1 = get_Const_tarval(c1);
@@ -4289,7 +4332,7 @@ static ir_node *transform_node_Mux(ir_node *n) {
 		}
 	}
 
-	if (get_irn_op(sel) == op_Proj && !mode_honor_signed_zeros(mode)) {
+	if (is_Proj(sel) && !mode_honor_signed_zeros(mode)) {
 		ir_node *cmp = get_Proj_pred(sel);
 		long     pn  = get_Proj_proj(sel);
 		ir_node *f   = get_Mux_false(n);
@@ -4304,77 +4347,79 @@ static ir_node *transform_node_Mux(ir_node *n) {
 		 * However, if +0 and -0 is handled differently, we cannot use the first
 		 * one.
 		 */
-		if (get_irn_op(cmp) == op_Cmp
-				&& classify_Const(get_Cmp_right(cmp)) == CNST_NULL) {
-			ir_node *block    = get_irn_n(n, -1);
-
-			if(is_negated_value(f, t)) {
-				ir_node *cmp_left = get_Cmp_left(cmp);
-
-				/* Psi(a >= 0, a, -a) = Psi(a <= 0, -a, a) ==> Abs(a) */
-				if ( (cmp_left == t && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt))
-					|| (cmp_left == f && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt)))
-				{
-					n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
-								   cmp_left, mode);
-					DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
-					return n;
-				/* Psi(a <= 0, a, -a) = Psi(a >= 0, -a, a) ==> -Abs(a) */
-				} else if ((cmp_left == t && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt))
-					|| (cmp_left == f && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt)))
-				{
-					n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
-								   cmp_left, mode);
-					n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph,
-					                 block, n, mode);
-					DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
-					return n;
+		if (is_Cmp(cmp)) {
+			ir_node *cmp_r = get_Cmp_right(cmp);
+			if (is_Const(cmp_r) && is_Const_null(cmp_r)) {
+				ir_node *block    = get_irn_n(n, -1);
+
+				if(is_negated_value(f, t)) {
+					ir_node *cmp_left = get_Cmp_left(cmp);
+
+					/* Psi(a >= 0, a, -a) = Psi(a <= 0, -a, a) ==> Abs(a) */
+					if ( (cmp_left == t && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt))
+						|| (cmp_left == f && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt)))
+					{
+						n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
+										 cmp_left, mode);
+						DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
+						return n;
+					/* Psi(a <= 0, a, -a) = Psi(a >= 0, -a, a) ==> -Abs(a) */
+					} else if ((cmp_left == t && (pn == pn_Cmp_Le || pn == pn_Cmp_Lt))
+						|| (cmp_left == f && (pn == pn_Cmp_Ge || pn == pn_Cmp_Gt)))
+					{
+						n = new_rd_Abs(get_irn_dbg_info(n), current_ir_graph, block,
+										 cmp_left, mode);
+						n = new_rd_Minus(get_irn_dbg_info(n), current_ir_graph,
+														 block, n, mode);
+						DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
+						return n;
+					}
 				}
-			}
 
-			if (mode_is_int(mode) && mode_is_signed(mode) &&
-				get_mode_arithmetic(mode) == irma_twos_complement) {
-				ir_node *x = get_Cmp_left(cmp);
+				if (mode_is_int(mode) && mode_is_signed(mode) &&
+					get_mode_arithmetic(mode) == irma_twos_complement) {
+					ir_node *x = get_Cmp_left(cmp);
 
-				/* the following optimization works only with signed integer two-complement mode */
+					/* the following optimization works only with signed integer two-complement mode */
 
-				if (mode == get_irn_mode(x)) {
-					/*
-					 * FIXME: this restriction is two rigid, as it would still
-					 * work if mode(x) = Hs and mode == Is, but at least it removes
-					 * all wrong cases.
-					 */
-					if ((pn == pn_Cmp_Lt || pn == pn_Cmp_Le) &&
-					    classify_Const(t) == CNST_ALL_ONE &&
-					    classify_Const(f) == CNST_NULL) {
+					if (mode == get_irn_mode(x)) {
 						/*
-						 * Mux(x:T </<= 0, 0, -1) -> Shrs(x, sizeof_bits(T) - 1)
-						 * Conditions:
-						 * T must be signed.
+						 * FIXME: this restriction is two rigid, as it would still
+						 * work if mode(x) = Hs and mode == Is, but at least it removes
+						 * all wrong cases.
 						 */
-						n = new_rd_Shrs(get_irn_dbg_info(n),
-								current_ir_graph, block, x,
+						if ((pn == pn_Cmp_Lt || pn == pn_Cmp_Le) &&
+								is_Const(t) && is_Const_all_one(t) &&
+								is_Const(f) && is_Const_null(f)) {
+							/*
+							 * Mux(x:T </<= 0, 0, -1) -> Shrs(x, sizeof_bits(T) - 1)
+							 * Conditions:
+							 * T must be signed.
+							 */
+							n = new_rd_Shrs(get_irn_dbg_info(n),
+									current_ir_graph, block, x,
+									new_r_Const_long(current_ir_graph, block, mode_Iu,
+									get_mode_size_bits(mode) - 1),
+									mode);
+							DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_SHR);
+							return n;
+						} else if ((pn == pn_Cmp_Gt || pn == pn_Cmp_Ge) &&
+								is_Const(t) && is_Const_one(t) &&
+								is_Const(f) && is_Const_null(f)) {
+							/*
+							 * Mux(x:T >/>= 0, 0, 1) -> Shr(-x, sizeof_bits(T) - 1)
+							 * Conditions:
+							 * T must be signed.
+							 */
+							n = new_rd_Shr(get_irn_dbg_info(n),
+								current_ir_graph, block,
+								new_r_Minus(current_ir_graph, block, x, mode),
 								new_r_Const_long(current_ir_graph, block, mode_Iu,
 								get_mode_size_bits(mode) - 1),
 								mode);
-						DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_SHR);
-						return n;
-					} else if ((pn == pn_Cmp_Gt || pn == pn_Cmp_Ge) &&
-					           classify_Const(t) == CNST_ONE &&
-					           classify_Const(f) == CNST_NULL) {
-						/*
-						 * Mux(x:T >/>= 0, 0, 1) -> Shr(-x, sizeof_bits(T) - 1)
-						 * Conditions:
-						 * T must be signed.
-						 */
-						n = new_rd_Shr(get_irn_dbg_info(n),
-							current_ir_graph, block,
-							new_r_Minus(current_ir_graph, block, x, mode),
-							new_r_Const_long(current_ir_graph, block, mode_Iu,
-							get_mode_size_bits(mode) - 1),
-							mode);
-						DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_SHR);
-						return n;
+							DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_SHR);
+							return n;
+						}
 					}
 				}
 			}
@@ -5058,7 +5103,7 @@ ir_node *optimize_in_place_2(ir_node *n) {
 	ir_node *oldn = n;
 	ir_opcode iro = get_irn_opcode(n);
 
-	if (!get_opt_optimize() && (get_irn_op(n) != op_Phi)) return n;
+	if (!get_opt_optimize() && !is_Phi(n)) return n;
 
 	/* constant expression evaluation / constant folding */
 	if (get_opt_constant_folding()) {