nsz Git - libfirm/blob - ir/be/beverify.c

   1 /*
   2  * Author:      Matthias Braun
   3  * Date:                05.05.2006
   4  * Copyright:   (c) Universitaet Karlsruhe
   5  * License:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
   6  *
   7  */
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif
  11
  12 #include "beverify.h"
  13 #include "belive.h"
  14 #include "besched.h"
  15
  16 #include "irnode.h"
  17 #include "irgraph.h"
  18 #include "irgwalk.h"
  19 #include "irprintf.h"
  20 #include "irdump_t.h"
  21
  22 typedef struct be_verify_register_pressure_env_t_ {
  23         const arch_env_t *arch_env;
  24         const arch_register_class_t *cls;
  25         int registers_available;
  26         int problem_found;
  27 } be_verify_register_pressure_env_t;
  28
  29 static void print_living_values(pset *live_nodes)
  30 {
  31         ir_node *node;
  32
  33         ir_printf("\t");
  34         foreach_pset(live_nodes, node) {
  35                 ir_printf("%+F ", node);
  36         }
  37         ir_printf("\n");
  38 }
  39
  40 static void verify_liveness_walker(ir_node *bl, void *data)
  41 {
  42         be_verify_register_pressure_env_t *env = (be_verify_register_pressure_env_t*) data;
  43         int pressure;
  44         pset *live_nodes = pset_new_ptr_default();
  45         ir_node *irn;
  46
  47         // collect register pressure info
  48         be_liveness_end_of_block(env->arch_env, env->cls, bl, live_nodes);
  49         pressure = pset_count(live_nodes);
  50         if(pressure > env->registers_available) {
  51                 ir_printf("Verify Warning: Register pressure too high at end of block %+F (%d/%d):\n",
  52                         bl, pressure, env->registers_available);
  53                 print_living_values(live_nodes);
  54                 env->problem_found = 1;
  55         }
  56         sched_foreach_reverse(bl, irn) {
  57                 int pressure;
  58
  59                 if(is_Phi(irn))
  60                         break;
  61
  62                 be_liveness_transfer(env->arch_env, env->cls, irn, live_nodes);
  63                 pressure = pset_count(live_nodes);
  64
  65                 if(pressure > env->registers_available) {
  66                         ir_printf("Verify Warning: Register pressure too high before %+F (in block %+F) (%d/%d).\n",
  67                                 irn, bl, pressure, env->registers_available);
  68                         print_living_values(live_nodes);
  69                         env->problem_found = 1;
  70                 }
  71         }
  72         del_pset(live_nodes);
  73 }
  74
  75 void be_verify_register_pressure(const arch_env_t *arch_env, const arch_register_class_t *cls, ir_graph *irg)
  76 {
  77         be_verify_register_pressure_env_t env;
  78
  79         be_liveness(irg);
  80
  81         env.arch_env = arch_env;
  82         env.cls = cls;
  83         env.registers_available = arch_count_non_ignore_regs(arch_env, cls);
  84         env.problem_found = 0;
  85
  86         irg_block_walk_graph(irg, verify_liveness_walker, NULL, &env);
  87
  88         assert(env.problem_found == 0);
  89 }
  90
  91 typedef struct be_verify_schedule_env_t_ {
  92         int problem_found;
  93         ir_graph *irg;
  94 } be_verify_schedule_env_t;
  95
  96 static void verify_schedule_walker(ir_node *bl, void *data)
  97 {
  98         be_verify_schedule_env_t *env = (be_verify_schedule_env_t*) data;
  99         ir_node *irn;
 100         int non_phi_found = 0;
 101         int first_cfchange_found = 0;
 102
 103         /*
 104          * Make sure that all phi nodes are scheduled at the beginning of the block, and that there
 105          * are no nodes scheduled after a control flow changing node
 106          */
 107         sched_foreach(bl, irn) {
 108                 if(is_Phi(irn)) {
 109                         if(non_phi_found) {
 110                                 ir_printf("Verify Warning: Phi node %+F scheduled after non-Phi nodes in block %+F (%s)\n",
 111                                         irn, bl, get_irg_dump_name(env->irg));
 112                                 env->problem_found = 1;
 113                         }
 114                         continue;
 115                 }
 116
 117                 non_phi_found = 1;
 118                 if(is_cfop(irn) && get_irn_opcode(irn) != iro_Start) {
 119                         first_cfchange_found = 1;
 120                 } else {
 121                         if(first_cfchange_found) {
 122                                 ir_printf("Verify Warning: Node %+F scheduled after control flow changing node in block %+F (%s)\n",
 123                                         irn, bl, get_irg_dump_name(env->irg));
 124                                 env->problem_found = 1;
 125                         }
 126                 }
 127         }
 128 }
 129
 130
 131 void be_verify_schedule(ir_graph *irg)
 132 {
 133         be_verify_schedule_env_t env;
 134
 135         env.problem_found = 0;
 136         env.irg = irg;
 137
 138         irg_block_walk_graph(irg, verify_schedule_walker, NULL, &env);
 139
 140         assert(env.problem_found == 0);
 141 }