remove unused be_FrameLoad and be_FrameStore

[libfirm] / ir / ir / irvrfy.c

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index 5a05ae1..3e98cbb 100644 (file)
--- 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,