nsz Git - libfirm/blob - ir/ir/irvrfy.c

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief    Check irnodes for correctness.
  23  * @author   Christian Schaefer, Goetz Lindenmaier, Till Riedel, Michael Beck
  24  * @version  $Id$
  25  */
  26 #include "config.h"
  27
  28 #include "irprog.h"
  29 #include "irop_t.h"
  30 #include "irgraph_t.h"
  31 #include "ircgcons.h"
  32 #include "irvrfy_t.h"
  33 #include "irgwalk.h"
  34 #include "irdump.h"
  35 #include "irdom_t.h"
  36 #include "irprintf.h"
  37 #include "irouts.h"
  38 #include "irflag_t.h"
  39 #include "irpass_t.h"
  40
  41 /** if this flag is set, verify entity types in Load & Store nodes */
  42 static int vrfy_entities = 0;
  43
  44 const char *firm_vrfy_failure_msg;
  45
  46 /* enable verification of Load/Store entities */
  47 void vrfy_enable_entity_tests(int enable)
  48 {
  49         vrfy_entities = enable;
  50 }
  51
  52 #ifndef NDEBUG
  53
  54 /**
  55  * little helper for NULL modes
  56  */
  57 static const char *get_mode_name_ex(ir_mode *mode)
  58 {
  59         if (! mode)
  60                 return "<no mode>";
  61         return get_mode_name(mode);
  62 }
  63
  64 /** the last IRG, on which a verification error was found */
  65 static ir_graph *last_irg_error = NULL;
  66
  67 /**
  68  * print the name of the entity of an verification failure
  69  *
  70  * @param node  the node caused the failure
  71  */
  72 static void show_entity_failure(ir_node *node)
  73 {
  74         ir_graph *irg = get_irn_irg(node);
  75
  76         if (last_irg_error == irg)
  77                 return;
  78
  79         last_irg_error = irg;
  80
  81         if (irg == get_const_code_irg()) {
  82                 fprintf(stderr, "\nFIRM: irn_vrfy_irg() <of CONST_CODE_IRG> failed\n");
  83         } else {
  84                 ir_entity *ent = get_irg_entity(irg);
  85
  86                 if (ent) {
  87                         ir_type *ent_type = get_entity_owner(ent);
  88
  89                         if (ent_type) {
  90                                 ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() %+F::%s failed\n",
  91                                            ent_type, get_entity_name(ent));
  92                         } else {
  93                                 fprintf(stderr, "\nFIRM: irn_vrfy_irg() <NULL>::%s failed\n", get_entity_name(ent));
  94                         }
  95                 } else {
  96                         fprintf(stderr, "\nFIRM: irn_vrfy_irg() <IRG %p> failed\n", (void *)irg);
  97                 }
  98         }
  99 }
 100
 101 /**
 102  * Prints a failure for a Node
 103  */
 104 static void show_node_failure(ir_node *n)
 105 {
 106         show_entity_failure(n);
 107         fprintf(stderr, "  node %ld %s%s\n" ,
 108                 get_irn_node_nr(n),
 109                 get_irn_opname(n), get_irn_modename(n)
 110         );
 111 }
 112
 113 /**
 114  * Prints a failure message for a binop
 115  */
 116 static void show_binop_failure(ir_node *n, const char *text)
 117 {
 118         ir_node *left  = get_binop_left(n);
 119         ir_node *right = get_binop_right(n);
 120
 121         show_entity_failure(n);
 122         fprintf(stderr, "  node %ld %s%s(%s%s, %s%s) did not match (%s)\n",
 123                 get_irn_node_nr(n),
 124                 get_irn_opname(n), get_irn_modename(n),
 125                 get_irn_opname(left), get_irn_modename(left),
 126                 get_irn_opname(right), get_irn_modename(right),
 127                 text);
 128 }
 129
 130 /**
 131  * Prints a failure message for an unop
 132  */
 133 static void show_unop_failure(ir_node *n, const char *text)
 134 {
 135         ir_node *op  = get_unop_op(n);
 136
 137         show_entity_failure(n);
 138         fprintf(stderr, "  node %ld %s%s(%s%s) did not match (%s)\n",
 139                 get_irn_node_nr(n),
 140                 get_irn_opname(n), get_irn_modename(n),
 141                 get_irn_opname(op), get_irn_modename(op),
 142                 text);
 143 }
 144
 145 /**
 146  * Prints a failure message for an op with 3 operands
 147  */
 148 static void show_triop_failure(ir_node *n, const char *text)
 149 {
 150         ir_node *op0  = get_irn_n(n, 0);
 151         ir_node *op1  = get_irn_n(n, 1);
 152         ir_node *op2  = get_irn_n(n, 2);
 153
 154         show_entity_failure(n);
 155         fprintf(stderr, "  of node %ld %s%s(%s%s, %s%s, %s%s) did not match (%s)\n",
 156                 get_irn_node_nr(n),
 157                 get_irn_opname(n), get_irn_modename(n),
 158                 get_irn_opname(op0), get_irn_modename(op0),
 159                 get_irn_opname(op1), get_irn_modename(op1),
 160                 get_irn_opname(op2), get_irn_modename(op2),
 161                 text);
 162 }
 163
 164 /**
 165  * Prints a failure message for a proj
 166  */
 167 static void show_proj_failure(ir_node *n)
 168 {
 169         ir_node *op  = get_Proj_pred(n);
 170         int proj     = get_Proj_proj(n);
 171
 172         show_entity_failure(n);
 173         fprintf(stderr, "  node %ld %s%s %d(%s%s) failed\n" ,
 174                 get_irn_node_nr(n),
 175                 get_irn_opname(n), get_irn_modename(n), proj,
 176                 get_irn_opname(op), get_irn_modename(op));
 177 }
 178
 179 /**
 180  * Prints a failure message for a proj from Start
 181  */
 182 static void show_proj_mode_failure(ir_node *n, ir_type *ty)
 183 {
 184         long proj  = get_Proj_proj(n);
 185         ir_mode *m = get_type_mode(ty);
 186         char type_name[256];
 187         ir_print_type(type_name, sizeof(type_name), ty);
 188
 189         show_entity_failure(n);
 190         fprintf(stderr, "  Proj %ld mode %s proj %ld (type %s mode %s) failed\n" ,
 191                 get_irn_node_nr(n),
 192                 get_irn_modename(n),
 193                 proj,
 194                 type_name,
 195                 get_mode_name_ex(m));
 196 }
 197
 198 /**
 199  * Prints a failure message for a proj
 200  */
 201 static void show_proj_failure_ent(ir_node *n, ir_entity *ent)
 202 {
 203         ir_node *op  = get_Proj_pred(n);
 204         int proj     = get_Proj_proj(n);
 205         ir_mode *m   = get_type_mode(get_entity_type(ent));
 206         char type_name[256];
 207         ir_print_type(type_name, sizeof(type_name), get_entity_type(ent));
 208
 209         show_entity_failure(n);
 210         fprintf(stderr, "  node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
 211                 get_irn_node_nr(n),
 212                 get_irn_opname(n), get_irn_modename(n), proj,
 213                 get_irn_opname(op), get_irn_modename(op),
 214                 get_entity_name(ent), type_name,
 215                 get_mode_name_ex(m));
 216 }
 217
 218 /**
 219  * Show a node and a graph
 220  */
 221 static void show_node_on_graph(ir_graph *irg, ir_node *n)
 222 {
 223         ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() of %+F, node %+F\n", irg, n);
 224 }
 225
 226 /**
 227  * Show call parameters
 228  */
 229 static void show_call_param(ir_node *n, ir_type *mt)
 230 {
 231         int i;
 232         char type_name[256];
 233         ir_print_type(type_name, sizeof(type_name), mt);
 234
 235         show_entity_failure(n);
 236         fprintf(stderr, "  Call type-check failed: %s(", type_name);
 237         for (i = 0; i < get_method_n_params(mt); ++i) {
 238                 fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i))));
 239         }
 240         fprintf(stderr, ") != CALL(");
 241
 242         for (i = 0; i < get_Call_n_params(n); ++i) {
 243                 fprintf(stderr, "%s ", get_mode_name_ex(get_irn_mode(get_Call_param(n, i))));
 244         }
 245         fprintf(stderr, ")\n");
 246 }
 247
 248 /**
 249  * Show return modes
 250  */
 251 static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i)
 252 {
 253         ir_entity *ent = get_irg_entity(irg);
 254
 255         show_entity_failure(n);
 256         fprintf(stderr, "  Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
 257                 get_irn_node_nr(n), get_entity_name(ent),
 258                 get_mode_name_ex(get_irn_mode(get_Return_res(n, i))),
 259                 get_mode_name_ex(get_type_mode(get_method_res_type(mt, i)))
 260         );
 261 }
 262
 263 /**
 264  * Show return number of results
 265  */
 266 static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt)
 267 {
 268         ir_entity *ent = get_irg_entity(irg);
 269
 270         show_entity_failure(n);
 271         fprintf(stderr, "  Return node %ld in entity \"%s\" has %d results different from type %d\n",
 272                 get_irn_node_nr(n), get_entity_name(ent),
 273                 get_Return_n_ress(n), get_method_n_ress(mt));
 274 }
 275
 276 /**
 277  * Show Phi input
 278  */
 279 static void show_phi_failure(ir_node *phi, ir_node *pred, int pos)
 280 {
 281         (void) pos;
 282         show_entity_failure(phi);
 283         fprintf(stderr, "  Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
 284                 get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
 285                 get_irn_node_nr(pred), get_mode_name_ex(get_irn_mode(pred)));
 286 }
 287
 288 /**
 289  * Show Phi inputs
 290  */
 291 static void show_phi_inputs(ir_node *phi, ir_node *block)
 292 {
 293         show_entity_failure(phi);
 294         fprintf(stderr, "  Phi node %ld has %d inputs, its Block %ld has %d\n",
 295                 get_irn_node_nr(phi),   get_irn_arity(phi),
 296                 get_irn_node_nr(block), get_irn_arity(block));
 297 }
 298
 299 #endif /* #ifndef NDEBUG */
 300
 301 /**
 302  * If the address is Sel or SymConst, return the entity.
 303  *
 304  * @param ptr  the node representing the address
 305  */
 306 static ir_entity *get_ptr_entity(ir_node *ptr)
 307 {
 308         if (is_Sel(ptr)) {
 309                 return get_Sel_entity(ptr);
 310         } else if (is_SymConst_addr_ent(ptr)) {
 311                 return get_SymConst_entity(ptr);
 312         }
 313         return NULL;
 314 }
 315
 316 /**
 317  * verify a Proj(Start) node
 318  */
 319 static int verify_node_Proj_Start(ir_node *n, ir_node *p)
 320 {
 321         ir_mode *mode = get_irn_mode(p);
 322         long proj     = get_Proj_proj(p);
 323         (void) n;
 324
 325         ASSERT_AND_RET_DBG(
 326                 (
 327                         (proj == pn_Start_X_initial_exec && mode == mode_X) ||
 328                         (proj == pn_Start_M              && mode == mode_M) ||
 329                         (proj == pn_Start_P_frame_base   && mode_is_reference(mode)) ||
 330                         (proj == pn_Start_P_tls          && mode_is_reference(mode)) ||
 331                         (proj == pn_Start_T_args         && mode == mode_T)
 332                 ),
 333                 "wrong Proj from Start", 0,
 334                 show_proj_failure(p);
 335         );
 336         return 1;
 337 }
 338
 339 /**
 340  * verify a Proj(Cond) node
 341  */
 342 static int verify_node_Proj_Cond(ir_node *pred, ir_node *p)
 343 {
 344         ir_mode *mode = get_irn_mode(p);
 345         long proj     = get_Proj_proj(p);
 346
 347         ASSERT_AND_RET_DBG(
 348                 (
 349                         (proj >= 0 && mode == mode_X && get_irn_mode(get_Cond_selector(pred)) == mode_b) ||   /* compare */
 350                         (mode == mode_X && mode_is_int(get_irn_mode(get_Cond_selector(pred)))) ||             /* switch */
 351                         is_Bad(get_Cond_selector(pred))                                                       /* rare */
 352                 ),
 353                 "wrong Proj from Cond", 0,
 354                 show_proj_failure(p);
 355         );
 356         return 1;
 357 }
 358
 359 /**
 360  * verify a Proj(Raise) node
 361  */
 362 static int verify_node_Proj_Raise(ir_node *n, ir_node *p)
 363 {
 364         ir_mode *mode = get_irn_mode(p);
 365         long proj     = get_Proj_proj(p);
 366         (void) n;
 367
 368         ASSERT_AND_RET_DBG(
 369                 ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
 370                 "wrong Proj from Raise", 0,
 371                 show_proj_failure(p);
 372         );
 373         return 1;
 374 }
 375
 376 /**
 377  * verify a Proj(InstOf) node
 378  */
 379 static int verify_node_Proj_InstOf(ir_node *n, ir_node *p)
 380 {
 381         ir_mode *mode = get_irn_mode(p);
 382         long proj     = get_Proj_proj(p);
 383         (void) n;
 384
 385         ASSERT_AND_RET_DBG(
 386                 (
 387                         (proj == pn_InstOf_M         && mode == mode_M) ||
 388                         (proj == pn_InstOf_X_regular && mode == mode_X) ||
 389                         (proj == pn_InstOf_X_except  && mode == mode_X) ||
 390                         (proj == pn_InstOf_res       && mode_is_reference(mode))
 391                 ),
 392                 "wrong Proj from InstOf", 0,
 393                 show_proj_failure(p);
 394         );
 395         return 1;
 396 }
 397
 398 /**
 399  * verify a Proj(Call) node
 400  */
 401 static int verify_node_Proj_Call(ir_node *n, ir_node *p)
 402 {
 403         ir_mode *mode = get_irn_mode(p);
 404         long proj     = get_Proj_proj(p);
 405
 406         ASSERT_AND_RET_DBG(
 407                 (
 408                         (proj == pn_Call_M                && mode == mode_M) ||
 409                         (proj == pn_Call_X_regular        && mode == mode_X) ||
 410                         (proj == pn_Call_X_except         && mode == mode_X) ||
 411                         (proj == pn_Call_T_result         && mode == mode_T) ||
 412                         (proj == pn_Call_P_value_res_base && mode_is_reference(mode))
 413                 ),
 414                 "wrong Proj from Call", 0,
 415                 show_proj_failure(p);
 416         );
 417         /* if we have exception flow, we must have a real Memory input */
 418         if (proj == pn_Call_X_regular)
 419                 ASSERT_AND_RET(
 420                         !is_NoMem(get_Call_mem(n)),
 421                         "Regular Proj from FunctionCall", 0);
 422         else if (proj == pn_Call_X_except)
 423                 ASSERT_AND_RET(
 424                         !is_NoMem(get_Call_mem(n)),
 425                         "Exception Proj from FunctionCall", 0);
 426         return 1;
 427 }
 428
 429 /**
 430  * verify a Proj(Quot) node
 431  */
 432 static int verify_node_Proj_Quot(ir_node *n, ir_node *p)
 433 {
 434         ir_mode *mode = get_irn_mode(p);
 435         long proj     = get_Proj_proj(p);
 436
 437         ASSERT_AND_RET_DBG(
 438                 (
 439                         (proj == pn_Quot_M         && mode == mode_M) ||
 440                         (proj == pn_Quot_X_regular && mode == mode_X) ||
 441                         (proj == pn_Quot_X_except  && mode == mode_X) ||
 442                         (proj == pn_Quot_res       && mode_is_float(mode) && mode == get_Quot_resmode(n))
 443                 ),
 444                 "wrong Proj from Quot", 0,
 445                 show_proj_failure(p);
 446         );
 447         if (proj == pn_Quot_X_regular)
 448                 ASSERT_AND_RET(
 449                         get_irn_pinned(n) == op_pin_state_pinned,
 450                         "Regular Proj from unpinned Quot", 0);
 451         else if (proj == pn_Quot_X_except)
 452                 ASSERT_AND_RET(
 453                         get_irn_pinned(n) == op_pin_state_pinned,
 454                         "Exception Proj from unpinned Quot", 0);
 455         else if (proj == pn_Quot_M)
 456                 ASSERT_AND_RET(
 457                         get_irn_pinned(n) == op_pin_state_pinned,
 458                         "Memory Proj from unpinned Quot", 0);
 459         return 1;
 460 }
 461
 462 /**
 463  * verify a Proj(DivMod) node
 464  */
 465 static int verify_node_Proj_DivMod(ir_node *n, ir_node *p)
 466 {
 467         ir_mode *mode = get_irn_mode(p);
 468         long proj     = get_Proj_proj(p);
 469
 470         ASSERT_AND_RET_DBG(
 471                 (
 472                         (proj == pn_DivMod_M         && mode == mode_M) ||
 473                         (proj == pn_DivMod_X_regular && mode == mode_X) ||
 474                         (proj == pn_DivMod_X_except  && mode == mode_X) ||
 475                         (proj == pn_DivMod_res_div   && mode_is_int(mode) && mode == get_DivMod_resmode(n)) ||
 476                         (proj == pn_DivMod_res_mod   && mode_is_int(mode) && mode == get_DivMod_resmode(n))
 477                 ),
 478                 "wrong Proj from DivMod", 0,
 479                 show_proj_failure(p);
 480         );
 481         if (proj == pn_DivMod_X_regular)
 482                 ASSERT_AND_RET(
 483                         get_irn_pinned(n) == op_pin_state_pinned,
 484                         "Regular Proj from unpinned DivMod", 0);
 485         else if (proj == pn_DivMod_X_except)
 486                 ASSERT_AND_RET(
 487                         get_irn_pinned(n) == op_pin_state_pinned,
 488                         "Exception Proj from unpinned DivMod", 0);
 489         else if (proj == pn_DivMod_M)
 490                 ASSERT_AND_RET(
 491                         get_irn_pinned(n) == op_pin_state_pinned,
 492                         "Memory Proj from unpinned DivMod", 0);
 493         return 1;
 494 }
 495
 496 /**
 497  * verify a Proj(Div) node
 498  */
 499 static int verify_node_Proj_Div(ir_node *n, ir_node *p)
 500 {
 501         ir_mode *mode = get_irn_mode(p);
 502         long proj     = get_Proj_proj(p);
 503
 504         ASSERT_AND_RET_DBG(
 505                 (
 506                         (proj == pn_Div_M         && mode == mode_M) ||
 507                         (proj == pn_Div_X_regular && mode == mode_X) ||
 508                         (proj == pn_Div_X_except  && mode == mode_X) ||
 509                         (proj == pn_Div_res       && mode_is_int(mode) && mode == get_Div_resmode(n))
 510                 ),
 511                 "wrong Proj from Div", 0,
 512                 show_proj_failure(p);
 513         );
 514         if (proj == pn_Div_X_regular)
 515                 ASSERT_AND_RET(
 516                         get_irn_pinned(n) == op_pin_state_pinned,
 517                         "Regular Proj from unpinned Div", 0);
 518         else if (proj == pn_Div_X_except)
 519                 ASSERT_AND_RET(
 520                         get_irn_pinned(n) == op_pin_state_pinned,
 521                         "Exception Proj from unpinned Div", 0);
 522         else if (proj == pn_Div_M)
 523                 ASSERT_AND_RET(
 524                         get_irn_pinned(n) == op_pin_state_pinned,
 525                         "Memory Proj from unpinned Div", 0);
 526         return 1;
 527 }
 528
 529 /**
 530  * verify a Proj(Mod) node
 531  */
 532 static int verify_node_Proj_Mod(ir_node *n, ir_node *p)
 533 {
 534         ir_mode *mode = get_irn_mode(p);
 535         long proj     = get_Proj_proj(p);
 536
 537         ASSERT_AND_RET_DBG(
 538                 (
 539                         (proj == pn_Mod_M         && mode == mode_M) ||
 540                         (proj == pn_Mod_X_regular && mode == mode_X) ||
 541                         (proj == pn_Mod_X_except  && mode == mode_X) ||
 542                         (proj == pn_Mod_res       && mode_is_int(mode) && mode == get_Mod_resmode(n))
 543                 ),
 544                 "wrong Proj from Mod", 0,
 545                 show_proj_failure(p);
 546         );
 547         if (proj == pn_Mod_X_regular)
 548                 ASSERT_AND_RET(
 549                         get_irn_pinned(n) == op_pin_state_pinned,
 550                         "Regular Proj from unpinned Mod", 0);
 551         else if (proj == pn_Mod_X_except)
 552                 ASSERT_AND_RET(
 553                         get_irn_pinned(n) == op_pin_state_pinned,
 554                         "Exception Proj from unpinned Mod", 0);
 555         else if (proj == pn_Mod_M)
 556                 ASSERT_AND_RET(
 557                         get_irn_pinned(n) == op_pin_state_pinned,
 558                         "Memory Proj from unpinned Div", 0);
 559         return 1;
 560 }
 561
 562 /**
 563  * verify a Proj(Cmp) node
 564  */
 565 static int verify_node_Proj_Cmp(ir_node *n, ir_node *p)
 566 {
 567         ir_mode *mode = get_irn_mode(p);
 568         long proj     = get_Proj_proj(p);
 569         (void) n;
 570
 571         ASSERT_AND_RET_DBG(
 572                 (proj >= 0 && proj <= 15 && mode == mode_b),
 573                 "wrong Proj from Cmp", 0,
 574                 show_proj_failure(p);
 575         );
 576         ASSERT_AND_RET_DBG(
 577                 (mode_is_float(get_irn_mode(get_Cmp_left(n))) || !(proj & pn_Cmp_Uo)),
 578                 "unordered Proj for non-float Cmp", 0,
 579                 show_proj_failure(p);
 580         );
 581         return 1;
 582 }
 583
 584 /**
 585  * verify a Proj(Load) node
 586  */
 587 static int verify_node_Proj_Load(ir_node *n, ir_node *p)
 588 {
 589         ir_mode *mode = get_irn_mode(p);
 590         long proj     = get_Proj_proj(p);
 591
 592         if (proj == pn_Load_res) {
 593                 ir_node *ptr = get_Load_ptr(n);
 594                 ir_entity *ent = get_ptr_entity(ptr);
 595
 596                 if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) {
 597                         /* do NOT check this for lowered phases, see comment on Store */
 598                         ASSERT_AND_RET_DBG(
 599                                 (mode == get_type_mode(get_entity_type(ent))),
 600                                 "wrong data Proj from Load, entity type_mode failed", 0,
 601                                 show_proj_failure_ent(p, ent);
 602                         );
 603                 }
 604                 else {
 605                         ASSERT_AND_RET_DBG(
 606                                 mode_is_data(mode) && mode == get_Load_mode(n),
 607                                 "wrong data Proj from Load", 0,
 608                                 show_proj_failure(p);
 609                         );
 610                 }
 611         }
 612         else {
 613                 ASSERT_AND_RET_DBG(
 614                         (
 615                                 (proj == pn_Load_M         && mode == mode_M) ||
 616                                 (proj == pn_Load_X_regular && mode == mode_X) ||
 617                                 (proj == pn_Load_X_except  && mode == mode_X)
 618                         ),
 619                         "wrong Proj from Load", 0,
 620                         show_proj_failure(p);
 621                 );
 622         }
 623         if (proj == pn_Load_X_regular) {
 624                 ASSERT_AND_RET(
 625                         get_irn_pinned(n) == op_pin_state_pinned,
 626                         "Regular Proj from unpinned Load", 0);
 627         } else if (proj == pn_Load_X_except) {
 628                 ASSERT_AND_RET(
 629                         get_irn_pinned(n) == op_pin_state_pinned,
 630                         "Exception Proj from unpinned Load", 0);
 631         }
 632         return 1;
 633 }
 634
 635 /**
 636  * verify a Proj(Store) node
 637  */
 638 static int verify_node_Proj_Store(ir_node *n, ir_node *p)
 639 {
 640         ir_mode *mode = get_irn_mode(p);
 641         long proj     = get_Proj_proj(p);
 642
 643         ASSERT_AND_RET_DBG(
 644                 (
 645                         (proj == pn_Store_M         && mode == mode_M) ||
 646                         (proj == pn_Store_X_regular && mode == mode_X) ||
 647                         (proj == pn_Store_X_except  && mode == mode_X)
 648                 ),
 649                 "wrong Proj from Store", 0,
 650                 show_proj_failure(p);
 651         );
 652         if (proj == pn_Store_X_regular) {
 653                 ASSERT_AND_RET(
 654                         get_irn_pinned(n) == op_pin_state_pinned,
 655                         "Regular Proj from unpinned Store", 0);
 656         } else if (proj == pn_Store_X_except) {
 657                 ASSERT_AND_RET(
 658                         get_irn_pinned(n) == op_pin_state_pinned,
 659                         "Exception Proj from unpinned Store", 0);
 660         }
 661         return 1;
 662 }
 663
 664 /**
 665  * verify a Proj(Alloc) node
 666  */
 667 static int verify_node_Proj_Alloc(ir_node *n, ir_node *p)
 668 {
 669         ir_mode *mode = get_irn_mode(p);
 670         long proj     = get_Proj_proj(p);
 671         (void) n;
 672
 673         ASSERT_AND_RET_DBG(
 674                 (
 675                         (proj == pn_Alloc_M         && mode == mode_M) ||
 676                         (proj == pn_Alloc_X_regular && mode == mode_X) ||
 677                         (proj == pn_Alloc_X_except  && mode == mode_X) ||
 678                         (proj == pn_Alloc_res       && mode_is_reference(mode))
 679                 ),
 680                 "wrong Proj from Alloc", 0,
 681                 show_proj_failure(p);
 682         );
 683         return 1;
 684 }
 685
 686 /**
 687  * verify a Proj(Proj) node
 688  */
 689 static int verify_node_Proj_Proj(ir_node *pred, ir_node *p)
 690 {
 691         ir_mode *mode = get_irn_mode(p);
 692         long proj     = get_Proj_proj(p);
 693         long nr       = get_Proj_proj(pred);
 694         ir_type *mt; /* A method type */
 695
 696         pred = skip_Id(get_Proj_pred(pred));
 697         ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
 698
 699         switch (get_irn_opcode(pred)) {
 700         case iro_Start:
 701                 mt = get_entity_type(get_irg_entity(get_irn_irg(pred)));
 702
 703                 if (nr == pn_Start_T_args) {
 704                         ASSERT_AND_RET(
 705                                 (proj >= 0 && mode_is_datab(mode)),
 706                                 "wrong Proj from Proj from Start", 0);
 707                         ASSERT_AND_RET(
 708                                 (proj < get_method_n_params(mt)),
 709                                 "More Projs for args than args in type", 0
 710                                 );
 711                         if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj)))
 712                                 /* value argument */ break;
 713
 714                         if (get_irg_phase_state(get_irn_irg(pred)) != phase_backend) {
 715                                 ASSERT_AND_RET_DBG(
 716                                                 (mode == get_type_mode(get_method_param_type(mt, proj))),
 717                                                 "Mode of Proj from Start doesn't match mode of param type.", 0,
 718                                                 show_proj_mode_failure(p, get_method_param_type(mt, proj));
 719                                                 );
 720                         }
 721                 }
 722                 break;
 723
 724         case iro_Call:
 725                 {
 726                         ASSERT_AND_RET(
 727                                 (proj >= 0 && mode_is_datab(mode)),
 728                                 "wrong Proj from Proj from Call", 0);
 729                         mt = get_Call_type(pred);
 730                         ASSERT_AND_RET(mt == get_unknown_type() || is_Method_type(mt),
 731                                         "wrong call type on call", 0);
 732                         ASSERT_AND_RET(
 733                                 (proj < get_method_n_ress(mt)),
 734                                 "More Projs for results than results in type.", 0);
 735                         if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
 736                                 /* value result */ break;
 737
 738                                 ASSERT_AND_RET(
 739                                 (mode == get_type_mode(get_method_res_type(mt, proj))),
 740                                 "Mode of Proj from Call doesn't match mode of result type.", 0);
 741                 }
 742                 break;
 743
 744         case iro_Tuple:
 745                 /* We don't test */
 746                 break;
 747
 748         case iro_Bad:
 749                 /* hmm, optimization did not remove it */
 750                 break;
 751
 752         default:
 753                 /* ASSERT_AND_RET(0, "Unknown opcode", 0); */
 754                 break;
 755         }
 756         return 1;
 757 }
 758
 759 /**
 760  * verify a Proj(Tuple) node
 761  */
 762 static int verify_node_Proj_Tuple(ir_node *n, ir_node *p)
 763 {
 764         (void) n;
 765         (void) p;
 766         /* We don't test */
 767         return 1;
 768 }
 769
 770 /**
 771  * verify a Proj(CallBegin) node
 772  */
 773 static int verify_node_Proj_CallBegin(ir_node *n, ir_node *p)
 774 {
 775         (void) n;
 776         (void) p;
 777         return 1;
 778 }
 779
 780 /**
 781  * verify a Proj(EndReg) node
 782  */
 783 static int verify_node_Proj_EndReg(ir_node *n, ir_node *p)
 784 {
 785         (void) n;
 786         (void) p;
 787 #ifdef INTERPROCEDURAL_VIEW
 788         ASSERT_AND_RET(
 789                 (get_irp_ip_view_state() != ip_view_no),
 790                 "EndReg may only appear if ip view is constructed.", 0);
 791 #endif
 792         return 1;
 793 }
 794
 795 /**
 796  * verify a Proj(EndExcept) node
 797  */
 798 static int verify_node_Proj_EndExcept(ir_node *n, ir_node *p)
 799 {
 800         (void) n;
 801         (void) p;
 802 #ifdef INTERPROCEDURAL_VIEW
 803         ASSERT_AND_RET(
 804                 (get_irp_ip_view_state() != ip_view_no),
 805                 "EndExcept may only appear if ip view is constructed.", 0);
 806 #endif
 807         return 1;
 808 }
 809
 810 /**
 811  * verify a Proj(CopyB) node
 812  */
 813 static int verify_node_Proj_CopyB(ir_node *n, ir_node *p)
 814 {
 815         ir_mode *mode = get_irn_mode(p);
 816         long proj     = get_Proj_proj(p);
 817
 818         ASSERT_AND_RET_DBG(
 819                 (
 820                         (proj == pn_CopyB_M         && mode == mode_M) ||
 821                         (proj == pn_CopyB_X_regular && mode == mode_X) ||
 822                         (proj == pn_CopyB_X_except  && mode == mode_X)
 823                 ),
 824                 "wrong Proj from CopyB", 0,
 825                 show_proj_failure(p);
 826         );
 827         if (proj == pn_CopyB_X_regular)
 828                 ASSERT_AND_RET(
 829                         get_irn_pinned(n) == op_pin_state_pinned,
 830                         "Regular Proj from unpinned CopyB", 0);
 831         else if (proj == pn_CopyB_X_except)
 832                 ASSERT_AND_RET(
 833                         get_irn_pinned(n) == op_pin_state_pinned,
 834                         "Exception Proj from unpinned CopyB", 0);
 835         return 1;
 836 }
 837
 838 /**
 839  * verify a Proj(Bound) node
 840  */
 841 static int verify_node_Proj_Bound(ir_node *n, ir_node *p)
 842 {
 843         ir_mode *mode = get_irn_mode(p);
 844         long proj     = get_Proj_proj(p);
 845
 846         /* ignore Bound checks of Bad */
 847         if (is_Bad(get_Bound_index(n)))
 848                 return 1;
 849         ASSERT_AND_RET_DBG(
 850                 (
 851                         (proj == pn_Bound_M         && mode == mode_M) ||
 852                         (proj == pn_Bound_X_regular && mode == mode_X) ||
 853                         (proj == pn_Bound_X_except  && mode == mode_X) ||
 854                         (proj == pn_Bound_res       && mode == get_irn_mode(get_Bound_index(n)))
 855                 ),
 856                 "wrong Proj from Bound", 0,
 857                 show_proj_failure(p);
 858         );
 859         return 1;
 860 }
 861
 862 /**
 863  * verify a Proj node
 864  */
 865 static int verify_node_Proj(ir_node *p, ir_graph *irg)
 866 {
 867         ir_node *pred;
 868         ir_op *op;
 869
 870         pred = skip_Id(get_Proj_pred(p));
 871         ASSERT_AND_RET(get_irn_mode(pred) == mode_T, "mode of a 'projed' node is not Tuple", 0);
 872         ASSERT_AND_RET(get_irg_pinned(irg) == op_pin_state_floats || get_nodes_block(pred) == get_nodes_block(p), "Proj must be in same block as its predecessor", 0);
 873
 874         op = get_irn_op(pred);
 875
 876         if (op->ops.verify_proj_node)
 877                 return op->ops.verify_proj_node(pred, p);
 878
 879         /* all went ok */
 880         return 1;
 881 }
 882
 883 /**
 884  * verify a Block node
 885  */
 886 static int verify_node_Block(ir_node *n, ir_graph *irg)
 887 {
 888         int i;
 889         ir_node *mb = get_Block_MacroBlock(n);
 890
 891         ASSERT_AND_RET(is_Block(mb) || is_Bad(mb), "Block node with wrong MacroBlock", 0);
 892
 893         if (is_Block(mb) && mb != n) {
 894                 ir_node *pred;
 895
 896                 /* Blocks with more than one predecessor must be header blocks */
 897                 ASSERT_AND_RET(get_Block_n_cfgpreds(n) == 1, "partBlock with more than one predecessor", 0);
 898                 if (get_irg_phase_state(irg) != phase_backend) {
 899                         pred = get_Block_cfgpred(n, 0);
 900                         if (is_Proj(pred)) {
 901                                 /* the predecessor MUST be a regular Proj */
 902                                 ir_node *frag_op = get_Proj_pred(pred);
 903                                 ASSERT_AND_RET(
 904                                         is_fragile_op(frag_op) && get_Proj_proj(pred) == pn_Generic_X_regular,
 905                                         "partBlock with non-regular predecessor", 0);
 906                         } else {
 907                                 /* We allow Jmps to be predecessors of partBlocks. This can happen due to optimization
 908                                    of fragile nodes during construction. It does not violate our assumption of dominance
 909                                    so let it. */
 910                                 ASSERT_AND_RET(is_Jmp(pred) || is_Bad(pred),
 911                                         "partBlock with non-regular predecessor", 0);
 912                         }
 913                 } else {
 914                         /* relax in backend: Bound nodes are probably lowered into conditional jumps */
 915                 }
 916         }
 917
 918         for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
 919                 ir_node *pred = get_Block_cfgpred(n, i);
 920                 ASSERT_AND_RET(
 921                         is_Bad(pred) || (get_irn_mode(pred) == mode_X),
 922                         "Block node must have a mode_X predecessor", 0);
 923         }
 924
 925         if (n == get_irg_end_block(irg) && get_irg_phase_state(irg) != phase_backend)
 926                 /* End block may only have Return, Raise or fragile ops as preds. */
 927                 for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
 928                         ir_node *pred =  skip_Proj(get_Block_cfgpred(n, i));
 929                         if (is_Proj(pred) || is_Tuple(pred))
 930                                 break;   /*  We can not test properly.  How many tuples are there? */
 931                         ASSERT_AND_RET(
 932                                 (
 933                                         is_Return(pred) ||
 934                                         is_Bad(pred)    ||
 935                                         is_Raise(pred)  ||
 936                                         is_fragile_op(pred)
 937                                 ),
 938                                 "End Block node", 0);
 939                 }
 940                 /*  irg attr must == graph we are in. */
 941                 ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
 942                 return 1;
 943 }
 944
 945 /**
 946  * verify a Start node
 947  */
 948 static int verify_node_Start(ir_node *n, ir_graph *irg)
 949 {
 950         ir_mode *mymode = get_irn_mode(n);
 951         (void) irg;
 952
 953         ASSERT_AND_RET(
 954                 /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
 955                 mymode == mode_T, "Start node", 0
 956                 );
 957         return 1;
 958 }
 959
 960 /**
 961  * verify a Jmp node
 962  */
 963 static int verify_node_Jmp(ir_node *n, ir_graph *irg)
 964 {
 965         ir_mode *mymode = get_irn_mode(n);
 966         (void) irg;
 967
 968         ASSERT_AND_RET(
 969                 /* Jmp: BB --> X */
 970                 mymode == mode_X, "Jmp node", 0
 971         );
 972         return 1;
 973 }
 974
 975 /**
 976  * verify an IJmp node
 977  */
 978 static int verify_node_IJmp(ir_node *n, ir_graph *irg)
 979 {
 980         ir_mode *mymode  = get_irn_mode(n);
 981         ir_mode *op1mode = get_irn_mode(get_IJmp_target(n));
 982         (void) irg;
 983
 984         ASSERT_AND_RET(
 985                 /* IJmp: BB x ref --> X */
 986                 mymode == mode_X && mode_is_reference(op1mode), "IJmp node", 0
 987         );
 988         return 1;
 989 }
 990
 991 /**
 992  * verify a Break node
 993  */
 994 static int verify_node_Break(ir_node *n, ir_graph *irg)
 995 {
 996         ir_mode *mymode = get_irn_mode(n);
 997         (void) irg;
 998
 999 #ifdef INTERPROCEDURAL_VIEW
1000         ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
1001                 "Break may only appear if ip view is constructed.", 0);
1002 #endif
1003         ASSERT_AND_RET(
1004                 /* Jmp: BB --> X */
1005                 mymode == mode_X, "Break node", 0
1006         );
1007         return 1;
1008 }
1009
1010 /**
1011  * verify a Cond node
1012  */
1013 static int verify_node_Cond(ir_node *n, ir_graph *irg)
1014 {
1015         ir_mode *mymode  = get_irn_mode(n);
1016         ir_mode *op1mode = get_irn_mode(get_Cond_selector(n));
1017         (void) irg;
1018
1019         ASSERT_AND_RET(
1020                 /* Cond: BB x b --> X x X */
1021                 (op1mode == mode_b ||
1022                 /* Cond: BB x int --> X^n */
1023                 mode_is_int(op1mode) ),  "Cond node", 0
1024                 );
1025         ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
1026
1027         return 1;
1028 }
1029
1030 /**
1031  * verify a Return node
1032  */
1033 static int verify_node_Return(ir_node *n, ir_graph *irg)
1034 {
1035         int i;
1036         ir_mode *mymode   = get_irn_mode(n);
1037         ir_mode *mem_mode = get_irn_mode(get_Return_mem(n));
1038         ir_type *mt;
1039
1040         /* Return: BB x M x data1 x ... x datan --> X */
1041
1042         ASSERT_AND_RET( mem_mode == mode_M, "Return node", 0 );  /* operand M */
1043
1044         for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
1045                 ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Return_res(n, i))), "Return node", 0 );  /* operand datai */
1046         }
1047         ASSERT_AND_RET( mymode == mode_X, "Result X", 0 );   /* result X */
1048         /* Compare returned results with result types of method type */
1049         mt = get_entity_type(get_irg_entity(irg));
1050         ASSERT_AND_RET_DBG( get_Return_n_ress(n) == get_method_n_ress(mt),
1051                 "Number of results for Return doesn't match number of results in type.", 0,
1052                 show_return_nres(irg, n, mt););
1053         for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
1054                 ir_type *res_type = get_method_res_type(mt, i);
1055
1056                 if (get_irg_phase_state(irg) != phase_backend) {
1057                         if (is_atomic_type(res_type)) {
1058                                 ASSERT_AND_RET_DBG(
1059                                         get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
1060                                         "Mode of result for Return doesn't match mode of result type.", 0,
1061                                         show_return_modes(irg, n, mt, i);
1062                                 );
1063                         } else {
1064                                 ASSERT_AND_RET_DBG(
1065                                         mode_is_reference(get_irn_mode(get_Return_res(n, i))),
1066                                         "Mode of result for Return doesn't match mode of result type.", 0,
1067                                         show_return_modes(irg, n, mt, i);
1068                                 );
1069                         }
1070                 }
1071         }
1072         return 1;
1073 }
1074
1075 /**
1076  * verify a Raise node
1077  */
1078 static int verify_node_Raise(ir_node *n, ir_graph *irg)
1079 {
1080         ir_mode *mymode  = get_irn_mode(n);
1081         ir_mode *op1mode = get_irn_mode(get_Raise_mem(n));
1082         ir_mode *op2mode = get_irn_mode(get_Raise_exo_ptr(n));
1083         (void) irg;
1084
1085         ASSERT_AND_RET(
1086                 /* Sel: BB x M x ref --> X x M */
1087                 op1mode == mode_M && mode_is_reference(op2mode) &&
1088                 mymode == mode_T, "Raise node", 0
1089         );
1090         return 1;
1091 }
1092
1093 /**
1094  * verify a Const node
1095  */
1096 static int verify_node_Const(ir_node *n, ir_graph *irg)
1097 {
1098         ir_mode *mymode = get_irn_mode(n);
1099         (void) irg;
1100
1101         ASSERT_AND_RET(
1102                 /* Const: BB --> data */
1103                 (mode_is_data(mymode) ||
1104                 mymode == mode_b)      /* we want boolean constants for static evaluation */
1105                 ,"Const node", 0       /* of Cmp. */
1106         );
1107         ASSERT_AND_RET(
1108                 /* the modes of the constant and teh tarval must match */
1109                 mymode == get_tarval_mode(get_Const_tarval(n)),
1110                 "Const node, tarval and node mode mismatch", 0
1111         );
1112         return 1;
1113 }
1114
1115 /**
1116  * verify a SymConst node
1117  */
1118 static int verify_node_SymConst(ir_node *n, ir_graph *irg)
1119 {
1120         ir_mode *mymode = get_irn_mode(n);
1121         (void) irg;
1122
1123         ASSERT_AND_RET(
1124                 /* SymConst: BB --> int*/
1125                 (mode_is_int(mymode) ||
1126                 /* SymConst: BB --> ref */
1127                 mode_is_reference(mymode))
1128                 ,"SymConst node", 0);
1129         return 1;
1130 }
1131
1132 /**
1133  * verify a Sel node
1134  */
1135 static int verify_node_Sel(ir_node *n, ir_graph *irg)
1136 {
1137         int i;
1138         ir_mode *mymode  = get_irn_mode(n);
1139         ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
1140         ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
1141         ir_entity *ent;
1142         (void) irg;
1143
1144         ASSERT_AND_RET_DBG(
1145                 /* Sel: BB x M x ref x int^n --> ref */
1146                 (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
1147                 "Sel node", 0, show_node_failure(n)
1148         );
1149
1150         for (i = get_Sel_n_indexs(n) - 1; i >= 0; --i) {
1151                 ASSERT_AND_RET_DBG(mode_is_int(get_irn_mode(get_Sel_index(n, i))), "Sel node", 0, show_node_failure(n));
1152         }
1153         ent = get_Sel_entity(n);
1154         ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n));
1155         return 1;
1156 }
1157
1158 /**
1159  * verify an InstOf node
1160  */
1161 static int verify_node_InstOf(ir_node *n, ir_graph *irg)
1162 {
1163         ir_mode *mymode  = get_irn_mode(n);
1164         ir_mode *op1mode = get_irn_mode(get_InstOf_obj(n));
1165         (void) irg;
1166
1167         ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
1168         ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
1169         return 1;
1170 }
1171
1172 /**
1173  * Check if the pinned state is right.
1174  */
1175 static int verify_right_pinned(ir_node *n)
1176 {
1177         ir_node *mem;
1178
1179         if (get_irn_pinned(n) == op_pin_state_pinned)
1180                 return 1;
1181         mem = get_Call_mem(n);
1182
1183         /* if it's not pinned, its memory predecessor must be NoMem or Pin */
1184         if (is_NoMem(mem) || is_Pin(mem))
1185                 return 1;
1186         return 0;
1187 }
1188
1189 /**
1190  * verify a Call node
1191  */
1192 static int verify_node_Call(ir_node *n, ir_graph *irg)
1193 {
1194         ir_mode *mymode  = get_irn_mode(n);
1195         ir_mode *op1mode = get_irn_mode(get_Call_mem(n));
1196         ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
1197         ir_type *mt;
1198         int i;
1199         (void) irg;
1200
1201         /* Call: BB x M x ref x data1 x ... x datan
1202         --> M x datan+1 x ... x data n+m */
1203         ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 );  /* operand M x ref */
1204
1205         /* NoMem nodes are only allowed as memory input if the Call is NOT pinned */
1206         ASSERT_AND_RET(verify_right_pinned(n),"Call node with wrong memory input", 0 );
1207
1208         mt = get_Call_type(n);
1209         if (get_unknown_type() == mt) {
1210                 return 1;
1211         }
1212
1213         for (i = get_Call_n_params(n) - 1; i >= 0; --i) {
1214                 ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Call_param(n, i))), "Call node", 0 );  /* operand datai */
1215         }
1216
1217         ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 );   /* result T */
1218         /* Compare arguments of node with those of type */
1219
1220         if (get_method_variadicity(mt) == variadicity_variadic) {
1221                 ASSERT_AND_RET_DBG(
1222                         get_Call_n_params(n) >= get_method_n_params(mt),
1223                         "Number of args for Call doesn't match number of args in variadic type.",
1224                         0,
1225                         ir_fprintf(stderr, "Call %+F has %d params, type %d\n",
1226                         n, get_Call_n_params(n), get_method_n_params(mt));
1227                 );
1228         } else {
1229                 ASSERT_AND_RET_DBG(
1230                         get_Call_n_params(n) == get_method_n_params(mt),
1231                         "Number of args for Call doesn't match number of args in non variadic type.",
1232                         0,
1233                         ir_fprintf(stderr, "Call %+F has %d params, type %d\n",
1234                         n, get_Call_n_params(n), get_method_n_params(mt));
1235                 );
1236         }
1237
1238         for (i = 0; i < get_method_n_params(mt); i++) {
1239                 ir_type *t = get_method_param_type(mt, i);
1240
1241                 if (get_irg_phase_state(irg) != phase_backend) {
1242                         if (is_atomic_type(t)) {
1243                                 ASSERT_AND_RET_DBG(
1244                                         get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
1245                                         "Mode of arg for Call doesn't match mode of arg type.", 0,
1246                                         show_call_param(n, mt);
1247                                 );
1248                         } else {
1249                                 /* call with a compound type, mode must be reference */
1250                                 ASSERT_AND_RET_DBG(
1251                                         mode_is_reference(get_irn_mode(get_Call_param(n, i))),
1252                                         "Mode of arg for Call doesn't match mode of arg type.", 0,
1253                                         show_call_param(n, mt);
1254                                 );
1255                         }
1256                 }
1257         }
1258
1259 #if 0
1260         if (Call_has_callees(n)) {
1261                 for (i = 0; i < get_Call_n_callees(n); i++) {
1262                         ASSERT_AND_RET(is_entity(get_Call_callee(n, i)), "callee array must contain entities.", 0);
1263                 }
1264         }
1265 #endif
1266         return 1;
1267 }
1268
1269 /**
1270  * verify an Add node
1271  */
1272 static int verify_node_Add(ir_node *n, ir_graph *irg)
1273 {
1274         ir_mode *mymode  = get_irn_mode(n);
1275         ir_mode *op1mode = get_irn_mode(get_Add_left(n));
1276         ir_mode *op2mode = get_irn_mode(get_Add_right(n));
1277         (void) irg;
1278
1279         ASSERT_AND_RET_DBG(
1280                 (
1281                         /* common Add: BB x numP x numP --> numP */
1282                         (op1mode == mymode && op2mode == op1mode && mode_is_data(mymode)) ||
1283                         /* Pointer Add: BB x ref x int --> ref */
1284                         (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
1285                         /* Pointer Add: BB x int x ref --> ref */
1286                         (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
1287                 ),
1288                 "Add node", 0,
1289                 show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
1290                         "/* Pointer Add: BB x ref x int --> ref */   |\n"
1291                         "/* Pointer Add: BB x int x ref --> ref */");
1292         );
1293         return 1;
1294 }
1295
1296 /**
1297  * verify a Sub node
1298  */
1299 static int verify_node_Sub(ir_node *n, ir_graph *irg)
1300 {
1301         ir_mode *mymode  = get_irn_mode(n);
1302         ir_mode *op1mode = get_irn_mode(get_Sub_left(n));
1303         ir_mode *op2mode = get_irn_mode(get_Sub_right(n));
1304         (void) irg;
1305
1306         ASSERT_AND_RET_DBG(
1307                 (
1308                         /* common Sub: BB x numP x numP --> numP */
1309                         (mymode ==op1mode && mymode == op2mode && mode_is_data(op1mode)) ||
1310                         /* Pointer Sub: BB x ref x int --> ref */
1311                         (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
1312                         /* Pointer Sub: BB x ref x ref --> int */
1313                         (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))
1314                 ),
1315                 "Sub node", 0,
1316                 show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
1317                         "/* Pointer Sub: BB x ref x int --> ref */   |\n"
1318                         "/* Pointer Sub: BB x ref x ref --> int */" );
1319                 );
1320         return 1;
1321 }
1322
1323 /**
1324  * verify a Minus node
1325  */
1326 static int verify_node_Minus(ir_node *n, ir_graph *irg)
1327 {
1328         ir_mode *mymode  = get_irn_mode(n);
1329         ir_mode *op1mode = get_irn_mode(get_Minus_op(n));
1330         (void) irg;
1331
1332         ASSERT_AND_RET_DBG(
1333                 /* Minus: BB x num --> num */
1334                 op1mode == mymode && mode_is_num(op1mode), "Minus node", 0,
1335                 show_unop_failure(n , "/* Minus: BB x num --> num */");
1336         );
1337         return 1;
1338 }
1339
1340 /**
1341  * verify a Mul node
1342  */
1343 static int verify_node_Mul(ir_node *n, ir_graph *irg)
1344 {
1345         ir_mode *mymode  = get_irn_mode(n);
1346         ir_mode *op1mode = get_irn_mode(get_Mul_left(n));
1347         ir_mode *op2mode = get_irn_mode(get_Mul_right(n));
1348         (void) irg;
1349
1350         ASSERT_AND_RET_DBG(
1351                 (
1352                         /* Mul: BB x int_n x int_n --> int_n|int_2n */
1353                         (mode_is_int(op1mode)   && op2mode == op1mode && mode_is_int(mymode) &&
1354                          (op1mode == mymode || get_mode_size_bits(op1mode) * 2 == get_mode_size_bits(mymode))) ||
1355                         /* Mul: BB x float x float --> float */
1356                         (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)
1357                 ),
1358                 "Mul node",0,
1359                 show_binop_failure(n, "/* Mul: BB x int_n x int_n --> int_n|int_2n */ |\n"
1360                 "/* Mul: BB x float x float --> float */");
1361         );
1362         return 1;
1363 }
1364
1365 /**
1366  * verify a Mulh node
1367  */
1368 static int verify_node_Mulh(ir_node *n, ir_graph *irg)
1369 {
1370         ir_mode *mymode  = get_irn_mode(n);
1371         ir_mode *op1mode = get_irn_mode(get_Mulh_left(n));
1372         ir_mode *op2mode = get_irn_mode(get_Mulh_right(n));
1373         (void) irg;
1374
1375         ASSERT_AND_RET_DBG(
1376                 (
1377                         /* Mulh: BB x int x int --> int */
1378                         (mode_is_int(op1mode) && op2mode == op1mode && op1mode == mymode)
1379                 ),
1380                 "Mulh node",0,
1381                 show_binop_failure(n, "/* Mulh: BB x int x int --> int */");
1382         );
1383         return 1;
1384 }
1385
1386 /**
1387  * verify a Quot node
1388  */
1389 static int verify_node_Quot(ir_node *n, ir_graph *irg)
1390 {
1391         ir_mode *mymode  = get_irn_mode(n);
1392         ir_mode *op1mode = get_irn_mode(get_Quot_mem(n));
1393         ir_mode *op2mode = get_irn_mode(get_Quot_left(n));
1394         ir_mode *op3mode = get_irn_mode(get_Quot_right(n));
1395         (void) irg;
1396
1397         ASSERT_AND_RET_DBG(
1398                 /* Quot: BB x M x float x float --> M x X x float */
1399                 op1mode == mode_M && op2mode == op3mode &&
1400                 get_mode_sort(op2mode) == irms_float_number &&
1401                 mymode == mode_T,
1402                 "Quot node",0,
1403                 show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
1404         );
1405         return 1;
1406 }
1407
1408 /**
1409  * verify a DivMod node
1410  */
1411 static int verify_node_DivMod(ir_node *n, ir_graph *irg)
1412 {
1413         ir_mode *mymode  = get_irn_mode(n);
1414         ir_mode *op1mode = get_irn_mode(get_DivMod_mem(n));
1415         ir_mode *op2mode = get_irn_mode(get_DivMod_left(n));
1416         ir_mode *op3mode = get_irn_mode(get_DivMod_right(n));
1417         (void) irg;
1418
1419         ASSERT_AND_RET(
1420                 /* DivMod: BB x M x int x int --> M x X x int x int */
1421                 op1mode == mode_M &&
1422                 mode_is_int(op2mode) &&
1423                 op3mode == op2mode &&
1424                 mymode == mode_T,
1425                 "DivMod node", 0
1426                 );
1427         return 1;
1428 }
1429
1430 /**
1431  * verify a Div node
1432  */
1433 static int verify_node_Div(ir_node *n, ir_graph *irg)
1434 {
1435         ir_mode *mymode  = get_irn_mode(n);
1436         ir_mode *op1mode = get_irn_mode(get_Div_mem(n));
1437         ir_mode *op2mode = get_irn_mode(get_Div_left(n));
1438         ir_mode *op3mode = get_irn_mode(get_Div_right(n));
1439         (void) irg;
1440
1441         ASSERT_AND_RET(
1442                 /* Div: BB x M x int x int --> M x X x int */
1443                 op1mode == mode_M &&
1444                 op2mode == op3mode &&
1445                 mode_is_int(op2mode) &&
1446                 mymode == mode_T,
1447                 "Div node", 0
1448                 );
1449         return 1;
1450 }
1451
1452 /**
1453  * verify a Mod node
1454  */
1455 static int verify_node_Mod(ir_node *n, ir_graph *irg)
1456 {
1457         ir_mode *mymode  = get_irn_mode(n);
1458         ir_mode *op1mode = get_irn_mode(get_Mod_mem(n));
1459         ir_mode *op2mode = get_irn_mode(get_Mod_left(n));
1460         ir_mode *op3mode = get_irn_mode(get_Mod_right(n));
1461         (void) irg;
1462
1463         ASSERT_AND_RET(
1464                 /* Mod: BB x M x int x int --> M x X x int */
1465                 op1mode == mode_M &&
1466                 op2mode == op3mode &&
1467                 mode_is_int(op2mode) &&
1468                 mymode == mode_T,
1469                 "Mod node", 0
1470                 );
1471         return 1;
1472 }
1473
1474 /**
1475  * verify an Abs node
1476  */
1477 static int verify_node_Abs(ir_node *n, ir_graph *irg)
1478 {
1479         ir_mode *mymode  = get_irn_mode(n);
1480         ir_mode *op1mode = get_irn_mode(get_Abs_op(n));
1481         (void) irg;
1482
1483         ASSERT_AND_RET_DBG(
1484                 /* Abs: BB x num --> num */
1485                 op1mode == mymode &&
1486                 mode_is_num (op1mode),
1487                 "Abs node", 0,
1488                 show_unop_failure(n, "/* Abs: BB x num --> num */");
1489         );
1490         return 1;
1491 }
1492
1493 /**
1494  * verify a logical And, Or, Eor node
1495  */
1496 static int verify_node_Logic(ir_node *n, ir_graph *irg)
1497 {
1498         ir_mode *mymode  = get_irn_mode(n);
1499         ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1500         ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1501         (void) irg;
1502
1503         ASSERT_AND_RET_DBG(
1504                 /* And or Or or Eor: BB x int x int --> int */
1505                 (mode_is_int(mymode) || mymode == mode_b) &&
1506                 op2mode == op1mode &&
1507                 mymode == op2mode,
1508                 "And, Or or Eor node", 0,
1509                 show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
1510         );
1511         return 1;
1512 }
1513
1514 #define verify_node_And   verify_node_Logic
1515 #define verify_node_Or    verify_node_Logic
1516 #define verify_node_Eor   verify_node_Logic
1517
1518 /**
1519  * verify a Not node
1520  */
1521 static int verify_node_Not(ir_node *n, ir_graph *irg)
1522 {
1523         ir_mode *mymode  = get_irn_mode(n);
1524         ir_mode *op1mode = get_irn_mode(get_Not_op(n));
1525         (void) irg;
1526
1527         ASSERT_AND_RET_DBG(
1528                 /* Not: BB x int --> int */
1529                 (mode_is_int(mymode) || mymode == mode_b) &&
1530                 mymode == op1mode,
1531                 "Not node", 0,
1532                 show_unop_failure(n, "/* Not: BB x int --> int */");
1533         );
1534         return 1;
1535 }
1536
1537 /**
1538  * verify a Cmp node
1539  */
1540 static int verify_node_Cmp(ir_node *n, ir_graph *irg)
1541 {
1542         ir_mode *mymode  = get_irn_mode(n);
1543         ir_mode *op1mode = get_irn_mode(get_Cmp_left(n));
1544         ir_mode *op2mode = get_irn_mode(get_Cmp_right(n));
1545         (void) irg;
1546
1547         ASSERT_AND_RET_DBG(
1548                 /* Cmp: BB x datab x datab --> b16 */
1549                 mode_is_datab(op1mode) &&
1550                 op2mode == op1mode &&
1551                 mymode == mode_T,
1552                 "Cmp node", 0,
1553                 show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
1554         );
1555         return 1;
1556 }
1557
1558 /**
1559  * verify a Shift node
1560  */
1561 static int verify_node_Shift(ir_node *n, ir_graph *irg)
1562 {
1563         ir_mode *mymode  = get_irn_mode(n);
1564         ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1565         ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1566         (void) irg;
1567
1568         ASSERT_AND_RET_DBG(
1569                 /* Shl, Shr or Shrs: BB x int x int_u --> int */
1570                 mode_is_int(op1mode) &&
1571                 mode_is_int(op2mode) &&
1572                 !mode_is_signed(op2mode) &&
1573                 mymode == op1mode,
1574                 "Shl, Shr or Shrs node", 0,
1575                 show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
1576         );
1577         return 1;
1578 }
1579
1580 #define verify_node_Shl   verify_node_Shift
1581 #define verify_node_Shr   verify_node_Shift
1582 #define verify_node_Shrs  verify_node_Shift
1583
1584 /**
1585  * verify a Rotl node
1586  */
1587 static int verify_node_Rotl(ir_node *n, ir_graph *irg)
1588 {
1589         ir_mode *mymode  = get_irn_mode(n);
1590         ir_mode *op1mode = get_irn_mode(get_Rotl_left(n));
1591         ir_mode *op2mode = get_irn_mode(get_Rotl_right(n));
1592         (void) irg;
1593
1594         ASSERT_AND_RET_DBG(
1595                 /* Rotl: BB x int x int --> int */
1596                 mode_is_int(op1mode) &&
1597                 mode_is_int(op2mode) &&
1598                 mymode == op1mode,
1599                 "Rotl node", 0,
1600                 show_binop_failure(n, "/* Rotl: BB x int x int --> int */");
1601         );
1602         return 1;
1603 }
1604
1605 /**
1606  * verify a Conv node
1607  */
1608 static int verify_node_Conv(ir_node *n, ir_graph *irg)
1609 {
1610         ir_mode *mymode  = get_irn_mode(n);
1611         ir_mode *op1mode = get_irn_mode(get_Conv_op(n));
1612         (void) irg;
1613
1614         ASSERT_AND_RET_DBG(
1615                 get_irg_phase_state(irg) == phase_backend ||
1616                 (mode_is_datab(op1mode) && mode_is_data(mymode)),
1617                 "Conv node", 0,
1618                 show_unop_failure(n, "/* Conv: BB x datab --> data */");
1619         );
1620         return 1;
1621 }
1622
1623 /**
1624  * verify a Cast node
1625  */
1626 static int verify_node_Cast(ir_node *n, ir_graph *irg)
1627 {
1628         ir_mode *mymode  = get_irn_mode(n);
1629         ir_mode *op1mode = get_irn_mode(get_Cast_op(n));
1630         (void) irg;
1631
1632         ASSERT_AND_RET_DBG(
1633                 /* Conv: BB x datab1 --> datab2 */
1634                 mode_is_data(op1mode) && op1mode == mymode,
1635                 "Cast node", 0,
1636                 show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1637         );
1638         return 1;
1639 }
1640
1641 /**
1642  * verify a Phi node
1643  */
1644 static int verify_node_Phi(ir_node *n, ir_graph *irg)
1645 {
1646         ir_mode *mymode = get_irn_mode(n);
1647         ir_node *block  = get_nodes_block(n);
1648         int i;
1649         (void) irg;
1650
1651         /* a Phi node MUST have the same number of inputs as its block
1652          * Exception is a phi with 0 inputs which is used when (re)constructing the
1653          * SSA form */
1654         if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building && get_irn_arity(n) > 0) {
1655                 ASSERT_AND_RET_DBG(
1656                         get_irn_arity(n) == get_irn_arity(block),
1657                         "wrong number of inputs in Phi node", 0,
1658                         show_phi_inputs(n, block);
1659                 );
1660         }
1661
1662         /* Phi: BB x dataM^n --> dataM */
1663         for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
1664                 ir_node *pred = get_Phi_pred(n, i);
1665                 if (!is_Bad(pred)) {
1666                         ASSERT_AND_RET_DBG(
1667                                 get_irn_mode(pred) == mymode,
1668                                 "Phi node", 0,
1669                                 show_phi_failure(n, pred, i);
1670                         );
1671                 }
1672         }
1673         ASSERT_AND_RET(mode_is_dataM(mymode) || mymode == mode_b, "Phi node", 0 );
1674
1675         if (mymode == mode_M) {
1676                 for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
1677                         int j;
1678                         ir_node *pred_i = get_Phi_pred(n, i);
1679
1680                         if (is_Bad(pred_i))
1681                                 continue;
1682                         for (j = i - 1; j >= 0; --j) {
1683                                 ir_node *pred_j = get_Phi_pred(n, j);
1684
1685                                 if (is_Bad(pred_j))
1686                                         continue;
1687 #if 0
1688                                 /* currently this checks fails for blocks with exception
1689                                    outputs (and these are NOT basic blocks).  So it is disabled yet. */
1690                                 ASSERT_AND_RET_DBG(
1691                                         (pred_i == pred_j) || (get_irn_n(pred_i, -1) != get_irn_n(pred_j, -1)),
1692                                         "At least two different PhiM predecessors are in the same block",
1693                                         0,
1694                                         ir_printf("%+F and %+F of %+F are in %+F\n", pred_i, pred_j, n, get_irn_n(pred_i, -1))
1695                                 );
1696 #endif
1697                         }
1698                 }
1699         }
1700         return 1;
1701 }
1702
1703 /**
1704  * verify a Filter node
1705  */
1706 static int verify_node_Filter(ir_node *n, ir_graph *irg)
1707 {
1708         (void) n;
1709         (void) irg;
1710 #ifdef INTERPROCEDURAL_VIEW
1711         ASSERT_AND_RET((get_irp_ip_view_state() != ip_view_no),
1712                 "Filter may only appear if ip view is constructed.", 0);
1713 #endif
1714         /* We should further do tests as for Proj and Phi. */
1715         return 1;
1716 }
1717
1718 /**
1719  * verify a Load node
1720  */
1721 static int verify_node_Load(ir_node *n, ir_graph *irg)
1722 {
1723         ir_mode *mymode  = get_irn_mode(n);
1724         ir_mode *op1mode = get_irn_mode(get_Load_mem(n));
1725         ir_mode *op2mode = get_irn_mode(get_Load_ptr(n));
1726
1727         ASSERT_AND_RET(op1mode == mode_M, "Load node", 0);
1728         if (get_irg_phase_state(irg) != phase_backend) {
1729                 ASSERT_AND_RET(mode_is_reference(op2mode), "Load node", 0 );
1730         }
1731         ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
1732
1733         /*
1734          * jack's gen_add_firm_code:simpleSel seems to build Load (Load
1735          * (Proj (Proj))) sometimes ...
1736
1737          * interprete.c:ai_eval seems to assume that this happens, too
1738
1739          * obset.c:get_abstval_any can't deal with this if the load has
1740          * mode_T
1741          *
1742           {
1743           ir_entity *ent = hunt_for_entity (get_Load_ptr (n), n);
1744           assert ((NULL != ent) || (mymode != mode_T));
1745           }
1746          */
1747
1748         return 1;
1749 }
1750
1751 /**
1752  * verify a Store node
1753  */
1754 static int verify_node_Store(ir_node *n, ir_graph *irg)
1755 {
1756         ir_entity *target;
1757
1758         ir_mode *mymode  = get_irn_mode(n);
1759         ir_mode *op1mode = get_irn_mode(get_Store_mem(n));
1760         ir_mode *op2mode = get_irn_mode(get_Store_ptr(n));
1761         ir_mode *op3mode = get_irn_mode(get_Store_value(n));
1762
1763         ASSERT_AND_RET(op1mode == mode_M && mode_is_datab(op3mode), "Store node", 0 );
1764         if (get_irg_phase_state(irg) != phase_backend) {
1765                 ASSERT_AND_RET(mode_is_reference(op2mode), "Store node", 0 );
1766         }
1767         ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
1768
1769         target = get_ptr_entity(get_Store_ptr(n));
1770         if (vrfy_entities && target && get_irg_phase_state(current_ir_graph) == phase_high) {
1771                 /*
1772                  * If lowered code, any Sels that add 0 may be removed, causing
1773                  * an direct access to entities of array or compound type.
1774                  * Prevent this by checking the phase.
1775                  */
1776                 ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
1777                         "Store node", 0);
1778         }
1779
1780         return 1;
1781 }
1782
1783 /**
1784  * verify an Alloc node
1785  */
1786 static int verify_node_Alloc(ir_node *n, ir_graph *irg)
1787 {
1788         ir_mode *mymode  = get_irn_mode(n);
1789         ir_mode *op1mode = get_irn_mode(get_Alloc_mem(n));
1790         ir_mode *op2mode = get_irn_mode(get_Alloc_count(n));
1791         (void) irg;
1792
1793         ASSERT_AND_RET_DBG(
1794                 /* Alloc: BB x M x int_u --> M x X x ref */
1795                 op1mode == mode_M &&
1796                 mode_is_int(op2mode) &&
1797                 !mode_is_signed(op2mode) &&
1798                 mymode == mode_T,
1799                 "Alloc node", 0,
1800                 show_node_failure(n);
1801         );
1802         return 1;
1803 }
1804
1805 /**
1806  * verify a Free node
1807  */
1808 static int verify_node_Free(ir_node *n, ir_graph *irg)
1809 {
1810         ir_mode *mymode  = get_irn_mode(n);
1811         ir_mode *op1mode = get_irn_mode(get_Free_mem(n));
1812         ir_mode *op2mode = get_irn_mode(get_Free_ptr(n));
1813         ir_mode *op3mode = get_irn_mode(get_Free_size(n));
1814         (void) irg;
1815
1816         ASSERT_AND_RET_DBG(
1817                 /* Free: BB x M x ref x int_u --> M */
1818                 op1mode == mode_M && mode_is_reference(op2mode) &&
1819                 mode_is_int(op3mode) &&
1820                 !mode_is_signed(op3mode) &&
1821                 mymode == mode_M,
1822                 "Free node", 0,
1823                 show_triop_failure(n, "/* Free: BB x M x ref x int_u --> M */");
1824         );
1825         return 1;
1826 }
1827
1828 /**
1829  * verify a Sync node
1830  */
1831 static int verify_node_Sync(ir_node *n, ir_graph *irg)
1832 {
1833         int i;
1834         ir_mode *mymode  = get_irn_mode(n);
1835         (void) irg;
1836
1837         /* Sync: BB x M^n --> M */
1838         for (i = get_Sync_n_preds(n) - 1; i >= 0; --i) {
1839                 ASSERT_AND_RET( get_irn_mode(get_Sync_pred(n, i)) == mode_M, "Sync node", 0 );
1840         };
1841         ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
1842         return 1;
1843 }
1844
1845 /**
1846  * verify a Confirm node
1847  */
1848 static int verify_node_Confirm(ir_node *n, ir_graph *irg)
1849 {
1850         ir_mode *mymode  = get_irn_mode(n);
1851         ir_mode *op1mode = get_irn_mode(get_Confirm_value(n));
1852         ir_mode *op2mode = get_irn_mode(get_Confirm_bound(n));
1853         (void) irg;
1854
1855         ASSERT_AND_RET_DBG(
1856                 /* Confirm: BB x T x T --> T */
1857                 op1mode == mymode &&
1858                 op2mode == mymode,
1859                 "Confirm node", 0,
1860                 show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
1861         );
1862         return 1;
1863 }
1864
1865 /**
1866  * verify a Mux node
1867  */
1868 static int verify_node_Mux(ir_node *n, ir_graph *irg)
1869 {
1870         ir_mode *mymode  = get_irn_mode(n);
1871         ir_mode *op1mode = get_irn_mode(get_Mux_sel(n));
1872         ir_mode *op2mode = get_irn_mode(get_Mux_true(n));
1873         ir_mode *op3mode = get_irn_mode(get_Mux_false(n));
1874         (void) irg;
1875
1876         ASSERT_AND_RET(
1877                 /* Mux: BB x b x datab x datab --> datab */
1878                 op1mode == mode_b &&
1879                 op2mode == mymode &&
1880                 op3mode == mymode &&
1881                 mode_is_datab(mymode),
1882                 "Mux node", 0
1883                 );
1884         return 1;
1885 }
1886
1887 /**
1888  * verify a CopyB node
1889  */
1890 static int verify_node_CopyB(ir_node *n, ir_graph *irg)
1891 {
1892         ir_mode *mymode  = get_irn_mode(n);
1893         ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n));
1894         ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n));
1895         ir_mode *op3mode = get_irn_mode(get_CopyB_src(n));
1896         ir_type *t = get_CopyB_type(n);
1897
1898         /* CopyB: BB x M x ref x ref --> M x X */
1899         ASSERT_AND_RET(mymode == mode_T && op1mode == mode_M, "CopyB node", 0);
1900         if (get_irg_phase_state(irg) != phase_backend) {
1901                 ASSERT_AND_RET(mode_is_reference(op2mode) && mode_is_reference(op3mode),
1902                         "CopyB node", 0 );
1903         }
1904
1905         ASSERT_AND_RET(
1906                 is_compound_type(t),
1907                 "CopyB node should copy compound types only", 0 );
1908
1909         /* NoMem nodes are only allowed as memory input if the CopyB is NOT pinned.
1910            This should happen RARELY, as CopyB COPIES MEMORY */
1911         ASSERT_AND_RET(verify_right_pinned(n), "CopyB node with wrong memory input", 0 );
1912         return 1;
1913 }
1914
1915 /**
1916  * verify a Bound node
1917  */
1918 static int verify_node_Bound(ir_node *n, ir_graph *irg)
1919 {
1920         ir_mode *mymode  = get_irn_mode(n);
1921         ir_mode *op1mode = get_irn_mode(get_Bound_mem(n));
1922         ir_mode *op2mode = get_irn_mode(get_Bound_index(n));
1923         ir_mode *op3mode = get_irn_mode(get_Bound_lower(n));
1924         ir_mode *op4mode = get_irn_mode(get_Bound_upper(n));
1925         (void) irg;
1926
1927         /* Bound: BB x M x int x int x int --> M x X */
1928         ASSERT_AND_RET(
1929                 mymode == mode_T &&
1930                 op1mode == mode_M &&
1931                 op2mode == op3mode &&
1932                 op3mode == op4mode &&
1933                 mode_is_int(op3mode),
1934                 "Bound node", 0 );
1935         return 1;
1936 }
1937
1938 /**
1939  * Check dominance.
1940  * For each usage of a node, it is checked, if the block of the
1941  * node dominates the block of the usage (for phis: the predecessor
1942  * block of the phi for the corresponding edge).
1943  *
1944  * @return non-zero on success, 0 on dominance error
1945  */
1946 static int check_dominance_for_node(ir_node *use)
1947 {
1948         if (is_Block(use)) {
1949                 ir_node *mbh = get_Block_MacroBlock(use);
1950
1951                 if (mbh != use) {
1952                         /* must be a partBlock */
1953                         if (is_Block(mbh)) {
1954                                 ASSERT_AND_RET(block_dominates(mbh, use), "MacroBlock header must dominate a partBlock", 0);
1955                         }
1956                 }
1957         }
1958         /* This won't work for blocks and the end node */
1959         else if (use != get_irg_end(current_ir_graph) && use != current_ir_graph->anchor) {
1960                 int i;
1961                 ir_node *bl = get_nodes_block(use);
1962
1963                 for (i = get_irn_arity(use) - 1; i >= 0; --i) {
1964                         ir_node *def    = get_irn_n(use, i);
1965                         ir_node *def_bl = get_nodes_block(def);
1966                         ir_node *use_bl = bl;
1967
1968                         /* ignore dead definition blocks, will be removed */
1969                         if (is_Block_dead(def_bl) || get_Block_dom_depth(def_bl) == -1)
1970                                 continue;
1971
1972                         if (is_Phi(use))
1973                                 use_bl = get_Block_cfgpred_block(bl, i);
1974
1975                         /* ignore dead use blocks, will be removed */
1976                         if (is_Block_dead(use_bl) || get_Block_dom_depth(use_bl) == -1)
1977                                 continue;
1978
1979                         ASSERT_AND_RET_DBG(
1980                                 block_dominates(def_bl, use_bl),
1981                                 "the definition of a value used violates the dominance property", 0,
1982                                 ir_fprintf(stderr,
1983                                 "graph %+F: %+F of %+F must dominate %+F of user %+F input %d\n",
1984                                 current_ir_graph, def_bl, def, use_bl, use, i
1985                                 );
1986                         );
1987                 }
1988         }
1989         return 1;
1990 }
1991
1992 /* Tests the modes of n and its predecessors. */
1993 int irn_vrfy_irg(ir_node *n, ir_graph *irg)
1994 {
1995         int i;
1996         ir_op *op;
1997
1998         if (!get_node_verification_mode())
1999                 return 1;
2000
2001         /*
2002          * do NOT check placement in interprocedural view, as we don't always
2003          * know the "right" graph ...
2004          */
2005
2006 #ifndef NDEBUG
2007         /* this is an expensive check for large graphs (it has a quadratic
2008          * runtime but with a small constant); so do NOT run it in release mode
2009          */
2010         ASSERT_AND_RET_DBG(
2011                 node_is_in_irgs_storage(irg, n),
2012                 "Node is not stored on proper IR graph!", 0,
2013                 show_node_on_graph(irg, n);
2014         );
2015 #endif
2016         assert(get_irn_irg(n) == irg);
2017         {
2018                 unsigned idx           = get_irn_idx(n);
2019                 ir_node *node_from_map = get_idx_irn(irg, idx);
2020                 ASSERT_AND_RET_DBG(node_from_map == n, "Node index and index map entry differ", 0,
2021                         ir_printf("node %+F node in map %+F(%p)\n", n, node_from_map, node_from_map));
2022         }
2023
2024         op = get_irn_op(n);
2025
2026         /* We don't want to test nodes whose predecessors are Bad,
2027            as we would have to special case that for each operation. */
2028         if (op != op_Phi && op != op_Block) {
2029                 for (i = get_irn_arity(n) - 1; i >= 0; --i) {
2030                         if (is_Bad(get_irn_n(n, i)))
2031                                 return 1;
2032                 }
2033         }
2034
2035         if (_get_op_pinned(op) >= op_pin_state_exc_pinned) {
2036                 op_pin_state state = get_irn_pinned(n);
2037                 ASSERT_AND_RET_DBG(
2038                         state == op_pin_state_floats ||
2039                         state == op_pin_state_pinned,
2040                         "invalid pin state", 0,
2041                         ir_printf("node %+F", n));
2042         }
2043
2044         if (op->ops.verify_node)
2045                 return op->ops.verify_node(n, irg);
2046
2047         /* All went ok */
2048         return 1;
2049 }
2050
2051 int irn_vrfy(ir_node *n)
2052 {
2053 #ifdef DEBUG_libfirm
2054         return irn_vrfy_irg(n, current_ir_graph);
2055 #else
2056         (void)n;
2057         return 1;
2058 #endif
2059 }
2060
2061 /*-----------------------------------------------------------------*/
2062 /* Verify the whole graph.                                         */
2063 /*-----------------------------------------------------------------*/
2064
2065 #ifdef DEBUG_libfirm
2066 /**
2067  * Walker to check every node
2068  */
2069 static void vrfy_wrap(ir_node *node, void *env)
2070 {
2071         int *res = env;
2072         *res = irn_vrfy_irg(node, current_ir_graph);
2073 }
2074
2075 /**
2076  * Walker to check every node including SSA property.
2077  * Only called if dominance info is available.
2078  */
2079 static void vrfy_wrap_ssa(ir_node *node, void *env)
2080 {
2081         int *res = env;
2082
2083         *res = irn_vrfy_irg(node, current_ir_graph);
2084         if (*res) {
2085                 *res = check_dominance_for_node(node);
2086         }
2087 }
2088
2089 #endif /* DEBUG_libfirm */
2090
2091 /*
2092  * Calls irn_vrfy for each node in irg.
2093  * Graph must be in state "op_pin_state_pinned".
2094  * If dominance info is available, check the SSA property.
2095  */
2096 int irg_verify(ir_graph *irg, unsigned flags)
2097 {
2098         int res = 1;
2099 #ifdef DEBUG_libfirm
2100         ir_graph *rem;
2101
2102         rem = current_ir_graph;
2103         current_ir_graph = irg;
2104
2105 #ifndef NDEBUG
2106     last_irg_error = NULL;
2107 #endif /* NDEBUG */
2108
2109         assert(get_irg_pinned(irg) == op_pin_state_pinned && "Verification need pinned graph");
2110
2111         if (flags & VRFY_ENFORCE_SSA)
2112                 compute_doms(irg);
2113
2114         irg_walk_anchors(
2115                 irg,
2116                 get_irg_dom_state(irg) == dom_consistent &&
2117                 get_irg_pinned(irg) == op_pin_state_pinned ? vrfy_wrap_ssa : vrfy_wrap,
2118                 NULL, &res
2119         );
2120
2121         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
2122                 ir_entity *ent = get_irg_entity(irg);
2123
2124                 if (ent)
2125                         fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
2126                 else
2127                         fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)irg);
2128         }
2129
2130         current_ir_graph = rem;
2131 #else
2132         (void)irg;
2133         (void)flags;
2134 #endif /* DEBUG_libfirm */
2135
2136         return res;
2137 }
2138
2139 struct pass_t {
2140         ir_graph_pass_t pass;
2141         unsigned        flags;
2142 };
2143
2144 /**
2145  * Wrapper to irg_verify to be run as an ir_graph pass.
2146  */
2147 static int irg_verify_wrapper(ir_graph *irg, void *context)
2148 {
2149         struct pass_t *pass = context;
2150         irg_verify(irg, pass->flags);
2151         /* do NOT rerun the pass if verify is ok :-) */
2152         return 0;
2153 }
2154
2155 /* Creates an ir_graph pass for irg_verify(). */
2156 ir_graph_pass_t *irg_verify_pass(const char *name, unsigned flags)
2157 {
2158         struct pass_t *pass = XMALLOCZ(struct pass_t);
2159
2160         def_graph_pass_constructor(
2161                 &pass->pass, name ? name : "irg_verify", irg_verify_wrapper);
2162
2163         /* neither dump for verify */
2164         pass->pass.dump_irg   = (DUMP_ON_IRG_FUNC)ir_prog_no_dump;
2165         pass->pass.verify_irg = (RUN_ON_IRG_FUNC)ir_prog_no_verify;
2166
2167         pass->flags = flags;
2168         return &pass->pass;
2169 }
2170
2171 /* create a verify pass */
2172 int irn_vrfy_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
2173 {
2174         int res;
2175         firm_verification_t old = get_node_verification_mode();
2176
2177         firm_vrfy_failure_msg = NULL;
2178         do_node_verification(FIRM_VERIFICATION_ERROR_ONLY);
2179         res = irn_vrfy_irg(n, irg);
2180         if (res && get_irg_dom_state(irg) == dom_consistent &&
2181             get_irg_pinned(irg) == op_pin_state_pinned)
2182                 res = check_dominance_for_node(n);
2183         do_node_verification(old);
2184         *bad_string = firm_vrfy_failure_msg;
2185
2186         return res;
2187 }
2188
2189
2190 typedef struct _vrfy_bad_env_t {
2191         int flags;
2192         int res;
2193 } vrfy_bad_env_t;
2194
2195 /**
2196  * Pre-Walker: check Bad predecessors of node.
2197  */
2198 static void check_bads(ir_node *node, void *env)
2199 {
2200         vrfy_bad_env_t *venv = env;
2201         int i, arity = get_irn_arity(node);
2202
2203         if (is_Block(node)) {
2204                 if ((venv->flags & BAD_CF) == 0) {
2205
2206                         /* check for Bad Block predecessor */
2207                         for (i = 0; i < arity; ++i) {
2208                                 ir_node *pred = get_irn_n(node, i);
2209
2210                                 if (is_Bad(pred)) {
2211                                         venv->res |= BAD_CF;
2212
2213                                         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2214                                                 fprintf(stderr, "irg_vrfy_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node));
2215                                         }
2216                                         if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2217                                                 dump_ir_block_graph_sched(current_ir_graph, "-assert");
2218                                                 assert(0 && "Bad CF detected");
2219                                         }
2220                                 }
2221                         }
2222                 }
2223         } else {
2224                 if ((venv->flags & BAD_BLOCK) == 0) {
2225
2226                         /* check for Bad Block */
2227                         if (is_Bad(get_nodes_block(node))) {
2228                                 venv->res |= BAD_BLOCK;
2229
2230                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2231                                         fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Block\n", get_irn_node_nr(node));
2232                                 }
2233                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2234                                         dump_ir_block_graph_sched(current_ir_graph, "-assert");
2235                                         assert(0 && "Bad CF detected");
2236                                 }
2237                         }
2238                 }
2239
2240                 if ((venv->flags & TUPLE) == 0) {
2241                         if (is_Tuple(node)) {
2242                                 venv->res |= TUPLE;
2243
2244                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2245                                         fprintf(stderr, "irg_vrfy_bads: node %ld is a Tuple\n", get_irn_node_nr(node));
2246                                 }
2247                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2248                                         dump_ir_block_graph_sched(current_ir_graph, "-assert");
2249                                         assert(0 && "Tuple detected");
2250                                 }
2251                         }
2252                 }
2253
2254                 for (i = 0; i < arity; ++i) {
2255                         ir_node *pred = get_irn_n(node, i);
2256
2257                         if (is_Bad(pred)) {
2258                                 /* check for Phi with Bad inputs */
2259                                 if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
2260                                         if (venv->flags & BAD_CF)
2261                                                 continue;
2262                                         else {
2263                                                 venv->res |= BAD_CF;
2264
2265                                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2266                                                         fprintf(stderr, "irg_vrfy_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node));
2267                                                 }
2268                                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2269                                                         dump_ir_block_graph_sched(current_ir_graph, "-assert");
2270                                                         assert(0 && "Bad CF detected");
2271                                                 }
2272                                         }
2273                                 }
2274
2275                                 /* Bad node input */
2276                                 if ((venv->flags & BAD_DF) == 0) {
2277                                         venv->res |= BAD_DF;
2278
2279                                         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2280                                                 fprintf(stderr, "irg_vrfy_bads: node %ld has Bad Input\n", get_irn_node_nr(node));
2281                                         }
2282                                         if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2283                                                 dump_ir_block_graph_sched(current_ir_graph, "-assert");
2284                                                 assert(0 && "Bad NON-CF detected");
2285                                         }
2286                                 }
2287                         }
2288                 }
2289         }
2290 }
2291
2292 /*
2293  * verify occurrence of bad nodes
2294  */
2295 int irg_vrfy_bads(ir_graph *irg, int flags)
2296 {
2297         vrfy_bad_env_t env;
2298
2299         env.flags = flags;
2300         env.res   = 0;
2301
2302         irg_walk_graph(irg, check_bads, NULL, &env);
2303
2304         return env.res;
2305 }
2306
2307 /*
2308  * set the default verify operation
2309  */
2310 void firm_set_default_verifyer(ir_opcode code, ir_op_ops *ops)
2311 {
2312 #define CASE(a)                           \
2313    case iro_##a:                          \
2314      ops->verify_node  = verify_node_##a; \
2315      break
2316
2317         switch (code) {
2318         CASE(Proj);
2319         CASE(Block);
2320         CASE(Start);
2321         CASE(Jmp);
2322         CASE(IJmp);
2323         CASE(Break);
2324         CASE(Cond);
2325         CASE(Return);
2326         CASE(Raise);
2327         CASE(Const);
2328         CASE(SymConst);
2329         CASE(Sel);
2330         CASE(InstOf);
2331         CASE(Call);
2332         CASE(Add);
2333         CASE(Sub);
2334         CASE(Minus);
2335         CASE(Mul);
2336         CASE(Mulh);
2337         CASE(Quot);
2338         CASE(DivMod);
2339         CASE(Div);
2340         CASE(Mod);
2341         CASE(Abs);
2342         CASE(And);
2343         CASE(Or);
2344         CASE(Eor);
2345         CASE(Not);
2346         CASE(Cmp);
2347         CASE(Shl);
2348         CASE(Shr);
2349         CASE(Shrs);
2350         CASE(Rotl);
2351         CASE(Conv);
2352         CASE(Cast);
2353         CASE(Phi);
2354         CASE(Filter);
2355         CASE(Load);
2356         CASE(Store);
2357         CASE(Alloc);
2358         CASE(Free);
2359         CASE(Sync);
2360         CASE(Confirm);
2361         CASE(Mux);
2362         CASE(CopyB);
2363         CASE(Bound);
2364         default:
2365                 /* leave NULL */;
2366         }
2367 #undef CASE
2368
2369 #define CASE(a)                          \
2370    case iro_##a:                         \
2371      ops->verify_proj_node  = verify_node_Proj_##a; \
2372      break
2373
2374         switch (code) {
2375         CASE(Start);
2376         CASE(Cond);
2377         CASE(Raise);
2378         CASE(InstOf);
2379         CASE(Call);
2380         CASE(Quot);
2381         CASE(DivMod);
2382         CASE(Div);
2383         CASE(Mod);
2384         CASE(Cmp);
2385         CASE(Load);
2386         CASE(Store);
2387         CASE(Alloc);
2388         CASE(Proj);
2389         CASE(Tuple);
2390         CASE(CallBegin);
2391         CASE(EndReg);
2392         CASE(EndExcept);
2393         CASE(CopyB);
2394         CASE(Bound);
2395         default:
2396                 /* leave NULL */;
2397         }
2398 #undef CASE
2399 }