#include "beverify.h"
#include "belive.h"
#include "besched.h"
-#include "benode_t.h"
+#include "benode.h"
#include "beirg.h"
#include "beintlive_t.h"
/**
* Print all nodes of a pset into a file.
*/
-static void print_living_values(FILE *F, const ir_nodeset_t *live_nodes) {
+static void print_living_values(FILE *F, const ir_nodeset_t *live_nodes)
+{
ir_nodeset_iterator_t iter;
ir_node *node;
/**
* Check if number of live nodes never exceeds the number of available registers.
*/
-static void verify_liveness_walker(ir_node *block, void *data) {
+static void verify_liveness_walker(ir_node *block, void *data)
+{
be_verify_register_pressure_env_t *env = (be_verify_register_pressure_env_t *)data;
ir_nodeset_t live_nodes;
ir_node *irn;
/**
* Simple schedule checker.
*/
-static void verify_schedule_walker(ir_node *block, void *data) {
+static void verify_schedule_walker(ir_node *block, void *data)
+{
be_verify_schedule_env_t *env = (be_verify_schedule_env_t*) data;
ir_node *node;
ir_node *non_phi_found = NULL;
env->problem_found = 1;
}
- if(be_is_Keep(node)) {
+ if(be_is_Keep(node) || be_is_CopyKeep(node)) {
/* 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);
- while(be_is_Keep(prev))
+ while(be_is_Keep(prev) || be_is_CopyKeep(prev))
prev = sched_prev(prev);
for(i = 0; i < arity; ++i) {
if (get_irn_mode(node) == mode_M)
return 0;
break;
+ case iro_Start:
+ case iro_Jmp:
+ case beo_Return:
+ return 1;
default:
break;
}
return 1;
}
-static void check_schedule(ir_node *node, void *data) {
+static void check_schedule(ir_node *node, void *data)
+{
be_verify_schedule_env_t *env = data;
int should_be;
int scheduled;
int problem_found;
} be_verify_spillslots_env_t;
-static int cmp_spill(const void* d1, const void* d2, size_t size) {
+static int cmp_spill(const void* d1, const void* d2, size_t size)
+{
const spill_t* s1 = d1;
const spill_t* s2 = d2;
(void) size;
return s1->spill != s2->spill;
}
-static spill_t *find_spill(be_verify_spillslots_env_t *env, ir_node *node) {
+static spill_t *find_spill(be_verify_spillslots_env_t *env, ir_node *node)
+{
spill_t spill;
spill.spill = 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, ir_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);
return res;
}
-static ir_node *get_memory_edge(const ir_node *node) {
+static ir_node *get_memory_edge(const ir_node *node)
+{
int i, arity;
ir_node *result = NULL;
void collect(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_entity* ent);
static
-void be_check_entity(be_verify_spillslots_env_t *env, ir_node *node, ir_entity *ent) {
+void be_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, ir_entity* ent) {
+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(node);
be_check_entity(env, node, spillent);
get_spill(env, node, ent);
}
}
-static void collect_memperm(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_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);
}
}
-static void collect_memphi(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_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);
}
}
-static void collect(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_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)) {
* This walker function searches for reloads and collects all the spills
* and memphis attached to them.
*/
-static void collect_spills_walker(ir_node *node, void *data) {
+static void collect_spills_walker(ir_node *node, void *data)
+{
be_verify_spillslots_env_t *env = data;
/* @@@ ia32_classify returns classification of Proj_pred :-/ */
}
}
-static void check_lonely_spills(ir_node *node, void *data) {
+static void check_lonely_spills(ir_node *node, void *data)
+{
be_verify_spillslots_env_t *env = data;
if(be_is_Spill(node) || (is_Proj(node) && be_is_MemPerm(get_Proj_pred(node)))) {
* @param b The second value.
* @return 1, if a and b interfere, 0 if not.
*/
-static int my_values_interfere(const ir_node *a, const ir_node *b) {
+static int my_values_interfere(const ir_node *a, const ir_node *b)
+{
const ir_edge_t *edge;
ir_node *bb;
int a2b = value_dominates(a, b);
const arch_register_t *pred_reg = arch_get_irn_register(pred);
if (reg != pred_reg && !arch_register_type_is(pred_reg, joker)) {
+ const char *pred_name = pred_reg != NULL ? pred_reg->name : "(null)";
+ const char *reg_name = reg != NULL ? reg->name : "(null)";
ir_fprintf(stderr, "Verify warning: Input %d of %+F in block %+F(%s) uses register %s instead of %s\n",
- i, node, get_nodes_block(node), get_irg_dump_name(irg), pred_reg->name, reg->name);
+ i, node, get_nodes_block(node),
+ get_irg_dump_name(irg), pred_name, reg_name);
problem_found = 1;
}
}
}
}
-static void value_used(ir_node *node) {
+static void value_used(ir_node *block, ir_node *node)
+{
const arch_register_t *reg;
ir_node *reg_node;
reg_node = registers[reg->index];
if (reg_node != NULL && reg_node != node) {
ir_fprintf(stderr, "Verify warning: Register %s assigned more than once in block %+F(%s) (nodes %+F %+F)\n",
- reg->name, get_nodes_block(node), get_irg_dump_name(irg),
+ reg->name, block, get_irg_dump_name(irg),
node, reg_node);
problem_found = 1;
}
registers[reg->index] = NULL;
}
-static void verify_block_register_allocation(ir_node *block, void *data) {
+static void verify_block_register_allocation(ir_node *block, void *data)
+{
int i, nregclasses;
(void) data;
be_lv_foreach(lv, block, be_lv_state_end, idx) {
ir_node *node = be_lv_get_irn(lv, block, idx);
- value_used(node);
+ value_used(block, node);
}
sched_foreach_reverse(block, node) {
arity = get_irn_arity(node);
for (i2 = 0; i2 < arity; ++i2) {
ir_node *use = get_irn_n(node, i2);
- value_used(use);
+ value_used(block, use);
}
}
}
}
}
-int be_verify_register_allocation(const be_irg_t *birg) {
+int be_verify_register_allocation(const be_irg_t *birg)
+{
arch_env = be_get_birg_arch_env(birg);
irg = be_get_birg_irg(birg);
lv = be_liveness(irg);
int problem_found;
} verify_out_dead_nodes_env;
-static void check_out_edges(ir_node *node, verify_out_dead_nodes_env *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;
bitset_set(reachable, get_irn_idx(node));
}
-int be_verify_out_edges(ir_graph *irg) {
+int be_verify_out_edges(ir_graph *irg)
+{
verify_out_dead_nodes_env env;
return 1;