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