X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeverify.c;h=9bb6c885b1fb3eee70e59baf3aae5c5b7fab7a64;hb=d07cec1341e61a5321ec44d93455bbbac312be75;hp=74df99fa58b7e384303f201823e9b2becc3b2d31;hpb=bb5461e3f6f900c09222814f2eec779684f28f73;p=libfirm diff --git a/ir/be/beverify.c b/ir/be/beverify.c index 74df99fa5..9bb6c885b 100644 --- a/ir/be/beverify.c +++ b/ir/be/beverify.c @@ -62,11 +62,12 @@ typedef struct be_verify_register_pressure_env_t_ { /** * Print all nodes of a pset into a file. */ -static void print_living_values(FILE *F, pset *live_nodes) { +static void print_living_values(FILE *F, const ir_nodeset_t *live_nodes) { + ir_nodeset_iterator_t iter; ir_node *node; ir_fprintf(F, "\t"); - foreach_pset(live_nodes, node) { + foreach_ir_nodeset(live_nodes, node, iter) { ir_fprintf(F, "%+F ", node); } ir_fprintf(F, "\n"); @@ -77,18 +78,20 @@ static void print_living_values(FILE *F, pset *live_nodes) { */ static void verify_liveness_walker(ir_node *block, void *data) { be_verify_register_pressure_env_t *env = (be_verify_register_pressure_env_t *)data; - pset *live_nodes = pset_new_ptr_default(); + ir_nodeset_t live_nodes; ir_node *irn; int pressure; /* collect register pressure info, start with end of a block */ - be_liveness_end_of_block(env->lv, env->arch_env, env->cls, block, live_nodes); + ir_nodeset_init(&live_nodes); + be_liveness_end_of_block(env->lv, env->arch_env, env->cls, block, + &live_nodes); - pressure = pset_count(live_nodes); + pressure = ir_nodeset_size(&live_nodes); if(pressure > env->registers_available) { ir_fprintf(stderr, "Verify Warning: Register pressure too high at end of block %+F(%s) (%d/%d):\n", block, get_irg_dump_name(env->irg), pressure, env->registers_available); - print_living_values(stderr, live_nodes); + print_living_values(stderr, &live_nodes); env->problem_found = 1; } @@ -96,18 +99,18 @@ static void verify_liveness_walker(ir_node *block, void *data) { if (is_Phi(irn)) break; - be_liveness_transfer(env->arch_env, env->cls, irn, live_nodes); + be_liveness_transfer(env->arch_env, env->cls, irn, &live_nodes); - pressure = pset_count(live_nodes); + pressure = ir_nodeset_size(&live_nodes); if(pressure > env->registers_available) { ir_fprintf(stderr, "Verify Warning: Register pressure too high before node %+F in %+F(%s) (%d/%d):\n", irn, block, get_irg_dump_name(env->irg), pressure, env->registers_available); - print_living_values(stderr, live_nodes); + print_living_values(stderr, &live_nodes); env->problem_found = 1; } } - del_pset(live_nodes); + ir_nodeset_destroy(&live_nodes); } /** @@ -134,7 +137,7 @@ int be_verify_register_pressure(const be_irg_t *birg, -//--------------------------------------------------------------------------- +/*--------------------------------------------------------------------------- */ @@ -153,7 +156,7 @@ static void verify_schedule_walker(ir_node *block, void *data) { ir_node *node; int non_phi_found = 0; int cfchange_found = 0; - // TODO ask arch about delay branches + /* TODO ask arch about delay branches */ int delay_branches = 0; int last_timestep = INT_MIN; @@ -169,20 +172,20 @@ static void verify_schedule_walker(ir_node *block, void *data) { int i, arity; int timestep; - // this node is scheduled + /* this node is scheduled */ if(bitset_is_set(env->scheduled, get_irn_idx(node))) { ir_fprintf(stderr, "Verify warning: %+F appears to be schedule twice\n"); env->problem_found = 1; } bitset_set(env->scheduled, get_irn_idx(node)); - // Check that scheduled nodes are in the correct block + /* Check that scheduled nodes are in the correct block */ if(get_nodes_block(node) != block) { ir_fprintf(stderr, "Verify warning: %+F is in block %+F but scheduled in %+F\n", node, get_nodes_block(node), block); env->problem_found = 1; } - // Check that timesteps are increasing + /* Check that timesteps are increasing */ timestep = sched_get_time_step(node); if(timestep <= last_timestep) { ir_fprintf(stderr, "Verify warning: Schedule timestep did not increase at node %+F\n", @@ -191,7 +194,7 @@ static void verify_schedule_walker(ir_node *block, void *data) { } last_timestep = timestep; - // Check that phis come before any other node + /* Check that phis come before any other node */ if (is_Phi(node)) { if (non_phi_found) { ir_fprintf(stderr, "Verify Warning: Phi node %+F scheduled after non-Phi nodes in block %+F (%s)\n", @@ -202,7 +205,7 @@ static void verify_schedule_walker(ir_node *block, void *data) { non_phi_found = 1; } - // Check for control flow changing nodes + /* Check for control flow changing nodes */ if (is_cfop(node) && get_irn_opcode(node) != iro_Start) { /* check, that only one CF operation is scheduled */ if (cfchange_found == 1) { @@ -212,7 +215,7 @@ static void verify_schedule_walker(ir_node *block, void *data) { } cfchange_found = 1; } else if (cfchange_found) { - // proj and keepany aren't real instructions... + /* proj and keepany aren't real instructions... */ if(!is_Proj(node) && !be_is_Keep(node)) { /* check for delay branches */ if (delay_branches == 0) { @@ -225,7 +228,7 @@ static void verify_schedule_walker(ir_node *block, void *data) { } } - // Check that all uses come before their definitions + /* Check that all uses come before their definitions */ if(!is_Phi(node)) { int nodetime = sched_get_time_step(node); for(i = 0, arity = get_irn_arity(node); i < arity; ++i) { @@ -242,14 +245,15 @@ static void verify_schedule_walker(ir_node *block, void *data) { } } - // Check that no dead nodes are scheduled + /* Check that no dead nodes are scheduled */ if(get_irn_n_edges(node) == 0) { ir_fprintf(stderr, "Verify warning: Node %+F is dead but scheduled in block %+F (%s)\n", node, block, get_irg_dump_name(env->irg)); env->problem_found = 1; } - // check that all projs/keeps are behind their nodes +#ifdef SCHEDULE_PROJS + /* check that all projs/keeps are behind their nodes */ if(is_Proj(node)) { ir_node *prev = sched_prev(node); while(is_Proj(prev)) @@ -260,35 +264,18 @@ static void verify_schedule_walker(ir_node *block, void *data) { env->problem_found = 1; } } +#endif if(be_is_Keep(node)) { - int arity = get_irn_arity(node); - int problem = 0; + /* at least 1 of the keep arguments has to be it schedule + * predecessor */ + int arity = get_irn_arity(node); + int problem = 1; + ir_node *prev = sched_prev(node); for(i = 0; i < arity; ++i) { ir_node *in = get_irn_n(node, i); - ir_node *succ = sched_next(in); - while(succ != node && !sched_is_end(succ)) { - /* the node in between has to be another input of the - * keep or a Proj */ - int i2; - int found = 0; - - if(is_Proj(succ)) { - succ = sched_next(succ); - continue; - } - - for(i2 = 0; i2 < arity; ++i2) { - ir_node *in2 = get_irn_n(node, i2); - if(in2 == succ) { - found = 1; - break; - } - } - if(!found) - problem = 1; - - succ = sched_next(succ); - } + in = skip_Proj(in); + if(in == prev) + problem = 0; } if(problem) { ir_fprintf(stderr, "%+F not scheduled after its pred node in block %+F (%s)\n", @@ -316,11 +303,16 @@ static int should_be_scheduled(be_verify_schedule_env_t *env, ir_node *node) { if(is_Phi(node) || is_Sync(node) || is_Pin(node)) return 0; } +#ifdef SCHEDULE_PROJS if(is_Proj(node)) { if(get_irn_mode(node) == mode_X) return 0; return should_be_scheduled(env, get_Proj_pred(node)); } +#else + if(is_Proj(node)) + return 0; +#endif if(be_is_Keep(node) && get_irn_opcode(get_nodes_block(node)) == iro_Bad) return 0; @@ -371,7 +363,7 @@ int be_verify_schedule(const be_irg_t *birg) env.arch_env = birg->main_env->arch_env; irg_block_walk_graph(env.irg, verify_schedule_walker, NULL, &env); - // check if all nodes are scheduled + /* check if all nodes are scheduled */ irg_walk_graph(env.irg, check_schedule, NULL, &env); return ! env.problem_found; @@ -379,7 +371,7 @@ int be_verify_schedule(const be_irg_t *birg) -//--------------------------------------------------------------------------- +/*--------------------------------------------------------------------------- */ @@ -520,7 +512,7 @@ static void collect_memphi(be_verify_spillslots_env_t *env, ir_node *node, ir_no spill.ent = ent; res = set_insert(env->spills, &spill, sizeof(spill), hash); - // is 1 of the arguments a spill? + /* is 1 of the arguments a spill? */ for(i = 0, arity = get_irn_arity(node); i < arity; ++i) { ir_node* arg = get_irn_n(node, i); collect(env, arg, reload, ent); @@ -535,7 +527,7 @@ static void collect(be_verify_spillslots_env_t *env, ir_node *node, ir_node *rel } else if(is_Phi(node) && get_irn_mode(node) == mode_M) { collect_memphi(env, node, reload, ent); } else { - // Disabled for now, spills might get transformed by the backend + /* Disabled for now, spills might get transformed by the backend */ #if 0 ir_fprintf(stderr, "Verify warning: No spill, memperm or memphi attached to node %+F found from node %+F in block %+F(%s)\n", node, reload, get_nodes_block(node), get_irg_dump_name(env->irg)); @@ -552,7 +544,7 @@ static void collect_spills_walker(ir_node *node, void *data) { be_verify_spillslots_env_t *env = data; const arch_env_t *arch_env = env->arch_env; - // @@@ ia32_classify returns classification of Proj_pred :-/ + /* @@@ ia32_classify returns classification of Proj_pred :-/ */ if(is_Proj(node)) return; @@ -645,7 +637,7 @@ int be_verify_spillslots(const arch_env_t *arch_env, ir_graph *irg) -//--------------------------------------------------------------------------- +/*--------------------------------------------------------------------------- */ @@ -696,7 +688,7 @@ static int my_values_interfere(const ir_node *a, const ir_node *b) { if(get_irn_opcode(user) == iro_End) continue; - // in case of phi arguments we compare with the block the value comes from + /* in case of phi arguments we compare with the block the value comes from */ if(is_Phi(user)) { ir_node *phiblock = get_nodes_block(user); if(phiblock == bb) @@ -713,7 +705,7 @@ static int my_values_interfere(const ir_node *a, const ir_node *b) { -//--------------------------------------------------------------------------- +/*--------------------------------------------------------------------------- */ @@ -724,7 +716,9 @@ typedef struct _be_verify_register_allocation_env_t { int problem_found; } be_verify_register_allocation_env_t; -static void check_register_constraints(ir_node *node, be_verify_register_allocation_env_t *env) { +static void check_register_constraints(ir_node *node, + be_verify_register_allocation_env_t *env) +{ const arch_env_t *arch_env = env->arch_env; const arch_register_t *reg; int i, arity; @@ -778,14 +772,17 @@ static void check_register_constraints(ir_node *node, be_verify_register_allocat } static void check_register_allocation(be_verify_register_allocation_env_t *env, - const arch_register_class_t *regclass, pset *nodes) { + const arch_register_class_t *regclass, + ir_nodeset_t *nodes) +{ const arch_env_t *arch_env = env->arch_env; const arch_register_t *reg = NULL; int fail = 0; bitset_t *registers = bitset_alloca(arch_register_class_n_regs(regclass)); ir_node *node; + ir_nodeset_iterator_t iter; - foreach_pset(nodes, node) { + foreach_ir_nodeset(nodes, node, iter) { if (arch_get_irn_reg_class(arch_env, node, -1) != regclass) continue; @@ -796,7 +793,6 @@ static void check_register_allocation(be_verify_register_allocation_env_t *env, continue; if (bitset_is_set(registers, reg->index)) { - pset_break(nodes); fail = 1; break; } @@ -808,7 +804,7 @@ static void check_register_allocation(be_verify_register_allocation_env_t *env, reg->name, get_nodes_block(node), get_irg_dump_name(env->irg)); env->problem_found = 1; - foreach_pset(nodes, node) { + foreach_ir_nodeset(nodes, node, iter) { if (arch_get_irn_register(arch_env, node) == reg) { ir_fprintf(stderr, " at node %+F\n", node); } @@ -826,21 +822,24 @@ static void verify_block_register_allocation(ir_node *block, void *data) { for (i = 0; i < nregclasses; ++i) { const arch_register_class_t *regclass = arch_isa_get_reg_class(isa, i); ir_node *node; - pset *live_nodes = pset_new_ptr_default(); + ir_nodeset_t live_nodes; + + ir_nodeset_init(&live_nodes); - be_liveness_end_of_block(env->lv, env->arch_env, regclass, block, live_nodes); - check_register_allocation(env, regclass, live_nodes); + be_liveness_end_of_block(env->lv, env->arch_env, regclass, block, + &live_nodes); + check_register_allocation(env, regclass, &live_nodes); sched_foreach_reverse(block, node) { if (is_Phi(node)) break; - be_liveness_transfer(env->arch_env, regclass, node, live_nodes); - check_register_allocation(env, regclass, live_nodes); + be_liveness_transfer(env->arch_env, regclass, node, &live_nodes); + check_register_allocation(env, regclass, &live_nodes); check_register_constraints(node, env); } - del_pset(live_nodes); + ir_nodeset_destroy(&live_nodes); } } @@ -862,7 +861,7 @@ int be_verify_register_allocation(const arch_env_t *arch_env, ir_graph *irg) { -//--------------------------------------------------------------------------- +/*--------------------------------------------------------------------------- */