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