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