X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firvrfy.c;h=3e98cbb31f7bba208f26b3297b14c8fa402c112f;hb=fad022b108892a74b02bef7dfb13315caef5a3fc;hp=5a05ae17b34296f55cc4b42614c24a292ba323d5;hpb=cf05e3a9cccf0d59d3d6e74ea6ab812fc869d184;p=libfirm

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index 5a05ae17b..3e98cbb31 100644
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -256,6 +256,7 @@ static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt) {
  * Show Phi input
  */
 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos) {
+	(void) pos;
 	show_entity_failure(phi);
 	fprintf(stderr, "  Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
 		get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
@@ -288,6 +289,7 @@ static ir_entity *get_ptr_entity(ir_node *ptr) {
 static int verify_node_Proj_Start(ir_node *n, ir_node *p) {
 	ir_mode *mode = get_irn_mode(p);
 	long proj     = get_Proj_proj(p);
+	(void) n;
 
 	ASSERT_AND_RET_DBG(
 		(
@@ -331,6 +333,7 @@ static int verify_node_Proj_Cond(ir_node *pred, ir_node *p) {
 static int verify_node_Proj_Raise(ir_node *n, ir_node *p) {
 	ir_mode *mode = get_irn_mode(p);
 	long proj     = get_Proj_proj(p);
+	(void) n;
 
 	ASSERT_AND_RET_DBG(
 		((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
@@ -346,6 +349,7 @@ static int verify_node_Proj_Raise(ir_node *n, ir_node *p) {
 static int verify_node_Proj_InstOf(ir_node *n, ir_node *p) {
 	ir_mode *mode = get_irn_mode(p);
 	long proj     = get_Proj_proj(p);
+	(void) n;
 
 	ASSERT_AND_RET_DBG(
 		(
@@ -530,6 +534,7 @@ static int verify_node_Proj_Mod(ir_node *n, ir_node *p) {
 static int verify_node_Proj_Cmp(ir_node *n, ir_node *p) {
 	ir_mode *mode = get_irn_mode(p);
 	long proj     = get_Proj_proj(p);
+	(void) n;
 
 	ASSERT_AND_RET_DBG(
 		(proj >= 0 && proj <= 15 && mode == mode_b),
@@ -623,6 +628,7 @@ static int verify_node_Proj_Store(ir_node *n, ir_node *p) {
 static int verify_node_Proj_Alloc(ir_node *n, ir_node *p) {
 	ir_mode *mode = get_irn_mode(p);
 	long proj     = get_Proj_proj(p);
+	(void) n;
 
 	ASSERT_AND_RET_DBG(
 		(
@@ -655,7 +661,7 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
 
 		if (nr == pn_Start_T_args) {
 			ASSERT_AND_RET(
-				(proj >= 0 && mode_is_data(mode)),
+				(proj >= 0 && mode_is_datab(mode)),
 				"wrong Proj from Proj from Start", 0);
 			ASSERT_AND_RET(
 				(proj < get_method_n_params(mt)),
@@ -684,7 +690,7 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
 	case iro_Call:
 		{
 			ASSERT_AND_RET(
-				(proj >= 0 && mode_is_data(mode)),
+				(proj >= 0 && mode_is_datab(mode)),
 				"wrong Proj from Proj from Call", 0);
 			mt = get_Call_type(pred);
 			ASSERT_AND_RET(
@@ -718,6 +724,8 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) {
  * verify a Proj(Tuple) node
  */
 static int verify_node_Proj_Tuple(ir_node *n, ir_node *p) {
+	(void) n;
+	(void) p;
 	/* We don't test */
 	return 1;
 }
@@ -726,6 +734,8 @@ static int verify_node_Proj_Tuple(ir_node *n, ir_node *p) {
  * verify a Proj(CallBegin) node
  */
 static int verify_node_Proj_CallBegin(ir_node *n, ir_node *p) {
+	(void) n;
+	(void) p;
 	return 1;
 }
 
@@ -733,6 +743,8 @@ static int verify_node_Proj_CallBegin(ir_node *n, ir_node *p) {
  * verify a Proj(EndReg) node
  */
 static int verify_node_Proj_EndReg(ir_node *n, ir_node *p) {
+	(void) n;
+	(void) p;
 	ASSERT_AND_RET(
 		(get_irp_ip_view_state() != ip_view_no),
 		"EndReg may only appear if ip view is constructed.", 0);
@@ -743,6 +755,8 @@ static int verify_node_Proj_EndReg(ir_node *n, ir_node *p) {
  * verify a Proj(EndExcept) node
  */
 static int verify_node_Proj_EndExcept(ir_node *n, ir_node *p) {
+	(void) n;
+	(void) p;
 	ASSERT_AND_RET(
 		(get_irp_ip_view_state() != ip_view_no),
 		"EndExcept may only appear if ip view is constructed.", 0);
@@ -807,6 +821,7 @@ static int
 verify_node_Proj(ir_node *p, ir_graph *irg) {
 	ir_node *pred;
 	ir_op *op;
+	(void) irg;
 
 	pred = skip_Id(get_Proj_pred(p));
 	ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
@@ -864,6 +879,7 @@ static int verify_node_Block(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_Start(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode = get_irn_mode(n);
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* Start: BB --> X x M x ref x data1 x ... x datan x ref */
@@ -877,6 +893,7 @@ static int verify_node_Start(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_Jmp(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode = get_irn_mode(n);
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* Jmp: BB --> X */
@@ -891,6 +908,7 @@ static int verify_node_Jmp(ir_node *n, ir_graph *irg) {
 static int verify_node_IJmp(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_IJmp_target(n));
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* IJmp: BB x ref --> X */
@@ -904,6 +922,7 @@ static int verify_node_IJmp(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_Break(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode = get_irn_mode(n);
+	(void) irg;
 
 	ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
 		"Break may only appear if ip view is constructed.", 0);
@@ -920,6 +939,7 @@ static int verify_node_Break(ir_node *n, ir_graph *irg) {
 static int verify_node_Cond(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Cond_selector(n));
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* Cond: BB x b --> X x X */
@@ -946,7 +966,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) {
 	ASSERT_AND_RET( mem_mode == mode_M, "Return node", 0 );  /* operand M */
 
 	for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
-		ASSERT_AND_RET( mode_is_data(get_irn_mode(get_Return_res(n, i))), "Return node", 0 );  /* operand datai */
+		ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Return_res(n, i))), "Return node", 0 );  /* operand datai */
 	}
 	ASSERT_AND_RET( mymode == mode_X, "Result X", 0 );   /* result X */
 	/* Compare returned results with result types of method type */
@@ -981,6 +1001,7 @@ static int verify_node_Raise(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Raise_mem(n));
 	ir_mode *op2mode = get_irn_mode(get_Raise_exo_ptr(n));
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* Sel: BB x M x ref --> X x M */
@@ -995,6 +1016,7 @@ static int verify_node_Raise(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_Const(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode = get_irn_mode(n);
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* Const: BB --> data */
@@ -1015,6 +1037,7 @@ static int verify_node_Const(ir_node *n, ir_graph *irg) {
  */
 static int verify_node_SymConst(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode = get_irn_mode(n);
+	(void) irg;
 
 	if (get_SymConst_kind(n) == symconst_addr_ent) {
 		ir_entity *ent = get_SymConst_entity(n);
@@ -1044,6 +1067,7 @@ static int verify_node_Sel(ir_node *n, ir_graph *irg) {
 	ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
 	ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
 	ir_entity *ent;
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Sel: BB x M x ref x int^n --> ref */
@@ -1065,12 +1089,29 @@ static int verify_node_Sel(ir_node *n, ir_graph *irg) {
 static int verify_node_InstOf(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_InstOf_obj(n));
+	(void) irg;
 
 	ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
 	ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
 	return 1;
 }
 
+/**
+ * Check if the pinned state is right.
+ */
+static int verify_right_pinned(ir_node *n) {
+	ir_node *mem;
+
+	if (get_irn_pinned(n) == op_pin_state_pinned)
+		return 1;
+	mem = get_Call_mem(n);
+
+	/* if it's not pinned, its memory predecessor must be NoMem or Pin */
+	if (is_NoMem(mem) || is_Pin(mem))
+		return 1;
+	return 0;
+}
+
 /**
  * verify a Call node
  */
@@ -1080,16 +1121,14 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) {
 	ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
 	ir_type *mt;
 	int i;
+	(void) irg;
 
 	/* Call: BB x M x ref x data1 x ... x datan
 	--> M x datan+1 x ... x data n+m */
 	ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 );  /* operand M x ref */
 
 	/* NoMem nodes are only allowed as memory input if the Call is NOT pinned */
-	ASSERT_AND_RET(
-		(get_irn_op(get_Call_mem(n)) == op_NoMem) ||
-		(get_irn_op(get_Call_mem(n)) != op_NoMem && get_irn_pinned(n) == op_pin_state_pinned),
-		"Call node with wrong memory input", 0 );
+	ASSERT_AND_RET(verify_right_pinned(n),"Call node with wrong memory input", 0 );
 
 	mt = get_Call_type(n);
 	if(get_unknown_type() == mt) {
@@ -1097,7 +1136,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) {
 	}
 
 	for (i = get_Call_n_params(n) - 1; i >= 0; --i) {
-		ASSERT_AND_RET( mode_is_data(get_irn_mode(get_Call_param(n, i))), "Call node", 0 );  /* operand datai */
+		ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Call_param(n, i))), "Call node", 0 );  /* operand datai */
 	}
 
 	ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 );   /* result T */
@@ -1154,11 +1193,12 @@ static int verify_node_Add(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Add_left(n));
 	ir_mode *op2mode = get_irn_mode(get_Add_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		(
 			/* common Add: BB x numP x numP --> numP */
-			(op1mode == mymode && op2mode == op1mode && mode_is_numP(mymode)) ||
+			(op1mode == mymode && op2mode == op1mode && mode_is_data(mymode)) ||
 			/* Pointer Add: BB x ref x int --> ref */
 			(mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
 			/* Pointer Add: BB x int x ref --> ref */
@@ -1179,11 +1219,12 @@ static int verify_node_Sub(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Sub_left(n));
 	ir_mode *op2mode = get_irn_mode(get_Sub_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		(
 			/* common Sub: BB x numP x numP --> numP */
-			(mymode ==op1mode && mymode == op2mode && mode_is_numP(op1mode)) ||
+			(mymode ==op1mode && mymode == op2mode && mode_is_data(op1mode)) ||
 			/* Pointer Sub: BB x ref x int --> ref */
 			(op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
 			/* Pointer Sub: BB x int x ref --> ref */
@@ -1206,6 +1247,7 @@ static int verify_node_Sub(ir_node *n, ir_graph *irg) {
 static int verify_node_Minus(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Minus_op(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Minus: BB x num --> num */
@@ -1222,6 +1264,7 @@ static int verify_node_Mul(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Mul_left(n));
 	ir_mode *op2mode = get_irn_mode(get_Mul_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		(
@@ -1245,6 +1288,7 @@ static int verify_node_Quot(ir_node *n, ir_graph *irg) {
 	ir_mode *op1mode = get_irn_mode(get_Quot_mem(n));
 	ir_mode *op2mode = get_irn_mode(get_Quot_left(n));
 	ir_mode *op3mode = get_irn_mode(get_Quot_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Quot: BB x M x float x float --> M x X x float */
@@ -1265,6 +1309,7 @@ static int verify_node_DivMod(ir_node *n, ir_graph *irg) {
 	ir_mode *op1mode = get_irn_mode(get_DivMod_mem(n));
 	ir_mode *op2mode = get_irn_mode(get_DivMod_left(n));
 	ir_mode *op3mode = get_irn_mode(get_DivMod_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* DivMod: BB x M x int x int --> M x X x int x int */
@@ -1285,6 +1330,7 @@ static int verify_node_Div(ir_node *n, ir_graph *irg) {
 	ir_mode *op1mode = get_irn_mode(get_Div_mem(n));
 	ir_mode *op2mode = get_irn_mode(get_Div_left(n));
 	ir_mode *op3mode = get_irn_mode(get_Div_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* Div: BB x M x int x int --> M x X x int */
@@ -1305,6 +1351,7 @@ static int verify_node_Mod(ir_node *n, ir_graph *irg) {
 	ir_mode *op1mode = get_irn_mode(get_Mod_mem(n));
 	ir_mode *op2mode = get_irn_mode(get_Mod_left(n));
 	ir_mode *op3mode = get_irn_mode(get_Mod_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* Mod: BB x M x int x int --> M x X x int */
@@ -1323,6 +1370,7 @@ static int verify_node_Mod(ir_node *n, ir_graph *irg) {
 static int verify_node_Abs(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Abs_op(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Abs: BB x num --> num */
@@ -1341,6 +1389,7 @@ static int verify_node_Logic(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_binop_left(n));
 	ir_mode *op2mode = get_irn_mode(get_binop_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* And or Or or Eor: BB x int x int --> int */
@@ -1363,10 +1412,11 @@ static int verify_node_Logic(ir_node *n, ir_graph *irg) {
 static int verify_node_Not(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Not_op(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Not: BB x int --> int */
-		mode_is_int(mymode) &&
+		(mode_is_int(mymode) || mymode == mode_b) &&
 		mymode == op1mode,
 		"Not node", 0,
 		show_unop_failure(n, "/* Not: BB x int --> int */");
@@ -1381,10 +1431,11 @@ static int verify_node_Cmp(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Cmp_left(n));
 	ir_mode *op2mode = get_irn_mode(get_Cmp_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Cmp: BB x datab x datab --> b16 */
-		mode_is_data (op1mode) &&
+		mode_is_datab(op1mode) &&
 		op2mode == op1mode &&
 		mymode == mode_T,
 		"Cmp node", 0,
@@ -1400,6 +1451,7 @@ static int verify_node_Shift(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_binop_left(n));
 	ir_mode *op2mode = get_irn_mode(get_binop_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Shl, Shr or Shrs: BB x int x int_u --> int */
@@ -1424,6 +1476,7 @@ static int verify_node_Rot(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Rot_left(n));
 	ir_mode *op2mode = get_irn_mode(get_Rot_right(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Rot: BB x int x int --> int */
@@ -1442,10 +1495,11 @@ static int verify_node_Rot(ir_node *n, ir_graph *irg) {
 static int verify_node_Conv(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Conv_op(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Conv: BB x datab1 --> datab2 */
-		mode_is_datab(op1mode) && mode_is_data(mymode),
+		mode_is_datab(op1mode) && mode_is_datab(mymode),
 		"Conv node", 0,
 		show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
 	);
@@ -1458,6 +1512,7 @@ static int verify_node_Conv(ir_node *n, ir_graph *irg) {
 static int verify_node_Cast(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Cast_op(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Conv: BB x datab1 --> datab2 */
@@ -1475,6 +1530,7 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode = get_irn_mode(n);
 	ir_node *block  = get_nodes_block(n);
 	int i;
+	(void) irg;
 
 	if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building) {
 		/* a Phi node MUST have the same number of inputs as its block */
@@ -1496,7 +1552,7 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) {
 			);
 		}
 	}
-	ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 );
+	ASSERT_AND_RET(mode_is_dataM(mymode) || mymode == mode_b, "Phi node", 0 );
 
 	if (mymode == mode_M) {
 		for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
@@ -1530,6 +1586,8 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) {
  * verify a Filter node
  */
 static int verify_node_Filter(ir_node *n, ir_graph *irg) {
+	(void) n;
+	(void) irg;
 	ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
 		"Filter may only appear if ip view is constructed.", 0);
 	/* We should further do tests as for Proj and Phi. */
@@ -1582,7 +1640,7 @@ static int verify_node_Store(ir_node *n, ir_graph *irg) {
 	ir_mode *op2mode = get_irn_mode(get_Store_ptr(n));
 	ir_mode *op3mode = get_irn_mode(get_Store_value(n));
 
-	ASSERT_AND_RET(op1mode == mode_M && mode_is_data(op3mode), "Store node", 0 );
+	ASSERT_AND_RET(op1mode == mode_M && mode_is_datab(op3mode), "Store node", 0 );
 	if (get_irg_phase_state(irg) != phase_backend) {
 		ASSERT_AND_RET(mode_is_reference(op2mode), "Store node", 0 );
 	} else {
@@ -1612,6 +1670,7 @@ static int verify_node_Alloc(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Alloc_mem(n));
 	ir_mode *op2mode = get_irn_mode(get_Alloc_size(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Alloc: BB x M x int_u --> M x X x ref */
@@ -1633,6 +1692,7 @@ static int verify_node_Free(ir_node *n, ir_graph *irg) {
 	ir_mode *op1mode = get_irn_mode(get_Free_mem(n));
 	ir_mode *op2mode = get_irn_mode(get_Free_ptr(n));
 	ir_mode *op3mode = get_irn_mode(get_Free_size(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Free: BB x M x ref x int_u --> M */
@@ -1652,6 +1712,7 @@ static int verify_node_Free(ir_node *n, ir_graph *irg) {
 static int verify_node_Sync(ir_node *n, ir_graph *irg) {
 	int i;
 	ir_mode *mymode  = get_irn_mode(n);
+	(void) irg;
 
 	/* Sync: BB x M^n --> M */
 	for (i = get_Sync_n_preds(n) - 1; i >= 0; --i) {
@@ -1668,6 +1729,7 @@ static int verify_node_Confirm(ir_node *n, ir_graph *irg) {
 	ir_mode *mymode  = get_irn_mode(n);
 	ir_mode *op1mode = get_irn_mode(get_Confirm_value(n));
 	ir_mode *op2mode = get_irn_mode(get_Confirm_bound(n));
+	(void) irg;
 
 	ASSERT_AND_RET_DBG(
 		/* Confirm: BB x T x T --> T */
@@ -1687,13 +1749,14 @@ static int verify_node_Mux(ir_node *n, ir_graph *irg) {
 	ir_mode *op1mode = get_irn_mode(get_Mux_sel(n));
 	ir_mode *op2mode = get_irn_mode(get_Mux_true(n));
 	ir_mode *op3mode = get_irn_mode(get_Mux_false(n));
+	(void) irg;
 
 	ASSERT_AND_RET(
 		/* Mux: BB x b x numP x numP --> numP */
 		op1mode == mode_b &&
 		op2mode == mymode &&
 		op3mode == mymode &&
-		mode_is_numP(mymode),
+		mode_is_data(mymode),
 		"Mux node", 0
 		);
 	return 1;
@@ -1727,10 +1790,7 @@ static int verify_node_CopyB(ir_node *n, ir_graph *irg) {
 
 	/* NoMem nodes are only allowed as memory input if the CopyB is NOT pinned.
 	   This should happen RARELY, as CopyB COPIES MEMORY */
-	ASSERT_AND_RET(
-		(get_irn_op(get_CopyB_mem(n)) == op_NoMem) ||
-		(get_irn_op(get_CopyB_mem(n)) != op_NoMem && get_irn_pinned(n) == op_pin_state_pinned),
-		"CopyB node with wrong memory input", 0 );
+	ASSERT_AND_RET(verify_right_pinned(n), "CopyB node with wrong memory input", 0 );
 	return 1;
 }
 
@@ -1743,6 +1803,7 @@ static int verify_node_Bound(ir_node *n, ir_graph *irg) {
 	ir_mode *op2mode = get_irn_mode(get_Bound_index(n));
 	ir_mode *op3mode = get_irn_mode(get_Bound_lower(n));
 	ir_mode *op4mode = get_irn_mode(get_Bound_upper(n));
+	(void) irg;
 
 	/* Bound: BB x M x int x int x int --> M x X */
 	ASSERT_AND_RET(
@@ -1765,7 +1826,7 @@ static int verify_node_Bound(ir_node *n, ir_graph *irg) {
  */
 static int check_dominance_for_node(ir_node *use) {
 	/* This won't work for blocks and the end node */
-	if (!is_Block(use) && use != get_irg_end(current_ir_graph)) {
+	if (!is_Block(use) && use != get_irg_end(current_ir_graph) && use != current_ir_graph->anchor) {
 		int i;
 		ir_node *bl = get_nodes_block(use);
 
@@ -1880,8 +1941,9 @@ static void vrfy_wrap_ssa(ir_node *node, void *env) {
 	int *res = env;
 
 	*res = irn_vrfy(node);
-	if (*res)
+	if (*res) {
 		*res = check_dominance_for_node(node);
+	}
 }
 
 #endif /* DEBUG_libfirm */
@@ -1905,7 +1967,7 @@ int irg_verify(ir_graph *irg, unsigned flags) {
 	if (flags & VRFY_ENFORCE_SSA)
 		compute_doms(irg);
 
-	irg_walk_graph(
+	irg_walk_anchors(
 		irg,
 		get_irg_dom_state(irg) == dom_consistent &&
 		get_irg_pinned(irg) == op_pin_state_pinned ? vrfy_wrap_ssa : vrfy_wrap,