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