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

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