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