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

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