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

   1 /*
   2  * Copyright (C) 1995-2010 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 "irverify_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 verify_entities = 0;
  42
  43 const char *firm_verify_failure_msg;
  44
  45 /* enable verification of Load/Store entities */
  46 void verify_enable_entity_tests(int enable)
  47 {
  48         verify_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_verify_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_verify_irg() %+F::%s failed\n",
  90                                            ent_type, get_entity_name(ent));
  91                         } else {
  92                                 fprintf(stderr, "\nFIRM: irn_verify_irg() <NULL>::%s failed\n", get_entity_name(ent));
  93                         }
  94                 } else {
  95                         fprintf(stderr, "\nFIRM: irn_verify_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_verify_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 (verify_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_start_block(irg)) {
 885                 ASSERT_AND_RET(get_Block_n_cfgpreds(n) == 0, "Start Block node", 0);
 886         }
 887
 888         if (n == get_irg_end_block(irg) && get_irg_phase_state(irg) != phase_backend)
 889                 /* End block may only have Return, Raise or fragile ops as preds. */
 890                 for (i = get_Block_n_cfgpreds(n) - 1; i >= 0; --i) {
 891                         ir_node *pred =  skip_Proj(get_Block_cfgpred(n, i));
 892                         if (is_Proj(pred) || is_Tuple(pred))
 893                                 break;   /*  We can not test properly.  How many tuples are there? */
 894                         ASSERT_AND_RET(
 895                                 (
 896                                         is_Return(pred) ||
 897                                         is_Bad(pred)    ||
 898                                         is_Raise(pred)  ||
 899                                         is_fragile_op(pred)
 900                                 ),
 901                                 "End Block node", 0);
 902                 }
 903                 /*  irg attr must == graph we are in. */
 904                 ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0);
 905                 return 1;
 906 }
 907
 908 /**
 909  * verify a Start node
 910  */
 911 static int verify_node_Start(ir_node *n, ir_graph *irg)
 912 {
 913         ir_mode *mymode = get_irn_mode(n);
 914         (void) irg;
 915
 916         ASSERT_AND_RET(
 917                 /* Start: BB --> X x M x ref x data1 x ... x datan x ref */
 918                 mymode == mode_T, "Start node", 0
 919                 );
 920         return 1;
 921 }
 922
 923 /**
 924  * verify a Jmp node
 925  */
 926 static int verify_node_Jmp(ir_node *n, ir_graph *irg)
 927 {
 928         ir_mode *mymode = get_irn_mode(n);
 929         (void) irg;
 930
 931         ASSERT_AND_RET(
 932                 /* Jmp: BB --> X */
 933                 mymode == mode_X, "Jmp node", 0
 934         );
 935         return 1;
 936 }
 937
 938 /**
 939  * verify an IJmp node
 940  */
 941 static int verify_node_IJmp(ir_node *n, ir_graph *irg)
 942 {
 943         ir_mode *mymode  = get_irn_mode(n);
 944         ir_mode *op1mode = get_irn_mode(get_IJmp_target(n));
 945         (void) irg;
 946
 947         ASSERT_AND_RET(
 948                 /* IJmp: BB x ref --> X */
 949                 mymode == mode_X && mode_is_reference(op1mode), "IJmp node", 0
 950         );
 951         return 1;
 952 }
 953
 954 /**
 955  * verify a Cond node
 956  */
 957 static int verify_node_Cond(ir_node *n, ir_graph *irg)
 958 {
 959         ir_mode *mymode  = get_irn_mode(n);
 960         ir_mode *op1mode = get_irn_mode(get_Cond_selector(n));
 961         (void) irg;
 962
 963         ASSERT_AND_RET(
 964                 /* Cond: BB x b --> X x X */
 965                 (op1mode == mode_b ||
 966                 /* Cond: BB x int --> X^n */
 967                 mode_is_int(op1mode) ),  "Cond node", 0
 968                 );
 969         ASSERT_AND_RET(mymode == mode_T, "Cond mode is not a tuple", 0);
 970
 971         return 1;
 972 }
 973
 974 /**
 975  * verify a Return node
 976  */
 977 static int verify_node_Return(ir_node *n, ir_graph *irg)
 978 {
 979         int i;
 980         ir_mode *mymode   = get_irn_mode(n);
 981         ir_mode *mem_mode = get_irn_mode(get_Return_mem(n));
 982         ir_type *mt;
 983
 984         /* Return: BB x M x data1 x ... x datan --> X */
 985
 986         ASSERT_AND_RET( mem_mode == mode_M, "Return node", 0 );  /* operand M */
 987
 988         for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
 989                 ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Return_res(n, i))), "Return node", 0 );  /* operand datai */
 990         }
 991         ASSERT_AND_RET( mymode == mode_X, "Result X", 0 );   /* result X */
 992         /* Compare returned results with result types of method type */
 993         mt = get_entity_type(get_irg_entity(irg));
 994         ASSERT_AND_RET_DBG( get_Return_n_ress(n) == get_method_n_ress(mt),
 995                 "Number of results for Return doesn't match number of results in type.", 0,
 996                 show_return_nres(irg, n, mt););
 997         for (i = get_Return_n_ress(n) - 1; i >= 0; --i) {
 998                 ir_type *res_type = get_method_res_type(mt, i);
 999
1000                 if (get_irg_phase_state(irg) != phase_backend) {
1001                         if (is_atomic_type(res_type)) {
1002                                 ASSERT_AND_RET_DBG(
1003                                         get_irn_mode(get_Return_res(n, i)) == get_type_mode(res_type),
1004                                         "Mode of result for Return doesn't match mode of result type.", 0,
1005                                         show_return_modes(irg, n, mt, i);
1006                                 );
1007                         } else {
1008                                 ASSERT_AND_RET_DBG(
1009                                         mode_is_reference(get_irn_mode(get_Return_res(n, i))),
1010                                         "Mode of result for Return doesn't match mode of result type.", 0,
1011                                         show_return_modes(irg, n, mt, i);
1012                                 );
1013                         }
1014                 }
1015         }
1016         return 1;
1017 }
1018
1019 /**
1020  * verify a Raise node
1021  */
1022 static int verify_node_Raise(ir_node *n, ir_graph *irg)
1023 {
1024         ir_mode *mymode  = get_irn_mode(n);
1025         ir_mode *op1mode = get_irn_mode(get_Raise_mem(n));
1026         ir_mode *op2mode = get_irn_mode(get_Raise_exo_ptr(n));
1027         (void) irg;
1028
1029         ASSERT_AND_RET(
1030                 /* Sel: BB x M x ref --> X x M */
1031                 op1mode == mode_M && mode_is_reference(op2mode) &&
1032                 mymode == mode_T, "Raise node", 0
1033         );
1034         return 1;
1035 }
1036
1037 /**
1038  * verify a Const node
1039  */
1040 static int verify_node_Const(ir_node *n, ir_graph *irg)
1041 {
1042         ir_mode *mymode = get_irn_mode(n);
1043         (void) irg;
1044
1045         ASSERT_AND_RET(
1046                 /* Const: BB --> data */
1047                 (mode_is_data(mymode) ||
1048                 mymode == mode_b)      /* we want boolean constants for static evaluation */
1049                 ,"Const node", 0       /* of Cmp. */
1050         );
1051         ASSERT_AND_RET(
1052                 /* the modes of the constant and teh tarval must match */
1053                 mymode == get_tarval_mode(get_Const_tarval(n)),
1054                 "Const node, tarval and node mode mismatch", 0
1055         );
1056         return 1;
1057 }
1058
1059 /**
1060  * verify a SymConst node
1061  */
1062 static int verify_node_SymConst(ir_node *n, ir_graph *irg)
1063 {
1064         ir_mode *mymode = get_irn_mode(n);
1065         (void) irg;
1066
1067         ASSERT_AND_RET(
1068                 /* SymConst: BB --> int*/
1069                 (mode_is_int(mymode) ||
1070                 /* SymConst: BB --> ref */
1071                 mode_is_reference(mymode))
1072                 ,"SymConst node", 0);
1073         return 1;
1074 }
1075
1076 /**
1077  * verify a Sel node
1078  */
1079 static int verify_node_Sel(ir_node *n, ir_graph *irg)
1080 {
1081         int i;
1082         ir_mode *mymode  = get_irn_mode(n);
1083         ir_mode *op1mode = get_irn_mode(get_Sel_mem(n));
1084         ir_mode *op2mode = get_irn_mode(get_Sel_ptr(n));
1085         ir_entity *ent;
1086         (void) irg;
1087
1088         ASSERT_AND_RET_DBG(
1089                 /* Sel: BB x M x ref x int^n --> ref */
1090                 (op1mode == mode_M && op2mode == mymode && mode_is_reference(mymode)),
1091                 "Sel node", 0, show_node_failure(n)
1092         );
1093
1094         for (i = get_Sel_n_indexs(n) - 1; i >= 0; --i) {
1095                 ASSERT_AND_RET_DBG(mode_is_int(get_irn_mode(get_Sel_index(n, i))), "Sel node", 0, show_node_failure(n));
1096         }
1097         ent = get_Sel_entity(n);
1098         ASSERT_AND_RET_DBG(ent, "Sel node with empty entity", 0, show_node_failure(n));
1099         return 1;
1100 }
1101
1102 /**
1103  * verify an InstOf node
1104  */
1105 static int verify_node_InstOf(ir_node *n, ir_graph *irg)
1106 {
1107         ir_mode *mymode  = get_irn_mode(n);
1108         ir_mode *op1mode = get_irn_mode(get_InstOf_obj(n));
1109         (void) irg;
1110
1111         ASSERT_AND_RET(mode_T == mymode, "mode of Instof is not a tuple", 0);
1112         ASSERT_AND_RET(mode_is_data(op1mode), "Instof not on data", 0);
1113         return 1;
1114 }
1115
1116 /**
1117  * Check if the pinned state is right.
1118  */
1119 static int verify_right_pinned(ir_node *n)
1120 {
1121         ir_node *mem;
1122
1123         if (get_irn_pinned(n) == op_pin_state_pinned)
1124                 return 1;
1125         mem = get_Call_mem(n);
1126
1127         /* if it's not pinned, its memory predecessor must be NoMem or Pin */
1128         if (is_NoMem(mem) || is_Pin(mem))
1129                 return 1;
1130         return 0;
1131 }
1132
1133 /**
1134  * verify a Call node
1135  */
1136 static int verify_node_Call(ir_node *n, ir_graph *irg)
1137 {
1138         ir_mode *mymode  = get_irn_mode(n);
1139         ir_mode *op1mode = get_irn_mode(get_Call_mem(n));
1140         ir_mode *op2mode = get_irn_mode(get_Call_ptr(n));
1141         ir_type *mt;
1142         int i;
1143         (void) irg;
1144
1145         /* Call: BB x M x ref x data1 x ... x datan
1146         --> M x datan+1 x ... x data n+m */
1147         ASSERT_AND_RET( op1mode == mode_M && mode_is_reference(op2mode), "Call node", 0 );  /* operand M x ref */
1148
1149         /* NoMem nodes are only allowed as memory input if the Call is NOT pinned */
1150         ASSERT_AND_RET(verify_right_pinned(n),"Call node with wrong memory input", 0 );
1151
1152         mt = get_Call_type(n);
1153         if (get_unknown_type() == mt) {
1154                 return 1;
1155         }
1156
1157         for (i = get_Call_n_params(n) - 1; i >= 0; --i) {
1158                 ASSERT_AND_RET( mode_is_datab(get_irn_mode(get_Call_param(n, i))), "Call node", 0 );  /* operand datai */
1159         }
1160
1161         ASSERT_AND_RET( mymode == mode_T, "Call result not a tuple", 0 );   /* result T */
1162         /* Compare arguments of node with those of type */
1163
1164         if (get_method_variadicity(mt) == variadicity_variadic) {
1165                 ASSERT_AND_RET_DBG(
1166                         get_Call_n_params(n) >= get_method_n_params(mt),
1167                         "Number of args for Call doesn't match number of args in variadic type.",
1168                         0,
1169                         ir_fprintf(stderr, "Call %+F has %d params, type %d\n",
1170                         n, get_Call_n_params(n), get_method_n_params(mt));
1171                 );
1172         } else {
1173                 ASSERT_AND_RET_DBG(
1174                         get_Call_n_params(n) == get_method_n_params(mt),
1175                         "Number of args for Call doesn't match number of args in non variadic type.",
1176                         0,
1177                         ir_fprintf(stderr, "Call %+F has %d params, type %d\n",
1178                         n, get_Call_n_params(n), get_method_n_params(mt));
1179                 );
1180         }
1181
1182         for (i = 0; i < get_method_n_params(mt); i++) {
1183                 ir_type *t = get_method_param_type(mt, i);
1184
1185                 if (get_irg_phase_state(irg) != phase_backend) {
1186                         if (is_atomic_type(t)) {
1187                                 ASSERT_AND_RET_DBG(
1188                                         get_irn_mode(get_Call_param(n, i)) == get_type_mode(t),
1189                                         "Mode of arg for Call doesn't match mode of arg type.", 0,
1190                                         show_call_param(n, mt);
1191                                 );
1192                         } else {
1193                                 /* call with a compound type, mode must be reference */
1194                                 ASSERT_AND_RET_DBG(
1195                                         mode_is_reference(get_irn_mode(get_Call_param(n, i))),
1196                                         "Mode of arg for Call doesn't match mode of arg type.", 0,
1197                                         show_call_param(n, mt);
1198                                 );
1199                         }
1200                 }
1201         }
1202
1203 #if 0
1204         if (Call_has_callees(n)) {
1205                 for (i = 0; i < get_Call_n_callees(n); i++) {
1206                         ASSERT_AND_RET(is_entity(get_Call_callee(n, i)), "callee array must contain entities.", 0);
1207                 }
1208         }
1209 #endif
1210         return 1;
1211 }
1212
1213 /**
1214  * verify an Add node
1215  */
1216 static int verify_node_Add(ir_node *n, ir_graph *irg)
1217 {
1218         ir_mode *mymode  = get_irn_mode(n);
1219         ir_mode *op1mode = get_irn_mode(get_Add_left(n));
1220         ir_mode *op2mode = get_irn_mode(get_Add_right(n));
1221         (void) irg;
1222
1223         ASSERT_AND_RET_DBG(
1224                 (
1225                         /* common Add: BB x numP x numP --> numP */
1226                         (op1mode == mymode && op2mode == op1mode && mode_is_data(mymode)) ||
1227                         /* Pointer Add: BB x ref x int --> ref */
1228                         (mode_is_reference(op1mode) && mode_is_int(op2mode) && op1mode == mymode) ||
1229                         /* Pointer Add: BB x int x ref --> ref */
1230                         (mode_is_int(op1mode) && op2mode == mymode && mode_is_reference(mymode))
1231                 ),
1232                 "Add node", 0,
1233                 show_binop_failure(n, "/* common Add: BB x numP x numP --> numP */ |\n"
1234                         "/* Pointer Add: BB x ref x int --> ref */   |\n"
1235                         "/* Pointer Add: BB x int x ref --> ref */");
1236         );
1237         return 1;
1238 }
1239
1240 /**
1241  * verify a Sub node
1242  */
1243 static int verify_node_Sub(ir_node *n, ir_graph *irg)
1244 {
1245         ir_mode *mymode  = get_irn_mode(n);
1246         ir_mode *op1mode = get_irn_mode(get_Sub_left(n));
1247         ir_mode *op2mode = get_irn_mode(get_Sub_right(n));
1248         (void) irg;
1249
1250         ASSERT_AND_RET_DBG(
1251                 (
1252                         /* common Sub: BB x numP x numP --> numP */
1253                         (mymode ==op1mode && mymode == op2mode && mode_is_data(op1mode)) ||
1254                         /* Pointer Sub: BB x ref x int --> ref */
1255                         (op1mode == mymode && mode_is_int(op2mode) && mode_is_reference(mymode)) ||
1256                         /* Pointer Sub: BB x ref x ref --> int */
1257                         (op1mode == op2mode && mode_is_reference(op2mode) && mode_is_int(mymode))
1258                 ),
1259                 "Sub node", 0,
1260                 show_binop_failure(n, "/* common Sub: BB x numP x numP --> numP */ |\n"
1261                         "/* Pointer Sub: BB x ref x int --> ref */   |\n"
1262                         "/* Pointer Sub: BB x ref x ref --> int */" );
1263                 );
1264         return 1;
1265 }
1266
1267 /**
1268  * verify a Minus node
1269  */
1270 static int verify_node_Minus(ir_node *n, ir_graph *irg)
1271 {
1272         ir_mode *mymode  = get_irn_mode(n);
1273         ir_mode *op1mode = get_irn_mode(get_Minus_op(n));
1274         (void) irg;
1275
1276         ASSERT_AND_RET_DBG(
1277                 /* Minus: BB x num --> num */
1278                 op1mode == mymode && mode_is_num(op1mode), "Minus node", 0,
1279                 show_unop_failure(n , "/* Minus: BB x num --> num */");
1280         );
1281         return 1;
1282 }
1283
1284 /**
1285  * verify a Mul node
1286  */
1287 static int verify_node_Mul(ir_node *n, ir_graph *irg)
1288 {
1289         ir_mode *mymode  = get_irn_mode(n);
1290         ir_mode *op1mode = get_irn_mode(get_Mul_left(n));
1291         ir_mode *op2mode = get_irn_mode(get_Mul_right(n));
1292         (void) irg;
1293
1294         ASSERT_AND_RET_DBG(
1295                 (
1296                         /* Mul: BB x int_n x int_n --> int_n|int_2n */
1297                         (mode_is_int(op1mode)   && op2mode == op1mode && mode_is_int(mymode) &&
1298                          (op1mode == mymode || get_mode_size_bits(op1mode) * 2 == get_mode_size_bits(mymode))) ||
1299                         /* Mul: BB x float x float --> float */
1300                         (mode_is_float(op1mode) && op2mode == op1mode && mymode == op1mode)
1301                 ),
1302                 "Mul node",0,
1303                 show_binop_failure(n, "/* Mul: BB x int_n x int_n --> int_n|int_2n */ |\n"
1304                 "/* Mul: BB x float x float --> float */");
1305         );
1306         return 1;
1307 }
1308
1309 /**
1310  * verify a Mulh node
1311  */
1312 static int verify_node_Mulh(ir_node *n, ir_graph *irg)
1313 {
1314         ir_mode *mymode  = get_irn_mode(n);
1315         ir_mode *op1mode = get_irn_mode(get_Mulh_left(n));
1316         ir_mode *op2mode = get_irn_mode(get_Mulh_right(n));
1317         (void) irg;
1318
1319         ASSERT_AND_RET_DBG(
1320                 (
1321                         /* Mulh: BB x int x int --> int */
1322                         (mode_is_int(op1mode) && op2mode == op1mode && op1mode == mymode)
1323                 ),
1324                 "Mulh node",0,
1325                 show_binop_failure(n, "/* Mulh: BB x int x int --> int */");
1326         );
1327         return 1;
1328 }
1329
1330 /**
1331  * verify a Quot node
1332  */
1333 static int verify_node_Quot(ir_node *n, ir_graph *irg)
1334 {
1335         ir_mode *mymode  = get_irn_mode(n);
1336         ir_mode *op1mode = get_irn_mode(get_Quot_mem(n));
1337         ir_mode *op2mode = get_irn_mode(get_Quot_left(n));
1338         ir_mode *op3mode = get_irn_mode(get_Quot_right(n));
1339         (void) irg;
1340
1341         ASSERT_AND_RET_DBG(
1342                 /* Quot: BB x M x float x float --> M x X x float */
1343                 op1mode == mode_M && op2mode == op3mode &&
1344                 get_mode_sort(op2mode) == irms_float_number &&
1345                 mymode == mode_T,
1346                 "Quot node",0,
1347                 show_binop_failure(n, "/* Quot: BB x M x float x float --> M x X x float */");
1348         );
1349         return 1;
1350 }
1351
1352 /**
1353  * verify a DivMod node
1354  */
1355 static int verify_node_DivMod(ir_node *n, ir_graph *irg)
1356 {
1357         ir_mode *mymode  = get_irn_mode(n);
1358         ir_mode *op1mode = get_irn_mode(get_DivMod_mem(n));
1359         ir_mode *op2mode = get_irn_mode(get_DivMod_left(n));
1360         ir_mode *op3mode = get_irn_mode(get_DivMod_right(n));
1361         (void) irg;
1362
1363         ASSERT_AND_RET(
1364                 /* DivMod: BB x M x int x int --> M x X x int x int */
1365                 op1mode == mode_M &&
1366                 mode_is_int(op2mode) &&
1367                 op3mode == op2mode &&
1368                 mymode == mode_T,
1369                 "DivMod node", 0
1370                 );
1371         return 1;
1372 }
1373
1374 /**
1375  * verify a Div node
1376  */
1377 static int verify_node_Div(ir_node *n, ir_graph *irg)
1378 {
1379         ir_mode *mymode  = get_irn_mode(n);
1380         ir_mode *op1mode = get_irn_mode(get_Div_mem(n));
1381         ir_mode *op2mode = get_irn_mode(get_Div_left(n));
1382         ir_mode *op3mode = get_irn_mode(get_Div_right(n));
1383         (void) irg;
1384
1385         ASSERT_AND_RET(
1386                 /* Div: BB x M x int x int --> M x X x int */
1387                 op1mode == mode_M &&
1388                 op2mode == op3mode &&
1389                 mode_is_int(op2mode) &&
1390                 mymode == mode_T,
1391                 "Div node", 0
1392                 );
1393         return 1;
1394 }
1395
1396 /**
1397  * verify a Mod node
1398  */
1399 static int verify_node_Mod(ir_node *n, ir_graph *irg)
1400 {
1401         ir_mode *mymode  = get_irn_mode(n);
1402         ir_mode *op1mode = get_irn_mode(get_Mod_mem(n));
1403         ir_mode *op2mode = get_irn_mode(get_Mod_left(n));
1404         ir_mode *op3mode = get_irn_mode(get_Mod_right(n));
1405         (void) irg;
1406
1407         ASSERT_AND_RET(
1408                 /* Mod: BB x M x int x int --> M x X x int */
1409                 op1mode == mode_M &&
1410                 op2mode == op3mode &&
1411                 mode_is_int(op2mode) &&
1412                 mymode == mode_T,
1413                 "Mod node", 0
1414                 );
1415         return 1;
1416 }
1417
1418 /**
1419  * verify a logical And, Or, Eor node
1420  */
1421 static int verify_node_Logic(ir_node *n, ir_graph *irg)
1422 {
1423         ir_mode *mymode  = get_irn_mode(n);
1424         ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1425         ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1426         (void) irg;
1427
1428         ASSERT_AND_RET_DBG(
1429                 /* And or Or or Eor: BB x int x int --> int */
1430                 (mode_is_int(mymode) || mymode == mode_b) &&
1431                 op2mode == op1mode &&
1432                 mymode == op2mode,
1433                 "And, Or or Eor node", 0,
1434                 show_binop_failure(n, "/* And or Or or Eor: BB x int x int --> int */");
1435         );
1436         return 1;
1437 }
1438
1439 #define verify_node_And   verify_node_Logic
1440 #define verify_node_Or    verify_node_Logic
1441 #define verify_node_Eor   verify_node_Logic
1442
1443 /**
1444  * verify a Not node
1445  */
1446 static int verify_node_Not(ir_node *n, ir_graph *irg)
1447 {
1448         ir_mode *mymode  = get_irn_mode(n);
1449         ir_mode *op1mode = get_irn_mode(get_Not_op(n));
1450         (void) irg;
1451
1452         ASSERT_AND_RET_DBG(
1453                 /* Not: BB x int --> int */
1454                 (mode_is_int(mymode) || mymode == mode_b) &&
1455                 mymode == op1mode,
1456                 "Not node", 0,
1457                 show_unop_failure(n, "/* Not: BB x int --> int */");
1458         );
1459         return 1;
1460 }
1461
1462 /**
1463  * verify a Cmp node
1464  */
1465 static int verify_node_Cmp(ir_node *n, ir_graph *irg)
1466 {
1467         ir_mode *mymode  = get_irn_mode(n);
1468         ir_mode *op1mode = get_irn_mode(get_Cmp_left(n));
1469         ir_mode *op2mode = get_irn_mode(get_Cmp_right(n));
1470         (void) irg;
1471
1472         ASSERT_AND_RET_DBG(
1473                 /* Cmp: BB x datab x datab --> b16 */
1474                 mode_is_datab(op1mode) &&
1475                 op2mode == op1mode &&
1476                 mymode == mode_T,
1477                 "Cmp node", 0,
1478                 show_binop_failure(n, "/* Cmp: BB x datab x datab --> b16 */");
1479         );
1480         return 1;
1481 }
1482
1483 /**
1484  * verify a Shift node
1485  */
1486 static int verify_node_Shift(ir_node *n, ir_graph *irg)
1487 {
1488         ir_mode *mymode  = get_irn_mode(n);
1489         ir_mode *op1mode = get_irn_mode(get_binop_left(n));
1490         ir_mode *op2mode = get_irn_mode(get_binop_right(n));
1491         (void) irg;
1492
1493         ASSERT_AND_RET_DBG(
1494                 /* Shl, Shr or Shrs: BB x int x int_u --> int */
1495                 mode_is_int(op1mode) &&
1496                 mode_is_int(op2mode) &&
1497                 !mode_is_signed(op2mode) &&
1498                 mymode == op1mode,
1499                 "Shl, Shr or Shrs node", 0,
1500                 show_binop_failure(n, "/* Shl, Shr or Shrs: BB x int x int_u --> int */");
1501         );
1502         return 1;
1503 }
1504
1505 #define verify_node_Shl   verify_node_Shift
1506 #define verify_node_Shr   verify_node_Shift
1507 #define verify_node_Shrs  verify_node_Shift
1508
1509 /**
1510  * verify a Rotl node
1511  */
1512 static int verify_node_Rotl(ir_node *n, ir_graph *irg)
1513 {
1514         ir_mode *mymode  = get_irn_mode(n);
1515         ir_mode *op1mode = get_irn_mode(get_Rotl_left(n));
1516         ir_mode *op2mode = get_irn_mode(get_Rotl_right(n));
1517         (void) irg;
1518
1519         ASSERT_AND_RET_DBG(
1520                 /* Rotl: BB x int x int --> int */
1521                 mode_is_int(op1mode) &&
1522                 mode_is_int(op2mode) &&
1523                 mymode == op1mode,
1524                 "Rotl node", 0,
1525                 show_binop_failure(n, "/* Rotl: BB x int x int --> int */");
1526         );
1527         return 1;
1528 }
1529
1530 /**
1531  * verify a Conv node
1532  */
1533 static int verify_node_Conv(ir_node *n, ir_graph *irg)
1534 {
1535         ir_mode *mymode  = get_irn_mode(n);
1536         ir_mode *op1mode = get_irn_mode(get_Conv_op(n));
1537         (void) irg;
1538
1539         ASSERT_AND_RET_DBG(
1540                 is_irg_state(irg, IR_GRAPH_STATE_BCONV_ALLOWED) ||
1541                 (mode_is_datab(op1mode) && mode_is_data(mymode)),
1542                 "Conv node", 0,
1543                 show_unop_failure(n, "/* Conv: BB x datab --> data */");
1544         );
1545         return 1;
1546 }
1547
1548 /**
1549  * verify a Cast node
1550  */
1551 static int verify_node_Cast(ir_node *n, ir_graph *irg)
1552 {
1553         ir_mode *mymode  = get_irn_mode(n);
1554         ir_mode *op1mode = get_irn_mode(get_Cast_op(n));
1555         (void) irg;
1556
1557         ASSERT_AND_RET_DBG(
1558                 /* Conv: BB x datab1 --> datab2 */
1559                 mode_is_data(op1mode) && op1mode == mymode,
1560                 "Cast node", 0,
1561                 show_unop_failure(n, "/* Conv: BB x datab1 --> datab2 */");
1562         );
1563         return 1;
1564 }
1565
1566 /**
1567  * verify a Phi node
1568  */
1569 static int verify_node_Phi(ir_node *n, ir_graph *irg)
1570 {
1571         ir_mode *mymode = get_irn_mode(n);
1572         ir_node *block  = get_nodes_block(n);
1573         int i;
1574         (void) irg;
1575
1576         /* a Phi node MUST have the same number of inputs as its block
1577          * Exception is a phi with 0 inputs which is used when (re)constructing the
1578          * SSA form */
1579         if (! is_Bad(block) && get_irg_phase_state(get_irn_irg(n)) != phase_building && get_irn_arity(n) > 0) {
1580                 ASSERT_AND_RET_DBG(
1581                         get_irn_arity(n) == get_irn_arity(block),
1582                         "wrong number of inputs in Phi node", 0,
1583                         show_phi_inputs(n, block);
1584                 );
1585         }
1586
1587         /* Phi: BB x dataM^n --> dataM */
1588         for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
1589                 ir_node *pred = get_Phi_pred(n, i);
1590                 if (!is_Bad(pred)) {
1591                         ASSERT_AND_RET_DBG(
1592                                 get_irn_mode(pred) == mymode,
1593                                 "Phi node", 0,
1594                                 show_phi_failure(n, pred, i);
1595                         );
1596                 }
1597         }
1598         ASSERT_AND_RET(mode_is_dataM(mymode) || mymode == mode_b, "Phi node", 0 );
1599
1600         if (mymode == mode_M) {
1601                 for (i = get_Phi_n_preds(n) - 1; i >= 0; --i) {
1602                         int j;
1603                         ir_node *pred_i = get_Phi_pred(n, i);
1604
1605                         if (is_Bad(pred_i))
1606                                 continue;
1607                         for (j = i - 1; j >= 0; --j) {
1608                                 ir_node *pred_j = get_Phi_pred(n, j);
1609
1610                                 if (is_Bad(pred_j))
1611                                         continue;
1612 #if 0
1613                                 /* currently this checks fails for blocks with exception
1614                                    outputs (and these are NOT basic blocks).  So it is disabled yet. */
1615                                 ASSERT_AND_RET_DBG(
1616                                         (pred_i == pred_j) || (get_irn_n(pred_i, -1) != get_irn_n(pred_j, -1)),
1617                                         "At least two different PhiM predecessors are in the same block",
1618                                         0,
1619                                         ir_printf("%+F and %+F of %+F are in %+F\n", pred_i, pred_j, n, get_irn_n(pred_i, -1))
1620                                 );
1621 #endif
1622                         }
1623                 }
1624         }
1625         return 1;
1626 }
1627
1628 /**
1629  * verify a Load node
1630  */
1631 static int verify_node_Load(ir_node *n, ir_graph *irg)
1632 {
1633         ir_mode *mymode  = get_irn_mode(n);
1634         ir_mode *op1mode = get_irn_mode(get_Load_mem(n));
1635         ir_mode *op2mode = get_irn_mode(get_Load_ptr(n));
1636
1637         ASSERT_AND_RET(op1mode == mode_M, "Load node", 0);
1638         if (get_irg_phase_state(irg) != phase_backend) {
1639                 ASSERT_AND_RET(mode_is_reference(op2mode), "Load node", 0 );
1640         }
1641         ASSERT_AND_RET( mymode == mode_T, "Load node", 0 );
1642
1643         /*
1644          * jack's gen_add_firm_code:simpleSel seems to build Load (Load
1645          * (Proj (Proj))) sometimes ...
1646
1647          * interprete.c:ai_eval seems to assume that this happens, too
1648
1649          * obset.c:get_abstval_any can't deal with this if the load has
1650          * mode_T
1651          *
1652           {
1653           ir_entity *ent = hunt_for_entity (get_Load_ptr (n), n);
1654           assert ((NULL != ent) || (mymode != mode_T));
1655           }
1656          */
1657
1658         return 1;
1659 }
1660
1661 /**
1662  * verify a Store node
1663  */
1664 static int verify_node_Store(ir_node *n, ir_graph *irg)
1665 {
1666         ir_entity *target;
1667
1668         ir_mode *mymode  = get_irn_mode(n);
1669         ir_mode *op1mode = get_irn_mode(get_Store_mem(n));
1670         ir_mode *op2mode = get_irn_mode(get_Store_ptr(n));
1671         ir_mode *op3mode = get_irn_mode(get_Store_value(n));
1672
1673         ASSERT_AND_RET(op1mode == mode_M && mode_is_datab(op3mode), "Store node", 0 );
1674         if (get_irg_phase_state(irg) != phase_backend) {
1675                 ASSERT_AND_RET(mode_is_reference(op2mode), "Store node", 0 );
1676         }
1677         ASSERT_AND_RET(mymode == mode_T, "Store node", 0);
1678
1679         target = get_ptr_entity(get_Store_ptr(n));
1680         if (verify_entities && target && get_irg_phase_state(current_ir_graph) == phase_high) {
1681                 /*
1682                  * If lowered code, any Sels that add 0 may be removed, causing
1683                  * an direct access to entities of array or compound type.
1684                  * Prevent this by checking the phase.
1685                  */
1686                 ASSERT_AND_RET( op3mode == get_type_mode(get_entity_type(target)),
1687                         "Store node", 0);
1688         }
1689
1690         return 1;
1691 }
1692
1693 /**
1694  * verify an Alloc node
1695  */
1696 static int verify_node_Alloc(ir_node *n, ir_graph *irg)
1697 {
1698         ir_mode *mymode  = get_irn_mode(n);
1699         ir_mode *op1mode = get_irn_mode(get_Alloc_mem(n));
1700         ir_mode *op2mode = get_irn_mode(get_Alloc_count(n));
1701         (void) irg;
1702
1703         ASSERT_AND_RET_DBG(
1704                 /* Alloc: BB x M x int_u --> M x X x ref */
1705                 op1mode == mode_M &&
1706                 mode_is_int(op2mode) &&
1707                 !mode_is_signed(op2mode) &&
1708                 mymode == mode_T,
1709                 "Alloc node", 0,
1710                 show_node_failure(n);
1711         );
1712         return 1;
1713 }
1714
1715 /**
1716  * verify a Free node
1717  */
1718 static int verify_node_Free(ir_node *n, ir_graph *irg)
1719 {
1720         ir_mode *mymode  = get_irn_mode(n);
1721         ir_mode *op1mode = get_irn_mode(get_Free_mem(n));
1722         ir_mode *op2mode = get_irn_mode(get_Free_ptr(n));
1723         ir_mode *op3mode = get_irn_mode(get_Free_size(n));
1724         (void) irg;
1725
1726         ASSERT_AND_RET_DBG(
1727                 /* Free: BB x M x ref x int_u --> M */
1728                 op1mode == mode_M && mode_is_reference(op2mode) &&
1729                 mode_is_int(op3mode) &&
1730                 !mode_is_signed(op3mode) &&
1731                 mymode == mode_M,
1732                 "Free node", 0,
1733                 show_triop_failure(n, "/* Free: BB x M x ref x int_u --> M */");
1734         );
1735         return 1;
1736 }
1737
1738 /**
1739  * verify a Sync node
1740  */
1741 static int verify_node_Sync(ir_node *n, ir_graph *irg)
1742 {
1743         int i;
1744         ir_mode *mymode  = get_irn_mode(n);
1745         (void) irg;
1746
1747         /* Sync: BB x M^n --> M */
1748         for (i = get_Sync_n_preds(n) - 1; i >= 0; --i) {
1749                 ASSERT_AND_RET( get_irn_mode(get_Sync_pred(n, i)) == mode_M, "Sync node", 0 );
1750         };
1751         ASSERT_AND_RET( mymode == mode_M, "Sync node", 0 );
1752         return 1;
1753 }
1754
1755 /**
1756  * verify a Confirm node
1757  */
1758 static int verify_node_Confirm(ir_node *n, ir_graph *irg)
1759 {
1760         ir_mode *mymode  = get_irn_mode(n);
1761         ir_mode *op1mode = get_irn_mode(get_Confirm_value(n));
1762         ir_mode *op2mode = get_irn_mode(get_Confirm_bound(n));
1763         (void) irg;
1764
1765         ASSERT_AND_RET_DBG(
1766                 /* Confirm: BB x T x T --> T */
1767                 op1mode == mymode &&
1768                 op2mode == mymode,
1769                 "Confirm node", 0,
1770                 show_binop_failure(n, "/* Confirm: BB x T x T --> T */");
1771         );
1772         return 1;
1773 }
1774
1775 /**
1776  * verify a Mux node
1777  */
1778 static int verify_node_Mux(ir_node *n, ir_graph *irg)
1779 {
1780         ir_mode *mymode  = get_irn_mode(n);
1781         ir_mode *op1mode = get_irn_mode(get_Mux_sel(n));
1782         ir_mode *op2mode = get_irn_mode(get_Mux_true(n));
1783         ir_mode *op3mode = get_irn_mode(get_Mux_false(n));
1784         (void) irg;
1785
1786         ASSERT_AND_RET(
1787                 /* Mux: BB x b x datab x datab --> datab */
1788                 op1mode == mode_b &&
1789                 op2mode == mymode &&
1790                 op3mode == mymode &&
1791                 mode_is_datab(mymode),
1792                 "Mux node", 0
1793                 );
1794         return 1;
1795 }
1796
1797 /**
1798  * verify a CopyB node
1799  */
1800 static int verify_node_CopyB(ir_node *n, ir_graph *irg)
1801 {
1802         ir_mode *mymode  = get_irn_mode(n);
1803         ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n));
1804         ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n));
1805         ir_mode *op3mode = get_irn_mode(get_CopyB_src(n));
1806         ir_type *t = get_CopyB_type(n);
1807
1808         /* CopyB: BB x M x ref x ref --> M x X */
1809         ASSERT_AND_RET(mymode == mode_T && op1mode == mode_M, "CopyB node", 0);
1810         if (get_irg_phase_state(irg) != phase_backend) {
1811                 ASSERT_AND_RET(mode_is_reference(op2mode) && mode_is_reference(op3mode),
1812                         "CopyB node", 0 );
1813         }
1814
1815         ASSERT_AND_RET(
1816                 is_compound_type(t) || is_Array_type(t),
1817                 "CopyB node should copy compound types only", 0 );
1818
1819         /* NoMem nodes are only allowed as memory input if the CopyB is NOT pinned.
1820            This should happen RARELY, as CopyB COPIES MEMORY */
1821         ASSERT_AND_RET(verify_right_pinned(n), "CopyB node with wrong memory input", 0 );
1822         return 1;
1823 }
1824
1825 /**
1826  * verify a Bound node
1827  */
1828 static int verify_node_Bound(ir_node *n, ir_graph *irg)
1829 {
1830         ir_mode *mymode  = get_irn_mode(n);
1831         ir_mode *op1mode = get_irn_mode(get_Bound_mem(n));
1832         ir_mode *op2mode = get_irn_mode(get_Bound_index(n));
1833         ir_mode *op3mode = get_irn_mode(get_Bound_lower(n));
1834         ir_mode *op4mode = get_irn_mode(get_Bound_upper(n));
1835         (void) irg;
1836
1837         /* Bound: BB x M x int x int x int --> M x X */
1838         ASSERT_AND_RET(
1839                 mymode == mode_T &&
1840                 op1mode == mode_M &&
1841                 op2mode == op3mode &&
1842                 op3mode == op4mode &&
1843                 mode_is_int(op3mode),
1844                 "Bound node", 0 );
1845         return 1;
1846 }
1847
1848 /**
1849  * Check dominance.
1850  * For each usage of a node, it is checked, if the block of the
1851  * node dominates the block of the usage (for phis: the predecessor
1852  * block of the phi for the corresponding edge).
1853  *
1854  * @return non-zero on success, 0 on dominance error
1855  */
1856 static int check_dominance_for_node(ir_node *use)
1857 {
1858         if (is_Block(use)) {
1859                 ir_node *mbh = get_Block_MacroBlock(use);
1860
1861                 if (mbh != use) {
1862                         /* must be a partBlock */
1863                         if (is_Block(mbh)) {
1864                                 ASSERT_AND_RET(block_dominates(mbh, use), "MacroBlock header must dominate a partBlock", 0);
1865                         }
1866                 }
1867         }
1868         /* This won't work for blocks and the end node */
1869         else if (use != get_irg_end(current_ir_graph) && use != current_ir_graph->anchor) {
1870                 int i;
1871                 ir_node *bl = get_nodes_block(use);
1872
1873                 for (i = get_irn_arity(use) - 1; i >= 0; --i) {
1874                         ir_node *def    = get_irn_n(use, i);
1875                         ir_node *def_bl = get_nodes_block(def);
1876                         ir_node *use_bl = bl;
1877
1878                         /* ignore dead definition blocks, will be removed */
1879                         if (is_Block_dead(def_bl) || get_Block_dom_depth(def_bl) == -1)
1880                                 continue;
1881
1882                         if (is_Phi(use))
1883                                 use_bl = get_Block_cfgpred_block(bl, i);
1884
1885                         /* ignore dead use blocks, will be removed */
1886                         if (is_Block_dead(use_bl) || get_Block_dom_depth(use_bl) == -1)
1887                                 continue;
1888
1889                         ASSERT_AND_RET_DBG(
1890                                 block_dominates(def_bl, use_bl),
1891                                 "the definition of a value used violates the dominance property", 0,
1892                                 ir_fprintf(stderr,
1893                                 "graph %+F: %+F of %+F must dominate %+F of user %+F input %d\n",
1894                                 current_ir_graph, def_bl, def, use_bl, use, i
1895                                 );
1896                         );
1897                 }
1898         }
1899         return 1;
1900 }
1901
1902 /* Tests the modes of n and its predecessors. */
1903 int irn_verify_irg(ir_node *n, ir_graph *irg)
1904 {
1905         int i;
1906         ir_op *op;
1907
1908         if (!get_node_verification_mode())
1909                 return 1;
1910
1911         /*
1912          * do NOT check placement in interprocedural view, as we don't always
1913          * know the "right" graph ...
1914          */
1915
1916 #ifndef NDEBUG
1917         /* this is an expensive check for large graphs (it has a quadratic
1918          * runtime but with a small constant); so do NOT run it in release mode
1919          */
1920         ASSERT_AND_RET_DBG(
1921                 node_is_in_irgs_storage(irg, n),
1922                 "Node is not stored on proper IR graph!", 0,
1923                 show_node_on_graph(irg, n);
1924         );
1925 #endif
1926         assert(get_irn_irg(n) == irg);
1927         {
1928                 unsigned idx           = get_irn_idx(n);
1929                 ir_node *node_from_map = get_idx_irn(irg, idx);
1930                 ASSERT_AND_RET_DBG(node_from_map == n, "Node index and index map entry differ", 0,
1931                         ir_printf("node %+F node in map %+F(%p)\n", n, node_from_map, node_from_map));
1932         }
1933
1934         op = get_irn_op(n);
1935
1936         /* We don't want to test nodes whose predecessors are Bad,
1937            as we would have to special case that for each operation. */
1938         if (op != op_Phi && op != op_Block) {
1939                 for (i = get_irn_arity(n) - 1; i >= 0; --i) {
1940                         if (is_Bad(get_irn_n(n, i)))
1941                                 return 1;
1942                 }
1943         }
1944
1945         if (_get_op_pinned(op) >= op_pin_state_exc_pinned) {
1946                 op_pin_state state = get_irn_pinned(n);
1947                 ASSERT_AND_RET_DBG(
1948                         state == op_pin_state_floats ||
1949                         state == op_pin_state_pinned,
1950                         "invalid pin state", 0,
1951                         ir_printf("node %+F", n));
1952         }
1953
1954         if (op->ops.verify_node)
1955                 return op->ops.verify_node(n, irg);
1956
1957         /* All went ok */
1958         return 1;
1959 }
1960
1961 int irn_verify(ir_node *n)
1962 {
1963 #ifdef DEBUG_libfirm
1964         return irn_verify_irg(n, current_ir_graph);
1965 #else
1966         (void)n;
1967         return 1;
1968 #endif
1969 }
1970
1971 /*-----------------------------------------------------------------*/
1972 /* Verify the whole graph.                                         */
1973 /*-----------------------------------------------------------------*/
1974
1975 #ifdef DEBUG_libfirm
1976 /**
1977  * Walker to check every node
1978  */
1979 static void verify_wrap(ir_node *node, void *env)
1980 {
1981         int *res = env;
1982         *res = irn_verify_irg(node, current_ir_graph);
1983 }
1984
1985 /**
1986  * Walker to check every node including SSA property.
1987  * Only called if dominance info is available.
1988  */
1989 static void verify_wrap_ssa(ir_node *node, void *env)
1990 {
1991         int *res = env;
1992
1993         *res = irn_verify_irg(node, current_ir_graph);
1994         if (*res) {
1995                 *res = check_dominance_for_node(node);
1996         }
1997 }
1998
1999 #endif /* DEBUG_libfirm */
2000
2001 /*
2002  * Calls irn_verify for each node in irg.
2003  * Graph must be in state "op_pin_state_pinned".
2004  * If dominance info is available, check the SSA property.
2005  */
2006 int irg_verify(ir_graph *irg, unsigned flags)
2007 {
2008         int res = 1;
2009 #ifdef DEBUG_libfirm
2010         ir_graph *rem;
2011
2012         rem = current_ir_graph;
2013         current_ir_graph = irg;
2014
2015 #ifndef NDEBUG
2016     last_irg_error = NULL;
2017 #endif /* NDEBUG */
2018
2019         assert(get_irg_pinned(irg) == op_pin_state_pinned && "Verification need pinned graph");
2020
2021         if (flags & VERIFY_ENFORCE_SSA)
2022                 compute_doms(irg);
2023
2024         irg_walk_anchors(
2025                 irg,
2026                 get_irg_dom_state(irg) == dom_consistent &&
2027                 get_irg_pinned(irg) == op_pin_state_pinned ? verify_wrap_ssa : verify_wrap,
2028                 NULL, &res
2029         );
2030
2031         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT && ! res) {
2032                 ir_entity *ent = get_irg_entity(irg);
2033
2034                 if (ent)
2035                         fprintf(stderr, "irg_verify: Verifying graph %s failed\n", get_entity_name(ent));
2036                 else
2037                         fprintf(stderr, "irg_verify: Verifying graph %p failed\n", (void *)irg);
2038         }
2039
2040         current_ir_graph = rem;
2041 #else
2042         (void)irg;
2043         (void)flags;
2044 #endif /* DEBUG_libfirm */
2045
2046         return res;
2047 }
2048
2049 struct pass_t {
2050         ir_graph_pass_t pass;
2051         unsigned        flags;
2052 };
2053
2054 /**
2055  * Wrapper to irg_verify to be run as an ir_graph pass.
2056  */
2057 static int irg_verify_wrapper(ir_graph *irg, void *context)
2058 {
2059         struct pass_t *pass = context;
2060         irg_verify(irg, pass->flags);
2061         /* do NOT rerun the pass if verify is ok :-) */
2062         return 0;
2063 }
2064
2065 /* Creates an ir_graph pass for irg_verify(). */
2066 ir_graph_pass_t *irg_verify_pass(const char *name, unsigned flags)
2067 {
2068         struct pass_t *pass = XMALLOCZ(struct pass_t);
2069
2070         def_graph_pass_constructor(
2071                 &pass->pass, name ? name : "irg_verify", irg_verify_wrapper);
2072
2073         /* neither dump for verify */
2074         pass->pass.dump_irg   = (DUMP_ON_IRG_FUNC)ir_prog_no_dump;
2075         pass->pass.verify_irg = (RUN_ON_IRG_FUNC)ir_prog_no_verify;
2076
2077         pass->flags = flags;
2078         return &pass->pass;
2079 }
2080
2081 /* create a verify pass */
2082 int irn_verify_irg_dump(ir_node *n, ir_graph *irg, const char **bad_string)
2083 {
2084         int res;
2085         firm_verification_t old = get_node_verification_mode();
2086
2087         firm_verify_failure_msg = NULL;
2088         do_node_verification(FIRM_VERIFICATION_ERROR_ONLY);
2089         res = irn_verify_irg(n, irg);
2090         if (res && get_irg_dom_state(irg) == dom_consistent &&
2091             get_irg_pinned(irg) == op_pin_state_pinned)
2092                 res = check_dominance_for_node(n);
2093         do_node_verification(old);
2094         *bad_string = firm_verify_failure_msg;
2095
2096         return res;
2097 }
2098
2099 typedef struct verify_bad_env_t {
2100         int flags;
2101         int res;
2102 } verify_bad_env_t;
2103
2104 /**
2105  * Pre-Walker: check Bad predecessors of node.
2106  */
2107 static void check_bads(ir_node *node, void *env)
2108 {
2109         verify_bad_env_t *venv = env;
2110         int i, arity = get_irn_arity(node);
2111
2112         if (is_Block(node)) {
2113                 if ((venv->flags & BAD_CF) == 0) {
2114
2115                         /* check for Bad Block predecessor */
2116                         for (i = 0; i < arity; ++i) {
2117                                 ir_node *pred = get_irn_n(node, i);
2118
2119                                 if (is_Bad(pred)) {
2120                                         venv->res |= BAD_CF;
2121
2122                                         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2123                                                 fprintf(stderr, "irg_verify_bads: Block %ld has Bad predecessor\n", get_irn_node_nr(node));
2124                                         }
2125                                         if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2126                                                 dump_ir_graph(current_ir_graph, "-assert");
2127                                                 assert(0 && "Bad CF detected");
2128                                         }
2129                                 }
2130                         }
2131                 }
2132         } else {
2133                 if ((venv->flags & BAD_BLOCK) == 0) {
2134
2135                         /* check for Bad Block */
2136                         if (is_Bad(get_nodes_block(node))) {
2137                                 venv->res |= BAD_BLOCK;
2138
2139                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2140                                         fprintf(stderr, "irg_verify_bads: node %ld has Bad Block\n", get_irn_node_nr(node));
2141                                 }
2142                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2143                                         dump_ir_graph(current_ir_graph, "-assert");
2144                                         assert(0 && "Bad CF detected");
2145                                 }
2146                         }
2147                 }
2148
2149                 if ((venv->flags & TUPLE) == 0) {
2150                         if (is_Tuple(node)) {
2151                                 venv->res |= TUPLE;
2152
2153                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2154                                         fprintf(stderr, "irg_verify_bads: node %ld is a Tuple\n", get_irn_node_nr(node));
2155                                 }
2156                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2157                                         dump_ir_graph(current_ir_graph, "-assert");
2158                                         assert(0 && "Tuple detected");
2159                                 }
2160                         }
2161                 }
2162
2163                 for (i = 0; i < arity; ++i) {
2164                         ir_node *pred = get_irn_n(node, i);
2165
2166                         if (is_Bad(pred)) {
2167                                 /* check for Phi with Bad inputs */
2168                                 if (is_Phi(node) && !is_Bad(get_nodes_block(node)) && is_Bad(get_irn_n(get_nodes_block(node), i))) {
2169                                         if (venv->flags & BAD_CF)
2170                                                 continue;
2171                                         else {
2172                                                 venv->res |= BAD_CF;
2173
2174                                                 if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2175                                                         fprintf(stderr, "irg_verify_bads: Phi %ld has Bad Input\n", get_irn_node_nr(node));
2176                                                 }
2177                                                 if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2178                                                         dump_ir_graph(current_ir_graph, "-assert");
2179                                                         assert(0 && "Bad CF detected");
2180                                                 }
2181                                         }
2182                                 }
2183
2184                                 /* Bad node input */
2185                                 if ((venv->flags & BAD_DF) == 0) {
2186                                         venv->res |= BAD_DF;
2187
2188                                         if (get_node_verification_mode() == FIRM_VERIFICATION_REPORT) {
2189                                                 fprintf(stderr, "irg_verify_bads: node %ld has Bad Input\n", get_irn_node_nr(node));
2190                                         }
2191                                         if (get_node_verification_mode() == FIRM_VERIFICATION_ON) {
2192                                                 dump_ir_graph(current_ir_graph, "-assert");
2193                                                 assert(0 && "Bad NON-CF detected");
2194                                         }
2195                                 }
2196                         }
2197                 }
2198         }
2199 }
2200
2201 /*
2202  * verify occurrence of bad nodes
2203  */
2204 int irg_verify_bads(ir_graph *irg, int flags)
2205 {
2206         verify_bad_env_t env;
2207
2208         env.flags = flags;
2209         env.res   = 0;
2210
2211         irg_walk_graph(irg, check_bads, NULL, &env);
2212
2213         return env.res;
2214 }
2215
2216 /*
2217  * set the default verify operation
2218  */
2219 void firm_set_default_verifyer(ir_opcode code, ir_op_ops *ops)
2220 {
2221 #define CASE(a)                           \
2222    case iro_##a:                          \
2223      ops->verify_node  = verify_node_##a; \
2224      break
2225
2226         switch (code) {
2227         CASE(Proj);
2228         CASE(Block);
2229         CASE(Start);
2230         CASE(Jmp);
2231         CASE(IJmp);
2232         CASE(Cond);
2233         CASE(Return);
2234         CASE(Raise);
2235         CASE(Const);
2236         CASE(SymConst);
2237         CASE(Sel);
2238         CASE(InstOf);
2239         CASE(Call);
2240         CASE(Add);
2241         CASE(Sub);
2242         CASE(Minus);
2243         CASE(Mul);
2244         CASE(Mulh);
2245         CASE(Quot);
2246         CASE(DivMod);
2247         CASE(Div);
2248         CASE(Mod);
2249         CASE(And);
2250         CASE(Or);
2251         CASE(Eor);
2252         CASE(Not);
2253         CASE(Cmp);
2254         CASE(Shl);
2255         CASE(Shr);
2256         CASE(Shrs);
2257         CASE(Rotl);
2258         CASE(Conv);
2259         CASE(Cast);
2260         CASE(Phi);
2261         CASE(Load);
2262         CASE(Store);
2263         CASE(Alloc);
2264         CASE(Free);
2265         CASE(Sync);
2266         CASE(Confirm);
2267         CASE(Mux);
2268         CASE(CopyB);
2269         CASE(Bound);
2270         default:
2271                 /* leave NULL */;
2272         }
2273 #undef CASE
2274
2275 #define CASE(a)                          \
2276    case iro_##a:                         \
2277      ops->verify_proj_node  = verify_node_Proj_##a; \
2278      break
2279
2280         switch (code) {
2281         CASE(Start);
2282         CASE(Cond);
2283         CASE(Raise);
2284         CASE(InstOf);
2285         CASE(Call);
2286         CASE(Quot);
2287         CASE(DivMod);
2288         CASE(Div);
2289         CASE(Mod);
2290         CASE(Cmp);
2291         CASE(Load);
2292         CASE(Store);
2293         CASE(Alloc);
2294         CASE(Proj);
2295         CASE(Tuple);
2296         CASE(CopyB);
2297         CASE(Bound);
2298         default:
2299                 /* leave NULL */;
2300         }
2301 #undef CASE
2302 }