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