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   }
 567
 568   opcode = get_irn_opcode(n);
 569
 570   /* We don't want to test nodes whose predecessors are Bad,
 571      as we would have to special case that for each operation. */
 572   if (opcode != iro_Phi && opcode != iro_Block)
 573     for (i = 0; i < get_irn_arity(n); i++) {
 574       opcode1 = get_irn_opcode(get_irn_n(n, i));
 575       if (opcode1 == iro_Bad)
 576         return 1;
 577     }
 578
 579   mymode = get_irn_mode(n);
 580   in = get_irn_in(n);
 581
 582   switch (opcode) {
 583
 584     case iro_Block:
 585       for (i = 0; i < get_Block_n_cfgpreds(n); ++i) {
 586         ir_node *pred =  get_Block_cfgpred(n, i);
 587         ASSERT_AND_RET(
 588                        (is_Bad(pred)     ||
 589                         is_Unknown(pred) ||
 590                         (get_irn_mode(pred) == mode_X)
 591                         ), "Block node", 0);
 592       }
 593       /*  End block may only have Return, Raise or fragile ops as preds. */
 594       if (n == get_irg_end_block(irg))
 595         for (i = 0; i < get_Block_n_cfgpreds(n); ++i) {
 596           ir_node *pred =  skip_Proj(get_Block_cfgpred(n, i));
 597           if (is_Proj(pred) || get_irn_op(pred) == op_Tuple)
 598             break;   /*  We can not test properly.  How many tuples are there? */
 599           ASSERT_AND_RET(((get_irn_op(pred) == op_Return) ||
 600                           is_Bad(pred)                    ||
 601                           (get_irn_op(pred) == op_Raise)  ||
 602                           is_fragile_op(pred)               ),
 603                          "End Block node", 0);
 604         }
 605       /*  irg attr must == graph we are in. */
 606       if (! get_interprocedural_view()) {
 607         ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
 608       }
 609
 610       break;
 611
 612     case iro_Start:
 613       ASSERT_AND_RET(
 614                      /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
 615                      mymode == mode_T, "Start node", 0
 616                      );
 617       break;
 618
 619     case iro_Jmp:
 620       ASSERT_AND_RET(
 621                      /* Jmp: BB --> X */
 622                      mymode == mode_X, "Jmp node", 0
 623                      );
 624       break;
 625
 626     case iro_Break:
 627       ASSERT_AND_RET(
 628                      /* Jmp: BB --> X */
 629                      mymode == mode_X, "Jmp node", 0
 630                      );
 631       break;
 632
 633     case iro_Cond:
 634       op1mode = get_irn_mode(in[1]);
 635       ASSERT_AND_RET(
 636                      /* Cond: BB x b --> X x X */
 637                      (op1mode == mode_b ||
 638                       /* Cond: BB x int --> X^n */
 639                       mode_is_int(op1mode) ),  "Cond node", 0
 640                      );
 641       ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
 642       break;
 643
 644     case iro_Return:
 645       op1mode = get_irn_mode(in[1]);
 646       /* Return: BB x M x data1 x ... x datan --> X */
 647       /* printf("mode: %s, code %s\n", ID_TO_STR(n->mode->name), ID_TO_STR(n->op->name));*/
 648       ASSERT_AND_RET( op1mode == mode_M, "Return node", 0 );  /* operand M */
 649       for (i = 2; i < get_irn_arity(n); i++) {
 650         ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Return node", 0 );  /* operand datai */
 651       };
 652       ASSERT_AND_RET( mymode == mode_X, "Result X", 0 );   /* result X */
 653       /* Compare returned results with result types of method type */
 654       mt = get_entity_type(get_irg_entity(irg));
 655       ASSERT_AND_RET_DBG( get_Return_n_ress(n) == get_method_n_ress(mt),
 656         "Number of results for Return doesn't match number of results in type.", 0,
 657       show_return_nres(irg, n, mt););
 658       for (i = 0; i < get_Return_n_ress(n); i++) {
 659         type *res_type = get_method_res_type(mt, i);
 660
 661         if (is_atomic_type(res_type)) {
 662           ASSERT_AND_RET_DBG(
 663             get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
 664             "Mode of result for Return doesn't match mode of result type.", 0,
 665             show_return_modes(irg, n, mt, i);
 666           );
 667         }
 668         else {
 669           ASSERT_AND_RET_DBG(
 670             mode_is_reference(get_irn_mode(get_Return_res(n, i))),
 671             "Mode of result for Return doesn't match mode of result type.", 0,
 672             show_return_modes(irg, n, mt, i);
 673           );
 674         }
 675       }
 676       break;
 677
 678     case iro_Raise:
 679       op1mode = get_irn_mode(in[1]);
 680       op2mode = get_irn_mode(in[2]);
 681       ASSERT_AND_RET(
 682                      /* Sel: BB x M x ref --> X x M */
 683                      op1mode == mode_M && mode_is_reference(op2mode) &&
 684                      mymode == mode_T, "Raise node", 0
 685                      );
 686       break;
 687
 688     case iro_Const: {
 689       ASSERT_AND_RET(
 690                      /* Const: BB --> data */
 691                      (mode_is_data (mymode) ||
 692                       mymode == mode_b)      /* we want boolean constants for static evaluation */
 693                      ,"Const node", 0        /* of Cmp. */
 694                      );
 695       } break;
 696     case iro_SymConst:
 697       if (get_SymConst_kind(n) == symconst_addr_ent) {
 698         entity *ent = get_SymConst_entity(n);
 699         if (is_Method_type(get_entity_type(ent)) &&
 700             get_irn_irg(n) != get_const_code_irg()) {
 701 #if 1
 702           ASSERT_AND_RET((get_entity_peculiarity(ent) != peculiarity_description),
 703                          "A constant must address an existing method.", 0);
 704 #endif
 705         }
 706       }
 707       ASSERT_AND_RET(
 708                      /* SymConst: BB --> int*/
 709                      (mode_is_int(mymode) ||
 710                       /* SymConst: BB --> ref */
 711                       mode_is_reference(mymode))
 712                      ,"SymConst node", 0);
 713       break;
 714
 715     case iro_Sel:
 716       op1mode = get_irn_mode(in[1]);
 717       op2mode = get_irn_mode(in[2]);
 718       ASSERT_AND_RET_DBG(
 719                          /* Sel: BB x M x ref x int^n --> ref */
 720                          (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
 721                          "Sel node", 0, show_node_failure(n)
 722                          );
 723       for (i=3; i < get_irn_arity(n); i++)
 724         {
 725           ASSERT_AND_RET_DBG(mode_is_int(get_irn_mode(in[i])), "Sel node", 0, show_node_failure(n));
 726         }
 727       ent = get_Sel_entity(n);
 728       ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n));
 729       break;
 730
 731     case iro_InstOf:
 732       ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
 733       ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
 734       break;
 735
 736     case iro_Call:
 737       op1mode = get_irn_mode(in[1]);
 738       op2mode = get_irn_mode(in[2]);
 739       /* Call: BB x M x ref x data1 x ... x datan
 740          --> M x datan+1 x ... x data n+m */
 741       ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 );  /* operand M x ref */
 742
 743       mt = get_Call_type(n);
 744       if(get_unknown_type() == mt) {
 745         break;
 746       }
 747
 748       for (i=3; i < get_irn_arity(n); i++) {
 749         ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Call node", 0 );  /* operand datai */
 750       };
 751       ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 );   /* result T */
 752       /* Compare arguments of node with those of type */
 753
 754       if (get_method_variadicity(mt) == variadicity_variadic) {
 755         ASSERT_AND_RET_DBG(
 756                            get_Call_n_params(n) >= get_method_n_params(mt),
 757                            "Number of args for Call doesn't match number of args in variadic type.",
 758                            0,
 759                            fprintf(stderr, "Call has %d params, method %s type %d\n",
 760                                    get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
 761                            );
 762       }
 763       else {
 764         ASSERT_AND_RET(
 765                        get_Call_n_params(n) == get_method_n_params(mt),
 766                        "Number of args for Call doesn't match number of args in non variadic type.",
 767                        0);
 768       }
 769
 770       for (i = 0; i < get_method_n_params(mt); i++) {
 771         type *t = get_method_param_type(mt, i);
 772
 773         if (is_atomic_type(t)) {
 774           ASSERT_AND_RET_DBG(
 775                              get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
 776                              "Mode of arg for Call doesn't match mode of arg type.", 0,
 777                              show_call_param(n, mt);
 778                              );
 779         }
 780         else {
 781           /* call with a compound type, mode must be reference */
 782           ASSERT_AND_RET_DBG(
 783                              mode_is_reference(get_irn_mode(get_Call_param(n, i))),
 784                              "Mode of arg for Call doesn't match mode of arg type.", 0,
 785                              show_call_param(n, mt);
 786                              );
 787         }
 788       }
 789
 790 #if 0
 791       if (Call_has_callees(n)) {
 792         for (i = 0; i < get_Call_n_callees(n); i++) {
 793           ASSERT_AND_RET(is_entity(get_Call_callee(n, i)), "callee array must contain entities.", 0);
 794         }
 795       }
 796 #endif
 797       break;
 798
 799     case iro_Add:
 800       op1mode = get_irn_mode(in[1]);
 801       op2mode = get_irn_mode(in[2]);
 802       ASSERT_AND_RET_DBG(
 803                          (
 804                           /* common Add: BB x numP x numP --> numP */
 805                           (op1mode == mymode && op2mode == op1mode && mode_is_numP(mymode)) ||
 806                           /* Pointer Add: BB x ref x int --> ref */
 807                           (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
 808                           /* Pointer Add: BB x int x ref --> ref */
 809                           (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
 810                           ),
 811                          "Add node", 0,
 812                          show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
 813                                             "/* Pointer Add: BB x ref x int --> ref */   |\n"
 814                                             "/* Pointer Add: BB x int x ref --> ref */");
 815                          );
 816       if (mode_is_reference(op1mode) != mode_is_reference(op2mode)) {
 817         /* BB x ref x int --> ref or BB x int x ref --> ref */
 818         op_is_symmetric = 0;
 819       } else {
 820         /* BB x num x num --> num or BB x ref x ref */
 821         op_is_symmetric = 2;
 822       }
 823       break;
 824
 825     case iro_Sub:
 826       op1mode = get_irn_mode(in[1]);
 827       op2mode = get_irn_mode(in[2]);
 828       ASSERT_AND_RET_DBG(
 829                          /* common Sub: BB x numP x numP --> numP */
 830                          ((mymode ==op1mode && mymode == op2mode && mode_is_numP(op1mode)) ||
 831                           /* Pointer Sub: BB x ref x int --> ref */
 832                           (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
 833                           /* Pointer Sub: BB x int x ref --> ref */
 834                           (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode)) ||
 835                           /* Pointer Sub: BB x ref x ref --> int */
 836                           (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))),
 837                          "Sub node", 0,
 838                          show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
 839                                             "/* Pointer Sub: BB x ref x int --> ref */   |\n"
 840                                             "/* Pointer Sub: BB x int x ref --> ref */   |\n"
 841                                             "/* Pointer Sub: BB x ref x ref --> int */" );
 842                          );
 843       if (mode_is_reference(op1mode) != mode_is_reference(op2mode)) {
 844         op_is_symmetric = 0;
 845       } else {
 846         op_is_symmetric = 2;
 847       }
 848       break;
 849
 850     case iro_Minus:
 851       op1mode = get_irn_mode(in[1]);
 852       ASSERT_AND_RET_DBG(
 853                          /* Minus: BB x num --> num */
 854                          op1mode == mymode && mode_is_num(op1mode), "Minus node", 0,
 855                          show_unop_failure(n , "/* Minus: BB x num --> num */");
 856                          );
 857       op_is_symmetric = 2;
 858       break;
 859
 860     case iro_Mul:
 861       op1mode = get_irn_mode(in[1]);
 862       op2mode = get_irn_mode(in[2]);
 863       ASSERT_AND_RET_DBG(
 864                          /* Mul: BB x int1 x int1 --> int2 */
 865                          ((mode_is_int(op1mode)   && op2mode == op1mode && mode_is_int(mymode)) ||
 866                          /* Mul: BB x float x float --> float */
 867                           (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)),
 868                          "Mul node",0,
 869                          show_binop_failure(n, "/* Mul: BB x int1 x int1 --> int2 */ |\n"
 870                                                "/* Mul: BB x float x float --> float */");
 871                          );
 872       op_is_symmetric = 2;
 873       break;
 874
 875     case iro_Quot:
 876       op1mode = get_irn_mode(in[1]);
 877       op2mode = get_irn_mode(in[2]);
 878       op3mode = get_irn_mode(in[3]);
 879       ASSERT_AND_RET_DBG(
 880                          /* Quot: BB x M x float x float --> M x X x float */
 881                          op1mode == mode_M && op2mode == op3mode &&
 882                          get_mode_sort(op2mode) == irms_float_number &&
 883                          mymode == mode_T,
 884                          "Quot node",0,
 885                          show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
 886                          );
 887       op_is_symmetric = 2;
 888       break;
 889
 890     case iro_DivMod:
 891       op1mode = get_irn_mode(in[1]);
 892       op2mode = get_irn_mode(in[2]);
 893       op3mode = get_irn_mode(in[3]);
 894       ASSERT_AND_RET(
 895                      /* DivMod: BB x M x int x int --> M x X x int x int */
 896                      op1mode == mode_M &&
 897                      mode_is_int(op2mode) &&
 898                      op3mode == op2mode &&
 899                      mymode == mode_T,
 900                      "DivMod node", 0
 901                      );
 902       op_is_symmetric = 1;
 903       break;
 904
 905     case iro_Div:
 906     case iro_Mod:
 907       op1mode = get_irn_mode(in[1]);
 908       op2mode = get_irn_mode(in[2]);
 909       op3mode = get_irn_mode(in[3]);
 910       ASSERT_AND_RET(
 911                      /* Div or Mod: BB x M x int x int --> M x X x int */
 912                      op1mode == mode_M &&
 913                      op2mode == op3mode &&
 914                      mode_is_int(op2mode) &&
 915                      mymode == mode_T,
 916                      "Div or Mod node", 0
 917                      );
 918       op_is_symmetric = 1;
 919       break;
 920
 921     case iro_Abs:
 922       op1mode = get_irn_mode(in[1]);
 923       ASSERT_AND_RET_DBG(
 924                          /* Abs: BB x num --> num */
 925                          op1mode == mymode &&
 926                          mode_is_num (op1mode),
 927                          "Abs node", 0,
 928                          show_unop_failure(n, "/* Abs: BB x num --> num */");
 929                          );
 930       op_is_symmetric = 2;
 931       break;
 932
 933     case iro_And:
 934     case iro_Or:
 935     case iro_Eor:
 936       op1mode = get_irn_mode(in[1]);
 937       op2mode = get_irn_mode(in[2]);
 938       ASSERT_AND_RET_DBG(
 939                          /* And or Or or Eor: BB x int x int --> int */
 940                          mode_is_int(mymode) &&
 941                          op2mode == op1mode &&
 942                          mymode == op2mode,
 943                          "And, Or or Eor node", 0,
 944                          show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
 945                          );
 946       op_is_symmetric = 2;
 947       break;
 948
 949     case iro_Not:
 950       op1mode = get_irn_mode(in[1]);
 951       ASSERT_AND_RET_DBG(
 952                          /* Not: BB x int --> int */
 953                          mode_is_int(mymode) &&
 954                          mymode == op1mode,
 955                          "Not node", 0,
 956                          show_unop_failure(n, "/* Not: BB x int --> int */");
 957                          );
 958       op_is_symmetric = 2;
 959       break;
 960
 961
 962     case iro_Cmp:
 963       op1mode = get_irn_mode(in[1]);
 964       op2mode = get_irn_mode(in[2]);
 965       ASSERT_AND_RET_DBG(
 966                          /* Cmp: BB x datab x datab --> b16 */
 967                          mode_is_data (op1mode) &&
 968                          op2mode == op1mode &&
 969                          mymode == mode_T,
 970                          "Cmp node", 0,
 971                          show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
 972                          );
 973       break;
 974
 975     case iro_Shl:
 976     case iro_Shr:
 977     case iro_Shrs:
 978       op1mode = get_irn_mode(in[1]);
 979       op2mode = get_irn_mode(in[2]);
 980       ASSERT_AND_RET_DBG(
 981                          /* Shl, Shr or Shrs: BB x int x int_u --> int */
 982                          mode_is_int(op1mode) &&
 983                          mode_is_int(op2mode) &&
 984                          !mode_is_signed(op2mode) &&
 985                          mymode == op1mode,
 986                          "Shl, Shr, Shr or Rot node", 0,
 987                          show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
 988                          );
 989       break;
 990
 991     case iro_Rot:
 992       op1mode = get_irn_mode(in[1]);
 993       op2mode = get_irn_mode(in[2]);
 994       ASSERT_AND_RET_DBG(
 995                          /* Rot: BB x int x int --> int */
 996                          mode_is_int(op1mode) &&
 997                          mode_is_int(op2mode) &&
 998                          mymode == op1mode,
 999                          "Rot node", 0,
1000                          show_binop_failure(n, "/* Rot: BB x int x int --> int */");
1001                          );
1002       break;
1003
1004     case iro_Conv:
1005       op1mode = get_irn_mode(in[1]);
1006       ASSERT_AND_RET_DBG(
1007                          /* Conv: BB x datab1 --> datab2 */
1008                          mode_is_datab(op1mode) && mode_is_data(mymode),
1009                          "Conv node", 0,
1010                          show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1011                          );
1012       break;
1013
1014     case iro_Cast:
1015       op1mode = get_irn_mode(in[1]);
1016       ASSERT_AND_RET_DBG(
1017                          /* Conv: BB x datab1 --> datab2 */
1018                          mode_is_data(op1mode) && op1mode == mymode,
1019                          "Cast node", 0,
1020                          show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1021                          );
1022       break;
1023
1024     case iro_Phi:
1025     {
1026       ir_node *block = get_nodes_block(n);
1027
1028       if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building) {
1029         /* a Phi node MUST have the same number of inputs as its block */
1030         ASSERT_AND_RET_DBG(
1031           get_irn_arity(n) == get_irn_arity(block),
1032           "wrong number of inputs in Phi node", 0,
1033           show_phi_inputs(n, block);
1034         );
1035       }
1036
1037       /* Phi: BB x dataM^n --> dataM */
1038       for (i = 1; i < get_irn_arity(n); i++) {
1039         if (!is_Bad(in[i]) && (get_irn_op(in[i]) != op_Unknown))
1040           ASSERT_AND_RET_DBG(
1041                              get_irn_mode(in[i]) == mymode,
1042                              "Phi node", 0,
1043                              show_phi_failure(n, in[i], i);
1044                              );
1045       };
1046       ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 );
1047       break;
1048     }
1049     case iro_Load:
1050       op1mode = get_irn_mode(in[1]);
1051       op2mode = get_irn_mode(in[2]);
1052       ASSERT_AND_RET(
1053                      /* Load: BB x M x ref --> M x X x data */
1054                      op1mode == mode_M && mode_is_reference(op2mode),
1055                      "Load node", 0
1056                      );
1057       ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
1058
1059       /*
1060        * jack's gen_add_firm_code:simpleSel seems to build Load (Load
1061        * (Proj (Proj))) sometimes ...
1062
1063        * interprete.c:ai_eval seems to assume that this happens, too
1064
1065        * obset.c:get_abstval_any can't deal with this if the load has
1066        * mode_T
1067        *
1068       {
1069         entity *ent = hunt_for_entity (get_Load_ptr (n), n);
1070         assert ((NULL != ent) || (mymode != mode_T));
1071       }
1072       */
1073
1074       break;
1075
1076     case iro_Store: {
1077       entity *target;
1078
1079       op1mode = get_irn_mode(in[1]);
1080       op2mode = get_irn_mode(in[2]);
1081       op3mode = get_irn_mode(in[3]);
1082       ASSERT_AND_RET(
1083                      /* Load: BB x M x ref data --> M x X */
1084                      op1mode == mode_M && mode_is_reference(op2mode) && mode_is_data(op3mode),
1085                      "Store node", 0
1086                      );
1087       ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
1088
1089       target = get_ptr_entity(in[2]);
1090       if (vrfy_entities && target && get_irg_phase_state(current_ir_graph) == phase_high) {
1091         /*
1092          * If lowered code, any Sels that add 0 may be removed, causing
1093          * an direct access to entities of array or compound type.
1094          * Prevent this by checking the phase.
1095          */
1096         ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
1097                         "Store node", 0);
1098       }
1099
1100       break;
1101     }
1102
1103     case iro_Alloc:
1104       op1mode = get_irn_mode(in[1]);
1105       op2mode = get_irn_mode(in[2]);
1106       ASSERT_AND_RET_DBG(
1107                          /* Alloc: BB x M x int_u --> M x X x ref */
1108                          op1mode == mode_M &&
1109                          mode_is_int(op2mode) &&
1110                          !mode_is_signed(op2mode) &&
1111                          mymode == mode_T,
1112                          "Alloc node", 0,
1113                          show_binop_failure(n, "/* Alloc: BB x M x int_u --> M x X x ref */");
1114                          );
1115       break;
1116
1117     case iro_Free:
1118       op1mode = get_irn_mode(in[1]);
1119       op2mode = get_irn_mode(in[2]);
1120       op3mode = get_irn_mode(in[3]);
1121       ASSERT_AND_RET_DBG(
1122                          /* Free: BB x M x ref x int_u --> M */
1123                          op1mode == mode_M && mode_is_reference(op2mode) &&
1124                          mode_is_int(op3mode) &&
1125                          !mode_is_signed(op3mode) &&
1126                          mymode == mode_M,
1127                          "Free node", 0,
1128                          show_triop_failure(n, "/* Free: BB x M x ref x int_u --> M */");
1129                          );
1130       break;
1131
1132     case iro_Sync:
1133       /* Sync: BB x M^n --> M */
1134       for (i=1; i < get_irn_arity(n); i++) {
1135         ASSERT_AND_RET( get_irn_mode(in[i]) == mode_M, "Sync node", 0 );
1136       };
1137       ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
1138       break;
1139
1140     case iro_Proj:
1141       return vrfy_Proj_proj(n, irg);
1142       break;
1143
1144     case iro_Confirm:
1145       op1mode = get_irn_mode(in[1]);
1146       op2mode = get_irn_mode(in[2]);
1147       ASSERT_AND_RET_DBG(
1148                          /* Confirm: BB x T x T --> T */
1149                          op1mode == mymode &&
1150                          op2mode == mymode,
1151                          "Confirm node", 0,
1152                          show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
1153                          );
1154       break;
1155
1156     case iro_Mux:
1157       op1mode = get_irn_mode(in[1]);
1158       op2mode = get_irn_mode(in[2]);
1159       op3mode = get_irn_mode(in[3]);
1160       ASSERT_AND_RET(
1161                          /* Mux: BB x b x numP x numP --> numP */
1162                          op1mode == mode_b &&
1163                          op2mode == mymode &&
1164                          op3mode == mymode &&
1165                          mode_is_numP(mymode),
1166                          "Mux node", 0
1167                          );
1168       break;
1169
1170     default:
1171       break;
1172     }
1173
1174   /* All went ok */
1175   return 1;
1176 }
1177
1178 int irn_vrfy(ir_node *n)
1179 {
1180   int res = 1;
1181 #ifdef DEBUG_libfirm
1182   res = irn_vrfy_irg(n, current_ir_graph);
1183 #endif
1184   return res;
1185 }
1186
1187 /*-----------------------------------------------------------------*/
1188 /* Verify the whole graph.                                         */
1189 /*-----------------------------------------------------------------*/
1190
1191 /* This *is* used, except gcc doesn't notice that */
1192 static void vrfy_wrap(ir_node *node, void *env)
1193 {
1194   int *res = env;
1195
1196   *res = irn_vrfy(node);
1197 }
1198
1199 int irg_vrfy(ir_graph *irg)
1200 {
1201   int res = 1;
1202 #ifdef DEBUG_libfirm
1203   ir_graph *rem;
1204
1205   rem = current_ir_graph;
1206   current_ir_graph = irg;
1207
1208   assert(get_irg_pinned(irg) == op_pin_state_pinned);
1209
1210   irg_walk_graph(irg, vrfy_wrap, NULL, &res);
1211
1212   current_ir_graph = rem;
1213
1214   if (opt_do_node_verification == NODE_VERIFICATION_REPORT && ! res) {
1215     entity *ent = get_irg_entity(current_ir_graph);
1216
1217     if (ent)
1218       fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
1219     else
1220       fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph);
1221   }
1222
1223 #endif
1224   return res;
1225 }
1226
1227 int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
1228 {
1229   int res;
1230   node_verification_t old = opt_do_node_verification;
1231
1232   bad_msg = NULL;
1233   opt_do_node_verification = NODE_VERIFICATION_ERROR_ONLY;
1234   res = irn_vrfy_irg(n, irg);
1235   opt_do_node_verification = old;
1236   *bad_string = bad_msg;
1237
1238   return res;
1239 }
1240
1241
1242 typedef struct _vrfy_bad_env_t {
1243   int flags;
1244   int res;
1245 } vrfy_bad_env_t;
1246
1247 static void check_bads(ir_node *node, void *env)
1248 {
1249   vrfy_bad_env_t *venv = env;
1250   int i, arity = get_irn_arity(node);
1251
1252   if (is_Block(node)) {
1253     if ((venv->flags & BAD_CF) == 0) {
1254
1255       /* check for Bad Block predecessor */
1256       for (i = 0; i < arity; ++i) {
1257         ir_node *pred = get_irn_n(node, i);
1258
1259         if (is_Bad(pred)) {
1260           venv->res |= BAD_CF;
1261
1262           if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1263             fprintf(stderr, "irg_vrfy_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node));
1264           }
1265           if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1266             assert(0 && "Bad CF detected");
1267           }
1268         }
1269       }
1270     }
1271   }
1272   else {
1273     if ((venv->flags & BAD_BLOCK) == 0) {
1274
1275       /* check for Bad Block */
1276       if (is_Bad(get_nodes_block(node))) {
1277         venv->res |= BAD_BLOCK;
1278
1279         if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1280           fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Block\n", get_irn_node_nr(node));
1281         }
1282         if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1283           assert(0 && "Bad CF detected");
1284         }
1285       }
1286     }
1287
1288     if ((venv->flags & TUPLE) == 0) {
1289       if (get_irn_op(node) == op_Tuple) {
1290         venv->res |= TUPLE;
1291
1292         if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1293           fprintf(stderr, "irg_vrfy_bads: node %ld is a Tuple\n", get_irn_node_nr(node));
1294         }
1295         if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1296           assert(0 && "Tuple detected");
1297         }
1298       }
1299     }
1300
1301     for (i = 0; i < arity; ++i) {
1302       ir_node *pred = get_irn_n(node, i);
1303
1304       if (is_Bad(pred)) {
1305         /* check for Phi with Bad inputs */
1306         if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
1307           if (venv->flags & BAD_CF)
1308             continue;
1309           else {
1310             venv->res |= BAD_CF;
1311
1312             if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1313               fprintf(stderr, "irg_vrfy_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node));
1314             }
1315             if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1316               assert(0 && "Bad CF detected");
1317             }
1318           }
1319         }
1320
1321         /* Bad node input */
1322         if ((venv->flags & BAD_DF) == 0) {
1323           venv->res |= BAD_DF;
1324
1325           if (opt_do_node_verification == NODE_VERIFICATION_REPORT) {
1326             fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Input\n", get_irn_node_nr(node));
1327           }
1328           if (opt_do_node_verification == NODE_VERIFICATION_ON) {
1329             assert(0 && "Bad NON-CF detected");
1330           }
1331         }
1332       }
1333     }
1334   }
1335 }
1336
1337 /*
1338  * verify occurance of bad nodes
1339  */
1340 int irg_vrfy_bads(ir_graph *irg, int flags)
1341 {
1342   vrfy_bad_env_t env;
1343
1344   env.flags = flags;
1345   env.res   = 0;
1346
1347   irg_walk_graph(irg, check_bads, NULL, &env);
1348
1349   return env.res;
1350 }