X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firvrfy.c;h=1b392e0e90745cd17086a651746717456ab6ef96;hb=b78bdd4d94de46de4156272e6dbfe44e97933a5b;hp=bb4af61124a5b67a9aafdacd7b5d6700efbeb5be;hpb=c422849e18b406efefdee0ec160b3bf303b3d657;p=libfirm diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c index bb4af6112..1b392e0e9 100644 --- a/ir/ir/irvrfy.c +++ b/ir/ir/irvrfy.c @@ -6,7 +6,7 @@ * Modified by: Goetz Lindenmaier. Till Riedel. Michael Beck. * Created: * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universit�t Karlsruhe + * Copyright: (c) 1998-2003 Universität Karlsruhe * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ @@ -14,20 +14,21 @@ # include "config.h" #endif -# include "irprog.h" -# include "irop_t.h" -# include "irgraph_t.h" -# include "ircgcons.h" -# include "irvrfy_t.h" -# include "irgwalk.h" -# include "irdump.h" -# include "irdom_t.h" -# include "irprintf.h" +#include "irprog.h" +#include "irop_t.h" +#include "irgraph_t.h" +#include "ircgcons.h" +#include "irvrfy_t.h" +#include "irgwalk.h" +#include "irdump.h" +#include "irdom_t.h" +#include "irprintf.h" +#include "irouts.h" +#include "irflag_t.h" /** if this flag is set, verify entity types in Load & Store nodes */ static int vrfy_entities = 0; -node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON; const char *firm_vrfy_failure_msg; /* enable verification of Load/Store entities */ @@ -44,10 +45,6 @@ static const char *get_mode_name_ex(ir_mode *mode) { return get_mode_name(mode); } -void do_node_verification(node_verification_t mode) { - opt_do_node_verification = mode; -} - /** the last IRG, on which a verify error was found */ static ir_graph *last_irg_error = NULL; @@ -70,7 +67,7 @@ static void show_entity_failure(ir_node *node) entity *ent = get_irg_entity(irg); if (ent) { - type *ent_type = get_entity_owner(ent); + ir_type *ent_type = get_entity_owner(ent); if (ent_type) { if (ent_type == get_glob_type()) @@ -169,7 +166,7 @@ static void show_proj_failure(ir_node *n) /** * Prints a failure message for a proj from Start */ -static void show_proj_mode_failure(ir_node *n, type *ty) +static void show_proj_mode_failure(ir_node *n, ir_type *ty) { long proj = get_Proj_proj(n); ir_mode *m = get_type_mode(ty); @@ -206,22 +203,13 @@ static void show_proj_failure_ent(ir_node *n, entity *ent) */ static void show_node_on_graph(ir_graph *irg, ir_node *n) { - entity *ent = get_irg_entity(irg); - - if (ent) - fprintf(stderr, "\nFIRM: irn_vrfy_irg() of entity %s, node %ld %s%s\n", - get_entity_name(ent), - get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n)); - else - fprintf(stderr, "\nFIRM: irn_vrfy_irg() of graph %p, node %ld %s%s\n", - (void *)irg, - get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n)); + ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() of %+F, node %+F\n", irg, n); } /** - * Show call params + * Show call parameters */ -static void show_call_param(ir_node *n, type *mt) +static void show_call_param(ir_node *n, ir_type *mt) { int i; @@ -242,7 +230,7 @@ static void show_call_param(ir_node *n, type *mt) /** * Show return modes */ -static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i) +static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i) { entity *ent = get_irg_entity(irg); @@ -257,7 +245,7 @@ static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i) /** * Show return number of results */ -static void show_return_nres(ir_graph *irg, ir_node *n, type *mt) +static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt) { entity *ent = get_irg_entity(irg); @@ -312,6 +300,7 @@ static int verify_node_Proj_Start(ir_node *n, ir_node *p) { (proj == pn_Start_M && mode == mode_M) || (proj == pn_Start_P_frame_base && mode_is_reference(mode)) || (proj == pn_Start_P_globals && mode_is_reference(mode)) || + (proj == pn_Start_P_tls && mode_is_reference(mode)) || (proj == pn_Start_T_args && mode == mode_T) || (proj == pn_Start_P_value_arg_base && mode_is_reference(mode)) || (proj == pn_Start_P_value_arg_base && mode == mode_T) /* FIXME: only one of those */ @@ -602,7 +591,7 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) { ir_mode *mode = get_irn_mode(p); long proj = get_Proj_proj(p); long nr = get_Proj_proj(pred); - type *mt; /* A method type */ + ir_type *mt; /* A method type */ pred = skip_Id(get_Proj_pred(pred)); ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0); @@ -667,7 +656,8 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) { break; default: - ASSERT_AND_RET(0, "Unknown opcode", 0); + /* ASSERT_AND_RET(0, "Unknown opcode", 0); */ + break; } return 1; } @@ -705,6 +695,48 @@ static int verify_node_Proj_EndExcept(ir_node *n, ir_node *p) { return 1; } +/** + * verify a Proj(CopyB) node + */ +static int verify_node_Proj_CopyB(ir_node *n, ir_node *p) { + ir_mode *mode = get_irn_mode(p); + long proj = get_Proj_proj(p); + + ASSERT_AND_RET_DBG( + ((proj == pn_CopyB_M_regular && mode == mode_M) || + (proj == pn_CopyB_X_except && mode == mode_X) || + (proj == pn_CopyB_M_except && mode == mode_M)), + "wrong Proj from CopyB", 0, + show_proj_failure(p); + ); + if (proj == pn_CopyB_X_except) + ASSERT_AND_RET( + get_irn_pinned(n) == op_pin_state_pinned, + "Exception Proj from unpinned CopyB", 0); + return 1; +} + +/** + * verify a Proj(Bound) node + */ +static int verify_node_Proj_Bound(ir_node *n, ir_node *p) { + ir_mode *mode = get_irn_mode(p); + long proj = get_Proj_proj(p); + + ASSERT_AND_RET_DBG( + ((proj == pn_Bound_M && mode == mode_M) || + (proj == pn_Bound_X_except && mode == mode_X) || + (proj == pn_Bound_res && mode == get_irn_mode(get_Bound_index(n)))), + "wrong Proj from Bound", 0, + show_proj_failure(p); + ); + if (proj == pn_Bound_X_except) + ASSERT_AND_RET( + get_irn_pinned(n) == op_pin_state_pinned, + "Exception Proj from unpinned Bound", 0); + return 1; +} + /** * verify a Proj node */ @@ -718,8 +750,8 @@ verify_node_Proj(ir_node *p, ir_graph *irg) { op = get_irn_op(pred); - if (op->verify_proj_node) - return op->verify_proj_node(pred, p); + if (op->ops.verify_proj_node) + return op->ops.verify_proj_node(pred, p); /* all went ok */ return 1; @@ -746,7 +778,7 @@ static int verify_node_Block(ir_node *n, ir_graph *irg) { ir_node *pred = skip_Proj(get_Block_cfgpred(n, i)); if (is_Proj(pred) || get_irn_op(pred) == op_Tuple) break; /* We can not test properly. How many tuples are there? */ - ASSERT_AND_RET(((get_irn_op(pred) == op_Return) || + ASSERT_AND_RET((is_Return(pred) || is_Bad(pred) || (get_irn_op(pred) == op_Raise) || is_fragile_op(pred) ), @@ -828,6 +860,7 @@ static int verify_node_Cond(ir_node *n, ir_graph *irg) { mode_is_int(op1mode) ), "Cond node", 0 ); ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0); + return 1; } @@ -838,7 +871,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) { int i; ir_mode *mymode = get_irn_mode(n); ir_mode *mem_mode = get_irn_mode(get_Return_mem(n)); - type *mt; + ir_type *mt; /* Return: BB x M x data1 x ... x datan --> X */ @@ -854,7 +887,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) { "Number of results for Return doesn't match number of results in type.", 0, show_return_nres(irg, n, mt);); for (i = get_Return_n_ress(n) - 1; i >= 0; --i) { - type *res_type = get_method_res_type(mt, i); + ir_type *res_type = get_method_res_type(mt, i); if (is_atomic_type(res_type)) { ASSERT_AND_RET_DBG( @@ -902,6 +935,11 @@ static int verify_node_Const(ir_node *n, ir_graph *irg) { mymode == mode_b) /* we want boolean constants for static evaluation */ ,"Const node", 0 /* of Cmp. */ ); + ASSERT_AND_RET( + /* the modes of the constant and teh tarval must match */ + mymode == get_tarval_mode(get_Const_tarval(n)), + "Const node, tarval and node mode mismatch", 0 + ); return 1; } @@ -973,7 +1011,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) { ir_mode *mymode = get_irn_mode(n); ir_mode *op1mode = get_irn_mode(get_Call_mem(n)); ir_mode *op2mode = get_irn_mode(get_Call_ptr(n)); - type *mt; + ir_type *mt; int i; /* Call: BB x M x ref x data1 x ... x datan @@ -1015,7 +1053,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) { } for (i = 0; i < get_method_n_params(mt); i++) { - type *t = get_method_param_type(mt, i); + ir_type *t = get_method_param_type(mt, i); if (is_atomic_type(t)) { ASSERT_AND_RET_DBG( @@ -1237,7 +1275,7 @@ static int verify_node_Logic(ir_node *n, ir_graph *irg) { ASSERT_AND_RET_DBG( /* And or Or or Eor: BB x int x int --> int */ - mode_is_int(mymode) && + (mode_is_int(mymode) || mymode == mode_b) && op2mode == op1mode && mymode == op2mode, "And, Or or Eor node", 0, @@ -1561,46 +1599,115 @@ static int verify_node_Mux(ir_node *n, ir_graph *irg) { return 1; } +/** + * verify a CopyB node + */ +static int verify_node_CopyB(ir_node *n, ir_graph *irg) { + ir_mode *mymode = get_irn_mode(n); + ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n)); + ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n)); + ir_mode *op3mode = get_irn_mode(get_CopyB_src(n)); + ir_type *t = get_CopyB_type(n); + + /* CopyB: BB x M x ref x ref --> M x X */ + ASSERT_AND_RET( + mymode == mode_T && + op1mode == mode_M && + mode_is_reference(op2mode) && + mode_is_reference(op3mode), + "CopyB node", 0 ); /* operand M x ref x ref */ + + ASSERT_AND_RET( + is_compound_type(t), + "CopyB node should copy compound types only", 0 ); + + /* 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 ); + return 1; +} + +/** + * verify a Bound node + */ +static int verify_node_Bound(ir_node *n, ir_graph *irg) { + ir_mode *mymode = get_irn_mode(n); + ir_mode *op1mode = get_irn_mode(get_Bound_mem(n)); + 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)); + + /* Bound: BB x M x ref x ref --> M x X */ + ASSERT_AND_RET( + mymode == mode_T && + op1mode == mode_M && + op2mode == op3mode && + op3mode == op4mode && + mode_is_int(op3mode), + "Bound node", 0 ); /* operand M x int x int x int */ + + /* NoMem nodes are only allowed as memory input if the Bound is NOT pinned. + This should happen RARELY, as Bound COPIES MEMORY */ + ASSERT_AND_RET( + (get_irn_op(get_Bound_mem(n)) == op_NoMem) || + (get_irn_op(get_Bound_mem(n)) != op_NoMem && get_irn_pinned(n) == op_pin_state_pinned), + "Bound node with wrong memory input", 0 ); + return 1; +} + /* * Check dominance. * For each usage of a node, it is checked, if the block of the * node dominates the block of the usage (for phis: the predecessor * block of the phi for the corresponding edge). */ -static int check_dominance_for_node(ir_node *irn) +static int check_dominance_for_node(ir_node *use) { - /* This won't work for blocks and the end node */ - if(!is_Block(irn) && irn != get_irg_end(current_ir_graph)) { - int i, n; - ir_node *bl = get_nodes_block(irn); - - for(i = 0, n = get_irn_arity(irn); i < n; ++i) { - ir_node *op = get_irn_n(irn, i); - ir_node *def_bl = get_nodes_block(op); - ir_node *use_bl = bl; - - if(is_Phi(irn)) - use_bl = get_Block_cfgpred_block(bl, i); - - ASSERT_AND_RET_DBG(block_dominates(def_bl, use_bl), - "the definition of a value used violates the dominance property", 0, - ir_fprintf(stderr, - "graph %+F: %+F of %+F must dominate %+F of user %+F\n", - current_ir_graph, def_bl, op, use_bl, irn);); - } - } + /* This won't work for blocks and the end node */ + if (!is_Block(use) && use != get_irg_end(current_ir_graph)) { + int i; + ir_node *bl = get_nodes_block(use); - return 1; -} + for (i = get_irn_arity(use) - 1; i >= 0; --i) { + ir_node *def = get_irn_n(use, i); + ir_node *def_bl = get_nodes_block(def); + ir_node *use_bl = bl; + /* ignore dead definition blocks, will be removed */ + if (is_Block_dead(def_bl) || get_Block_dom_depth(def_bl) == -1) + continue; + if (is_Phi(use)) + use_bl = get_Block_cfgpred_block(bl, i); + + /* ignore dead use blocks, will be removed */ + if (is_Block_dead(use_bl) || get_Block_dom_depth(use_bl) == -1) + continue; + + ASSERT_AND_RET_DBG( + block_dominates(def_bl, use_bl), + "the definition of a value used violates the dominance property", 0, + ir_fprintf(stderr, + "graph %+F: %+F of %+F must dominate %+F of user %+F input %d\n", + current_ir_graph, def_bl, def, use_bl, use, i + ); + ); + } + } + return 1; +} + +/* Tests the modes of n and its predecessors. */ int irn_vrfy_irg(ir_node *n, ir_graph *irg) { int i; ir_op *op; - if (!opt_do_node_verification) - return 1; + if (!get_node_verification_mode()) + return 1; if (!get_interprocedural_view()) { /* @@ -1613,20 +1720,25 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) show_node_on_graph(irg, n); ); assert(get_irn_irg(n) == irg); + { + unsigned idx = get_irn_idx(n); + ir_node *node_from_map = get_idx_irn(irg, idx); + ASSERT_AND_RET_DBG(node_from_map == n, "Node index and index map entry differ", 0, ir_printf("node %+F node in map %+F(%p)", n, node_from_map, node_from_map)); + } } op = get_irn_op(n); /* We don't want to test nodes whose predecessors are Bad, as we would have to special case that for each operation. */ - if (op != op_Phi && op != op_Block) - for (i = get_irn_arity(n) - 1; i >= 0; --i) { - if (is_Bad(get_irn_n(n, i))) - return 1; - } + if (op != op_Phi && op != op_Block) + for (i = get_irn_arity(n) - 1; i >= 0; --i) { + if (is_Bad(get_irn_n(n, i))) + return 1; + } - if (op->verify_node) - return op->verify_node(n, irg); + if (op->ops.verify_node) + return op->ops.verify_node(n, irg); /* All went ok */ return 1; @@ -1645,18 +1757,36 @@ int irn_vrfy(ir_node *n) /* Verify the whole graph. */ /*-----------------------------------------------------------------*/ -/* This *is* used, except gcc doesn't notice that */ -static void vrfy_wrap(ir_node *node, void *env) +#ifdef DEBUG_libfirm +/** + * Walker to check every node + */ +static void vrfy_wrap(ir_node *node, void *env) { + int *res = env; + *res = irn_vrfy(node); +} + +/** + * Walker to check every node including SSA property. + * Only called if dominance info is available. + */ +static void vrfy_wrap_ssa(ir_node *node, void *env) { int *res = env; *res = irn_vrfy(node); - - if(*res && get_irg_dom_state(current_ir_graph) == dom_consistent) - *res = check_dominance_for_node(node); + if (*res) + *res = check_dominance_for_node(node); } -int irg_vrfy(ir_graph *irg) +#endif /* DEBUG_libfirm */ + +/* + * Calls irn_vrfy for each node in irg. + * Graph must be in state "op_pin_state_pinned". + * If dominance info is available, check the SSA property. + */ +int irg_verify(ir_graph *irg, unsigned flags) { int res = 1; #ifdef DEBUG_libfirm @@ -1666,12 +1796,22 @@ int irg_vrfy(ir_graph *irg) current_ir_graph = irg; last_irg_error = NULL; - assert(get_irg_pinned(irg) == op_pin_state_pinned); - irg_walk_graph(irg, vrfy_wrap, NULL, &res); + assert(get_irg_pinned(irg) == op_pin_state_pinned && "Verification need pinned graph"); + + if (flags & VRFY_ENFORCE_SSA) + compute_doms(irg); + + irg_walk_graph( + irg, + get_irg_dom_state(irg) == dom_consistent && + get_irg_pinned(irg) == op_pin_state_pinned ? + vrfy_wrap_ssa : vrfy_wrap, + NULL, &res + ); current_ir_graph = rem; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT && ! res) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) { entity *ent = get_irg_entity(current_ir_graph); if (ent) @@ -1679,9 +1819,7 @@ int irg_vrfy(ir_graph *irg) else fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph); } - - -#endif +#endif /* DEBUG_libfirm */ return res; } @@ -1689,12 +1827,15 @@ int irg_vrfy(ir_graph *irg) int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string) { int res; - node_verification_t old = opt_do_node_verification; + firm_verification_t old = get_node_verification_mode(); firm_vrfy_failure_msg = NULL; - opt_do_node_verification = NODE_VERIFICATION_ERROR_ONLY; + do_node_verification(FIRM_VERIFICATION_ERROR_ONLY); res = irn_vrfy_irg(n, irg); - opt_do_node_verification = old; + if (! res && get_irg_dom_state(irg) == dom_consistent && + get_irg_pinned(irg) == op_pin_state_pinned) + res = check_dominance_for_node(n); + do_node_verification(old); *bad_string = firm_vrfy_failure_msg; return res; @@ -1706,6 +1847,9 @@ typedef struct _vrfy_bad_env_t { int res; } vrfy_bad_env_t; +/** + * Pre-Walker: check Bad predecessors of node. + */ static void check_bads(ir_node *node, void *env) { vrfy_bad_env_t *venv = env; @@ -1721,10 +1865,10 @@ static void check_bads(ir_node *node, void *env) if (is_Bad(pred)) { venv->res |= BAD_CF; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { assert(0 && "Bad CF detected"); } } @@ -1738,10 +1882,10 @@ static void check_bads(ir_node *node, void *env) if (is_Bad(get_nodes_block(node))) { venv->res |= BAD_BLOCK; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Block\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { assert(0 && "Bad CF detected"); } } @@ -1751,10 +1895,10 @@ static void check_bads(ir_node *node, void *env) if (get_irn_op(node) == op_Tuple) { venv->res |= TUPLE; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: node %ld is a Tuple\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { assert(0 && "Tuple detected"); } } @@ -1771,10 +1915,10 @@ static void check_bads(ir_node *node, void *env) else { venv->res |= BAD_CF; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { assert(0 && "Bad CF detected"); } } @@ -1784,10 +1928,10 @@ static void check_bads(ir_node *node, void *env) if ((venv->flags & BAD_DF) == 0) { venv->res |= BAD_DF; - if (opt_do_node_verification == NODE_VERIFICATION_REPORT) { + if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) { fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Input\n", get_irn_node_nr(node)); } - if (opt_do_node_verification == NODE_VERIFICATION_ON) { + if (get_node_verification_mode() == FIRM_VERIFICATION_ON) { assert(0 && "Bad NON-CF detected"); } } @@ -1797,7 +1941,7 @@ static void check_bads(ir_node *node, void *env) } /* - * verify occurance of bad nodes + * verify occurrence of bad nodes */ int irg_vrfy_bads(ir_graph *irg, int flags) { @@ -1814,14 +1958,14 @@ int irg_vrfy_bads(ir_graph *irg, int flags) /* * set the default verify operation */ -void firm_set_default_verifyer(ir_op *op) +void firm_set_default_verifyer(opcode code, ir_op_ops *ops) { -#define CASE(a) \ - case iro_##a: \ - op->verify_node = verify_node_##a; \ +#define CASE(a) \ + case iro_##a: \ + ops->verify_node = verify_node_##a; \ break - switch (op->code) { + switch (code) { CASE(Proj); CASE(Block); CASE(Start); @@ -1865,17 +2009,19 @@ void firm_set_default_verifyer(ir_op *op) CASE(Sync); CASE(Confirm); CASE(Mux); + CASE(CopyB); + CASE(Bound); default: - op->verify_node = NULL; + /* leave NULL */; } #undef CASE #define CASE(a) \ case iro_##a: \ - op->verify_proj_node = verify_node_Proj_##a; \ + ops->verify_proj_node = verify_node_Proj_##a; \ break - switch (op->code) { + switch (code) { CASE(Start); CASE(Cond); CASE(Raise); @@ -1894,8 +2040,10 @@ void firm_set_default_verifyer(ir_op *op) CASE(CallBegin); CASE(EndReg); CASE(EndExcept); + CASE(CopyB); + CASE(Bound); default: - op->verify_proj_node = NULL; + /* leave NULL */; } #undef CASE }