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 "irgraph_t.h"
  18 # include "irvrfy.h"
  19 # include "irgwalk.h"
  20
  21 #ifdef NDEBUG
  22 /*
  23  * in RELEASE mode, returns ret if the expression expr evaluates to zero
  24  * in ASSERT mode, asserts the expression expr (and the string string).
  25  */
  26 #define ASSERT_AND_RET(expr, string, ret)               if (!(expr)) return (ret)
  27
  28 /*
  29  * in RELEASE mode, returns ret if the expression expr evaluates to zero
  30  * in ASSERT mode, executes blk if the expression expr evaluates to zero and asserts
  31  */
  32 #define ASSERT_AND_RET_DBG(expr, string, ret, blk)      if (!(expr)) return (ret)
  33 #else
  34 #define ASSERT_AND_RET(expr, string, ret)               do { assert((expr) && string); if (!(expr)) return (ret); } while(0)
  35 #define ASSERT_AND_RET_DBG(expr, string, ret, blk)      do { if (!(expr)) { { blk } assert(0 && string); return (ret); } } while(0)
  36 #endif
  37
  38 /* @@@ replace use of array "in" by access functions. */
  39 ir_node **get_irn_in(ir_node *node);
  40
  41 bool opt_do_node_verification = 1;
  42 void do_node_verification(bool b) {
  43   opt_do_node_verification = b;
  44 }
  45
  46 /**
  47  * Prints a failure message for a binop
  48  */
  49 static void show_binop_failure(ir_node *n, const char *text)
  50 {
  51   ir_node *left  = get_binop_left(n);
  52   ir_node *right = get_binop_right(n);
  53
  54   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s(%s%s, %s%s) did not match (%s)\n",
  55       get_irn_node_nr(n),
  56       get_irn_opname(n), get_irn_modename(n),
  57       get_irn_opname(left), get_irn_modename(left),
  58       get_irn_opname(right), get_irn_modename(right),
  59       text);
  60 }
  61
  62 /**
  63  * Prints a failure message for an unop
  64  */
  65 static void show_unop_failure(ir_node *n, const char *text)
  66 {
  67   ir_node *op  = get_unop_op(n);
  68
  69   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s(%s%s) did not match (%s)\n",
  70       get_irn_node_nr(n),
  71       get_irn_opname(n), get_irn_modename(n),
  72       get_irn_opname(op), get_irn_modename(op),
  73       text);
  74 }
  75
  76 /**
  77  * Prints a failure message for a proj
  78  */
  79 static void show_proj_failure(ir_node *n)
  80 {
  81   ir_node *op  = get_Proj_pred(n);
  82   int proj     = get_Proj_proj(n);
  83
  84   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s %d(%s%s) failed\n" ,
  85       get_irn_node_nr(n),
  86       get_irn_opname(n), get_irn_modename(n), proj,
  87       get_irn_opname(op), get_irn_modename(op));
  88 }
  89
  90 /**
  91  * Prints a failure message for a proj
  92  */
  93 static void show_proj_failure_ent(ir_node *n, entity *ent)
  94 {
  95   ir_node *op  = get_Proj_pred(n);
  96   int proj     = get_Proj_proj(n);
  97   ir_mode *m   = get_type_mode(get_entity_type(ent));
  98
  99   fprintf(stderr, "\nFIRM: irn_vrfy_irg() of node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
 100       get_irn_node_nr(n),
 101       get_irn_opname(n), get_irn_modename(n), proj,
 102       get_irn_opname(op), get_irn_modename(op),
 103       get_entity_name(ent), get_type_name(get_entity_type(ent)),
 104       m ? get_mode_name(m) : "<no mode>");
 105 }
 106
 107
 108 /**
 109  * Show a node and a graph
 110  */
 111 static void show_node_on_graph(ir_graph *irg, ir_node *n)
 112 {
 113   entity *ent = get_irg_ent(irg);
 114
 115   if (ent)
 116     fprintf(stderr, "\nFIRM: irn_vrfy_irg() of entity %s, node %ld %s%s\n",
 117       get_entity_name(ent),
 118       get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
 119   else
 120     fprintf(stderr, "\nFIRM: irn_vrfy_irg() of graph %p, node %ld %s%s\n",
 121       (void *)irg,
 122       get_irn_node_nr(n), get_irn_opname(n), get_irn_modename(n));
 123 }
 124
 125 /**
 126  * Show call params
 127  */
 128 static void show_call_param(ir_node *n, type *mt)
 129 {
 130   int i;
 131
 132   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Call type-check failed: %s(", get_type_name(mt));
 133   for (i = 0; i < get_method_n_params(mt); ++i) {
 134     fprintf(stderr, "%s ", get_mode_name(get_type_mode(get_method_param_type(mt, i))));
 135   }
 136   fprintf(stderr, ") != CALL(");
 137
 138   for (i = 0; i < get_Call_n_params(n); ++i) {
 139     fprintf(stderr, "%s ", get_mode_name(get_irn_mode(get_Call_param(n, i))));
 140   }
 141   fprintf(stderr, ")\n");
 142
 143 }
 144
 145 /**
 146  * Show return modes
 147  */
 148 static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i)
 149 {
 150   entity *ent = get_irg_ent(irg);
 151
 152   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
 153     get_irn_node_nr(n), get_entity_name(ent),
 154     get_mode_name(get_irn_mode(get_Return_res(n, i))),
 155     get_mode_name(get_type_mode(get_method_res_type(mt, i)))
 156   );
 157 }
 158
 159 /**
 160  * Show return number of results
 161  */
 162 static void show_return_nres(ir_graph *irg, ir_node *n, type *mt)
 163 {
 164   entity *ent = get_irg_ent(irg);
 165
 166   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Return node %ld in entity \"%s\" has %d results different from type %d\n",
 167     get_irn_node_nr(n), get_entity_name(ent),
 168     get_Return_n_ress(n), get_method_n_ress(mt));
 169 }
 170
 171 /**
 172  * Show Phi input
 173  */
 174 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos)
 175 {
 176   fprintf(stderr, "\nFIRM: irn_vrfy_irg() Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
 177     get_irn_node_nr(phi), get_mode_name(get_irn_mode(phi)),
 178     get_irn_node_nr(pred), get_mode_name(get_irn_mode(pred)));
 179 }
 180
 181 INLINE static int
 182 vrfy_Proj_proj(ir_node *p, ir_graph *irg) {
 183   ir_node *pred;
 184   ir_mode *mode;
 185   int proj;
 186
 187   pred = skip_nop(get_Proj_pred(p));
 188   assert(get_irn_mode(pred) == mode_T);
 189   mode = get_irn_mode(p);
 190   proj = get_Proj_proj(p);
 191
 192   switch (get_irn_opcode(pred)) {
 193     case iro_Start:
 194       ASSERT_AND_RET_DBG(
 195           (
 196            (proj == pns_initial_exec   && mode == mode_X) ||
 197            (proj == pns_global_store   && mode == mode_M) ||
 198            (proj == pns_frame_base     && mode_is_reference(mode)) ||
 199            (proj == pns_globals        && mode_is_reference(mode)) ||
 200            (proj == pns_args           && mode == mode_T) ||
 201            (proj == pns_value_arg_base && mode_is_reference(mode))
 202           ),
 203           "wrong Proj from Start", 0,
 204           show_proj_failure(p);
 205       );
 206       break;
 207
 208     case iro_Cond:
 209       ASSERT_AND_RET_DBG(
 210         (proj >= 0 && mode == mode_X),
 211         "wrong Proj from Cond", 0,
 212         show_proj_failure(p);
 213       );
 214       break;
 215
 216     case iro_Raise:
 217       ASSERT_AND_RET_DBG(
 218         ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
 219         "wrong Proj from Raise", 0,
 220         show_proj_failure(p);
 221       );
 222       break;
 223
 224     case iro_InstOf:
 225       ASSERT_AND_RET_DBG(
 226         (proj >= 0 && mode == mode_X),
 227         "wrong Proj from InstOf", 0,
 228         show_proj_failure(p);
 229       );
 230       break;
 231
 232     case iro_Call:
 233       ASSERT_AND_RET_DBG(
 234         ((proj == pn_Call_M_regular        && mode == mode_M) ||
 235          (proj == pn_Call_X_except         && mode == mode_X) ||
 236          (proj == pn_Call_T_result         && mode == mode_T) ||
 237          (proj == pn_Call_M_except         && mode == mode_M) ||
 238          (proj == pn_Call_P_value_res_base && mode == mode_P)),
 239         "wrong Proj from Call", 0,
 240         show_proj_failure(p);
 241       );
 242       break;
 243
 244     case iro_Quot:
 245       ASSERT_AND_RET_DBG(
 246         ((proj == pn_Quot_M        && mode == mode_M) ||
 247          (proj == pn_Quot_X_except && mode == mode_X) ||
 248          (proj == pn_Quot_res      && mode_is_float(mode))),
 249         "wrong Proj from Quot", 0,
 250         show_proj_failure(p);
 251       );
 252       break;
 253
 254     case iro_DivMod:
 255       ASSERT_AND_RET_DBG(
 256         ((proj == pn_DivMod_M        && mode == mode_M) ||
 257          (proj == pn_DivMod_X_except && mode == mode_X) ||
 258          (proj == pn_DivMod_res_div  && mode_is_int(mode)) ||
 259          (proj == pn_DivMod_res_mod  && mode_is_int(mode))),
 260         "wrong Proj from DivMod", 0,
 261         show_proj_failure(p);
 262       );
 263       break;
 264
 265     case iro_Div:
 266       ASSERT_AND_RET_DBG(
 267         ((proj == pn_Div_M        && mode == mode_M) ||
 268          (proj == pn_Div_X_except && mode == mode_X) ||
 269          (proj == pn_Div_res      && mode_is_int(mode))),
 270         "wrong Proj from Div or Mod", 0,
 271         show_proj_failure(p);
 272       );
 273       break;
 274
 275     case iro_Mod:
 276       ASSERT_AND_RET_DBG(
 277         ((proj == pn_Mod_M        && mode == mode_M) ||
 278          (proj == pn_Mod_X_except && mode == mode_X) ||
 279          (proj == pn_Mod_res      && mode_is_int(mode))),
 280         "wrong Proj from Div or Mod", 0,
 281         show_proj_failure(p);
 282       );
 283       break;
 284
 285     case iro_Cmp:
 286       ASSERT_AND_RET_DBG(
 287         (proj >= 0 && proj <= 15 && mode == mode_b),
 288         "wrong Proj from Cmp", 0,
 289         show_proj_failure(p);
 290       );
 291       break;
 292
 293     case iro_Load:
 294       if (proj == pn_Load_res) {
 295         ir_node *ptr = get_Load_ptr(pred);
 296         entity *ent = NULL;
 297         if (get_irn_op(ptr) == op_Sel) {
 298           ent = get_Sel_entity(ptr);
 299         } /*
 300         We may not test this, after lowering and optimization the Const can
 301         have an unexpected type.
 302     else if ((get_irn_op(ptr) == op_Const) &&
 303                    tarval_is_entity(get_Const_tarval(ptr))) {
 304           ent = get_tarval_entity(get_Const_tarval(ptr));
 305         } */
 306         if (ent) {
 307           ASSERT_AND_RET_DBG(
 308             (mode == get_type_mode(get_entity_type(ent))),
 309             "wrong data Proj from Load, entity type_mode failed", 0,
 310             show_proj_failure_ent(p, ent);
 311           );
 312         }
 313         else {
 314           ASSERT_AND_RET_DBG(
 315             mode_is_data(mode),
 316            "wrong data Proj from Load", 0,
 317            show_proj_failure(p);
 318          );
 319         }
 320       } else {
 321         ASSERT_AND_RET_DBG(
 322           ((proj == pn_Load_M        && mode == mode_M) ||
 323            (proj == pn_Load_X_except && mode == mode_X)),
 324           "wrong Proj from Load", 0,
 325           show_proj_failure(p);
 326         );
 327       }
 328       break;
 329
 330     case iro_Store:
 331       ASSERT_AND_RET_DBG(
 332         ((proj == pn_Store_M        && mode == mode_M) ||
 333          (proj == pn_Store_X_except && mode == mode_X)),
 334         "wrong Proj from Store", 0,
 335         show_proj_failure(p);
 336       );
 337       break;
 338
 339     case iro_Alloc:
 340       ASSERT_AND_RET_DBG(
 341         (
 342          (proj == pn_Alloc_M        && mode == mode_M) ||
 343          (proj == pn_Alloc_X_except /* && mode == mode_X*/) ||
 344          (proj == pn_Alloc_res      && mode_is_reference(mode))
 345         ),
 346         "wrong Proj from Alloc", 0,
 347         show_proj_failure(p);
 348       );
 349       break;
 350
 351     case iro_Proj:
 352       {
 353         type *mt; /* A method type */
 354         pred = skip_nop(get_Proj_pred(pred));
 355         ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
 356         switch (get_irn_opcode(pred))
 357         {
 358           case iro_Start:
 359             {
 360               ASSERT_AND_RET(
 361                   (proj >= 0 && mode_is_data(mode)),
 362                   "wrong Proj from Proj from Start", 0);
 363               mt = get_entity_type(get_irg_ent(irg));
 364               ASSERT_AND_RET(
 365                 (proj < get_method_n_params(mt)),
 366                 "More Projs for args than args in type", 0
 367               );
 368               if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj)))
 369                 /* value argument */ break;
 370
 371               ASSERT_AND_RET(
 372                   (mode == get_type_mode(get_method_param_type(mt, proj))),
 373                   "Mode of Proj from Start doesn't match mode of param type.", 0);
 374             }
 375             break;
 376
 377           case iro_Call:
 378             {
 379               ASSERT_AND_RET(
 380                   (proj >= 0 && mode_is_data(mode)),
 381                   "wrong Proj from Proj from Call", 0);
 382               mt = get_Call_type(pred);
 383               ASSERT_AND_RET(
 384                   (proj < get_method_n_ress(mt)),
 385                   "More Projs for results than results in type.", 0);
 386               if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
 387                 /* value result */ break;
 388
 389               ASSERT_AND_RET(
 390                   (mode == get_type_mode(get_method_res_type(mt, proj))),
 391                   "Mode of Proj from Call doesn't match mode of result type.", 0);
 392             }
 393             break;
 394
 395           case iro_Tuple:
 396             /* We don't test */
 397             break;
 398
 399           default:
 400             ASSERT_AND_RET(0, "Unknown opcode", 0);
 401         }
 402         break;
 403
 404       }
 405     case iro_Tuple:
 406       /* We don't test */
 407       break;
 408
 409     case iro_CallBegin:
 410       break;
 411
 412     case iro_EndReg:
 413       break;
 414
 415     case iro_EndExcept:
 416       break;
 417
 418     default:
 419       ASSERT_AND_RET(0, "Unknown opcode", 0);
 420   }
 421
 422   /* all went ok */
 423   return 1;
 424 }
 425
 426 int irn_vrfy_irg(ir_node *n, ir_graph *irg)
 427 {
 428   int i;
 429   int opcode, opcode1;
 430   ir_mode *mymode, *op1mode = NULL, *op2mode, *op3mode;
 431   int op_is_symmetric = 1;  /*  0: asymmetric
 432                                 1: operands have identical modes
 433                                 2: modes of operands == mode of this node */
 434   type *mt; /* A method type */
 435
 436   ir_node **in;
 437
 438   if (!opt_do_node_verification) return 1;
 439
 440   if (! interprocedural_view) {
 441     /*
 442      * do NOT check placement in interprocedural view, as we don't always know
 443      * the "right" graph ...
 444      */
 445     ASSERT_AND_RET_DBG(
 446       node_is_in_irgs_storage(irg, n),
 447       "Node is not stored on proper IR graph!", 0,
 448       show_node_on_graph(irg, n);
 449     );
 450   }
 451
 452   opcode = get_irn_opcode(n);
 453
 454   /* We don't want to test nodes whose predecessors are Bad or Unknown,
 455      as we would have to special case that for each operation. */
 456   if (opcode != iro_Phi && opcode != iro_Block)
 457     for (i = 0; i < get_irn_arity(n); i++) {
 458       opcode1 = get_irn_opcode(get_irn_n(n, i));
 459       if (opcode1 == iro_Bad /*|| opcode1 == iro_Unknown*/)  /* GL: for analyses mode must be correct. */
 460         return 1;
 461     }
 462
 463   mymode = get_irn_mode(n);
 464   in = get_irn_in(n);
 465
 466   switch (opcode)
 467   {
 468
 469     case iro_Block:
 470       for (i = 0; i < get_Block_n_cfgpreds(n); ++i) {
 471         ir_node *pred =  get_Block_cfgpred(n, i);
 472         ASSERT_AND_RET(
 473           (is_Bad(pred)     ||
 474            is_Unknown(pred) ||
 475            (get_irn_mode(pred) == mode_X)
 476           ), "Block node", 0);
 477       }
 478       // End block may only have Return, Raise or fragile ops as preds.
 479       if (n == get_irg_end_block(irg))
 480         for (i = 0; i < get_Block_n_cfgpreds(n); ++i) {
 481           ir_node *pred =  skip_Proj(get_Block_cfgpred(n, i));
 482           if (is_Proj(pred) || get_irn_op(pred) == op_Tuple)
 483             break;   // We can not test properly.  How many tuples are there?
 484           ASSERT_AND_RET(((get_irn_op(pred) == op_Return) ||
 485                           is_Bad(pred)                    ||
 486                           (get_irn_op(pred) == op_Raise)  ||
 487                           is_fragile_op(pred)               ),
 488                          "End Block node", 0);
 489         }
 490       // irg attr must == graph we are in.
 491       if (! interprocedural_view) {
 492         ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
 493       }
 494
 495       break;
 496
 497     case iro_Start:
 498       ASSERT_AND_RET(
 499           /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
 500           mymode == mode_T, "Start node", 0
 501           );
 502       break;
 503
 504     case iro_Jmp:
 505       ASSERT_AND_RET(
 506           /* Jmp: BB --> X */
 507           mymode == mode_X, "Jmp node", 0
 508           );
 509       break;
 510
 511     case iro_Break:
 512       ASSERT_AND_RET(
 513           /* Jmp: BB --> X */
 514           mymode == mode_X, "Jmp node", 0
 515           );
 516       break;
 517
 518     case iro_Cond:
 519       op1mode = get_irn_mode(in[1]);
 520       ASSERT_AND_RET(
 521           /* Cond: BB x b --> X x X */
 522           (op1mode == mode_b ||
 523            /* Cond: BB x int --> X^n */
 524            mode_is_int(op1mode) ),  "Cond node", 0
 525           );
 526       ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
 527       break;
 528
 529     case iro_Return:
 530       op1mode = get_irn_mode(in[1]);
 531       /* Return: BB x M x data1 x ... x datan --> X */
 532       /* printf("mode: %s, code %s\n", ID_TO_STR(n->mode->name), ID_TO_STR(n->op->name));*/
 533       ASSERT_AND_RET( op1mode == mode_M, "Return node", 0 );  /* operand M */
 534       for (i=2; i < get_irn_arity(n); i++) {
 535         ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Return node", 0 );  /* operand datai */
 536       };
 537       ASSERT_AND_RET( mymode == mode_X, "Result X", 0 );   /* result X */
 538       /* Compare returned results with result types of method type */
 539       mt = get_entity_type(get_irg_ent(irg));
 540       ASSERT_AND_RET_DBG( get_Return_n_ress(n) == get_method_n_ress(mt),
 541         "Number of results for Return doesn't match number of results in type.", 0,
 542         show_return_nres(irg, n, mt););
 543       for (i = 0; i < get_Return_n_ress(n); i++)
 544         ASSERT_AND_RET_DBG(
 545           get_irn_mode(get_Return_res(n, i)) == get_type_mode(get_method_res_type(mt, i)),
 546           "Mode of result for Return doesn't match mode of result type.", 0,
 547            show_return_modes(irg, n, mt, i););
 548       break;
 549
 550     case iro_Raise:
 551       op1mode = get_irn_mode(in[1]);
 552       op2mode = get_irn_mode(in[2]);
 553       ASSERT_AND_RET(
 554           /* Sel: BB x M x ref --> X x M */
 555           op1mode == mode_M && mode_is_reference(op2mode) &&
 556           mymode == mode_T, "Raise node", 0
 557           );
 558       break;
 559
 560     case iro_Const:
 561       ASSERT_AND_RET(
 562           /* Const: BB --> data */
 563           (mode_is_data (mymode) ||
 564            mymode == mode_b)      /* we want boolean constants for static evaluation */
 565           ,"Const node", 0        /* of Cmp. */
 566           );
 567       break;
 568
 569     case iro_SymConst:
 570       ASSERT_AND_RET(
 571           /* SymConst: BB --> int*/
 572           (mode_is_int(mymode) ||
 573            /* SymConst: BB --> ref */
 574            mode_is_reference(mymode))
 575           ,"SymConst node", 0);
 576       break;
 577
 578     case iro_Sel:
 579       op1mode = get_irn_mode(in[1]);
 580       op2mode = get_irn_mode(in[2]);
 581       ASSERT_AND_RET(
 582           /* Sel: BB x M x ref x int^n --> ref */
 583           (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
 584           "Sel node", 0
 585           );
 586       for (i=3; i < get_irn_arity(n); i++)
 587       {
 588         ASSERT_AND_RET(mode_is_int(get_irn_mode(in[i])), "Sel node", 0);
 589       }
 590       break;
 591
 592     case iro_InstOf:
 593       ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
 594       ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
 595       break;
 596
 597     case iro_Call:
 598       op1mode = get_irn_mode(in[1]);
 599       op2mode = get_irn_mode(in[2]);
 600       /* Call: BB x M x ref x data1 x ... x datan
 601          --> M x datan+1 x ... x data n+m */
 602       ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 );  /* operand M x ref */
 603       for (i=3; i < get_irn_arity(n); i++) {
 604         ASSERT_AND_RET( mode_is_data(get_irn_mode(in[i])), "Call node", 0 );  /* operand datai */
 605       };
 606       ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 );   /* result T */
 607       /* Compare arguments of node with those of type */
 608       mt = get_Call_type(n);
 609
 610       if (get_method_variadicity(mt) == variadicity_variadic) {
 611         ASSERT_AND_RET_DBG(
 612             get_Call_n_params(n) >= get_method_n_params(mt),
 613             "Number of args for Call doesn't match number of args in variadic type.",
 614             0,
 615             fprintf(stderr, "Call has %d params, method %s type %d\n",
 616               get_Call_n_params(n), get_type_name(mt), get_method_n_params(mt));
 617             );
 618       }
 619       else {
 620         ASSERT_AND_RET(
 621             get_Call_n_params(n) == get_method_n_params(mt),
 622             "Number of args for Call doesn't match number of args in non variadic type.",
 623             0);
 624       }
 625
 626       for (i = 0; i < get_method_n_params(mt); i++) {
 627         ASSERT_AND_RET_DBG(
 628             get_irn_mode(get_Call_param(n, i)) == get_type_mode(get_method_param_type(mt, i)),
 629             "Mode of arg for Call doesn't match mode of arg type.", 0,
 630             show_call_param(n, mt);
 631             );
 632       }
 633       break;
 634
 635     case iro_Add:
 636       op1mode = get_irn_mode(in[1]);
 637       op2mode = get_irn_mode(in[2]);
 638       ASSERT_AND_RET_DBG(
 639           (
 640            /* common Add: BB x numP x numP --> numP */
 641            (op1mode == mymode && op2mode == op1mode && mode_is_numP(mymode)) ||
 642            /* Pointer Add: BB x ref x int --> ref */
 643            (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
 644            /* Pointer Add: BB x int x ref --> ref */
 645            (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
 646           ),
 647           "Add node", 0,
 648           show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
 649                                 "/* Pointer Add: BB x ref x int --> ref */   |\n"
 650                                 "/* Pointer Add: BB x int x ref --> ref */");
 651           );
 652       if (mode_is_reference(op1mode) != mode_is_reference(op2mode)) {
 653         /* BB x ref x int --> ref or BB x int x ref --> ref */
 654         op_is_symmetric = 0;
 655       } else {
 656         /* BB x num x num --> num or BB x ref x ref */
 657         op_is_symmetric = 2;
 658       }
 659       break;
 660
 661     case iro_Sub:
 662       op1mode = get_irn_mode(in[1]);
 663       op2mode = get_irn_mode(in[2]);
 664       ASSERT_AND_RET_DBG(
 665           /* common Sub: BB x numP x numP --> numP */
 666           ((mymode ==op1mode && mymode == op2mode && mode_is_numP(op1mode)) ||
 667            /* Pointer Sub: BB x ref x int --> ref */
 668            (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
 669            /* Pointer Sub: BB x int x ref --> ref */
 670            (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode)) ||
 671            /* Pointer Sub: BB x ref x ref --> int */
 672            (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))),
 673           "Sub node", 0,
 674           show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
 675                                 "/* Pointer Sub: BB x ref x int --> ref */   |\n"
 676                                 "/* Pointer Sub: BB x int x ref --> ref */   |\n"
 677                                 "/* Pointer Sub: BB x ref x ref --> int */" );
 678           );
 679       if (mode_is_reference(op1mode) != mode_is_reference(op2mode)) {
 680         op_is_symmetric = 0;
 681       } else {
 682         op_is_symmetric = 2;
 683       }
 684       break;
 685
 686     case iro_Minus:
 687       op1mode = get_irn_mode(in[1]);
 688       ASSERT_AND_RET_DBG(
 689           /* Minus: BB x float --> float */
 690           op1mode == mymode && get_mode_sort(op1mode) == irms_float_number, "Minus node", 0,
 691           show_unop_failure(n , "/* Minus: BB x float --> float */");
 692           );
 693       op_is_symmetric = 2;
 694       break;
 695
 696     case iro_Mul:
 697       op1mode = get_irn_mode(in[1]);
 698       op2mode = get_irn_mode(in[2]);
 699       ASSERT_AND_RET_DBG(
 700           /* Mul: BB x int1 x int1 --> int2 */
 701           ((mode_is_int(op1mode)   && op2mode == op1mode && mode_is_int(mymode)) ||
 702            (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)),
 703           "Mul node",0,
 704           show_binop_failure(n, "/* Mul: BB x int1 x int1 --> int2 */");
 705           );
 706       op_is_symmetric = 2;
 707       break;
 708
 709     case iro_Quot:
 710       op1mode = get_irn_mode(in[1]);
 711       op2mode = get_irn_mode(in[2]);
 712       op3mode = get_irn_mode(in[3]);
 713       ASSERT_AND_RET_DBG(
 714           /* Quot: BB x M x float x float --> M x X x float */
 715           op1mode == mode_M && op2mode == op3mode &&
 716           get_mode_sort(op2mode) == irms_float_number &&
 717           mymode == mode_T,
 718           "Quot node",0,
 719           show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
 720           );
 721       op_is_symmetric = 2;
 722       break;
 723
 724     case iro_DivMod:
 725       op1mode = get_irn_mode(in[1]);
 726       op2mode = get_irn_mode(in[2]);
 727       op3mode = get_irn_mode(in[3]);
 728       ASSERT_AND_RET(
 729           /* DivMod: BB x M x int x int --> M x X x int x int */
 730           op1mode == mode_M &&
 731           mode_is_int(op2mode) &&
 732           op3mode == op2mode &&
 733           mymode == mode_T,
 734           "DivMod node", 0
 735           );
 736       op_is_symmetric = 1;
 737       break;
 738
 739     case iro_Div:
 740     case iro_Mod:
 741       op1mode = get_irn_mode(in[1]);
 742       op2mode = get_irn_mode(in[2]);
 743       op3mode = get_irn_mode(in[3]);
 744       ASSERT_AND_RET(
 745           /* Div or Mod: BB x M x int x int --> M x X x int */
 746           op1mode == mode_M &&
 747           op2mode == op3mode &&
 748           mode_is_int(op2mode) &&
 749           mymode == mode_T,
 750           "Div or Mod node", 0
 751           );
 752       op_is_symmetric = 1;
 753       break;
 754
 755     case iro_Abs:
 756       op1mode = get_irn_mode(in[1]);
 757       ASSERT_AND_RET_DBG(
 758         /* Abs: BB x num --> num */
 759         op1mode == mymode &&
 760         mode_is_num (op1mode),
 761         "Abs node", 0,
 762         show_unop_failure(n, "/* Abs: BB x num --> num */");
 763       );
 764       op_is_symmetric = 2;
 765       break;
 766
 767     case iro_And:
 768     case iro_Or:
 769     case iro_Eor:
 770       op1mode = get_irn_mode(in[1]);
 771       op2mode = get_irn_mode(in[2]);
 772       ASSERT_AND_RET_DBG(
 773         /* And or Or or Eor: BB x int x int --> int */
 774         mode_is_int(mymode) &&
 775         op2mode == op1mode &&
 776         mymode == op2mode,
 777         "And, Or or Eor node", 0,
 778         show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
 779       );
 780       op_is_symmetric = 2;
 781       break;
 782
 783     case iro_Not:
 784       op1mode = get_irn_mode(in[1]);
 785       ASSERT_AND_RET_DBG(
 786         /* Not: BB x int --> int */
 787         mode_is_int(mymode) &&
 788         mymode == op1mode,
 789         "Not node", 0,
 790         show_unop_failure(n, "/* Not: BB x int --> int */");
 791       );
 792       op_is_symmetric = 2;
 793       break;
 794
 795
 796     case iro_Cmp:
 797       op1mode = get_irn_mode(in[1]);
 798       op2mode = get_irn_mode(in[2]);
 799       ASSERT_AND_RET_DBG(
 800         /* Cmp: BB x datab x datab --> b16 */
 801         mode_is_data (op1mode) &&
 802         op2mode == op1mode &&
 803         mymode == mode_T,
 804         "Cmp node", 0,
 805         show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
 806       );
 807       break;
 808
 809     case iro_Shl:
 810     case iro_Shr:
 811     case iro_Shrs:
 812       op1mode = get_irn_mode(in[1]);
 813       op2mode = get_irn_mode(in[2]);
 814       ASSERT_AND_RET_DBG(
 815         /* Shl, Shr or Shrs: BB x int x int_u --> int */
 816         mode_is_int(op1mode) &&
 817         mode_is_int(op2mode) &&
 818         !mode_is_signed(op2mode) &&
 819         mymode == op1mode,
 820         "Shl, Shr, Shr or Rot node", 0,
 821         show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
 822       );
 823       break;
 824
 825     case iro_Rot:
 826       op1mode = get_irn_mode(in[1]);
 827       op2mode = get_irn_mode(in[2]);
 828       ASSERT_AND_RET_DBG(
 829         /* Rot: BB x int x int --> int */
 830         mode_is_int(op1mode) &&
 831         mode_is_int(op2mode) &&
 832         mymode == op1mode,
 833         "Rot node", 0,
 834         show_binop_failure(n, "/* Rot: BB x int x int --> int */");
 835       );
 836       break;
 837
 838     case iro_Conv:
 839       op1mode = get_irn_mode(in[1]);
 840       ASSERT_AND_RET_DBG(
 841         /* Conv: BB x datab1 --> datab2 */
 842         mode_is_datab(op1mode) && mode_is_data(mymode),
 843         "Conv node", 0,
 844         show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
 845       );
 846       break;
 847
 848     case iro_Cast:
 849       op1mode = get_irn_mode(in[1]);
 850       ASSERT_AND_RET_DBG(
 851         /* Conv: BB x datab1 --> datab2 */
 852         mode_is_data(op1mode) && op1mode == mymode,
 853         "Cast node", 0,
 854         show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
 855       );
 856       break;
 857
 858     case iro_Phi:
 859       /* Phi: BB x dataM^n --> dataM */
 860       for (i = 1; i < get_irn_arity(n); i++) {
 861         if (!is_Bad(in[i]) && (get_irn_op(in[i]) != op_Unknown))
 862           ASSERT_AND_RET_DBG(
 863               get_irn_mode(in[i]) == mymode,
 864               "Phi node", 0,
 865               show_phi_failure(n, in[i], i);
 866           );
 867       };
 868       ASSERT_AND_RET( mode_is_dataM(mymode), "Phi node", 0 );
 869       break;
 870
 871     case iro_Load:
 872       op1mode = get_irn_mode(in[1]);
 873       op2mode = get_irn_mode(in[2]);
 874       ASSERT_AND_RET(
 875           /* Load: BB x M x ref --> M x X x data */
 876           op1mode == mode_M && mode_is_reference(op2mode),
 877           "Load node", 0
 878           );
 879       ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
 880       break;
 881
 882     case iro_Store:
 883       op1mode = get_irn_mode(in[1]);
 884       op2mode = get_irn_mode(in[2]);
 885       op3mode = get_irn_mode(in[3]);
 886       ASSERT_AND_RET(
 887           /* Load: BB x M x ref data --> M x X */
 888           op1mode == mode_M && mode_is_reference(op2mode) && mode_is_data(op3mode),
 889           "Store node", 0
 890           );
 891       ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
 892       break;
 893
 894     case iro_Alloc:
 895       op1mode = get_irn_mode(in[1]);
 896       op2mode = get_irn_mode(in[2]);
 897       ASSERT_AND_RET_DBG(
 898         /* Alloc: BB x M x int_u --> M x X x ref */
 899         op1mode == mode_M &&
 900         mode_is_int(op2mode) &&
 901         !mode_is_signed(op2mode) &&
 902         mymode == mode_T,
 903         "Alloc node", 0,
 904         show_binop_failure(n, "/* Alloc: BB x M x int_u --> M x X x ref */");
 905       );
 906       break;
 907
 908     case iro_Free:
 909       op1mode = get_irn_mode(in[1]);
 910       op2mode = get_irn_mode(in[2]);
 911       ASSERT_AND_RET_DBG(
 912         /* Free: BB x M x ref --> M */
 913         op1mode == mode_M && mode_is_reference(op2mode) &&
 914         mymode == mode_M,
 915         "Free node", 0,
 916         show_binop_failure(n, "/* Free: BB x M x ref --> M */");
 917       );
 918       break;
 919
 920     case iro_Sync:
 921       /* Sync: BB x M^n --> M */
 922       for (i=1; i < get_irn_arity(n); i++) {
 923         ASSERT_AND_RET( get_irn_mode(in[i]) == mode_M, "Sync node", 0 );
 924       };
 925       ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
 926       break;
 927
 928     case iro_Proj:
 929       return vrfy_Proj_proj(n, irg);
 930       break;
 931
 932     case iro_Confirm:
 933       op1mode = get_irn_mode(in[1]);
 934       op2mode = get_irn_mode(in[2]);
 935       ASSERT_AND_RET_DBG(
 936         /* Confirm: BB x T x T --> T */
 937         op1mode == mymode &&
 938         op2mode == mymode,
 939         "Confirm node", 0,
 940         show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
 941       );
 942       break;
 943
 944     default:
 945       break;
 946   }
 947
 948   /* All went ok */
 949   return 1;
 950 }
 951
 952 int irn_vrfy(ir_node *n)
 953 {
 954   int res = 1;
 955 #ifdef DEBUG_libfirm
 956   res = irn_vrfy_irg(n, current_ir_graph);
 957 #endif
 958   return res;
 959 }
 960
 961 /*******************************************************************/
 962 /* Verify the whole graph.                                         */
 963 /*******************************************************************/
 964
 965 static void vrfy_wrap(ir_node *node, void *env)
 966 {
 967   int *res = env;
 968
 969   *res = irn_vrfy(node);
 970 }
 971
 972 int irg_vrfy(ir_graph *irg)
 973 {
 974   int res = 1;
 975 #ifdef DEBUG_libfirm
 976   ir_graph *rem;
 977
 978   rem = current_ir_graph;
 979   current_ir_graph = irg;
 980
 981   assert(get_irg_pinned(irg) == pinned);
 982
 983   irg_walk(irg->end, vrfy_wrap, NULL, &res);
 984
 985   current_ir_graph = rem;
 986 #endif
 987   return res;
 988 }