2 * Author: Matthias Braun
4 * Copyright: (c) Universitaet Karlsruhe
5 * License: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
14 #include "besched_t.h"
23 typedef struct be_verify_register_pressure_env_t_ {
24 ir_graph *irg; /**< the irg to verify */
25 const arch_env_t *arch_env; /**< an architecture environment */
26 const arch_register_class_t *cls; /**< the register class to check for */
27 int registers_available; /**< number of available registers */
28 int problem_found; /**< flag indicating if a problem was found */
29 } be_verify_register_pressure_env_t;
32 * Print all nodes of a pset into a file.
34 static void print_living_values(FILE *F, pset *live_nodes)
39 foreach_pset(live_nodes, node) {
40 ir_fprintf(F, "%+F ", node);
46 * Check if number of live nodes never exceeds the number of available registers.
48 static void verify_liveness_walker(ir_node *block, void *data)
50 be_verify_register_pressure_env_t *env = (be_verify_register_pressure_env_t *)data;
51 pset *live_nodes = pset_new_ptr_default();
55 /* collect register pressure info, start with end of a block */
56 be_liveness_end_of_block(env->arch_env, env->cls, block, live_nodes);
58 pressure = pset_count(live_nodes);
59 if(pressure > env->registers_available) {
60 ir_fprintf(stderr, "Verify Warning: Register pressure too high at end of block %+F(%s) (%d/%d):\n",
61 block, get_irg_dump_name(env->irg), pressure, env->registers_available);
62 print_living_values(stderr, live_nodes);
63 env->problem_found = 1;
66 sched_foreach_reverse(block, irn) {
70 be_liveness_transfer(env->arch_env, env->cls, irn, live_nodes);
72 pressure = pset_count(live_nodes);
74 if(pressure > env->registers_available) {
75 ir_fprintf(stderr, "Verify Warning: Register pressure too high before node %+F in %+F(%s) (%d/%d):\n",
76 irn, block, get_irg_dump_name(env->irg), pressure, env->registers_available);
77 print_living_values(stderr, live_nodes);
78 env->problem_found = 1;
85 * Start a walk over the irg and check the register pressure.
87 int be_verify_register_pressure(const arch_env_t *arch_env, const arch_register_class_t *cls, ir_graph *irg)
89 be_verify_register_pressure_env_t env;
94 env.arch_env = arch_env;
96 env.registers_available = arch_count_non_ignore_regs(arch_env, cls);
97 env.problem_found = 0;
99 irg_block_walk_graph(irg, verify_liveness_walker, NULL, &env);
101 return ! env.problem_found;
104 typedef struct be_verify_schedule_env_t_ {
105 int problem_found; /**< flags indicating if there was a problem */
106 ir_graph *irg; /**< the irg to check */
107 } be_verify_schedule_env_t;
110 * Simple schedule checker.
112 static void verify_schedule_walker(ir_node *block, void *data)
114 be_verify_schedule_env_t *env = (be_verify_schedule_env_t*) data;
116 int non_phi_found = 0;
117 int cfchange_found = 0;
118 // TODO ask arch about delay branches
119 int delay_branches = 0;
120 pset *uses = pset_new_ptr_default();
123 * Tests for the following things:
124 * 1. Make sure that all phi nodes are scheduled at the beginning of the block
125 * 2. There is 1 or no control flow changing node scheduled and exactly delay_branches operations after it.
126 * 3. No value is defined after it has been used
128 sched_foreach(block, node) {
134 ir_fprintf(stderr, "Verify Warning: Phi node %+F scheduled after non-Phi nodes in block %+F (%s)\n",
135 node, block, get_irg_dump_name(env->irg));
136 env->problem_found = 1;
142 // 2. Check for control flow changing nodes
143 if (is_cfop(node) && get_irn_opcode(node) != iro_Start) {
144 /* check, that only one CF operation is scheduled */
145 if (cfchange_found == 1) {
146 ir_fprintf(stderr, "Verify Warning: More than 1 control flow changing node (%+F) scheduled in block %+F (%s)\n",
147 node, block, get_irg_dump_name(env->irg));
148 env->problem_found = 1;
151 } else if (cfchange_found) {
152 // proj and keepany aren't real instructions...
153 if(!is_Proj(node) && !be_is_Keep(node)) {
154 /* check for delay branches */
155 if (delay_branches == 0) {
156 ir_fprintf(stderr, "Verify Warning: Node %+F scheduled after control flow changing node (+delay branches) in block %+F (%s)\n",
157 node, block, get_irg_dump_name(env->irg));
158 env->problem_found = 1;
166 if(pset_find_ptr(uses, node)) {
167 ir_fprintf(stderr, "Verify Warning: Value %+F used before it was defined in block %+F (%s)\n",
168 node, block, get_irg_dump_name(env->irg));
169 env->problem_found = 1;
172 for(i = 0, arity = get_irn_arity(node); i < arity; ++i) {
173 pset_insert_ptr(uses, get_irn_n(node, i));
179 /* check that all delay branches are filled (at least with NOPs) */
180 if (cfchange_found && delay_branches != 0) {
181 ir_fprintf(stderr, "Not all delay slots filled after jump (%d/%d) in block %+F (%s)\n",
182 block, get_irg_dump_name(env->irg));
183 env->problem_found = 1;
188 * Start a walk over the irg and check schedule.
190 int be_verify_schedule(ir_graph *irg)
192 be_verify_schedule_env_t env;
194 env.problem_found = 0;
197 irg_block_walk_graph(irg, verify_schedule_walker, NULL, &env);
199 return ! env.problem_found;