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

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