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