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