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
  22 #ifdef NDEBUG
  23 /*
  24  * in RELEASE mode, returns ret if the expression expr evaluates to zero
  25  * in ASSERT mode, asserts the expression expr (and the string string).
  26  */
  27 #define ASSERT_AND_RET(expr, string, ret)       if (!(expr)) return (ret)
  28
  29 /*
  30  * in RELEASE mode, returns ret if the expression expr evaluates to zero
  31  * in ASSERT mode, executes blk if the expression expr evaluates to zero and asserts expr
  32  */
  33 #define ASSERT_AND_RET_DBG(expr, string, ret, blk)      if (!(expr)) return (ret)
  34 #else
  35 #define ASSERT_AND_RET(expr, string, ret) \
  36 do { \
  37   if (opt_do_node_verification == NODE_VERIFICATION_ON) \
  38     assert((expr) && string); \
  39   if (!(expr)) { \
  40     if (opt_do_node_verification == NODE_VERIFICATION_REPORT) \
  41       fprintf(stderr, #expr " : " string "\n"); \
  42     bad_msg = #expr " && " string; \
  43     return (ret); \
  44   } \
  45 } while(0)
  46
  47 #define ASSERT_AND_RET_DBG(expr, string, ret, blk) \
  48 do { \
  49   if (!(expr)) { \
  50     bad_msg = #expr " && " string; \
  51     if (opt_do_node_verification != NODE_VERIFICATION_ERROR_ONLY) { blk; } \
  52     if (opt_do_node_verification == NODE_VERIFICATION_REPORT) \
  53       fprintf(stderr, #expr " : " string "\n"); \
  54     else if (opt_do_node_verification == NODE_VERIFICATION_ON) \
  55       assert((expr) && string); \
  56     return (ret); \
  57   } \
  58 } while(0)
  59
  60 #endif
  61
  62 /* @@@ replace use of array "in" by access functions. */
  63 ir_node **get_irn_in(ir_node *node);
  64
  65 static node_verification_t opt_do_node_verification = NODE_VERIFICATION_ON;
  66 static const char *bad_msg;
  67
  68 /**
  69  * little helper for NULL modes
  70  */
  71 static const char *get_mode_name_ex(ir_mode *mode)
  72 {
  73   if (! mode)
  74     return "<no mode>";
  75   return get_mode_name(mode);
  76 }
  77
  78 void do_node_verification(node_verification_t mode)
  79 {
  80   opt_do_node_verification = mode;
  81 }
  82
  83 /**
  84  * Prints a failure for a Node
  85  */
  86 static void show_node_failure(ir_node *n)
  87 {
  88   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s\n" ,
  89     get_irn_node_nr(n),
  90     get_irn_opname(n), get_irn_modename(n)
  91   );
  92 }
  93
  94 /**
  95  * Prints a failure message for a binop
  96  */
  97 static void show_binop_failure(ir_node *n, const char *text)
  98 {
  99   ir_node *left  = get_binop_left(n);
 100   ir_node *right = get_binop_right(n);
 101
 102   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s(%s%s, %s%s) did not match (%s)\n",
 103       get_irn_node_nr(n),
 104       get_irn_opname(n), get_irn_modename(n),
 105       get_irn_opname(left), get_irn_modename(left),
 106       get_irn_opname(right), get_irn_modename(right),
 107       text);
 108 }
 109
 110 /**
 111  * Prints a failure message for an unop
 112  */
 113 static void show_unop_failure(ir_node *n, const char *text)
 114 {
 115   ir_node *op  = get_unop_op(n);
 116
 117   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s(%s%s) did not match (%s)\n",
 118       get_irn_node_nr(n),
 119       get_irn_opname(n), get_irn_modename(n),
 120       get_irn_opname(op), get_irn_modename(op),
 121       text);
 122 }
 123
 124 /**
 125  * Prints a failure message for a proj
 126  */
 127 static void show_proj_failure(ir_node *n)
 128 {
 129   ir_node *op  = get_Proj_pred(n);
 130   int proj     = get_Proj_proj(n);
 131
 132   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s %d(%s%s) failed\n" ,
 133       get_irn_node_nr(n),
 134       get_irn_opname(n), get_irn_modename(n), proj,
 135       get_irn_opname(op), get_irn_modename(op));
 136 }
 137
 138 /**
 139  * Prints a failure message for a proj
 140  */
 141 static void show_proj_failure_ent(ir_node *n, entity *ent)
 142 {
 143   ir_node *op  = get_Proj_pred(n);
 144   int proj     = get_Proj_proj(n);
 145   ir_mode *m   = get_type_mode(get_entity_type(ent));
 146
 147   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
 148       get_irn_node_nr(n),
 149       get_irn_opname(n), get_irn_modename(n), proj,
 150       get_irn_opname(op), get_irn_modename(op),
 151       get_entity_name(ent), get_type_name(get_entity_type(ent)),
 152       get_mode_name_ex(m));
 153 }
 154
 155 /**
 156  * Show a node and a graph
 157  */
 158 static void show_node_on_graph(ir_graph *irg, ir_node *n)
 159 {
 160   entity *ent = get_irg_ent(irg);
 161
 162   if (ent)
 163     fprintf(stderr, "\nFIRM: irn_vrfy_irg() of entity %s, node %ld %s%s\n",
 164       get_entity_name(ent),
 165       get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
 166   else
 167     fprintf(stderr, "\nFIRM: irn_vrfy_irg() of graph %p, node %ld %s%s\n",
 168       (void *)irg,
 169       get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
 170 }
 171
 172 /**
 173  * Show call params
 174  */
 175 static void show_call_param(ir_node *n, type *mt)
 176 {
 177   int i;
 178
 179   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Call type-check failed: %s(", get_type_name(mt));
 180   for (i = 0; i < get_method_n_params(mt); ++i) {
 181     fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i))));
 182   }
 183   fprintf(stderr, ") != CALL(");
 184
 185   for (i = 0; i < get_Call_n_params(n); ++i) {
 186     fprintf(stderr, "%s ", get_mode_name_ex(get_irn_mode(get_Call_param(n, i))));
 187   }
 188   fprintf(stderr, ")\n");
 189
 190 }
 191
 192 /**
 193  * Show return modes
 194  */
 195 static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i)
 196 {
 197   entity *ent = get_irg_ent(irg);
 198
 199   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
 200     get_irn_node_nr(n), get_entity_name(ent),
 201     get_mode_name_ex(get_irn_mode(get_Return_res(n, i))),
 202     get_mode_name_ex(get_type_mode(get_method_res_type(mt, i)))
 203   );
 204 }
 205
 206 /**
 207  * Show return number of results
 208  */
 209 static void show_return_nres(ir_graph *irg, ir_node *n, type *mt)
 210 {
 211   entity *ent = get_irg_ent(irg);
 212
 213   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Return node %ld in entity \"%s\" has %d results different from type %d\n",
 214     get_irn_node_nr(n), get_entity_name(ent),
 215     get_Return_n_ress(n), get_method_n_ress(mt));
 216 }
 217
 218 /**
 219  * Show Phi input
 220  */
 221 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos)
 222 {
 223   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
 224     get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
 225     get_irn_node_nr(pred), get_mode_name_ex(get_irn_mode(pred)));
 226 }
 227
 228 /**
 229  * verify the Proj number
 230  */
 231 static int
 232 vrfy_Proj_proj(ir_node *p, ir_graph *irg) {
 233   ir_node *pred;
 234   ir_mode *mode;
 235   int proj;
 236
 237   pred = skip_nop(get_Proj_pred(p));
 238   ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
 239   mode = get_irn_mode(p);
 240   proj = get_Proj_proj(p);
 241
 242   switch (get_irn_opcode(pred)) {
 243     case iro_Start:
 244       ASSERT_AND_RET_DBG(
 245           (
 246            (proj == pns_initial_exec   && mode == mode_X) ||
 247            (proj == pns_global_store   && mode == mode_M) ||
 248            (proj == pns_frame_base     && mode_is_reference(mode)) ||
 249            (proj == pns_globals        && mode_is_reference(mode)) ||
 250            (proj == pns_args           && mode == mode_T) ||
 251            (proj == pns_value_arg_base && mode_is_reference(mode)) ||
 252            (proj == pns_value_arg_base && mode == mode_T)    /* FIXME: only one of those */
 253           ),
 254           "wrong Proj from Start", 0,
 255       show_proj_failure(p);
 256       );
 257       break;
 258
 259     case iro_Cond:
 260       ASSERT_AND_RET_DBG(
 261         (proj >= 0 && mode == mode_X),
 262     "wrong Proj from Cond", 0,
 263     show_proj_failure(p);
 264       );
 265       break;
 266
 267     case iro_Raise:
 268       ASSERT_AND_RET_DBG(
 269         ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
 270         "wrong Proj from Raise", 0,
 271     show_proj_failure(p);
 272       );
 273       break;
 274
 275     case iro_InstOf:
 276       ASSERT_AND_RET_DBG(
 277     (proj >= 0 && mode == mode_X),
 278     "wrong Proj from InstOf", 0,
 279     show_proj_failure(p);
 280       );
 281       break;
 282
 283     case iro_Call:
 284       ASSERT_AND_RET_DBG(
 285         ((proj == pn_Call_M_regular        && mode == mode_M) ||
 286          (proj == pn_Call_X_except         && mode == mode_X) ||
 287          (proj == pn_Call_T_result         && mode == mode_T) ||
 288          (proj == pn_Call_M_except         && mode == mode_M) ||
 289      (proj == pn_Call_P_value_res_base && mode == mode_P)),
 290         "wrong Proj from Call", 0,
 291         show_proj_failure(p);
 292       );
 293       break;
 294
 295     case iro_FuncCall:
 296       ASSERT_AND_RET_DBG(
 297         ((proj == pn_Call_M_regular        && mode == mode_M) ||
 298          (proj == pn_Call_X_except         && mode == mode_X) ||
 299          (proj == pn_Call_T_result         && mode == mode_T) ||
 300          (proj == pn_Call_M_except         && mode == mode_M) ||
 301      (proj == pn_Call_P_value_res_base && mode == mode_P)),
 302         "wrong Proj from FuncCall", 0,
 303         show_proj_failure(p);
 304       );
 305       break;
 306
 307     case iro_Quot:
 308       ASSERT_AND_RET_DBG(
 309         ((proj == pn_Quot_M        && mode == mode_M) ||
 310          (proj == pn_Quot_X_except && mode == mode_X) ||
 311          (proj == pn_Quot_res      && mode_is_float(mode))),
 312         "wrong Proj from Quot", 0,
 313     show_proj_failure(p);
 314       );
 315       break;
 316
 317     case iro_DivMod:
 318       ASSERT_AND_RET_DBG(
 319         ((proj == pn_DivMod_M        && mode == mode_M) ||
 320          (proj == pn_DivMod_X_except && mode == mode_X) ||
 321          (proj == pn_DivMod_res_div  && mode_is_int(mode)) ||
 322          (proj == pn_DivMod_res_mod  && mode_is_int(mode))),
 323         "wrong Proj from DivMod", 0,
 324     show_proj_failure(p);
 325       );
 326       break;
 327
 328     case iro_Div:
 329       ASSERT_AND_RET_DBG(
 330         ((proj == pn_Div_M        && mode == mode_M) ||
 331          (proj == pn_Div_X_except && mode == mode_X) ||
 332          (proj == pn_Div_res      && mode_is_int(mode))),
 333         "wrong Proj from Div or Mod", 0,
 334     show_proj_failure(p);
 335       );
 336       break;
 337
 338     case iro_Mod:
 339       ASSERT_AND_RET_DBG(
 340         ((proj == pn_Mod_M        && mode == mode_M) ||
 341          (proj == pn_Mod_X_except && mode == mode_X) ||
 342          (proj == pn_Mod_res      && mode_is_int(mode))),
 343         "wrong Proj from Div or Mod", 0,
 344     show_proj_failure(p);
 345       );
 346       break;
 347
 348     case iro_Cmp:
 349       ASSERT_AND_RET_DBG(
 350         (proj >= 0 && proj <= 15 && mode == mode_b),
 351         "wrong Proj from Cmp", 0,
 352     show_proj_failure(p);
 353       );
 354       break;
 355
 356     case iro_Load:
 357       if (proj == pn_Load_res) {
 358     ir_node *ptr = get_Load_ptr(pred);
 359     entity *ent = NULL;
 360     if (get_irn_op(ptr) == op_Sel) {
 361       ent = get_Sel_entity(ptr);
 362     } /*
 363         We may not test this, after lowering and optimization the Const can
 364         have an unexpected type.
 365     else if ((get_irn_op(ptr) == op_Const) &&
 366            tarval_is_entity(get_Const_tarval(ptr))) {
 367       ent = get_tarval_entity(get_Const_tarval(ptr));
 368     } */
 369     if (ent) {
 370       ASSERT_AND_RET_DBG(
 371         (mode == get_type_mode(get_entity_type(ent))),
 372         "wrong data Proj from Load, entity type_mode failed", 0,
 373         show_proj_failure_ent(p, ent);
 374       );
 375     }
 376     else {
 377       ASSERT_AND_RET_DBG(
 378         mode_is_data(mode),
 379        "wrong data Proj from Load", 0,
 380        show_proj_failure(p);
 381      );
 382     }
 383       } else {
 384     ASSERT_AND_RET_DBG(
 385       ((proj == pn_Load_M        && mode == mode_M) ||
 386        (proj == pn_Load_X_except && mode == mode_X)),
 387           "wrong Proj from Load", 0,
 388       show_proj_failure(p);
 389     );
 390       }
 391       break;
 392
 393     case iro_Store:
 394       ASSERT_AND_RET_DBG(
 395         ((proj == pn_Store_M        && mode == mode_M) ||
 396          (proj == pn_Store_X_except && mode == mode_X)),
 397         "wrong Proj from Store", 0,
 398     show_proj_failure(p);
 399       );
 400       break;
 401
 402     case iro_Alloc:
 403       ASSERT_AND_RET_DBG(
 404         (
 405          (proj == pn_Alloc_M        && mode == mode_M) ||
 406          (proj == pn_Alloc_X_except /* && mode == mode_X*/) ||
 407          (proj == pn_Alloc_res      && mode_is_reference(mode))
 408         ),
 409         "wrong Proj from Alloc", 0,
 410         show_proj_failure(p);
 411       );
 412       break;
 413
 414     case iro_Proj:
 415       {
 416         type *mt; /* A method type */
 417         long nr = get_Proj_proj(pred);
 418
 419         pred = skip_nop(get_Proj_pred(pred));
 420         ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
 421         switch (get_irn_opcode(pred))
 422         {
 423           case iro_Start:
 424             mt = get_entity_type(get_irg_ent(irg));
 425
 426         if (nr == pns_args) {
 427               ASSERT_AND_RET(
 428                   (proj >= 0 && mode_is_data(mode)),
 429                   "wrong Proj from Proj from Start", 0);
 430               ASSERT_AND_RET(
 431                 (proj < get_method_n_params(mt)),
 432                 "More Projs for args than args in type", 0
 433               );
 434               if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj)))
 435                 /* value argument */ break;
 436
 437               ASSERT_AND_RET(
 438                   (mode == get_type_mode(get_method_param_type(mt, proj))),
 439                   "Mode of Proj from Start doesn't match mode of param type.", 0);
 440             }
 441         else if (nr == pns_value_arg_base) {
 442           ASSERT_AND_RET(
 443                   (proj >= 0 && mode_is_reference(mode)),
 444                   "wrong Proj from Proj from Start", 0
 445               );
 446               ASSERT_AND_RET(
 447                 (proj < get_method_n_params(mt)),
 448                 "More Projs for args than args in type", 0
 449               );
 450         }
 451             break;
 452
 453           case iro_Call:
 454             {
 455               ASSERT_AND_RET(
 456                   (proj >= 0 && mode_is_data(mode)),
 457                   "wrong Proj from Proj from Call", 0);
 458               mt = get_Call_type(pred);
 459               ASSERT_AND_RET(
 460                   (proj < get_method_n_ress(mt)),
 461                   "More Projs for results than results in type.", 0);
 462               if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
 463                 /* value result */ break;
 464
 465               ASSERT_AND_RET(
 466                   (mode == get_type_mode(get_method_res_type(mt, proj))),
 467                   "Mode of Proj from Call doesn't match mode of result type.", 0);
 468             }
 469             break;
 470
 471           case iro_FuncCall:
 472             {
 473               ASSERT_AND_RET(
 474                   (proj >= 0 && mode_is_data(mode)),
 475                   "wrong Proj from Proj from FuncCall", 0);
 476               mt = get_FuncCall_type(pred);
 477               ASSERT_AND_RET(
 478                   (proj < get_method_n_ress(mt)),
 479                   "More Projs for results than results in type.", 0);
 480               if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
 481                 /* value result */ break;
 482
 483               ASSERT_AND_RET(
 484                   (mode == get_type_mode(get_method_res_type(mt, proj))),
 485                   "Mode of Proj from FuncCall doesn't match mode of result type.", 0);
 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 (! 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 or Unknown,
 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 /*|| opcode1 == iro_Unknown*/)  /* GL: for analyses mode must be correct. */
 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 (! 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_ent(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       tarval *tv = get_Const_tarval(n);
 669       if (tarval_is_entity(tv))
 670           ASSERT_AND_RET(
 671                          (get_irn_irg(n) == get_const_code_irg()) ||
 672                          (get_entity_peculiarity(tarval_to_entity(tv)) != peculiarity_description),
 673                          "descriptions have no address", 0);
 674           ASSERT_AND_RET(
 675                          /* Const: BB --> data */
 676                          (mode_is_data (mymode) ||
 677                           mymode == mode_b)      /* we want boolean constants for static evaluation */
 678                          ,"Const node", 0        /* of Cmp. */
 679                          );
 680      } break;
 681
 682     case iro_SymConst:
 683       ASSERT_AND_RET(
 684                      /* SymConst: BB --> int*/
 685                      (mode_is_int(mymode) ||
 686                       /* SymConst: BB --> ref */
 687                       mode_is_reference(mymode))
 688                      ,"SymConst node", 0);
 689       break;
 690
 691     case iro_Sel:
 692       op1mode = get_irn_mode(in[1]);
 693       op2mode = get_irn_mode(in[2]);
 694       ASSERT_AND_RET_DBG(
 695                          /* Sel: BB x M x ref x int^n --> ref */
 696                          (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
 697                          "Sel node", 0, show_node_failure(n)
 698                          );
 699       for (i=3; i < get_irn_arity(n); i++)
 700         {
 701           ASSERT_AND_RET_DBG(mode_is_int(get_irn_mode(in[i])), "Sel node", 0, show_node_failure(n));
 702         }
 703       ent = get_Sel_entity(n);
 704       ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n));
 705       break;
 706
 707     case iro_InstOf:
 708       ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
 709       ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
 710       break;
 711
 712     case iro_Call:
 713       op1mode = get_irn_mode(in[1]);
 714       op2mode = get_irn_mode(in[2]);
 715       /* Call: BB x M x ref x data1 x ... x datan
 716          --> M x datan+1 x ... x data n+m */
 717       ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 );  /* operand M x ref */
 718       for (i=3; i < get_irn_arity(n); i++) {
 719         ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Call node", 0 );  /* operand datai */
 720       };
 721       ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 );   /* result T */
 722       /* Compare arguments of node with those of type */
 723       mt = get_Call_type(n);
 724
 725       if (get_method_variadicity(mt) == variadicity_variadic) {
 726         ASSERT_AND_RET_DBG(
 727                            get_Call_n_params(n) >= get_method_n_params(mt),
 728                            "Number of args for Call doesn't match number of args in variadic type.",
 729                            0,
 730                            fprintf(stderr, "Call has %d params, method %s type %d\n",
 731                                    get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
 732                            );
 733       }
 734       else {
 735         ASSERT_AND_RET(
 736                        get_Call_n_params(n) == get_method_n_params(mt),
 737                        "Number of args for Call doesn't match number of args in non variadic type.",
 738                        0);
 739       }
 740
 741       for (i = 0; i < get_method_n_params(mt); i++) {
 742     type *t = get_method_param_type(mt, i);
 743
 744     if (is_atomic_type(t)) {
 745       ASSERT_AND_RET_DBG(
 746           get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
 747           "Mode of arg for Call doesn't match mode of arg type.", 0,
 748       show_call_param(n, mt);
 749       );
 750     }
 751     else {
 752       /* call with a compound type, mode must be reference */
 753       ASSERT_AND_RET_DBG(
 754           mode_is_reference(get_irn_mode(get_Call_param(n, i))),
 755           "Mode of arg for Call doesn't match mode of arg type.", 0,
 756       show_call_param(n, mt);
 757       );
 758     }
 759       }
 760       break;
 761
 762     case iro_Add:
 763       op1mode = get_irn_mode(in[1]);
 764       op2mode = get_irn_mode(in[2]);
 765       ASSERT_AND_RET_DBG(
 766                          (
 767                           /* common Add: BB x numP x numP --> numP */
 768                           (op1mode == mymode && op2mode == op1mode && mode_is_numP(mymode)) ||
 769                           /* Pointer Add: BB x ref x int --> ref */
 770                           (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
 771                           /* Pointer Add: BB x int x ref --> ref */
 772                           (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
 773                           ),
 774                          "Add node", 0,
 775                          show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
 776                                             "/* Pointer Add: BB x ref x int --> ref */   |\n"
 777                                             "/* Pointer Add: BB x int x ref --> ref */");
 778                          );
 779       if (mode_is_reference(op1mode) != mode_is_reference(op2mode)) {
 780         /* BB x ref x int --> ref or BB x int x ref --> ref */
 781         op_is_symmetric = 0;
 782       } else {
 783         /* BB x num x num --> num or BB x ref x ref */
 784         op_is_symmetric = 2;
 785       }
 786       break;
 787
 788     case iro_Sub:
 789       op1mode = get_irn_mode(in[1]);
 790       op2mode = get_irn_mode(in[2]);
 791       ASSERT_AND_RET_DBG(
 792                          /* common Sub: BB x numP x numP --> numP */
 793                          ((mymode ==op1mode && mymode == op2mode && mode_is_numP(op1mode)) ||
 794                           /* Pointer Sub: BB x ref x int --> ref */
 795                           (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
 796                           /* Pointer Sub: BB x int x ref --> ref */
 797                           (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode)) ||
 798                           /* Pointer Sub: BB x ref x ref --> int */
 799                           (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))),
 800                          "Sub node", 0,
 801                          show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
 802                                             "/* Pointer Sub: BB x ref x int --> ref */   |\n"
 803                                             "/* Pointer Sub: BB x int x ref --> ref */   |\n"
 804                                             "/* Pointer Sub: BB x ref x ref --> int */" );
 805                          );
 806       if (mode_is_reference(op1mode) != mode_is_reference(op2mode)) {
 807         op_is_symmetric = 0;
 808       } else {
 809         op_is_symmetric = 2;
 810       }
 811       break;
 812
 813     case iro_Minus:
 814       op1mode = get_irn_mode(in[1]);
 815       ASSERT_AND_RET_DBG(
 816                          /* Minus: BB x float --> float */
 817                          op1mode == mymode && get_mode_sort(op1mode) == irms_float_number, "Minus node", 0,
 818                          show_unop_failure(n , "/* Minus: BB x float --> float */");
 819                          );
 820       op_is_symmetric = 2;
 821       break;
 822
 823     case iro_Mul:
 824       op1mode = get_irn_mode(in[1]);
 825       op2mode = get_irn_mode(in[2]);
 826       ASSERT_AND_RET_DBG(
 827                          /* Mul: BB x int1 x int1 --> int2 */
 828                          ((mode_is_int(op1mode)   && op2mode == op1mode && mode_is_int(mymode)) ||
 829                          /* Mul: BB x float x float --> float */
 830                           (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)),
 831                          "Mul node",0,
 832                          show_binop_failure(n, "/* Mul: BB x int1 x int1 --> int2 */ |\n"
 833                                                "/* Mul: BB x float x float --> float */");
 834                          );
 835       op_is_symmetric = 2;
 836       break;
 837
 838     case iro_Quot:
 839       op1mode = get_irn_mode(in[1]);
 840       op2mode = get_irn_mode(in[2]);
 841       op3mode = get_irn_mode(in[3]);
 842       ASSERT_AND_RET_DBG(
 843                          /* Quot: BB x M x float x float --> M x X x float */
 844                          op1mode == mode_M && op2mode == op3mode &&
 845                          get_mode_sort(op2mode) == irms_float_number &&
 846                          mymode == mode_T,
 847                          "Quot node",0,
 848                          show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
 849                          );
 850       op_is_symmetric = 2;
 851       break;
 852
 853     case iro_DivMod:
 854       op1mode = get_irn_mode(in[1]);
 855       op2mode = get_irn_mode(in[2]);
 856       op3mode = get_irn_mode(in[3]);
 857       ASSERT_AND_RET(
 858                      /* DivMod: BB x M x int x int --> M x X x int x int */
 859                      op1mode == mode_M &&
 860                      mode_is_int(op2mode) &&
 861                      op3mode == op2mode &&
 862                      mymode == mode_T,
 863                      "DivMod node", 0
 864                      );
 865       op_is_symmetric = 1;
 866       break;
 867
 868     case iro_Div:
 869     case iro_Mod:
 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                      /* Div or Mod: BB x M x int x int --> M x X x int */
 875                      op1mode == mode_M &&
 876                      op2mode == op3mode &&
 877                      mode_is_int(op2mode) &&
 878                      mymode == mode_T,
 879                      "Div or Mod node", 0
 880                      );
 881       op_is_symmetric = 1;
 882       break;
 883
 884     case iro_Abs:
 885       op1mode = get_irn_mode(in[1]);
 886       ASSERT_AND_RET_DBG(
 887                          /* Abs: BB x num --> num */
 888                          op1mode == mymode &&
 889                          mode_is_num (op1mode),
 890                          "Abs node", 0,
 891                          show_unop_failure(n, "/* Abs: BB x num --> num */");
 892                          );
 893       op_is_symmetric = 2;
 894       break;
 895
 896     case iro_And:
 897     case iro_Or:
 898     case iro_Eor:
 899       op1mode = get_irn_mode(in[1]);
 900       op2mode = get_irn_mode(in[2]);
 901       ASSERT_AND_RET_DBG(
 902                          /* And or Or or Eor: BB x int x int --> int */
 903                          mode_is_int(mymode) &&
 904                          op2mode == op1mode &&
 905                          mymode == op2mode,
 906                          "And, Or or Eor node", 0,
 907                          show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
 908                          );
 909       op_is_symmetric = 2;
 910       break;
 911
 912     case iro_Not:
 913       op1mode = get_irn_mode(in[1]);
 914       ASSERT_AND_RET_DBG(
 915                          /* Not: BB x int --> int */
 916                          mode_is_int(mymode) &&
 917                          mymode == op1mode,
 918                          "Not node", 0,
 919                          show_unop_failure(n, "/* Not: BB x int --> int */");
 920                          );
 921       op_is_symmetric = 2;
 922       break;
 923
 924
 925     case iro_Cmp:
 926       op1mode = get_irn_mode(in[1]);
 927       op2mode = get_irn_mode(in[2]);
 928       ASSERT_AND_RET_DBG(
 929                          /* Cmp: BB x datab x datab --> b16 */
 930                          mode_is_data (op1mode) &&
 931                          op2mode == op1mode &&
 932                          mymode == mode_T,
 933                          "Cmp node", 0,
 934                          show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
 935                          );
 936       break;
 937
 938     case iro_Shl:
 939     case iro_Shr:
 940     case iro_Shrs:
 941       op1mode = get_irn_mode(in[1]);
 942       op2mode = get_irn_mode(in[2]);
 943       ASSERT_AND_RET_DBG(
 944                          /* Shl, Shr or Shrs: BB x int x int_u --> int */
 945                          mode_is_int(op1mode) &&
 946                          mode_is_int(op2mode) &&
 947                          !mode_is_signed(op2mode) &&
 948                          mymode == op1mode,
 949                          "Shl, Shr, Shr or Rot node", 0,
 950                          show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
 951                          );
 952       break;
 953
 954     case iro_Rot:
 955       op1mode = get_irn_mode(in[1]);
 956       op2mode = get_irn_mode(in[2]);
 957       ASSERT_AND_RET_DBG(
 958                          /* Rot: BB x int x int --> int */
 959                          mode_is_int(op1mode) &&
 960                          mode_is_int(op2mode) &&
 961                          mymode == op1mode,
 962                          "Rot node", 0,
 963                          show_binop_failure(n, "/* Rot: BB x int x int --> int */");
 964                          );
 965       break;
 966
 967     case iro_Conv:
 968       op1mode = get_irn_mode(in[1]);
 969       ASSERT_AND_RET_DBG(
 970                          /* Conv: BB x datab1 --> datab2 */
 971                          mode_is_datab(op1mode) && mode_is_data(mymode),
 972                          "Conv node", 0,
 973                          show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
 974                          );
 975       break;
 976
 977     case iro_Cast:
 978       op1mode = get_irn_mode(in[1]);
 979       ASSERT_AND_RET_DBG(
 980                          /* Conv: BB x datab1 --> datab2 */
 981                          mode_is_data(op1mode) && op1mode == mymode,
 982                          "Cast node", 0,
 983                          show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
 984                          );
 985       break;
 986
 987     case iro_Phi:
 988       /* Phi: BB x dataM^n --> dataM */
 989       for (i = 1; i < get_irn_arity(n); i++) {
 990         if (!is_Bad(in[i]) && (get_irn_op(in[i]) != op_Unknown))
 991           ASSERT_AND_RET_DBG(
 992                              get_irn_mode(in[i]) == mymode,
 993                              "Phi node", 0,
 994                              show_phi_failure(n, in[i], i);
 995                              );
 996       };
 997       ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 );
 998       break;
 999
1000     case iro_Load:
1001       op1mode = get_irn_mode(in[1]);
1002       op2mode = get_irn_mode(in[2]);
1003       ASSERT_AND_RET(
1004                      /* Load: BB x M x ref --> M x X x data */
1005                      op1mode == mode_M && mode_is_reference(op2mode),
1006                      "Load node", 0
1007                      );
1008       ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
1009
1010       /*
1011        * jack's gen_add_firm_code:simpleSel seems to build Load (Load
1012        * (Proj (Proj))) sometimes ...
1013
1014        * interprete.c:ai_eval seems to assume that this happens, too
1015
1016        * obset.c:get_abstval_any can't deal with this if the load has
1017        * mode_T
1018        *
1019       {
1020         entity *ent = hunt_for_entity (get_Load_ptr (n), n);
1021         assert ((NULL != ent) || (mymode != mode_T));
1022       }
1023       */
1024
1025       break;
1026
1027     case iro_Store:
1028       op1mode = get_irn_mode(in[1]);
1029       op2mode = get_irn_mode(in[2]);
1030       op3mode = get_irn_mode(in[3]);
1031       ASSERT_AND_RET(
1032                      /* Load: BB x M x ref data --> M x X */
1033                      op1mode == mode_M && mode_is_reference(op2mode) && mode_is_data(op3mode),
1034                      "Store node", 0
1035                      );
1036       ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
1037       break;
1038
1039     case iro_Alloc:
1040       op1mode = get_irn_mode(in[1]);
1041       op2mode = get_irn_mode(in[2]);
1042       ASSERT_AND_RET_DBG(
1043                          /* Alloc: BB x M x int_u --> M x X x ref */
1044                          op1mode == mode_M &&
1045                          mode_is_int(op2mode) &&
1046                          !mode_is_signed(op2mode) &&
1047                          mymode == mode_T,
1048                          "Alloc node", 0,
1049                          show_binop_failure(n, "/* Alloc: BB x M x int_u --> M x X x ref */");
1050                          );
1051       break;
1052
1053     case iro_Free:
1054       op1mode = get_irn_mode(in[1]);
1055       op2mode = get_irn_mode(in[2]);
1056       ASSERT_AND_RET_DBG(
1057                          /* Free: BB x M x ref --> M */
1058                          op1mode == mode_M && mode_is_reference(op2mode) &&
1059                          mymode == mode_M,
1060                          "Free node", 0,
1061                          show_binop_failure(n, "/* Free: BB x M x ref --> M */");
1062                          );
1063       break;
1064
1065     case iro_Sync:
1066       /* Sync: BB x M^n --> M */
1067       for (i=1; i < get_irn_arity(n); i++) {
1068         ASSERT_AND_RET( get_irn_mode(in[i]) == mode_M, "Sync node", 0 );
1069       };
1070       ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
1071       break;
1072
1073     case iro_Proj:
1074       return vrfy_Proj_proj(n, irg);
1075       break;
1076
1077     case iro_Confirm:
1078       op1mode = get_irn_mode(in[1]);
1079       op2mode = get_irn_mode(in[2]);
1080       ASSERT_AND_RET_DBG(
1081                          /* Confirm: BB x T x T --> T */
1082                          op1mode == mymode &&
1083                          op2mode == mymode,
1084                          "Confirm node", 0,
1085                          show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
1086                          );
1087       break;
1088
1089     default:
1090       break;
1091     }
1092
1093   /* All went ok */
1094   return 1;
1095 }
1096
1097 int irn_vrfy(ir_node *n)
1098 {
1099   int res = 1;
1100 #ifdef DEBUG_libfirm
1101   res = irn_vrfy_irg(n, current_ir_graph);
1102 #endif
1103   return res;
1104 }
1105
1106 /*-----------------------------------------------------------------*/
1107 /* Verify the whole graph.                                         */
1108 /*-----------------------------------------------------------------*/
1109
1110 /* This *is* used, except gcc doesn't notice that */
1111 static void vrfy_wrap(ir_node *node, void *env)
1112 {
1113   int *res = env;
1114
1115   *res = irn_vrfy(node);
1116 }
1117
1118 int irg_vrfy(ir_graph *irg)
1119 {
1120   int res = 1;
1121 #ifdef DEBUG_libfirm
1122   ir_graph *rem;
1123
1124   rem = current_ir_graph;
1125   current_ir_graph = irg;
1126
1127   assert(get_irg_pinned(irg) == pinned);
1128
1129   irg_walk(irg->end, vrfy_wrap, NULL, &res);
1130
1131   current_ir_graph = rem;
1132
1133   if (opt_do_node_verification == NODE_VERIFICATION_REPORT && ! res) {
1134     entity *ent = get_irg_entity(current_ir_graph);
1135
1136     if (ent)
1137       fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
1138     else
1139       fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)current_ir_graph);
1140   }
1141
1142 #endif
1143   return res;
1144 }
1145
1146 int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
1147 {
1148   int res;
1149   node_verification_t old = opt_do_node_verification;
1150
1151   bad_msg = NULL;
1152   opt_do_node_verification = NODE_VERIFICATION_ERROR_ONLY;
1153   res = irn_vrfy_irg(n, irg);
1154   opt_do_node_verification = old;
1155   *bad_string = bad_msg;
1156
1157   return res;
1158 }