From: Christian Würdig Date: Tue, 30 May 2006 09:02:35 +0000 (+0000) Subject: added comments X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=7571a0e5b826f0ca01e2719fcf2b5e7f0d3e8796;p=libfirm added comments fixed indents fixed CRLF --- diff --git a/ir/be/beverify.c b/ir/be/beverify.c index bcbb0514f..b75c54519 100644 --- a/ir/be/beverify.c +++ b/ir/be/beverify.c @@ -1,9 +1,9 @@ /* - * Author: Matthias Braun - * Date: 05.05.2006 - * Copyright: (c) Universitaet Karlsruhe - * License: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. - * + * Author: Matthias Braun + * Date: 05.05.2006 + * Copyright: (c) Universitaet Karlsruhe + * License: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * CVS-Id: $Id$ */ #ifdef HAVE_CONFIG_H #include "config.h" @@ -20,96 +20,102 @@ #include "irdump_t.h" typedef struct be_verify_register_pressure_env_t_ { - ir_graph *irg; - const arch_env_t *arch_env; - const arch_register_class_t *cls; - int registers_available; - int problem_found; + ir_graph *irg; /**< the irg to verify */ + const arch_env_t *arch_env; /**< an architecture environment */ + const arch_register_class_t *cls; /**< the register class to check for */ + int registers_available; /**< number of available registers */ + int problem_found; /**< flag indicating if a problem was found */ } be_verify_register_pressure_env_t; -static void print_living_values(pset *live_nodes) +/** + * Print all nodes of a pset into a file. + */ +static void print_living_values(FILE *F, pset *live_nodes) { ir_node *node; - ir_printf("\t"); + ir_fprintf(F, "\t"); foreach_pset(live_nodes, node) { - ir_printf("%+F ", node); + ir_fprintf(F, "%+F ", node); } - ir_printf("\n"); + ir_fprintf(F, "\n"); } +/** + * Check if number of live nodes never exceeds the number of available registers. + */ static void verify_liveness_walker(ir_node *bl, void *data) { - be_verify_register_pressure_env_t *env = (be_verify_register_pressure_env_t*) data; - int pressure; - pset *live_nodes = pset_new_ptr_default(); + be_verify_register_pressure_env_t *env = (be_verify_register_pressure_env_t *)data; + pset *live_nodes = pset_new_ptr_default(); ir_node *irn; - // collect register pressure info + /* collect register pressure info, start with end of a block */ be_liveness_end_of_block(env->arch_env, env->cls, bl, live_nodes); - pressure = pset_count(live_nodes); - if(pressure > env->registers_available) { - ir_printf("Verify Warning: Register pressure too high at end of block %+F(%s) (%d/%d):\n", - bl, get_irg_dump_name(env->irg), pressure, env->registers_available); - print_living_values(live_nodes); - env->problem_found = 1; - } + sched_foreach_reverse(bl, irn) { - int pressure; + int pressure = pset_count(live_nodes); - if(is_Phi(irn)) + if (is_Phi(irn)) break; - be_liveness_transfer(env->arch_env, env->cls, irn, live_nodes); - pressure = pset_count(live_nodes); - if(pressure > env->registers_available) { - ir_printf("Verify Warning: Register pressure too high before %+F (in block %+F(%s) (%d/%d).\n", - irn, bl, get_irg_dump_name(env->irg), pressure, env->registers_available); - print_living_values(live_nodes); + ir_fprintf(stderr, "Verify Warning: Register pressure too high at end of block %+F(%s) (%d/%d):\n", + bl, get_irg_dump_name(env->irg), pressure, env->registers_available); + print_living_values(stderr, live_nodes); env->problem_found = 1; } + + be_liveness_transfer(env->arch_env, env->cls, irn, live_nodes); } del_pset(live_nodes); } +/** + * Start a walk over the irg and check the register pressure. + */ int be_verify_register_pressure(const arch_env_t *arch_env, const arch_register_class_t *cls, ir_graph *irg) { be_verify_register_pressure_env_t env; be_liveness(irg); - env.irg = irg; - env.arch_env = arch_env; - env.cls = cls; + env.irg = irg; + env.arch_env = arch_env; + env.cls = cls; env.registers_available = arch_count_non_ignore_regs(arch_env, cls); - env.problem_found = 0; + env.problem_found = 0; - return !env.problem_found; + irg_block_walk_graph(irg, verify_liveness_walker, NULL, &env); + + return ! env.problem_found; } typedef struct be_verify_schedule_env_t_ { - int problem_found; - ir_graph *irg; + int problem_found; /**< flags indicating if there was a problem */ + ir_graph *irg; /**< the irg to check */ } be_verify_schedule_env_t; +/** + * Simple schedule checker. + */ static void verify_schedule_walker(ir_node *bl, void *data) { be_verify_schedule_env_t *env = (be_verify_schedule_env_t*) data; ir_node *irn; - int non_phi_found = 0; + int non_phi_found = 0; int cfchange_found = 0; // TODO ask ABI about delay branches int delay_branches = 0; /* - * Make sure that all phi nodes are scheduled at the beginning of the block, and that there - * is 1 or no control flow changing node scheduled as last operation + Make sure that all phi nodes are scheduled at the beginning of the block, and that there + is 1 or no control flow changing node scheduled as last operation */ sched_foreach(bl, irn) { - if(is_Phi(irn)) { - if(non_phi_found) { - ir_printf("Verify Warning: Phi node %+F scheduled after non-Phi nodes in block %+F (%s)\n", + if (is_Phi(irn)) { + if (non_phi_found) { + ir_fprintf(stderr, "Verify Warning: Phi node %+F scheduled after non-Phi nodes in block %+F (%s)\n", irn, bl, get_irg_dump_name(env->irg)); env->problem_found = 1; } @@ -117,16 +123,18 @@ static void verify_schedule_walker(ir_node *bl, void *data) } non_phi_found = 1; - if(is_cfop(irn) && get_irn_opcode(irn) != iro_Start) { - if(cfchange_found == 1) { - ir_printf("Verify Warning: More than 1 control flow changing node (%+F) scheduled in block %+F (%s)\n", + if (is_cfop(irn) && get_irn_opcode(irn) != iro_Start) { + /* check, that only one CF operation is scheduled */ + if (cfchange_found == 1) { + ir_fprintf(stderr, "Verify Warning: More than 1 control flow changing node (%+F) scheduled in block %+F (%s)\n", irn, bl, get_irg_dump_name(env->irg)); env->problem_found = 1; } cfchange_found = 1; - } else if(cfchange_found) { - if(delay_branches == 0) { - ir_printf("Verify Warning: Node %+F scheduled after control flow changing node (+delay branches) in block %+F (%s)\n", + } else if (cfchange_found) { + /* check for delay branches */ + if (delay_branches == 0) { + ir_fprintf(stderr, "Verify Warning: Node %+F scheduled after control flow changing node (+delay branches) in block %+F (%s)\n", irn, bl, get_irg_dump_name(env->irg)); env->problem_found = 1; } else { @@ -135,21 +143,25 @@ static void verify_schedule_walker(ir_node *bl, void *data) } } - if(cfchange_found && delay_branches != 0) { - ir_printf("Not all delay slots filled after jump (%d/%d) in block %+F (%s)\n", + /* check that all delay branches are used (at least with NOPs) */ + if (cfchange_found && delay_branches != 0) { + ir_fprintf(stderr, "Not all delay slots filled after jump (%d/%d) in block %+F (%s)\n", bl, get_irg_dump_name(env->irg)); env->problem_found = 1; } } +/** + * Start a walk over the irg and check schedule. + */ int be_verify_schedule(ir_graph *irg) { be_verify_schedule_env_t env; env.problem_found = 0; - env.irg = irg; + env.irg = irg; irg_block_walk_graph(irg, verify_schedule_walker, NULL, &env); - return !env.problem_found; + return ! env.problem_found; }