nsz Git - libfirm/blob - ir/ir/irvrfy.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irvrfy.c
   4  * Purpose:     Check irnodes for correctness.
   5  * Author:      Christian Schaefer
   6  * Modified by: Goetz Lindenmaier. Till Riedel
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include "config.h"
  15 #endif
  16
  17 # include "irprog.h"
  18 # include "irgraph_t.h"
  19 # include "irvrfy.h"
  20 # include "irgwalk.h"
  21 # include "irdump.h"
  22
  23 #ifdef NDEBUG
  24 /*
  25  * in RELEASE mode, returns ret if the expression expr evaluates to zero
  26  * in ASSERT mode, asserts the expression expr (and the string string).
  27  */
  28 #define ASSERT_AND_RET(expr, string, ret)       if (!(expr)) return (ret)
  29
  30 /*
  31  * in RELEASE mode, returns ret if the expression expr evaluates to zero
  32  * in ASSERT mode, executes blk if the expression expr evaluates to zero and asserts expr
  33  */
  34 #define ASSERT_AND_RET_DBG(expr, string, ret, blk)      if (!(expr)) return (ret)
  35 #else
  36 #define ASSERT_AND_RET(expr, string, ret) \
  37 do { \
  38   if (opt_do_node_verification == NODE_VERIFICATION_ON) {\
  39     if (!(expr) && current_ir_graph != get_const_code_irg()) \
  40     dump_ir_block_graph(current_ir_graph, "-assert"); \
  41     assert((expr) && string); } \
  42   if (!(expr)) { \
  43     if (opt_do_node_verification == NODE_VERIFICATION_REPORT) \
  44       fprintf(stderr, #expr " : " string "\n"); \
  45     bad_msg = #expr " && " string; \
  46     return (ret); \
  47   } \
  48 } while(0)
  49
  50 #define ASSERT_AND_RET_DBG(expr, string, ret, blk) \
  51 do { \
  52   if (!(expr)) { \
  53     bad_msg = #expr " && " string; \
  54     if (opt_do_node_verification != NODE_VERIFICATION_ERROR_ONLY) { blk; } \
  55     if (opt_do_node_verification == NODE_VERIFICATION_REPORT) \
  56       fprintf(stderr, #expr " : " string "\n"); \
  57     else if (opt_do_node_verification == NODE_VERIFICATION_ON) \
  58       assert((expr) && string); \
  59     return (ret); \
  60   } \
  61 } while(0)
  62
  63 #endif
  64
  65 /** if this flag is set, verify entity types in Load & Store nodes */
  66 static int vrfy_entities = 0;
  67
  68 /* @@@ replace use of array "in" by access functions. */
  69 ir_node **get_irn_in(ir_node *node);
  70
  71 static node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON;
  72 static const char *bad_msg;
  73
  74 /* enable verification of Load/Store entities */
  75 void vrfy_enable_entity_tests(int enable)
  76 {
  77   vrfy_entities = enable;
  78 }
  79
  80 /**
  81  * little helper for NULL modes
  82  */
  83 static const char *get_mode_name_ex(ir_mode *mode)
  84 {
  85   if (! mode)
  86     return "<no mode>";
  87   return get_mode_name(mode);
  88 }
  89
  90 void do_node_verification(node_verification_t mode)
  91 {
  92   opt_do_node_verification = mode;
  93 }
  94
  95 /**
  96  * Prints a failure for a Node
  97  */
  98 static void show_node_failure(ir_node *n)
  99 {
 100   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s\n" ,
 101     get_irn_node_nr(n),
 102     get_irn_opname(n), get_irn_modename(n)
 103   );
 104 }
 105
 106 /**
 107  * Prints a failure message for a binop
 108  */
 109 static void show_binop_failure(ir_node *n, const char *text)
 110 {
 111   ir_node *left  = get_binop_left(n);
 112   ir_node *right = get_binop_right(n);
 113
 114   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s(%s%s, %s%s) did not match (%s)\n",
 115       get_irn_node_nr(n),
 116       get_irn_opname(n), get_irn_modename(n),
 117       get_irn_opname(left), get_irn_modename(left),
 118       get_irn_opname(right), get_irn_modename(right),
 119       text);
 120 }
 121
 122 /**
 123  * Prints a failure message for an unop
 124  */
 125 static void show_unop_failure(ir_node *n, const char *text)
 126 {
 127   ir_node *op  = get_unop_op(n);
 128
 129   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s(%s%s) did not match (%s)\n",
 130       get_irn_node_nr(n),
 131       get_irn_opname(n), get_irn_modename(n),
 132       get_irn_opname(op), get_irn_modename(op),
 133       text);
 134 }
 135
 136 /**
 137  * Prints a failure message for an op with 3 operands
 138  */
 139 static void show_triop_failure(ir_node *n, const char *text)
 140 {
 141   ir_node *op0  = get_irn_n(n, 0);
 142   ir_node *op1  = get_irn_n(n, 1);
 143   ir_node *op2  = get_irn_n(n, 2);
 144
 145   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s(%s%s, %s%s, %s%s) did not match (%s)\n",
 146       get_irn_node_nr(n),
 147       get_irn_opname(n), get_irn_modename(n),
 148       get_irn_opname(op0), get_irn_modename(op0),
 149       get_irn_opname(op1), get_irn_modename(op1),
 150       get_irn_opname(op2), get_irn_modename(op2),
 151       text);
 152 }
 153
 154 /**
 155  * Prints a failure message for a proj
 156  */
 157 static void show_proj_failure(ir_node *n)
 158 {
 159   ir_node *op  = get_Proj_pred(n);
 160   int proj     = get_Proj_proj(n);
 161
 162   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s %d(%s%s) failed\n" ,
 163       get_irn_node_nr(n),
 164       get_irn_opname(n), get_irn_modename(n), proj,
 165       get_irn_opname(op), get_irn_modename(op));
 166 }
 167
 168 /**
 169  * Prints a failure message for a proj
 170  */
 171 static void show_proj_failure_ent(ir_node *n, entity *ent)
 172 {
 173   ir_node *op  = get_Proj_pred(n);
 174   int proj     = get_Proj_proj(n);
 175   ir_mode *m   = get_type_mode(get_entity_type(ent));
 176
 177   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
 178       get_irn_node_nr(n),
 179       get_irn_opname(n), get_irn_modename(n), proj,
 180       get_irn_opname(op), get_irn_modename(op),
 181       get_entity_name(ent), get_type_name(get_entity_type(ent)),
 182       get_mode_name_ex(m));
 183 }
 184
 185 /**
 186  * Show a node and a graph
 187  */
 188 static void show_node_on_graph(ir_graph *irg, ir_node *n)
 189 {
 190   entity *ent = get_irg_entity(irg);
 191
 192   if (ent)
 193     fprintf(stderr, "\nFIRM: irn_vrfy_irg() of entity %s, node %ld %s%s\n",
 194       get_entity_name(ent),
 195       get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
 196   else
 197     fprintf(stderr, "\nFIRM: irn_vrfy_irg() of graph %p, node %ld %s%s\n",
 198       (void *)irg,
 199       get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
 200 }
 201
 202 /**
 203  * Show call params
 204  */
 205 static void show_call_param(ir_node *n, type *mt)
 206 {
 207   int i;
 208
 209   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Call type-check failed: %s(", get_type_name(mt));
 210   for (i = 0; i < get_method_n_params(mt); ++i) {
 211     fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i))));
 212   }
 213   fprintf(stderr, ") != CALL(");
 214
 215   for (i = 0; i < get_Call_n_params(n); ++i) {
 216     fprintf(stderr, "%s ", get_mode_name_ex(get_irn_mode(get_Call_param(n, i))));
 217   }
 218   fprintf(stderr, ")\n");
 219
 220 }
 221
 222 /**
 223  * Show return modes
 224  */
 225 static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i)
 226 {
 227   entity *ent = get_irg_entity(irg);
 228
 229   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
 230     get_irn_node_nr(n), get_entity_name(ent),
 231     get_mode_name_ex(get_irn_mode(get_Return_res(n, i))),
 232     get_mode_name_ex(get_type_mode(get_method_res_type(mt, i)))
 233   );
 234 }
 235
 236 /**
 237  * Show return number of results
 238  */
 239 static void show_return_nres(ir_graph *irg, ir_node *n, type *mt)
 240 {
 241   entity *ent = get_irg_entity(irg);
 242
 243   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Return node %ld in entity \"%s\" has %d results different from type %d\n",
 244     get_irn_node_nr(n), get_entity_name(ent),
 245     get_Return_n_ress(n), get_method_n_ress(mt));
 246 }
 247
 248 /**
 249  * Show Phi input
 250  */
 251 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos)
 252 {
 253   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
 254     get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
 255     get_irn_node_nr(pred), get_mode_name_ex(get_irn_mode(pred)));
 256 }
 257
 258 /**
 259  * Show Phi inputs
 260  */
 261 static void show_phi_inputs(ir_node *phi, ir_node *block)
 262 {
 263   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Phi node %ld has %d inputs, its Block %ld has %d\n",
 264     get_irn_node_nr(phi),   get_irn_arity(phi),
 265     get_irn_node_nr(block), get_irn_arity(block));
 266 }
 267
 268 /* If the address is Sel or SymConst, return the entity. */
 269 static entity *get_ptr_entity(ir_node *ptr) {
 270   if (get_irn_op(ptr) == op_Sel) {
 271     return get_Sel_entity(ptr);
 272   } else if ((get_irn_op(ptr) == op_SymConst) && (get_SymConst_kind(ptr) == symconst_addr_ent)) {
 273     return get_SymConst_entity(ptr);
 274   }
 275   return NULL;
 276 }
 277
 278 /**
 279  * verify the Proj number
 280  */
 281 static int
 282 vrfy_Proj_proj(ir_node *p, ir_graph *irg) {
 283   ir_node *pred;
 284   ir_mode *mode;
 285   int proj;
 286
 287   pred = skip_Id(get_Proj_pred(p));
 288   ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
 289   mode = get_irn_mode(p);
 290   proj = get_Proj_proj(p);
 291
 292   switch (get_irn_opcode(pred)) {
 293     case iro_Start:
 294       ASSERT_AND_RET_DBG(
 295           (
 296            (proj == pn_Start_X_initial_exec && mode == mode_X) ||
 297            (proj == pn_Start_M         && mode == mode_M) ||
 298            (proj == pn_Start_P_frame_base && mode_is_reference(mode)) ||
 299            (proj == pn_Start_P_globals && mode_is_reference(mode)) ||
 300            (proj == pn_Start_T_args    && mode == mode_T) ||
 301            (proj == pn_Start_P_value_arg_base && mode_is_reference(mode)) ||
 302            (proj == pn_Start_P_value_arg_base && mode == mode_T)    /* FIXME: only one of those */
 303           ),
 304           "wrong Proj from Start", 0,
 305       show_proj_failure(p);
 306       );
 307       break;
 308
 309     case iro_Cond:
 310       ASSERT_AND_RET_DBG(
 311         (
 312           (proj >= 0 && mode == mode_X && get_irn_mode(get_Cond_selector(pred)) == mode_b) ||   /* compare */
 313           (mode == mode_X && mode_is_int(get_irn_mode(get_Cond_selector(pred))))                /* switch */
 314         ),
 315         "wrong Proj from Cond", 0,
 316         show_proj_failure(p);
 317       );
 318       break;
 319
 320     case iro_Raise:
 321       ASSERT_AND_RET_DBG(
 322         ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
 323         "wrong Proj from Raise", 0,
 324     show_proj_failure(p);
 325       );
 326       break;
 327
 328     case iro_InstOf:
 329       ASSERT_AND_RET_DBG(
 330     (proj >= 0 && mode == mode_X),
 331     "wrong Proj from InstOf", 0,
 332     show_proj_failure(p);
 333       );
 334       break;
 335
 336     case iro_Call:
 337       ASSERT_AND_RET_DBG(
 338         ((proj == pn_Call_M_regular        && mode == mode_M) ||
 339          (proj == pn_Call_X_except         && mode == mode_X) ||
 340          (proj == pn_Call_T_result         && mode == mode_T) ||
 341          (proj == pn_Call_M_except         && mode == mode_M) ||
 342      (proj == pn_Call_P_value_res_base && mode == mode_P)),
 343         "wrong Proj from Call", 0,
 344         show_proj_failure(p);
 345       );
 346
 347       break;
 348
 349     case iro_Quot:
 350       ASSERT_AND_RET_DBG(
 351         ((proj == pn_Quot_M        && mode == mode_M) ||
 352          (proj == pn_Quot_X_except && mode == mode_X) ||
 353          (proj == pn_Quot_res      && mode_is_float(mode))),
 354         "wrong Proj from Quot", 0,
 355     show_proj_failure(p);
 356       );
 357       break;
 358
 359     case iro_DivMod:
 360       ASSERT_AND_RET_DBG(
 361         ((proj == pn_DivMod_M        && mode == mode_M) ||
 362          (proj == pn_DivMod_X_except && mode == mode_X) ||
 363          (proj == pn_DivMod_res_div  && mode_is_int(mode)) ||
 364          (proj == pn_DivMod_res_mod  && mode_is_int(mode))),
 365         "wrong Proj from DivMod", 0,
 366     show_proj_failure(p);
 367       );
 368       break;
 369
 370     case iro_Div:
 371       ASSERT_AND_RET_DBG(
 372         ((proj == pn_Div_M        && mode == mode_M) ||
 373          (proj == pn_Div_X_except && mode == mode_X) ||
 374          (proj == pn_Div_res      && mode_is_int(mode))),
 375         "wrong Proj from Div or Mod", 0,
 376         show_proj_failure(p);
 377       );
 378       break;
 379
 380     case iro_Mod:
 381       ASSERT_AND_RET_DBG(
 382         ((proj == pn_Mod_M        && mode == mode_M) ||
 383          (proj == pn_Mod_X_except && mode == mode_X) ||
 384          (proj == pn_Mod_res      && mode_is_int(mode))),
 385         "wrong Proj from Div or Mod", 0,
 386     show_proj_failure(p);
 387       );
 388       break;
 389
 390     case iro_Cmp:
 391       ASSERT_AND_RET_DBG(
 392         (proj >= 0 && proj <= 15 && mode == mode_b),
 393         "wrong Proj from Cmp", 0,
 394     show_proj_failure(p);
 395       );
 396       break;
 397
 398     case iro_Load:
 399       if (proj == pn_Load_res) {
 400         ir_node *ptr = get_Load_ptr(pred);
 401         entity *ent = get_ptr_entity(ptr);
 402
 403         if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) {
 404           /* do NOT check this for lowered phases, see comment on Store */
 405           ASSERT_AND_RET_DBG(
 406                              (mode == get_type_mode(get_entity_type(ent))),
 407                              "wrong data Proj from Load, entity type_mode failed", 0,
 408                              show_proj_failure_ent(p, ent);
 409                              );
 410         }
 411         else {
 412           ASSERT_AND_RET_DBG(
 413                              mode_is_data(mode) && mode == get_Load_mode(pred),
 414                              "wrong data Proj from Load", 0,
 415                              show_proj_failure(p);
 416                              );
 417         }
 418       } else {
 419         ASSERT_AND_RET_DBG(
 420                            ((proj == pn_Load_M        && mode == mode_M) ||
 421                             (proj == pn_Load_X_except && mode == mode_X)),
 422                            "wrong Proj from Load", 0,
 423                            show_proj_failure(p);
 424                            );
 425       }
 426       break;
 427
 428     case iro_Store:
 429       ASSERT_AND_RET_DBG(
 430         ((proj == pn_Store_M        && mode == mode_M) ||
 431          (proj == pn_Store_X_except && mode == mode_X)),
 432         "wrong Proj from Store", 0,
 433         show_proj_failure(p);
 434       );
 435       break;
 436
 437     case iro_Alloc:
 438       ASSERT_AND_RET_DBG(
 439         (
 440          (proj == pn_Alloc_M        && mode == mode_M) ||
 441          (proj == pn_Alloc_X_except /* && mode == mode_X*/) ||
 442          (proj == pn_Alloc_res      && mode_is_reference(mode))
 443         ),
 444         "wrong Proj from Alloc", 0,
 445         show_proj_failure(p);
 446       );
 447       break;
 448
 449     case iro_Proj:
 450       {
 451         type *mt; /* A method type */
 452         long nr = get_Proj_proj(pred);
 453
 454         pred = skip_Id(get_Proj_pred(pred));
 455         ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
 456         switch (get_irn_opcode(pred))
 457         {
 458           case iro_Start:
 459             mt = get_entity_type(get_irg_entity(irg));
 460
 461             if (nr == pn_Start_T_args) {
 462                   ASSERT_AND_RET(
 463                       (proj >= 0 && mode_is_data(mode)),
 464                       "wrong Proj from Proj from Start", 0);
 465                   ASSERT_AND_RET(
 466                     (proj < get_method_n_params(mt)),
 467                     "More Projs for args than args in type", 0
 468                   );
 469                   if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj)))
 470                     /* value argument */ break;
 471
 472                   ASSERT_AND_RET(
 473                       (mode == get_type_mode(get_method_param_type(mt, proj))),
 474                       "Mode of Proj from Start doesn't match mode of param type.", 0);
 475                 }
 476             else if (nr == pn_Start_P_value_arg_base) {
 477               ASSERT_AND_RET(
 478                       (proj >= 0 && mode_is_reference(mode)),
 479                       "wrong Proj from Proj from Start", 0
 480                   );
 481                   ASSERT_AND_RET(
 482                     (proj < get_method_n_params(mt)),
 483                     "More Projs for args than args in type", 0
 484                   );
 485             }
 486             break;
 487
 488           case iro_Call:
 489             {
 490               ASSERT_AND_RET(
 491                   (proj >= 0 && mode_is_data(mode)),
 492                   "wrong Proj from Proj from Call", 0);
 493               mt = get_Call_type(pred);
 494               ASSERT_AND_RET(
 495                   (proj < get_method_n_ress(mt)),
 496                   "More Projs for results than results in type.", 0);
 497               if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
 498                 /* value result */ break;
 499
 500               ASSERT_AND_RET(
 501                   (mode == get_type_mode(get_method_res_type(mt, proj))),
 502                   "Mode of Proj from Call doesn't match mode of result type.", 0);
 503             }
 504             break;
 505
 506           case iro_Tuple:
 507             /* We don't test */
 508             break;
 509
 510           case iro_Bad:
 511             /* hmm, optimization did not remove it */
 512             break;
 513
 514           default:
 515             ASSERT_AND_RET(0, "Unknown opcode", 0);
 516         }
 517         break;
 518
 519       }
 520     case iro_Tuple:
 521       /* We don't test */
 522       break;
 523
 524     case iro_CallBegin:
 525       break;
 526
 527     case iro_EndReg:
 528       break;
 529
 530     case iro_EndExcept:
 531       break;
 532
 533     default:
 534       ASSERT_AND_RET(0, "Unknown opcode", 0);
 535   }
 536
 537   /* all went ok */
 538   return 1;
 539 }
 540
 541 int irn_vrfy_irg(ir_node *n, ir_graph *irg)
 542 {
 543   int i;
 544   int opcode, opcode1;
 545   ir_mode *mymode, *op1mode = NULL, *op2mode, *op3mode;
 546   int op_is_symmetric = 1;  /*  0: asymmetric
 547                                 1: operands have identical modes
 548                                 2: modes of operands == mode of this node */
 549   type *mt;                 /* A method type */
 550   entity *ent;
 551
 552   ir_node **in;
 553
 554   if (!opt_do_node_verification) return 1;
 555
 556   if (! get_interprocedural_view()) {
 557     /*
 558      * do NOT check placement in interprocedural view, as we don't always know
 559      * the "right" graph ...
 560      */
 561     ASSERT_AND_RET_DBG(
 562                        node_is_in_irgs_storage(irg, n),
 563                        "Node is not stored on proper IR graph!", 0,
 564                        show_node_on_graph(irg, n);
 565                        );
 566     assert(get_irn_irg(n) == irg);
 567   }
 568
 569   opcode = get_irn_opcode(n);
 570
 571   /* We don't want to test nodes whose predecessors are Bad,
 572      as we would have to special case that for each operation. */
 573   if (opcode != iro_Phi && opcode != iro_Block)
 574     for (i = 0; i < get_irn_arity(n); i++) {
 575       opcode1 = get_irn_opcode(get_irn_n(n, i));
 576       if (opcode1 == iro_Bad)
 577         return 1;
 578     }
 579
 580   mymode = get_irn_mode(n);
 581   in = get_irn_in(n);
 582
 583   switch (opcode) {
 584
 585     case iro_Block:
 586       for (i = 0; i < get_Block_n_cfgpreds(n); ++i) {
 587         ir_node *pred =  get_Block_cfgpred(n, i);
 588         ASSERT_AND_RET(
 589                        (is_Bad(pred)     ||
 590                         is_Unknown(pred) ||
 591                         (get_irn_mode(pred) == mode_X)
 592                         ), "Block node", 0);
 593       }
 594       /*  End block may only have Return, Raise or fragile ops as preds. */
 595       if (n == get_irg_end_block(irg))
 596         for (i = 0; i < get_Block_n_cfgpreds(n); ++i) {
 597           ir_node *pred =  skip_Proj(get_Block_cfgpred(n, i));
 598           if (is_Proj(pred) || get_irn_op(pred) == op_Tuple)
 599             break;   /*  We can not test properly.  How many tuples are there? */
 600           ASSERT_AND_RET(((get_irn_op(pred) == op_Return) ||
 601                           is_Bad(pred)                    ||
 602                           (get_irn_op(pred) == op_Raise)  ||
 603                           is_fragile_op(pred)               ),
 604                          "End Block node", 0);
 605         }
 606       /*  irg attr must == graph we are in. */
 607       if (! get_interprocedural_view()) {
 608         ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
 609       }
 610
 611       break;
 612
 613     case iro_Start:
 614       ASSERT_AND_RET(
 615                      /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
 616                      mymode == mode_T, "Start node", 0
 617                      );
 618       break;
 619
 620     case iro_Jmp:
 621       ASSERT_AND_RET(
 622                      /* Jmp: BB --> X */
 623                      mymode == mode_X, "Jmp node", 0
 624                      );
 625       break;
 626
 627     case iro_Break:
 628       ASSERT_AND_RET(
 629                      /* Jmp: BB --> X */
 630                      mymode == mode_X, "Jmp node", 0
 631                      );
 632       break;
 633
 634     case iro_Cond:
 635       op1mode = get_irn_mode(in[1]);
 636       ASSERT_AND_RET(
 637                      /* Cond: BB x b --> X x X */
 638                      (op1mode == mode_b ||
 639                       /* Cond: BB x int --> X^n */
 640                       mode_is_int(op1mode) ),  "Cond node", 0
 641                      );
 642       ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
 643       break;
 644
 645     case iro_Return:
 646       op1mode = get_irn_mode(in[1]);
 647       /* Return: BB x M x data1 x ... x datan --> X */
 648       /* printf("mode: %s, code %s\n", ID_TO_STR(n->mode->name), ID_TO_STR(n->op->name));*/
 649       ASSERT_AND_RET( op1mode == mode_M, "Return node", 0 );  /* operand M */
 650       for (i = 2; i < get_irn_arity(n); i++) {
 651         ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Return node", 0 );  /* operand datai */
 652       };
 653       ASSERT_AND_RET( mymode == mode_X, "Result X", 0 );   /* result X */
 654       /* Compare returned results with result types of method type */
 655       mt = get_entity_type(get_irg_entity(irg));
 656       ASSERT_AND_RET_DBG( get_Return_n_ress(n) == get_method_n_ress(mt),
 657         "Number of results for Return doesn't match number of results in type.", 0,
 658       show_return_nres(irg, n, mt););
 659       for (i = 0; i < get_Return_n_ress(n); i++) {
 660         type *res_type = get_method_res_type(mt, i);
 661
 662         if (is_atomic_type(res_type)) {
 663           ASSERT_AND_RET_DBG(
 664             get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
 665             "Mode of result for Return doesn't match mode of result type.", 0,
 666             show_return_modes(irg, n, mt, i);
 667           );
 668         }
 669         else {
 670           ASSERT_AND_RET_DBG(
 671             mode_is_reference(get_irn_mode(get_Return_res(n, i))),
 672             "Mode of result for Return doesn't match mode of result type.", 0,
 673             show_return_modes(irg, n, mt, i);
 674           );
 675         }
 676       }
 677       break;
 678
 679     case iro_Raise:
 680       op1mode = get_irn_mode(in[1]);
 681       op2mode = get_irn_mode(in[2]);
 682       ASSERT_AND_RET(
 683                      /* Sel: BB x M x ref --> X x M */
 684                      op1mode == mode_M && mode_is_reference(op2mode) &&
 685                      mymode == mode_T, "Raise node", 0
 686                      );
 687       break;
 688
 689     case iro_Const: {
 690       ASSERT_AND_RET(
 691                      /* Const: BB --> data */
 692                      (mode_is_data (mymode) ||
 693                       mymode == mode_b)      /* we want boolean constants for static evaluation */
 694                      ,"Const node", 0        /* of Cmp. */
 695                      );
 696       } break;
 697     case iro_SymConst:
 698       if (get_SymConst_kind(n) == symconst_addr_ent) {
 699         entity *ent = get_SymConst_entity(n);
 700         if (is_Method_type(get_entity_type(ent)) &&
 701             get_irn_irg(n) != get_const_code_irg()) {
 702 #if 1
 703           ASSERT_AND_RET((get_entity_peculiarity(ent) != peculiarity_description),
 704                          "A constant must address an existing method.", 0);
 705 #endif
 706         }
 707       }
 708       ASSERT_AND_RET(
 709                      /* SymConst: BB --> int*/
 710                      (mode_is_int(mymode) ||
 711                       /* SymConst: BB --> ref */
 712                       mode_is_reference(mymode))
 713                      ,"SymConst node", 0);
 714       break;
 715
 716     case iro_Sel:
 717       op1mode = get_irn_mode(in[1]);
 718       op2mode = get_irn_mode(in[2]);
 719       ASSERT_AND_RET_DBG(
 720                          /* Sel: BB x M x ref x int^n --> ref */
 721                          (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
 722                          "Sel node", 0, show_node_failure(n)
 723                          );
 724       for (i=3; i < get_irn_arity(n); i++)
 725         {
 726           ASSERT_AND_RET_DBG(mode_is_int(get_irn_mode(in[i])), "Sel node", 0, show_node_failure(n));
 727         }
 728       ent = get_Sel_entity(n);
 729       ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n));
 730       break;
 731
 732     case iro_InstOf:
 733       ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
 734       ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
 735       break;
 736
 737     case iro_Call:
 738       op1mode = get_irn_mode(in[1]);
 739       op2mode = get_irn_mode(in[2]);
 740       /* Call: BB x M x ref x data1 x ... x datan
 741          --> M x datan+1 x ... x data n+m */
 742       ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 );  /* operand M x ref */
 743
 744       mt = get_Call_type(n);
 745       if(get_unknown_type() == mt) {
 746         break;
 747       }
 748
 749       for (i=3; i < get_irn_arity(n); i++) {
 750         ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Call node", 0 );  /* operand datai */
 751       };
 752       ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 );   /* result T */
 753       /* Compare arguments of node with those of type */
 754
 755       if (get_method_variadicity(mt) == variadicity_variadic) {
 756         ASSERT_AND_RET_DBG(
 757                            get_Call_n_params(n) >= get_method_n_params(mt),
 758                            "Number of args for Call doesn't match number of args in variadic type.",
 759                            0,
 760                            fprintf(stderr, "Call has %d params, method %s type %d\n",
 761                                    get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
 762                            );
 763       }
 764       else {
 765         ASSERT_AND_RET(
 766                        get_Call_n_params(n) == get_method_n_params(mt),
 767                        "Number of args for Call doesn't match number of args in non variadic type.",
 768                        0);
 769       }
 770
 771       for (i = 0; i < get_method_n_params(mt); i++) {
 772         type *t = get_method_param_type(mt, i);
 773
 774         if (is_atomic_type(t)) {
 775           ASSERT_AND_RET_DBG(
 776                              get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
 777                              "Mode of arg for Call doesn't match mode of arg type.", 0,
 778                              show_call_param(n, mt);
 779                              );
 780         }
 781         else {
 782           /* call with a compound type, mode must be reference */
 783           ASSERT_AND_RET_DBG(
 784                              mode_is_reference(get_irn_mode(get_Call_param(n, i))),
 785                              "Mode of arg for Call doesn't match mode of arg type.", 0,
 786                              show_call_param(n, mt);
 787                              );
 788         }
 789       }
 790
 791 #if 0
 792       if (Call_has_callees(n)) {
 793         for (i = 0; i < get_Call_n_callees(n); i++) {
 794           ASSERT_AND_RET(is_entity(get_Call_callee(n, i)), "callee array must contain entities.", 0);
 795         }
 796       }
 797 #endif
 798       break;
 799
 800     case iro_Add:
 801       op1mode = get_irn_mode(in[1]);
 802       op2mode = get_irn_mode(in[2]);
 803       ASSERT_AND_RET_DBG(
 804                          (
 805                           /* common Add: BB x numP x numP --> numP */
 806                           (op1mode == mymode && op2mode == op1mode && mode_is_numP(mymode)) ||
 807                           /* Pointer Add: BB x ref x int --> ref */
 808                           (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
 809                           /* Pointer Add: BB x int x ref --> ref */
 810                           (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
 811                           ),
 812                          "Add node", 0,
 813                          show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
 814                                             "/* Pointer Add: BB x ref x int --> ref */   |\n"
 815                                             "/* Pointer Add: BB x int x ref --> ref */");
 816                          );
 817       if (mode_is_reference(op1mode) != mode_is_reference(op2mode)) {
 818         /* BB x ref x int --> ref or BB x int x ref --> ref */
 819         op_is_symmetric = 0;
 820       } else {
 821         /* BB x num x num --> num or BB x ref x ref */
 822         op_is_symmetric = 2;
 823       }
 824       break;
 825
 826     case iro_Sub:
 827       op1mode = get_irn_mode(in[1]);
 828       op2mode = get_irn_mode(in[2]);
 829       ASSERT_AND_RET_DBG(
 830                          /* common Sub: BB x numP x numP --> numP */
 831                          ((mymode ==op1mode && mymode == op2mode && mode_is_numP(op1mode)) ||
 832                           /* Pointer Sub: BB x ref x int --> ref */
 833                           (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
 834                           /* Pointer Sub: BB x int x ref --> ref */
 835                           (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode)) ||
 836                           /* Pointer Sub: BB x ref x ref --> int */
 837                           (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))),
 838                          "Sub node", 0,
 839                          show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
 840                                             "/* Pointer Sub: BB x ref x int --> ref */   |\n"
 841                                             "/* Pointer Sub: BB x int x ref --> ref */   |\n"
 842                                             "/* Pointer Sub: BB x ref x ref --> int */" );
 843                          );
 844       if (mode_is_reference(op1mode) != mode_is_reference(op2mode)) {
 845         op_is_symmetric = 0;
 846       } else {
 847         op_is_symmetric = 2;
 848       }
 849       break;
 850
 851     case iro_Minus:
 852       op1mode = get_irn_mode(in[1]);
 853       ASSERT_AND_RET_DBG(
 854                          /* Minus: BB x num --> num */
 855                          op1mode == mymode && mode_is_num(op1mode), "Minus node", 0,
 856                          show_unop_failure(n , "/* Minus: BB x num --> num */");
 857                          );
 858       op_is_symmetric = 2;
 859       break;
 860
 861     case iro_Mul:
 862       op1mode = get_irn_mode(in[1]);
 863       op2mode = get_irn_mode(in[2]);
 864       ASSERT_AND_RET_DBG(
 865                          /* Mul: BB x int1 x int1 --> int2 */
 866                          ((mode_is_int(op1mode)   && op2mode == op1mode && mode_is_int(mymode)) ||
 867                          /* Mul: BB x float x float --> float */
 868                           (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)),
 869                          "Mul node",0,
 870                          show_binop_failure(n, "/* Mul: BB x int1 x int1 --> int2 */ |\n"
 871                                                "/* Mul: BB x float x float --> float */");
 872                          );
 873       op_is_symmetric = 2;
 874       break;
 875
 876     case iro_Quot:
 877       op1mode = get_irn_mode(in[1]);
 878       op2mode = get_irn_mode(in[2]);
 879       op3mode = get_irn_mode(in[3]);
 880       ASSERT_AND_RET_DBG(
 881                          /* Quot: BB x M x float x float --> M x X x float */
 882                          op1mode == mode_M && op2mode == op3mode &&
 883                          get_mode_sort(op2mode) == irms_float_number &&
 884                          mymode == mode_T,
 885                          "Quot node",0,
 886                          show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
 887                          );
 888       op_is_symmetric = 2;
 889       break;
 890
 891     case iro_DivMod:
 892       op1mode = get_irn_mode(in[1]);
 893       op2mode = get_irn_mode(in[2]);
 894       op3mode = get_irn_mode(in[3]);
 895       ASSERT_AND_RET(
 896                      /* DivMod: BB x M x int x int --> M x X x int x int */
 897                      op1mode == mode_M &&
 898                      mode_is_int(op2mode) &&
 899                      op3mode == op2mode &&
 900                      mymode == mode_T,
 901                      "DivMod node", 0
 902                      );
 903       op_is_symmetric = 1;
 904       break;
 905
 906     case iro_Div:
 907     case iro_Mod:
 908       op1mode = get_irn_mode(in[1]);
 909       op2mode = get_irn_mode(in[2]);
 910       op3mode = get_irn_mode(in[3]);
 911       ASSERT_AND_RET(
 912                      /* Div or Mod: BB x M x int x int --> M x X x int */
 913                      op1mode == mode_M &&
 914                      op2mode == op3mode &&
 915                      mode_is_int(op2mode) &&
 916                      mymode == mode_T,
 917                      "Div or Mod node", 0
 918                      );
 919       op_is_symmetric = 1;
 920       break;
 921
 922     case iro_Abs:
 923       op1mode = get_irn_mode(in[1]);
 924       ASSERT_AND_RET_DBG(
 925                          /* Abs: BB x num --> num */
 926                          op1mode == mymode &&
 927                          mode_is_num (op1mode),
 928                          "Abs node", 0,
 929                          show_unop_failure(n, "/* Abs: BB x num --> num */");
 930                          );
 931       op_is_symmetric = 2;
 932       break;
 933
 934     case iro_And:
 935     case iro_Or:
 936     case iro_Eor:
 937       op1mode = get_irn_mode(in[1]);
 938       op2mode = get_irn_mode(in[2]);
 939       ASSERT_AND_RET_DBG(
 940                          /* And or Or or Eor: BB x int x int --> int */
 941                          mode_is_int(mymode) &&
 942                          op2mode == op1mode &&
 943                          mymode == op2mode,
 944                          "And, Or or Eor node", 0,
 945                          show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
 946                          );
 947       op_is_symmetric = 2;
 948       break;
 949
 950     case iro_Not:
 951       op1mode = get_irn_mode(in[1]);
 952       ASSERT_AND_RET_DBG(
 953                          /* Not: BB x int --> int */
 954                          mode_is_int(mymode) &&
 955                          mymode == op1mode,
 956                          "Not node", 0,
 957                          show_unop_failure(n, "/* Not: BB x int --> int */");
 958                          );
 959       op_is_symmetric = 2;
 960       break;
 961
 962
 963     case iro_Cmp:
 964       op1mode = get_irn_mode(in[1]);
 965       op2mode = get_irn_mode(in[2]);
 966       ASSERT_AND_RET_DBG(
 967                          /* Cmp: BB x datab x datab --> b16 */
 968                          mode_is_data (op1mode) &&
 969                          op2mode == op1mode &&
 970                          mymode == mode_T,
 971                          "Cmp node", 0,
 972                          show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
 973                          );
 974       break;
 975
 976     case iro_Shl:
 977     case iro_Shr:
 978     case iro_Shrs:
 979       op1mode = get_irn_mode(in[1]);
 980       op2mode = get_irn_mode(in[2]);
 981       ASSERT_AND_RET_DBG(
 982                          /* Shl, Shr or Shrs: BB x int x int_u --> int */
 983                          mode_is_int(op1mode) &&
 984                          mode_is_int(op2mode) &&
 985                          !mode_is_signed(op2mode) &&
 986                          mymode == op1mode,
 987                          "Shl, Shr, Shr or Rot node", 0,
 988                          show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
 989                          );
 990       break;
 991
 992     case iro_Rot:
 993       op1mode = get_irn_mode(in[1]);
 994       op2mode = get_irn_mode(in[2]);
 995       ASSERT_AND_RET_DBG(
 996                          /* Rot: BB x int x int --> int */
 997                          mode_is_int(op1mode) &&
 998                          mode_is_int(op2mode) &&
 999                          mymode == op1mode,
1000                          "Rot node", 0,
1001                          show_binop_failure(n, "/* Rot: BB x int x int --> int */");
1002                          );
1003       break;
1004
1005     case iro_Conv:
1006       op1mode = get_irn_mode(in[1]);
1007       ASSERT_AND_RET_DBG(
1008                          /* Conv: BB x datab1 --> datab2 */
1009                          mode_is_datab(op1mode) && mode_is_data(mymode),
1010                          "Conv node", 0,
1011                          show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1012                          );
1013       break;
1014
1015     case iro_Cast:
1016       op1mode = get_irn_mode(in[1]);
1017       ASSERT_AND_RET_DBG(
1018                          /* Conv: BB x datab1 --> datab2 */
1019                          mode_is_data(op1mode) && op1mode == mymode,
1020                          "Cast node", 0,
1021                          show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1022                          );
1023       break;
1024
1025     case iro_Phi:
1026     {
1027       ir_node *block = get_nodes_block(n);
1028
1029       if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building) {
1030         /* a Phi node MUST have the same number of inputs as its block */
1031         ASSERT_AND_RET_DBG(
1032           get_irn_arity(n) == get_irn_arity(block),
1033           "wrong number of inputs in Phi node", 0,
1034           show_phi_inputs(n, block);
1035         );
1036       }
1037
1038       /* Phi: BB x dataM^n --> dataM */
1039       for (i = 1; i < get_irn_arity(n); i++) {
1040         if (!is_Bad(in[i]) && (get_irn_op(in[i]) != op_Unknown))
1041           ASSERT_AND_RET_DBG(
1042                              get_irn_mode(in[i]) == mymode,
1043                              "Phi node", 0,
1044                              show_phi_failure(n, in[i], i);
1045                              );
1046       };
1047       ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 );
1048       break;
1049     }
1050     case iro_Load:
1051       op1mode = get_irn_mode(in[1]);
1052       op2mode = get_irn_mode(in[2]);
1053       ASSERT_AND_RET(
1054                      /* Load: BB x M x ref --> M x X x data */
1055                      op1mode == mode_M && mode_is_reference(op2mode),
1056                      "Load node", 0
1057                      );
1058       ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
1059
1060       /*
1061        * jack's gen_add_firm_code:simpleSel seems to build Load (Load
1062        * (Proj (Proj))) sometimes ...
1063
1064        * interprete.c:ai_eval seems to assume that this happens, too
1065
1066        * obset.c:get_abstval_any can't deal with this if the load has
1067        * mode_T
1068        *
1069       {
1070         entity *ent = hunt_for_entity (get_Load_ptr (n), n);
1071         assert ((NULL != ent) || (mymode != mode_T));
1072       }
1073       */
1074
1075       break;
1076
1077     case iro_Store: {
1078       entity *target;
1079
1080       op1mode = get_irn_mode(in[1]);
1081       op2mode = get_irn_mode(in[2]);
1082       op3mode = get_irn_mode(in[3]);
1083       ASSERT_AND_RET(
1084                      /* Load: BB x M x ref data --> M x X */
1085                      op1mode == mode_M && mode_is_reference(op2mode) && mode_is_data(op3mode),
1086                      "Store node", 0
1087                      );
1088       ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
1089
1090       target = get_ptr_entity(in[2]);
1091       if (vrfy_entities && target && get_irg_phase_state(current_ir_graph) == phase_high) {
1092         /*
1093          * If lowered code, any Sels that add 0 may be removed, causing
1094          * an direct access to entities of array or compound type.
1095          * Prevent this by checking the phase.
1096          */
1097         ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
1098                         "Store node", 0);
1099       }
1100
1101       break;
1102     }
1103
1104     case iro_Alloc:
1105       op1mode = get_irn_mode(in[1]);
1106       op2mode = get_irn_mode(in[2]);
1107       ASSERT_AND_RET_DBG(
1108                          /* Alloc: BB x M x int_u --> M x X x ref */
1109                          op1mode == mode_M &&
1110                          mode_is_int(op2mode) &&
1111                          !mode_is_signed(op2mode) &&
1112                          mymode == mode_T,
1113                          "Alloc node", 0,
1114                          show_binop_failure(n, "/* Alloc: BB x M x int_u --> M x X x ref */");
1115                          );
1116       break;
1117
1118     case iro_Free:
1119       op1mode = get_irn_mode(in[1]);
1120       op2mode = get_irn_mode(in[2]);
1121       op3mode = get_irn_mode(in[3]);
1122       ASSERT_AND_RET_DBG(
1123                          /* Free: BB x M x ref x int_u --> M */
1124                          op1mode == mode_M && mode_is_reference(op2mode) &&
1125                          mode_is_int(op3mode) &&
1126                          !mode_is_signed(op3mode) &&
1127                          mymode == mode_M,
1128                          "Free node", 0,
1129                          show_triop_failure(n, "/* Free: BB x M x ref x int_u --> M */");
1130                          );
1131       break;
1132
1133     case iro_Sync:
1134       /* Sync: BB x M^n --> M */
1135       for (i=1; i < get_irn_arity(n); i++) {
1136         ASSERT_AND_RET( get_irn_mode(in[i]) == mode_M, "Sync node", 0 );
1137       };
1138       ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
1139       break;
1140
1141     case iro_Proj:
1142       return vrfy_Proj_proj(n, irg);
1143       break;
1144
1145     case iro_Confirm:
1146       op1mode = get_irn_mode(in[1]);
1147       op2mode = get_irn_mode(in[2]);
1148       ASSERT_AND_RET_DBG(
1149                          /* Confirm: BB x T x T --> T */
1150                          op1mode == mymode &&
1151                          op2mode == mymode,
1152                          "Confirm node", 0,
1153                          show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
1154                          );
1155       break;
1156
1157     case iro_Mux:
1158       op1mode = get_irn_mode(in[1]);
1159       op2mode = get_irn_mode(in[2]);
1160       op3mode = get_irn_mode(in[3]);
1161       ASSERT_AND_RET(
1162                          /* Mux: BB x b x numP x numP --> numP */
1163                          op1mode == mode_b &&
1164                          op2mode == mymode &&
1165                          op3mode == mymode &&
1166                          mode_is_numP(mymode),
1167                          "Mux node", 0
1168                          );
1169       break;
1170
1171     default:
1172       break;
1173     }
1174
1175   /* All went ok */
1176   return 1;
1177 }
1178
1179 int irn_vrfy(ir_node *n)
1180 {
1181   int res = 1;
1182 #ifdef DEBUG_libfirm
1183   res = irn_vrfy_irg(n, current_ir_graph);
1184 #endif
1185   return res;
1186 }
1187
1188 /*-----------------------------------------------------------------*/
1189 /* Verify the whole graph.                                         */
1190 /*-----------------------------------------------------------------*/
1191
1192 /* This *is* used, except gcc doesn't notice that */
1193 static void vrfy_wrap(ir_node *node, void *env)
1194 {
1195   int *res = env;
1196
1197   *res = irn_vrfy(node);
1198 }
1199
1200 int irg_vrfy(ir_graph *irg)
1201 {
1202   int res = 1;
1203 #ifdef DEBUG_libfirm
1204   ir_graph *rem;
1205
1206   rem = current_ir_graph;
1207   current_ir_graph = irg;
1208
1209   assert(get_irg_pinned(irg) == op_pin_state_pinned);
1210
1211   irg_walk_graph(irg, vrfy_wrap, NULL, &res);
1212
1213   current_ir_graph = rem;
1214
1215   if (opt_do_node_verification == NODE_VERIFICATION_REPORT && ! res) {
1216     entity *ent = get_irg_entity(current_ir_graph);
1217
1218     if (ent)
1219       fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
1220     else
1221       fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph);
1222   }
1223
1224 #endif
1225   return res;
1226 }
1227
1228 int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
1229 {
1230   int res;
1231   node_verification_t old = opt_do_node_verification;
1232
1233   bad_msg = NULL;
1234   opt_do_node_verification = NODE_VERIFICATION_ERROR_ONLY;
1235   res = irn_vrfy_irg(n, irg);
1236   opt_do_node_verification = old;
1237   *bad_string = bad_msg;
1238
1239   return res;
1240 }
1241
1242
1243 typedef struct _vrfy_bad_env_t {
1244   int flags;
1245   int res;
1246 } vrfy_bad_env_t;
1247
1248 static void check_bads(ir_node *node, void *env)
1249 {
1250   vrfy_bad_env_t *venv = env;
1251   int i, arity = get_irn_arity(node);
1252
1253   if (is_Block(node)) {
1254     if ((venv->flags & BAD_CF) == 0) {
1255
1256       /* check for Bad Block predecessor */
1257       for (i = 0; i < arity; ++i) {
1258         ir_node *pred = get_irn_n(node, i);
1259
1260         if (is_Bad(pred)) {
1261           venv->res |= BAD_CF;
1262
1263           if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1264             fprintf(stderr, "irg_vrfy_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node));
1265           }
1266           if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1267             assert(0 && "Bad CF detected");
1268           }
1269         }
1270       }
1271     }
1272   }
1273   else {
1274     if ((venv->flags & BAD_BLOCK) == 0) {
1275
1276       /* check for Bad Block */
1277       if (is_Bad(get_nodes_block(node))) {
1278         venv->res |= BAD_BLOCK;
1279
1280         if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1281           fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Block\n", get_irn_node_nr(node));
1282         }
1283         if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1284           assert(0 && "Bad CF detected");
1285         }
1286       }
1287     }
1288
1289     if ((venv->flags & TUPLE) == 0) {
1290       if (get_irn_op(node) == op_Tuple) {
1291         venv->res |= TUPLE;
1292
1293         if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1294           fprintf(stderr, "irg_vrfy_bads: node %ld is a Tuple\n", get_irn_node_nr(node));
1295         }
1296         if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1297           assert(0 && "Tuple detected");
1298         }
1299       }
1300     }
1301
1302     for (i = 0; i < arity; ++i) {
1303       ir_node *pred = get_irn_n(node, i);
1304
1305       if (is_Bad(pred)) {
1306         /* check for Phi with Bad inputs */
1307         if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
1308           if (venv->flags & BAD_CF)
1309             continue;
1310           else {
1311             venv->res |= BAD_CF;
1312
1313             if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1314               fprintf(stderr, "irg_vrfy_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node));
1315             }
1316             if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1317               assert(0 && "Bad CF detected");
1318             }
1319           }
1320         }
1321
1322         /* Bad node input */
1323         if ((venv->flags & BAD_DF) == 0) {
1324           venv->res |= BAD_DF;
1325
1326           if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1327             fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Input\n", get_irn_node_nr(node));
1328           }
1329           if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1330             assert(0 && "Bad NON-CF detected");
1331           }
1332         }
1333       }
1334     }
1335   }
1336 }
1337
1338 /*
1339  * verify occurance of bad nodes
1340  */
1341 int irg_vrfy_bads(ir_graph *irg, int flags)
1342 {
1343   vrfy_bad_env_t env;
1344
1345   env.flags = flags;
1346   env.res   = 0;
1347
1348   irg_walk_graph(irg, check_bads, NULL, &env);
1349
1350   return env.res;
1351 }