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

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