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