Generate new_bd_* instead of new_rd_* functions in the backend. The nodes are always...

[libfirm] / ir / be / beverify.c

diff --git a/ir/be/beverify.c b/ir/be/beverify.c
index e5a41aa..c49be92 100644 (file)
--- a/ir/be/beverify.c
+++ b/ir/be/beverify.c
@@ -284,31 +284,28 @@ static void verify_schedule_walker(ir_node *block, void *data) {
 
 static int should_be_scheduled(ir_node *node)
 {
-       if(is_Block(node))
-               return -1;
-
-       if(is_Proj(node))
-               return 0;
-
-       if(get_irn_mode(node) == mode_M) {
-               if(is_Phi(node) || is_Sync(node) || is_Pin(node))
-                       return 0;
-       }
-       if(be_is_Keep(node) && get_irn_opcode(get_nodes_block(node)) == iro_Bad)
-               return 0;
-
        switch(get_irn_opcode(node)) {
+       case iro_Bad:
+       case iro_Block:
        case iro_End:
        case iro_NoMem:
-       case iro_Bad:
+       case iro_Pin:
+       case iro_Proj:
+       case iro_Sync:
        case iro_Unknown:
                return 0;
+       case iro_Phi:
+               if (get_irn_mode(node) == mode_M)
+                       return 0;
+               break;
        default:
                break;
        }
 
-       if (arch_irn_get_flags(node) & arch_irn_flags_ignore)
-               return -1;
+       if (get_irn_mode(node) != mode_T) {
+               if (arch_irn_is_ignore(node))
+                       return -1;
+       }
 
        return 1;
 }
@@ -544,11 +541,12 @@ static void collect_spills_walker(ir_node *node, void *data) {
        }
 }
 
-static void check_spillslot_interference(be_verify_spillslots_env_t *env) {
-       int spillcount = set_count(env->spills);
-       spill_t **spills = alloca(spillcount * sizeof(spills[0]));
-       spill_t *spill;
-       int i;
+static void check_spillslot_interference(be_verify_spillslots_env_t *env)
+{
+       int       spillcount = set_count(env->spills);
+       spill_t **spills     = ALLOCAN(spill_t*, spillcount);
+       spill_t  *spill;
+       int       i;
 
        for(spill = set_first(env->spills), i = 0; spill != NULL; spill = set_next(env->spills), ++i) {
                spills[i] = spill;
@@ -697,13 +695,13 @@ static void check_register_constraints(ir_node *node)
        int                   i, arity;
 
        /* verify output register */
-       if (arch_get_irn_reg_class(node, -1) != NULL) {
+       if (arch_get_irn_reg_class_out(node) != NULL) {
                reg = arch_get_irn_register(node);
                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(irg));
                        problem_found = 1;
-               } else if (!arch_register_type_is(reg, joker) && !arch_reg_is_allocatable(node, -1, reg)) {
+               } else if (!arch_register_type_is(reg, joker) && !arch_reg_out_is_allocatable(node, 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(irg));
                        problem_found = 1;
@@ -766,11 +764,11 @@ static void value_used(ir_node *node) {
        const arch_register_t *reg;
        ir_node               *reg_node;
 
-       if (arch_get_irn_reg_class(node, -1) != regclass)
+       if (arch_get_irn_reg_class_out(node) != regclass)
                return;
 
        reg = arch_get_irn_register(node);
-       if (reg->type & arch_register_type_virtual)
+       if (reg == NULL || reg->type & arch_register_type_virtual)
                return;
 
        reg_node = registers[reg->index];
@@ -789,11 +787,11 @@ static void value_def(ir_node *node)
        const arch_register_t *reg;
        ir_node               *reg_node;
 
-       if (arch_get_irn_reg_class(node, -1) != regclass)
+       if (arch_get_irn_reg_class_out(node) != regclass)
                return;
 
        reg = arch_get_irn_register(node);
-       if (reg->type & arch_register_type_virtual)
+       if (reg == NULL || reg->type & arch_register_type_virtual)
                return;
 
        reg_node = registers[reg->index];
@@ -820,8 +818,7 @@ static void verify_block_register_allocation(ir_node *block, void *data) {
                assert(lv->nodes && "live sets must be computed");
 
                n_regs    = arch_register_class_n_regs(regclass);
-               registers = alloca(n_regs * sizeof(registers[0]));
-               memset(registers, 0, n_regs * sizeof(registers[0]));
+               registers = ALLOCANZ(ir_node*, n_regs);
 
                be_lv_foreach(lv, block, be_lv_state_end, idx) {
                        ir_node *node = be_lv_get_irn(lv, block, idx);