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