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

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