X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fir%2Firvrfy.c;h=65d2d81f2e8b1e02ef4b04244c6bb43da854b54f;hb=2af4a97900b435e35d7c20350604e3863aff2b4c;hp=6c6b370190e8189916dc109ed5243743ac910832;hpb=72f71b7606deeb29ac27534a8aac268affde7e57;p=libfirm diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c index 6c6b37019..65d2d81f2 100644 --- a/ir/ir/irvrfy.c +++ b/ir/ir/irvrfy.c @@ -36,6 +36,7 @@ #include "irprintf.h" #include "irouts.h" #include "irflag_t.h" +#include "irpass_t.h" /** if this flag is set, verify entity types in Load & Store nodes */ static int vrfy_entities = 0; @@ -83,10 +84,8 @@ static void show_entity_failure(ir_node *node) { ir_type *ent_type = get_entity_owner(ent); if (ent_type) { - if (ent_type == get_glob_type()) - fprintf(stderr, "\nFIRM: irn_vrfy_irg() %s failed\n", get_entity_name(ent)); - else - fprintf(stderr, "\nFIRM: irn_vrfy_irg() %s::%s failed\n", get_type_name(ent_type), get_entity_name(ent)); + ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() %+F::%s failed\n", + ent_type, get_entity_name(ent)); } else { fprintf(stderr, "\nFIRM: irn_vrfy_irg() ::%s failed\n", get_entity_name(ent)); } @@ -175,13 +174,15 @@ static void show_proj_failure(ir_node *n) { 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); + char type_name[256]; + ir_print_type(type_name, sizeof(type_name), ty); show_entity_failure(n); fprintf(stderr, " Proj %ld mode %s proj %ld (type %s mode %s) failed\n" , get_irn_node_nr(n), get_irn_modename(n), proj, - get_type_name(ty), + type_name, get_mode_name_ex(m)); } @@ -192,13 +193,15 @@ static void show_proj_failure_ent(ir_node *n, ir_entity *ent) { ir_node *op = get_Proj_pred(n); int proj = get_Proj_proj(n); ir_mode *m = get_type_mode(get_entity_type(ent)); + char type_name[256]; + ir_print_type(type_name, sizeof(type_name), get_entity_type(ent)); show_entity_failure(n); fprintf(stderr, " node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" , get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n), proj, get_irn_opname(op), get_irn_modename(op), - get_entity_name(ent), get_type_name(get_entity_type(ent)), + get_entity_name(ent), type_name, get_mode_name_ex(m)); } @@ -214,9 +217,11 @@ static void show_node_on_graph(ir_graph *irg, ir_node *n) { */ static void show_call_param(ir_node *n, ir_type *mt) { int i; + char type_name[256]; + ir_print_type(type_name, sizeof(type_name), mt); show_entity_failure(n); - fprintf(stderr, " Call type-check failed: %s(", get_type_name(mt)); + fprintf(stderr, " Call type-check failed: %s(", type_name); for (i = 0; i < get_method_n_params(mt); ++i) { fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i)))); } @@ -302,12 +307,10 @@ static int verify_node_Proj_Start(ir_node *n, ir_node *p) { ASSERT_AND_RET_DBG( ( (proj == pn_Start_X_initial_exec && mode == mode_X) || - (proj == pn_Start_M && mode == mode_M) || - (proj == pn_Start_P_frame_base && 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 */ + (proj == pn_Start_M && mode == mode_M) || + (proj == pn_Start_P_frame_base && mode_is_reference(mode)) || + (proj == pn_Start_P_tls && mode_is_reference(mode)) || + (proj == pn_Start_T_args && mode == mode_T) ), "wrong Proj from Start", 0, show_proj_failure(p); @@ -360,11 +363,10 @@ static int verify_node_Proj_InstOf(ir_node *n, ir_node *p) { ASSERT_AND_RET_DBG( ( - (proj == pn_InstOf_M_regular && mode == mode_M) || + (proj == pn_InstOf_M && mode == mode_M) || (proj == pn_InstOf_X_regular && mode == mode_X) || (proj == pn_InstOf_X_except && mode == mode_X) || - (proj == pn_InstOf_res && mode_is_reference(mode)) || - (proj == pn_InstOf_M_except && mode == mode_M) + (proj == pn_InstOf_res && mode_is_reference(mode)) ), "wrong Proj from InstOf", 0, show_proj_failure(p); @@ -381,11 +383,10 @@ static int verify_node_Proj_Call(ir_node *n, ir_node *p) { ASSERT_AND_RET_DBG( ( - (proj == pn_Call_M_regular && mode == mode_M) || + (proj == pn_Call_M && mode == mode_M) || (proj == pn_Call_X_regular && mode == mode_X) || (proj == pn_Call_X_except && mode == mode_X) || (proj == pn_Call_T_result && mode == mode_T) || - (proj == pn_Call_M_except && mode == mode_M) || (proj == pn_Call_P_value_res_base && mode_is_reference(mode)) ), "wrong Proj from Call", 0, @@ -400,7 +401,7 @@ static int verify_node_Proj_Call(ir_node *n, ir_node *p) { ASSERT_AND_RET( !is_NoMem(get_Call_mem(n)), "Exception Proj from FunctionCall", 0); - else if (proj == pn_Call_M_regular || proj == pn_Call_M_except) + else if (proj == pn_Call_M) ASSERT_AND_RET( (!is_NoMem(get_Call_mem(n)) || 1), "Memory Proj from FunctionCall", 0); @@ -690,15 +691,6 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) { show_proj_mode_failure(p, get_method_param_type(mt, proj)); ); } - } else if (nr == pn_Start_P_value_arg_base) { - ASSERT_AND_RET( - (proj >= 0 && mode_is_reference(mode)), - "wrong Proj from Proj from Start", 0 - ); - ASSERT_AND_RET( - (proj < get_method_n_params(mt)), - "More Projs for args than args in type", 0 - ); } break; @@ -791,10 +783,9 @@ static int verify_node_Proj_CopyB(ir_node *n, ir_node *p) { ASSERT_AND_RET_DBG( ( - (proj == pn_CopyB_M_regular && mode == mode_M) || + (proj == pn_CopyB_M && mode == mode_M) || (proj == pn_CopyB_X_regular && mode == mode_X) || - (proj == pn_CopyB_X_except && mode == mode_X) || - (proj == pn_CopyB_M_except && mode == mode_M) + (proj == pn_CopyB_X_except && mode == mode_X) ), "wrong Proj from CopyB", 0, show_proj_failure(p); @@ -840,10 +831,10 @@ 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); + ASSERT_AND_RET(get_irg_pinned(irg) == op_pin_state_floats || get_nodes_block(pred) == get_nodes_block(p), "Proj must be in same block as its predecessor", 0); op = get_irn_op(pred); @@ -1082,20 +1073,11 @@ static int verify_node_Const(ir_node *n, ir_graph *irg) { /** * verify a SymConst node */ -static int verify_node_SymConst(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); - if (is_Method_type(get_entity_type(ent)) && - get_irn_irg(n) != get_const_code_irg()) { -#if 1 - ASSERT_AND_RET((get_entity_peculiarity(ent) != peculiarity_description), - "A constant must address an existing method.", 0); -#endif - } - } ASSERT_AND_RET( /* SymConst: BB --> int*/ (mode_is_int(mymode) || @@ -1194,16 +1176,16 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) { get_Call_n_params(n) >= get_method_n_params(mt), "Number of args for Call doesn't match number of args in variadic type.", 0, - ir_fprintf(stderr, "Call %+F has %d params, method %s type %d\n", - n, get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt)); + ir_fprintf(stderr, "Call %+F has %d params, type %d\n", + n, get_Call_n_params(n), get_method_n_params(mt)); ); } else { ASSERT_AND_RET_DBG( get_Call_n_params(n) == get_method_n_params(mt), "Number of args for Call doesn't match number of args in non variadic type.", 0, - ir_fprintf(stderr, "Call %+F has %d params, method %s type %d\n", - n, get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt)); + ir_fprintf(stderr, "Call %+F has %d params, type %d\n", + n, get_Call_n_params(n), get_method_n_params(mt)); ); } @@ -1602,8 +1584,10 @@ static int verify_node_Phi(ir_node *n, ir_graph *irg) { int i; (void) irg; + /* a Phi node MUST have the same number of inputs as its block + * Exception is a phi with 0 inputs which is used when (re)constructing the + * SSA form */ if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building && get_irn_arity(n) > 0) { - /* a Phi node MUST have the same number of inputs as its block */ ASSERT_AND_RET_DBG( get_irn_arity(n) == get_irn_arity(block), "wrong number of inputs in Phi node", 0, @@ -1943,16 +1927,22 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) { * do NOT check placement in interprocedural view, as we don't always know * the "right" graph ... */ + +#ifndef NDEBUG + /* this seems to be an expensive check in VS compile (9% over all runtime), + so do NOT run it in release mode */ ASSERT_AND_RET_DBG( node_is_in_irgs_storage(irg, n), "Node is not stored on proper IR graph!", 0, show_node_on_graph(irg, n); ); +#endif 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)); + 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", n, node_from_map, node_from_map)); } } @@ -2002,7 +1992,7 @@ int irn_vrfy(ir_node *n) { */ static void vrfy_wrap(ir_node *node, void *env) { int *res = env; - *res = irn_vrfy(node); + *res = irn_vrfy_irg(node, current_ir_graph); } /** @@ -2012,7 +2002,7 @@ static void vrfy_wrap(ir_node *node, void *env) { static void vrfy_wrap_ssa(ir_node *node, void *env) { int *res = env; - *res = irn_vrfy(node); + *res = irn_vrfy_irg(node, current_ir_graph); if (*res) { *res = check_dominance_for_node(node); } @@ -2049,16 +2039,16 @@ int irg_verify(ir_graph *irg, unsigned flags) { NULL, &res ); - current_ir_graph = rem; - if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) { - ir_entity *ent = get_irg_entity(current_ir_graph); + ir_entity *ent = get_irg_entity(irg); if (ent) fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent)); else - fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph); + fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)irg); } + + current_ir_graph = rem; #else (void)irg; (void)flags; @@ -2067,6 +2057,37 @@ int irg_verify(ir_graph *irg, unsigned flags) { return res; } +struct pass_t { + ir_graph_pass_t pass; + unsigned flags; +}; + +/** + * Wrapper to irg_verify to be run as an ir_graph pass. + */ +static int irg_verify_wrapper(ir_graph *irg, void *context) { + struct pass_t *pass = context; + irg_verify(irg, pass->flags); + /* do NOT rerun the pass if verify is ok :-) */ + return 0; +} + +/* Creates an ir_graph pass for irg_verify(). */ +ir_graph_pass_t *irg_verify_pass(const char *name, unsigned flags) { + struct pass_t *pass = XMALLOCZ(struct pass_t); + + def_graph_pass_constructor( + &pass->pass, name ? name : "irg_verify", irg_verify_wrapper); + + /* neither dump for verify */ + pass->pass.dump_irg = (DUMP_ON_IRG_FUNC)ir_prog_no_dump; + pass->pass.verify_irg = (RUN_ON_IRG_FUNC)ir_prog_no_verify; + + pass->flags = flags; + return &pass->pass; +} + +/* create a verify pass */ int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string) { int res; firm_verification_t old = get_node_verification_mode();