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