X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeverify.c;h=7b3f5d4f093b80ec23cfad58f6402f1eec94a847;hb=f73b8014037f87fca038a96e04a9a8cc5354079c;hp=21e1a1769bfcf8d1088dfd7f4a0000faa239af28;hpb=657d38c542f0a034a737b8fa58637151cfa7b4ad;p=libfirm diff --git a/ir/be/beverify.c b/ir/be/beverify.c index 21e1a1769..7b3f5d4f0 100644 --- a/ir/be/beverify.c +++ b/ir/be/beverify.c @@ -217,6 +217,7 @@ static int should_be_scheduled(ir_node *node) { case iro_End: case iro_NoMem: case iro_Bad: + case iro_Unknown: return 0; default: break; @@ -265,7 +266,7 @@ int be_verify_schedule(ir_graph *irg) typedef struct _spill_t { ir_node *spill; - entity *ent; + ir_entity *ent; } spill_t; typedef struct { @@ -289,7 +290,7 @@ static spill_t *find_spill(be_verify_spillslots_env_t *env, ir_node *node) { return set_find(env->spills, &spill, sizeof(spill), HASH_PTR(node)); } -static spill_t *get_spill(be_verify_spillslots_env_t *env, ir_node *node, entity *ent) { +static spill_t *get_spill(be_verify_spillslots_env_t *env, ir_node *node, ir_entity *ent) { spill_t spill, *res; int hash = HASH_PTR(node); @@ -320,17 +321,17 @@ static ir_node *get_memory_edge(const ir_node *node) { return result; } -static void collect(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, entity* ent); +static void collect(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_entity* ent); -static void check_entity(be_verify_spillslots_env_t *env, ir_node *node, entity *ent) { +static void check_entity(be_verify_spillslots_env_t *env, ir_node *node, ir_entity *ent) { if(ent == NULL) { ir_fprintf(stderr, "Verify warning: Node %+F in block %+F(%s) should have an entity assigned\n", node, get_nodes_block(node), get_irg_dump_name(env->irg)); } } -static void collect_spill(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, entity* ent) { - entity *spillent = arch_get_frame_entity(env->arch_env, node); +static void collect_spill(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_entity* ent) { + ir_entity *spillent = arch_get_frame_entity(env->arch_env, node); check_entity(env, node, spillent); get_spill(env, node, ent); @@ -341,13 +342,13 @@ static void collect_spill(be_verify_spillslots_env_t *env, ir_node *node, ir_nod } } -static void collect_memperm(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, entity* ent) { +static void collect_memperm(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_entity* ent) { int i, arity; spill_t spill, *res; int hash = HASH_PTR(node); int out; ir_node* memperm; - entity *spillent; + ir_entity *spillent; assert(is_Proj(node)); @@ -373,13 +374,13 @@ static void collect_memperm(be_verify_spillslots_env_t *env, ir_node *node, ir_n for(i = 0, arity = be_get_MemPerm_entity_arity(memperm); i < arity; ++i) { ir_node* arg = get_irn_n(memperm, i + 1); - entity* argent = be_get_MemPerm_in_entity(memperm, i); + ir_entity* argent = be_get_MemPerm_in_entity(memperm, i); collect(env, arg, memperm, argent); } } -static void collect_memphi(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, entity *ent) { +static void collect_memphi(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_entity *ent) { int i, arity; spill_t spill, *res; int hash = HASH_PTR(node); @@ -402,7 +403,7 @@ static void collect_memphi(be_verify_spillslots_env_t *env, ir_node *node, ir_no } } -static void collect(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, entity* ent) { +static void collect(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_entity* ent) { if(be_is_Spill(node)) { collect_spill(env, node, reload, ent); } else if(is_Proj(node)) { @@ -430,7 +431,7 @@ static void collect_spills_walker(ir_node *node, void *data) { if(arch_irn_class_is(arch_env, node, reload)) { ir_node *spill = get_memory_edge(node); - entity *ent; + ir_entity *ent; if(spill == NULL) { ir_fprintf(stderr, "Verify warning: No spill attached to reload %+F in block %+F(%s)\n", @@ -483,7 +484,7 @@ static void check_lonely_spills(ir_node *node, void *data) { if(be_is_Spill(node) || (is_Proj(node) && be_is_MemPerm(get_Proj_pred(node)))) { spill_t *spill = find_spill(env, node); if(be_is_Spill(node)) { - entity *ent = arch_get_frame_entity(env->arch_env, node); + ir_entity *ent = arch_get_frame_entity(env->arch_env, node); check_entity(env, node, ent); } @@ -597,39 +598,48 @@ typedef struct _be_verify_register_allocation_env_t { } be_verify_register_allocation_env_t; 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_env_t *arch_env = env->arch_env; const arch_register_t *reg; - int i, arity; + int i, arity; - if(arch_get_irn_reg_class(arch_env, node, -1) != NULL) { + /* verify output register */ + if (arch_get_irn_reg_class(arch_env, node, -1) != NULL) { reg = arch_get_irn_register(arch_env, node); - if(reg == NULL) { + if (reg == NULL) { ir_fprintf(stderr, "Verify warning: Node %+F in block %+F(%s) should have a register assigned\n", node, get_nodes_block(node), get_irg_dump_name(env->irg)); env->problem_found = 1; } - if(reg != NULL && !arch_reg_is_allocatable(arch_env, node, -1, reg)) { + else if (! arch_register_type_is(reg, joker) && !arch_reg_is_allocatable(arch_env, node, -1, reg)) { ir_fprintf(stderr, "Verify warning: Register %s assigned as output of %+F not allowed (register constraint) in block %+F(%s)\n", reg->name, node, get_nodes_block(node), get_irg_dump_name(env->irg)); env->problem_found = 1; } } + /* verify input register */ arity = get_irn_arity(node); - for(i = 0; i < arity; ++i) { + for (i = 0; i < arity; ++i) { ir_node *pred = get_irn_n(node, i); - if(arch_get_irn_reg_class(arch_env, node, i) == NULL) + if (is_Bad(pred)) { + ir_fprintf(stderr, "Verify warning: %+F in block %+F(%s) has Bad as input %d\n", + node, get_nodes_block(node), get_irg_dump_name(env->irg), i); + env->problem_found = 1; + continue; + } + + if (arch_get_irn_reg_class(arch_env, node, i) == NULL) continue; reg = arch_get_irn_register(arch_env, pred); - if(reg == NULL) { + if (reg == NULL) { ir_fprintf(stderr, "Verify warning: Node %+F in block %+F(%s) should have a register assigned\n", pred, get_nodes_block(pred), get_irg_dump_name(env->irg)); env->problem_found = 1; continue; } - if(!arch_reg_is_allocatable(arch_env, node, i, reg)) { + else if (! arch_register_type_is(reg, joker) && ! arch_reg_is_allocatable(arch_env, node, i, reg)) { ir_fprintf(stderr, "Verify warning: Register %s as input %d of %+F not allowed (register constraint) in block %+F(%s)\n", reg->name, i, node, get_nodes_block(node), get_irg_dump_name(env->irg)); env->problem_found = 1; @@ -639,25 +649,30 @@ 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_env_t *arch_env = env->arch_env; - ir_node *node; - const arch_register_t *reg = NULL; - int fail = 0; - - bitset_t *registers = bitset_alloca(arch_register_class_n_regs(regclass)); + 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; foreach_pset(nodes, node) { - if(arch_get_irn_reg_class(arch_env, node, -1) != regclass) + if (arch_get_irn_reg_class(arch_env, node, -1) != regclass) continue; reg = arch_get_irn_register(arch_env, node); - if(bitset_is_set(registers, reg->index)) { + + /* this problem is already reported in 'check_register_constraints' */ + if (! reg) + continue; + + if (bitset_is_set(registers, reg->index)) { pset_break(nodes); fail = 1; break; } bitset_set(registers, reg->index); } + if (fail) { ir_fprintf(stderr, "Verify warning: Register %s assigned more than once in block %+F(%s)\n", reg->name, get_nodes_block(node), get_irg_dump_name(env->irg)); @@ -723,26 +738,33 @@ int be_verify_register_allocation(const arch_env_t *arch_env, ir_graph *irg) { typedef struct _verify_out_dead_nodes_env { ir_graph *irg; bitset_t *reachable; - bitset_t *visited; int problem_found; } verify_out_dead_nodes_env; static void check_out_edges(ir_node *node, verify_out_dead_nodes_env *env) { + ir_graph *irg = env->irg; const ir_edge_t* edge; + if(irn_visited(node)) + return; + mark_irn_visited(node); + foreach_out_edge(node, edge) { ir_node* src = get_edge_src_irn(edge); if(!bitset_is_set(env->reachable, get_irn_idx(src))) { - ir_fprintf(stderr, "Verify warning: Node %+F in block %+F(%s) only reachable through out edges from %+F\n", - src, get_nodes_block(src), get_irg_dump_name(env->irg), node); - env->problem_found = 1; + if(src != get_irg_globals(irg) + && src != get_irg_tls(irg)) { + ir_fprintf(stderr, + "Verify warning: Node %+F in block %+F(%s) only reachable through out edges from %+F\n", + src, get_nodes_block(src), get_irg_dump_name(irg), node); + env->problem_found = 1; + } + continue; } - if(!bitset_is_set(env->visited, get_irn_idx(src))) { - bitset_set(env->visited, get_irn_idx(src)); - if(!is_Block(src)) - check_out_edges(src, env); + if(!is_Block(src)) { + check_out_edges(src, env); } } } @@ -757,10 +779,10 @@ int be_verify_out_edges(ir_graph *irg) { verify_out_dead_nodes_env env; env.irg = irg; env.reachable = bitset_alloca(get_irg_last_idx(irg)); - env.visited = bitset_alloca(get_irg_last_idx(irg)); env.problem_found = 0; irg_walk_graph(irg, set_reachable, NULL, env.reachable); + inc_irg_visited(irg); check_out_edges(get_irg_start(irg), &env); return !env.problem_found;