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