nsz Git - libfirm/blob - ir/ir/irvrfy.c

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