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