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

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