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