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

   1 /*
   2  * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   Representation of an intermediate operation.
  23  * @author  Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
  24  * @version $Id$
  25  */
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #ifdef HAVE_STRING_H
  31 # include <string.h>
  32 #endif
  33
  34 #include "ident.h"
  35 #include "irnode_t.h"
  36 #include "irgraph_t.h"
  37 #include "irmode_t.h"
  38 #include "typegmod.h"
  39 #include "irbackedge_t.h"
  40 #include "irdump.h"
  41 #include "irop_t.h"
  42 #include "irprog_t.h"
  43 #include "iredgekinds.h"
  44 #include "iredges_t.h"
  45
  46 #include "irhooks.h"
  47 #include "irtools.h"
  48
  49 /* some constants fixing the positions of nodes predecessors
  50    in the in array */
  51 #define CALL_PARAM_OFFSET     2
  52 #define FUNCCALL_PARAM_OFFSET 1
  53 #define SEL_INDEX_OFFSET      2
  54 #define RETURN_RESULT_OFFSET  1  /* mem is not a result */
  55 #define END_KEEPALIVE_OFFSET  0
  56
  57 static const char *pnc_name_arr [] = {
  58         "pn_Cmp_False", "pn_Cmp_Eq", "pn_Cmp_Lt", "pn_Cmp_Le",
  59         "pn_Cmp_Gt", "pn_Cmp_Ge", "pn_Cmp_Lg", "pn_Cmp_Leg",
  60         "pn_Cmp_Uo", "pn_Cmp_Ue", "pn_Cmp_Ul", "pn_Cmp_Ule",
  61         "pn_Cmp_Ug", "pn_Cmp_Uge", "pn_Cmp_Ne", "pn_Cmp_True"
  62 };
  63
  64 /**
  65  * returns the pnc name from an pnc constant
  66  */
  67 const char *get_pnc_string(int pnc) {
  68         return pnc_name_arr[pnc];
  69 }
  70
  71 /*
  72  * Calculates the negated (Complement(R)) pnc condition.
  73  */
  74 int get_negated_pnc(int pnc, ir_mode *mode) {
  75         pnc ^= pn_Cmp_True;
  76
  77         /* do NOT add the Uo bit for non-floating point values */
  78         if (! mode_is_float(mode))
  79                 pnc &= ~pn_Cmp_Uo;
  80
  81         return pnc;
  82 }
  83
  84 /* Calculates the inversed (R^-1) pnc condition, i.e., "<" --> ">" */
  85 int
  86 get_inversed_pnc(int pnc) {
  87         int code    = pnc & ~(pn_Cmp_Lt|pn_Cmp_Gt);
  88         int lesser  = pnc & pn_Cmp_Lt;
  89         int greater = pnc & pn_Cmp_Gt;
  90
  91         code |= (lesser ? pn_Cmp_Gt : 0) | (greater ? pn_Cmp_Lt : 0);
  92
  93         return code;
  94 }
  95
  96 /**
  97  * Indicates, whether additional data can be registered to ir nodes.
  98  * If set to 1, this is not possible anymore.
  99  */
 100 static int forbid_new_data = 0;
 101
 102 /**
 103  * The amount of additional space for custom data to be allocated upon
 104  * creating a new node.
 105  */
 106 unsigned firm_add_node_size = 0;
 107
 108
 109 /* register new space for every node */
 110 unsigned register_additional_node_data(unsigned size) {
 111         assert(!forbid_new_data && "Too late to register additional node data");
 112
 113         if (forbid_new_data)
 114                 return 0;
 115
 116         return firm_add_node_size += size;
 117 }
 118
 119
 120 void
 121 init_irnode(void) {
 122         /* Forbid the addition of new data to an ir node. */
 123         forbid_new_data = 1;
 124 }
 125
 126 /*
 127  * irnode constructor.
 128  * Create a new irnode in irg, with an op, mode, arity and
 129  * some incoming irnodes.
 130  * If arity is negative, a node with a dynamic array is created.
 131  */
 132 ir_node *
 133 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
 134          int arity, ir_node **in)
 135 {
 136         ir_node *res;
 137         size_t node_size = offsetof(ir_node, attr) + op->attr_size + firm_add_node_size;
 138         char *p;
 139         int i;
 140
 141         assert(irg && op && mode);
 142         p = obstack_alloc (irg->obst, node_size);
 143         memset(p, 0, node_size);
 144         res = (ir_node *) (p + firm_add_node_size);
 145
 146         res->kind     = k_ir_node;
 147         res->op       = op;
 148         res->mode     = mode;
 149         res->visited  = 0;
 150         res->node_idx = irg_register_node_idx(irg, res);
 151         res->link     = NULL;
 152         res->deps     = NULL;
 153
 154         if (arity < 0) {
 155                 res->in = NEW_ARR_F (ir_node *, 1);  /* 1: space for block */
 156         } else {
 157                 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
 158                 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
 159         }
 160
 161         res->in[0] = block;
 162         set_irn_dbg_info(res, db);
 163         res->out = NULL;
 164
 165 #ifdef DEBUG_libfirm
 166         res->node_nr = get_irp_new_node_nr();
 167 #endif
 168
 169         for(i = 0; i < EDGE_KIND_LAST; ++i)
 170                 INIT_LIST_HEAD(&res->edge_info[i].outs_head);
 171
 172         // don't put this into the for loop, arity is -1 for some nodes!
 173         edges_notify_edge(res, -1, res->in[0], NULL, irg);
 174         for (i = 1; i <= arity; ++i)
 175                 edges_notify_edge(res, i - 1, res->in[i], NULL, irg);
 176
 177         hook_new_node(irg, res);
 178
 179         return res;
 180 }
 181
 182 /*-- getting some parameters from ir_nodes --*/
 183
 184 int
 185 (is_ir_node)(const void *thing) {
 186         return _is_ir_node(thing);
 187 }
 188
 189 int
 190 (get_irn_intra_arity)(const ir_node *node) {
 191         return _get_irn_intra_arity(node);
 192 }
 193
 194 int
 195 (get_irn_inter_arity)(const ir_node *node) {
 196         return _get_irn_inter_arity(node);
 197 }
 198
 199 int (*_get_irn_arity)(const ir_node *node) = _get_irn_intra_arity;
 200
 201 int
 202 (get_irn_arity)(const ir_node *node) {
 203         return _get_irn_arity(node);
 204 }
 205
 206 /* Returns the array with ins. This array is shifted with respect to the
 207    array accessed by get_irn_n: The block operand is at position 0 not -1.
 208    (@@@ This should be changed.)
 209    The order of the predecessors in this array is not guaranteed, except that
 210    lists of operands as predecessors of Block or arguments of a Call are
 211    consecutive. */
 212 ir_node **
 213 get_irn_in(const ir_node *node) {
 214         assert(node);
 215         if (get_interprocedural_view()) { /* handle Filter and Block specially */
 216                 if (get_irn_opcode(node) == iro_Filter) {
 217                         assert(node->attr.filter.in_cg);
 218                         return node->attr.filter.in_cg;
 219                 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
 220                         return node->attr.block.in_cg;
 221                 }
 222                 /* else fall through */
 223         }
 224         return node->in;
 225 }
 226
 227 void
 228 set_irn_in(ir_node *node, int arity, ir_node **in) {
 229         int i;
 230         ir_node *** arr;
 231         ir_graph *irg = current_ir_graph;
 232         assert(node);
 233         if (get_interprocedural_view()) { /* handle Filter and Block specially */
 234                 if (get_irn_opcode(node) == iro_Filter) {
 235                         assert(node->attr.filter.in_cg);
 236                         arr = &node->attr.filter.in_cg;
 237                 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
 238                         arr = &node->attr.block.in_cg;
 239                 } else {
 240                         arr = &node->in;
 241                 }
 242         } else {
 243                 arr = &node->in;
 244         }
 245
 246         for (i = 0; i < arity; i++) {
 247                 if (i < ARR_LEN(*arr)-1)
 248                         edges_notify_edge(node, i, in[i], (*arr)[i+1], irg);
 249                 else
 250                         edges_notify_edge(node, i, in[i], NULL,        irg);
 251         }
 252         for(;i < ARR_LEN(*arr)-1; i++) {
 253                 edges_notify_edge(node, i, NULL, (*arr)[i+1], irg);
 254         }
 255
 256         if (arity != ARR_LEN(*arr) - 1) {
 257                 ir_node * block = (*arr)[0];
 258                 *arr = NEW_ARR_D(ir_node *, irg->obst, arity + 1);
 259                 (*arr)[0] = block;
 260         }
 261         fix_backedges(irg->obst, node);
 262
 263         memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
 264 }
 265
 266 ir_node *
 267 (get_irn_intra_n)(const ir_node *node, int n) {
 268         return _get_irn_intra_n (node, n);
 269 }
 270
 271 ir_node *
 272 (get_irn_inter_n)(const ir_node *node, int n) {
 273         return _get_irn_inter_n (node, n);
 274 }
 275
 276 ir_node *(*_get_irn_n)(const ir_node *node, int n) = _get_irn_intra_n;
 277
 278 ir_node *
 279 (get_irn_n)(const ir_node *node, int n) {
 280         return _get_irn_n(node, n);
 281 }
 282
 283 void
 284 set_irn_n (ir_node *node, int n, ir_node *in) {
 285         assert(node && node->kind == k_ir_node);
 286         assert(-1 <= n);
 287         assert(n < get_irn_arity(node));
 288         assert(in && in->kind == k_ir_node);
 289
 290         if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
 291                 /* Change block pred in both views! */
 292                 node->in[n + 1] = in;
 293                 assert(node->attr.filter.in_cg);
 294                 node->attr.filter.in_cg[n + 1] = in;
 295                 return;
 296         }
 297         if (get_interprocedural_view()) { /* handle Filter and Block specially */
 298                 if (get_irn_opcode(node) == iro_Filter) {
 299                         assert(node->attr.filter.in_cg);
 300                         node->attr.filter.in_cg[n + 1] = in;
 301                         return;
 302                 } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
 303                         node->attr.block.in_cg[n + 1] = in;
 304                         return;
 305                 }
 306                 /* else fall through */
 307         }
 308
 309         /* Call the hook */
 310         hook_set_irn_n(node, n, in, node->in[n + 1]);
 311
 312         /* Here, we rely on src and tgt being in the current ir graph */
 313         edges_notify_edge(node, n, in, node->in[n + 1], current_ir_graph);
 314
 315         node->in[n + 1] = in;
 316 }
 317
 318 int add_irn_n(ir_node *node, ir_node *in)
 319 {
 320         int pos;
 321         ir_graph *irg = get_irn_irg(node);
 322
 323         assert(node->op->opar == oparity_dynamic);
 324         pos = ARR_LEN(node->in) - 1;
 325         ARR_APP1(ir_node *, node->in, in);
 326         edges_notify_edge(node, pos, node->in[pos + 1], NULL, irg);
 327
 328         /* Call the hook */
 329         hook_set_irn_n(node, pos, node->in[pos + 1], NULL);
 330
 331         return pos;
 332 }
 333
 334 int
 335 (get_irn_deps)(const ir_node *node)
 336 {
 337         return _get_irn_deps(node);
 338 }
 339
 340 ir_node *
 341 (get_irn_dep)(const ir_node *node, int pos)
 342 {
 343         return _get_irn_dep(node, pos);
 344 }
 345
 346 void
 347 (set_irn_dep)(ir_node *node, int pos, ir_node *dep)
 348 {
 349         _set_irn_dep(node, pos, dep);
 350 }
 351
 352 int add_irn_dep(ir_node *node, ir_node *dep)
 353 {
 354         int res = 0;
 355
 356         if (node->deps == NULL) {
 357                 node->deps = NEW_ARR_F(ir_node *, 1);
 358                 node->deps[0] = dep;
 359         } else {
 360                 int i, n;
 361                 int first_zero = -1;
 362
 363                 for(i = 0, n = ARR_LEN(node->deps); i < n; ++i) {
 364                         if(node->deps[i] == NULL)
 365                                 first_zero = i;
 366
 367                         if(node->deps[i] == dep)
 368                                 return i;
 369                 }
 370
 371                 if (first_zero >= 0) {
 372                         node->deps[first_zero] = dep;
 373                         res = first_zero;
 374                 } else {
 375                         ARR_APP1(ir_node *, node->deps, dep);
 376                         res = n;
 377                 }
 378         }
 379
 380         edges_notify_edge_kind(node, res, dep, NULL, EDGE_KIND_DEP, get_irn_irg(node));
 381
 382         return res;
 383 }
 384
 385 void add_irn_deps(ir_node *tgt, ir_node *src)
 386 {
 387         int i, n;
 388
 389         for(i = 0, n = get_irn_deps(src); i < n; ++i)
 390                 add_irn_dep(tgt, get_irn_dep(src, i));
 391 }
 392
 393
 394 ir_mode *
 395 (get_irn_mode)(const ir_node *node) {
 396         return _get_irn_mode(node);
 397 }
 398
 399 void
 400 (set_irn_mode)(ir_node *node, ir_mode *mode) {
 401         _set_irn_mode(node, mode);
 402 }
 403
 404 modecode
 405 get_irn_modecode(const ir_node *node) {
 406         assert(node);
 407         return node->mode->code;
 408 }
 409
 410 /** Gets the string representation of the mode .*/
 411 const char *
 412 get_irn_modename(const ir_node *node) {
 413         assert(node);
 414         return get_mode_name(node->mode);
 415 }
 416
 417 ident *
 418 get_irn_modeident(const ir_node *node) {
 419         assert(node);
 420         return get_mode_ident(node->mode);
 421 }
 422
 423 ir_op *
 424 (get_irn_op)(const ir_node *node) {
 425         return _get_irn_op(node);
 426 }
 427
 428 /* should be private to the library: */
 429 void
 430 (set_irn_op)(ir_node *node, ir_op *op) {
 431         _set_irn_op(node, op);
 432 }
 433
 434 ir_opcode
 435 (get_irn_opcode)(const ir_node *node) {
 436         return _get_irn_opcode(node);
 437 }
 438
 439 const char *
 440 get_irn_opname(const ir_node *node) {
 441         assert(node);
 442         if ((get_irn_op((ir_node *)node) == op_Phi) &&
 443                 (get_irg_phase_state(get_irn_irg((ir_node *)node)) == phase_building) &&
 444                 (get_irn_arity((ir_node *)node) == 0)) return "Phi0";
 445         return get_id_str(node->op->name);
 446 }
 447
 448 ident *
 449 get_irn_opident(const ir_node *node) {
 450         assert(node);
 451         return node->op->name;
 452 }
 453
 454 unsigned long
 455 (get_irn_visited)(const ir_node *node) {
 456         return _get_irn_visited(node);
 457 }
 458
 459 void
 460 (set_irn_visited)(ir_node *node, unsigned long visited) {
 461         _set_irn_visited(node, visited);
 462 }
 463
 464 void
 465 (mark_irn_visited)(ir_node *node) {
 466         _mark_irn_visited(node);
 467 }
 468
 469 int
 470 (irn_not_visited)(const ir_node *node) {
 471         return _irn_not_visited(node);
 472 }
 473
 474 int
 475 (irn_visited)(const ir_node *node) {
 476         return _irn_visited(node);
 477 }
 478
 479 void
 480 (set_irn_link)(ir_node *node, void *link) {
 481         _set_irn_link(node, link);
 482 }
 483
 484 void *
 485 (get_irn_link)(const ir_node *node) {
 486         return _get_irn_link(node);
 487 }
 488
 489 op_pin_state
 490 (get_irn_pinned)(const ir_node *node) {
 491         return _get_irn_pinned(node);
 492 }
 493
 494 op_pin_state
 495 (is_irn_pinned_in_irg) (const ir_node *node) {
 496         return _is_irn_pinned_in_irg(node);
 497 }
 498
 499 void set_irn_pinned(ir_node *node, op_pin_state state) {
 500         /* due to optimization an opt may be turned into a Tuple */
 501         if (get_irn_op(node) == op_Tuple)
 502                 return;
 503
 504         assert(node && get_op_pinned(get_irn_op(node)) >= op_pin_state_exc_pinned);
 505         assert(state == op_pin_state_pinned || state == op_pin_state_floats);
 506
 507         node->attr.except.pin_state = state;
 508 }
 509
 510 #ifdef DO_HEAPANALYSIS
 511 /* Access the abstract interpretation information of a node.
 512    Returns NULL if no such information is available. */
 513 struct abstval *get_irn_abst_value(ir_node *n) {
 514         return n->av;
 515 }
 516 /* Set the abstract interpretation information of a node. */
 517 void set_irn_abst_value(ir_node *n, struct abstval *os) {
 518         n->av = os;
 519 }
 520 struct section *firm_get_irn_section(ir_node *n) {
 521         return n->sec;
 522 }
 523 void firm_set_irn_section(ir_node *n, struct section *s) {
 524         n->sec = s;
 525 }
 526 #else
 527 /* Dummies needed for firmjni. */
 528 struct abstval *get_irn_abst_value(ir_node *n) { return NULL; }
 529 void set_irn_abst_value(ir_node *n, struct abstval *os) {}
 530 struct section *firm_get_irn_section(ir_node *n) { return NULL; }
 531 void firm_set_irn_section(ir_node *n, struct section *s) {}
 532 #endif /* DO_HEAPANALYSIS */
 533
 534
 535 /* Outputs a unique number for this node */
 536 long get_irn_node_nr(const ir_node *node) {
 537         assert(node);
 538 #ifdef DEBUG_libfirm
 539         return node->node_nr;
 540 #else
 541         return (long)PTR_TO_INT(node);
 542 #endif
 543 }
 544
 545 const_attr
 546 get_irn_const_attr(ir_node *node) {
 547         assert(node->op == op_Const);
 548         return node->attr.con;
 549 }
 550
 551 long
 552 get_irn_proj_attr(ir_node *node) {
 553         assert(node->op == op_Proj);
 554         return node->attr.proj;
 555 }
 556
 557 alloc_attr
 558 get_irn_alloc_attr(ir_node *node) {
 559         assert(node->op == op_Alloc);
 560         return node->attr.alloc;
 561 }
 562
 563 free_attr
 564 get_irn_free_attr(ir_node *node) {
 565         assert(node->op == op_Free);
 566         return node->attr.free;
 567 }
 568
 569 symconst_attr
 570 get_irn_symconst_attr(ir_node *node) {
 571         assert(node->op == op_SymConst);
 572         return node->attr.symc;
 573 }
 574
 575 ir_type *
 576 get_irn_call_attr(ir_node *node) {
 577         assert(node->op == op_Call);
 578         return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 579 }
 580
 581 sel_attr
 582 get_irn_sel_attr(ir_node *node) {
 583         assert(node->op == op_Sel);
 584         return node->attr.sel;
 585 }
 586
 587 int
 588 get_irn_phi_attr(ir_node *node) {
 589         assert(node->op == op_Phi);
 590         return node->attr.phi0_pos;
 591 }
 592
 593 block_attr
 594 get_irn_block_attr(ir_node *node) {
 595         assert(node->op == op_Block);
 596         return node->attr.block;
 597 }
 598
 599 load_attr
 600 get_irn_load_attr(ir_node *node)
 601 {
 602   assert(node->op == op_Load);
 603   return node->attr.load;
 604 }
 605
 606 store_attr
 607 get_irn_store_attr(ir_node *node)
 608 {
 609   assert(node->op == op_Store);
 610   return node->attr.store;
 611 }
 612
 613 except_attr
 614 get_irn_except_attr(ir_node *node) {
 615         assert(node->op == op_Div || node->op == op_Quot ||
 616                node->op == op_DivMod || node->op == op_Mod || node->op == op_Call || node->op == op_Alloc);
 617         return node->attr.except;
 618 }
 619
 620 void *
 621 get_irn_generic_attr(ir_node *node) {
 622         return &node->attr;
 623 }
 624
 625 unsigned (get_irn_idx)(const ir_node *node) {
 626         assert(is_ir_node(node));
 627         return _get_irn_idx(node);
 628 }
 629
 630 int get_irn_pred_pos(ir_node *node, ir_node *arg) {
 631         int i;
 632         for (i = get_irn_arity(node) - 1; i >= 0; i--) {
 633                 if (get_irn_n(node, i) == arg)
 634                         return i;
 635         }
 636         return -1;
 637 }
 638
 639 /** manipulate fields of individual nodes **/
 640
 641 /* this works for all except Block */
 642 ir_node *
 643 get_nodes_block(const ir_node *node) {
 644         assert(node->op != op_Block);
 645         assert(is_irn_pinned_in_irg(node) && "block info may be incorrect");
 646         return get_irn_n(node, -1);
 647 }
 648
 649 void
 650 set_nodes_block(ir_node *node, ir_node *block) {
 651         assert(node->op != op_Block);
 652         set_irn_n(node, -1, block);
 653 }
 654
 655 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
 656  * from Start.  If so returns frame type, else Null. */
 657 ir_type *is_frame_pointer(ir_node *n) {
 658         if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_frame_base)) {
 659                 ir_node *start = get_Proj_pred(n);
 660                 if (get_irn_op(start) == op_Start) {
 661                         return get_irg_frame_type(get_irn_irg(start));
 662                 }
 663         }
 664         return NULL;
 665 }
 666
 667 /* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
 668  * from Start.  If so returns global type, else Null. */
 669 ir_type *is_globals_pointer(ir_node *n) {
 670         if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
 671                 ir_node *start = get_Proj_pred(n);
 672                 if (get_irn_op(start) == op_Start) {
 673                         return get_glob_type();
 674                 }
 675         }
 676         return NULL;
 677 }
 678
 679 /* Test whether arbitrary node is tls pointer, i.e. Proj(pn_Start_P_tls)
 680  * from Start.  If so returns tls type, else Null. */
 681 ir_type *is_tls_pointer(ir_node *n) {
 682         if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
 683                 ir_node *start = get_Proj_pred(n);
 684                 if (get_irn_op(start) == op_Start) {
 685                         return get_tls_type();
 686                 }
 687         }
 688         return NULL;
 689 }
 690
 691 /* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
 692  * from Start.  If so returns 1, else 0. */
 693 int is_value_arg_pointer(ir_node *n) {
 694         if ((get_irn_op(n) == op_Proj) &&
 695                 (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
 696                 (get_irn_op(get_Proj_pred(n)) == op_Start))
 697                 return 1;
 698         return 0;
 699 }
 700
 701 /* Returns an array with the predecessors of the Block. Depending on
 702    the implementation of the graph data structure this can be a copy of
 703    the internal representation of predecessors as well as the internal
 704    array itself. Therefore writing to this array might obstruct the ir. */
 705 ir_node **
 706 get_Block_cfgpred_arr(ir_node *node) {
 707         assert((node->op == op_Block));
 708         return (ir_node **)&(get_irn_in(node)[1]);
 709 }
 710
 711 int
 712 (get_Block_n_cfgpreds)(const ir_node *node) {
 713         return _get_Block_n_cfgpreds(node);
 714 }
 715
 716 ir_node *
 717 (get_Block_cfgpred)(ir_node *node, int pos) {
 718         return _get_Block_cfgpred(node, pos);
 719 }
 720
 721 void
 722 set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
 723         assert(node->op == op_Block);
 724         set_irn_n(node, pos, pred);
 725 }
 726
 727 ir_node  *
 728 (get_Block_cfgpred_block)(ir_node *node, int pos) {
 729         return _get_Block_cfgpred_block(node, pos);
 730 }
 731
 732 int
 733 get_Block_matured(ir_node *node) {
 734         assert(node->op == op_Block);
 735         return (int)node->attr.block.matured;
 736 }
 737
 738 void
 739 set_Block_matured(ir_node *node, int matured) {
 740         assert(node->op == op_Block);
 741         node->attr.block.matured = matured;
 742 }
 743
 744 unsigned long
 745 (get_Block_block_visited)(const ir_node *node) {
 746         return _get_Block_block_visited(node);
 747 }
 748
 749 void
 750 (set_Block_block_visited)(ir_node *node, unsigned long visit) {
 751         _set_Block_block_visited(node, visit);
 752 }
 753
 754 /* For this current_ir_graph must be set. */
 755 void
 756 (mark_Block_block_visited)(ir_node *node) {
 757         _mark_Block_block_visited(node);
 758 }
 759
 760 int
 761 (Block_not_block_visited)(const ir_node *node) {
 762         return _Block_not_block_visited(node);
 763 }
 764
 765 int
 766 (Block_block_visited)(const ir_node *node) {
 767         return _Block_block_visited(node);
 768 }
 769
 770 ir_node *
 771 get_Block_graph_arr (ir_node *node, int pos) {
 772         assert(node->op == op_Block);
 773         return node->attr.block.graph_arr[pos+1];
 774 }
 775
 776 void
 777 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
 778         assert(node->op == op_Block);
 779         node->attr.block.graph_arr[pos+1] = value;
 780 }
 781
 782 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
 783         assert(node->op == op_Block);
 784         if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
 785                 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
 786                 node->attr.block.in_cg[0] = NULL;
 787                 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
 788                 {
 789                         /* Fix backedge array.  fix_backedges() operates depending on
 790                            interprocedural_view. */
 791                         int ipv = get_interprocedural_view();
 792                         set_interprocedural_view(1);
 793                         fix_backedges(current_ir_graph->obst, node);
 794                         set_interprocedural_view(ipv);
 795                 }
 796         }
 797         memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
 798 }
 799
 800 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
 801         assert(node->op == op_Block &&
 802                node->attr.block.in_cg &&
 803                0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
 804         node->attr.block.in_cg[pos + 1] = pred;
 805 }
 806
 807 ir_node **get_Block_cg_cfgpred_arr(ir_node * node) {
 808         assert(node->op == op_Block);
 809         return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg  + 1;
 810 }
 811
 812 int get_Block_cg_n_cfgpreds(ir_node * node) {
 813         assert(node->op == op_Block);
 814         return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
 815 }
 816
 817 ir_node *get_Block_cg_cfgpred(ir_node * node, int pos) {
 818         assert(node->op == op_Block && node->attr.block.in_cg);
 819         return node->attr.block.in_cg[pos + 1];
 820 }
 821
 822 void remove_Block_cg_cfgpred_arr(ir_node * node) {
 823         assert(node->op == op_Block);
 824         node->attr.block.in_cg = NULL;
 825 }
 826
 827 ir_node *(set_Block_dead)(ir_node *block) {
 828         return _set_Block_dead(block);
 829 }
 830
 831 int (is_Block_dead)(const ir_node *block) {
 832         return _is_Block_dead(block);
 833 }
 834
 835 ir_extblk *get_Block_extbb(const ir_node *block) {
 836         ir_extblk *res;
 837         assert(is_Block(block));
 838         res = block->attr.block.extblk;
 839         assert(res == NULL || is_ir_extbb(res));
 840         return res;
 841 }
 842
 843 void set_Block_extbb(ir_node *block, ir_extblk *extblk) {
 844         assert(is_Block(block));
 845         assert(extblk == NULL || is_ir_extbb(extblk));
 846         block->attr.block.extblk = extblk;
 847 }
 848
 849 int
 850 get_End_n_keepalives(ir_node *end) {
 851         assert(end->op == op_End);
 852         return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
 853 }
 854
 855 ir_node *
 856 get_End_keepalive(ir_node *end, int pos) {
 857         assert(end->op == op_End);
 858         return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
 859 }
 860
 861 void
 862 add_End_keepalive (ir_node *end, ir_node *ka) {
 863         assert(end->op == op_End);
 864         add_irn_n(end, ka);
 865 }
 866
 867 void
 868 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
 869         assert(end->op == op_End);
 870         set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 871 }
 872
 873 /* Set new keep-alives */
 874 void set_End_keepalives(ir_node *end, int n, ir_node *in[]) {
 875         int i;
 876         ir_graph *irg = get_irn_irg(end);
 877
 878         /* notify that edges are deleted */
 879         for (i = END_KEEPALIVE_OFFSET; i < ARR_LEN(end->in) - 1; ++i) {
 880                 edges_notify_edge(end, i, NULL, end->in[i + 1], irg);
 881         }
 882         ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET);
 883
 884         for (i = 0; i < n; ++i) {
 885                 end->in[1 + END_KEEPALIVE_OFFSET + i] = in[i];
 886                 edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, end->in[1 + END_KEEPALIVE_OFFSET + i], NULL, irg);
 887         }
 888 }
 889
 890 /* Set new keep-alives from old keep-alives, skipping irn */
 891 void remove_End_keepalive(ir_node *end, ir_node *irn) {
 892         int     n = get_End_n_keepalives(end);
 893         ir_node **in;
 894         int     i, idx;
 895
 896         NEW_ARR_A(ir_node *, in, n);
 897
 898         for (idx = i = 0; i < n; ++i) {
 899                 ir_node *old_ka = get_End_keepalive(end, i);
 900
 901                 /* skip irn */
 902                 if (old_ka != irn)
 903                         in[idx++] = old_ka;
 904         }
 905
 906         /* set new keep-alives */
 907         set_End_keepalives(end, idx, in);
 908 }
 909
 910 void
 911 free_End (ir_node *end) {
 912         assert(end->op == op_End);
 913         end->kind = k_BAD;
 914         DEL_ARR_F(end->in);
 915         end->in = NULL;   /* @@@ make sure we get an error if we use the
 916                              in array afterwards ... */
 917 }
 918
 919 /* Return the target address of an IJmp */
 920 ir_node *get_IJmp_target(ir_node *ijmp) {
 921         assert(ijmp->op == op_IJmp);
 922         return get_irn_n(ijmp, 0);
 923 }
 924
 925 /** Sets the target address of an IJmp */
 926 void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
 927         assert(ijmp->op == op_IJmp);
 928         set_irn_n(ijmp, 0, tgt);
 929 }
 930
 931 /*
 932 > Implementing the case construct (which is where the constant Proj node is
 933 > important) involves far more than simply determining the constant values.
 934 > We could argue that this is more properly a function of the translator from
 935 > Firm to the target machine.  That could be done if there was some way of
 936 > projecting "default" out of the Cond node.
 937 I know it's complicated.
 938 Basically there are two proglems:
 939  - determining the gaps between the projs
 940  - determining the biggest case constant to know the proj number for
 941    the default node.
 942 I see several solutions:
 943 1. Introduce a ProjDefault node.  Solves both problems.
 944    This means to extend all optimizations executed during construction.
 945 2. Give the Cond node for switch two flavors:
 946    a) there are no gaps in the projs  (existing flavor)
 947    b) gaps may exist, default proj is still the Proj with the largest
 948       projection number.  This covers also the gaps.
 949 3. Fix the semantic of the Cond to that of 2b)
 950
 951 Solution 2 seems to be the best:
 952 Computing the gaps in the Firm representation is not too hard, i.e.,
 953 libFIRM can implement a routine that transforms between the two
 954 flavours.  This is also possible for 1) but 2) does not require to
 955 change any existing optimization.
 956 Further it should be far simpler to determine the biggest constant than
 957 to compute all gaps.
 958 I don't want to choose 3) as 2a) seems to have advantages for
 959 dataflow analysis and 3) does not allow to convert the representation to
 960 2a).
 961 */
 962 ir_node *
 963 get_Cond_selector(ir_node *node) {
 964         assert(node->op == op_Cond);
 965         return get_irn_n(node, 0);
 966 }
 967
 968 void
 969 set_Cond_selector(ir_node *node, ir_node *selector) {
 970         assert(node->op == op_Cond);
 971         set_irn_n(node, 0, selector);
 972 }
 973
 974 cond_kind
 975 get_Cond_kind(ir_node *node) {
 976         assert(node->op == op_Cond);
 977         return node->attr.cond.kind;
 978 }
 979
 980 void
 981 set_Cond_kind(ir_node *node, cond_kind kind) {
 982         assert(node->op == op_Cond);
 983         node->attr.cond.kind = kind;
 984 }
 985
 986 long
 987 get_Cond_defaultProj(ir_node *node) {
 988         assert(node->op == op_Cond);
 989         return node->attr.cond.default_proj;
 990 }
 991
 992 ir_node *
 993 get_Return_mem(ir_node *node) {
 994         assert(node->op == op_Return);
 995         return get_irn_n(node, 0);
 996 }
 997
 998 void
 999 set_Return_mem(ir_node *node, ir_node *mem) {
1000         assert(node->op == op_Return);
1001         set_irn_n(node, 0, mem);
1002 }
1003
1004 int
1005 get_Return_n_ress(ir_node *node) {
1006         assert(node->op == op_Return);
1007         return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
1008 }
1009
1010 ir_node **
1011 get_Return_res_arr (ir_node *node) {
1012         assert((node->op == op_Return));
1013         if (get_Return_n_ress(node) > 0)
1014                 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
1015         else
1016                 return NULL;
1017 }
1018
1019 /*
1020 void
1021 set_Return_n_res(ir_node *node, int results) {
1022         assert(node->op == op_Return);
1023 }
1024 */
1025
1026 ir_node *
1027 get_Return_res(ir_node *node, int pos) {
1028         assert(node->op == op_Return);
1029         assert(get_Return_n_ress(node) > pos);
1030         return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
1031 }
1032
1033 void
1034 set_Return_res(ir_node *node, int pos, ir_node *res){
1035         assert(node->op == op_Return);
1036         set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
1037 }
1038
1039 tarval *(get_Const_tarval)(ir_node *node) {
1040         return _get_Const_tarval(node);
1041 }
1042
1043 void
1044 set_Const_tarval(ir_node *node, tarval *con) {
1045         assert(node->op == op_Const);
1046         node->attr.con.tv = con;
1047 }
1048
1049 cnst_classify_t (classify_Const)(ir_node *node) {
1050         return _classify_Const(node);
1051 }
1052
1053
1054 /* The source language type.  Must be an atomic type.  Mode of type must
1055    be mode of node. For tarvals from entities type must be pointer to
1056    entity type. */
1057 ir_type *
1058 get_Const_type(ir_node *node) {
1059         assert(node->op == op_Const);
1060         return node->attr.con.tp;
1061 }
1062
1063 void
1064 set_Const_type(ir_node *node, ir_type *tp) {
1065         assert(node->op == op_Const);
1066         if (tp != firm_unknown_type) {
1067                 assert(is_atomic_type(tp));
1068                 assert(get_type_mode(tp) == get_irn_mode(node));
1069         }
1070         node->attr.con.tp = tp;
1071 }
1072
1073
1074 symconst_kind
1075 get_SymConst_kind(const ir_node *node) {
1076         assert(node->op == op_SymConst);
1077         return node->attr.symc.num;
1078 }
1079
1080 void
1081 set_SymConst_kind(ir_node *node, symconst_kind num) {
1082         assert(node->op == op_SymConst);
1083         node->attr.symc.num = num;
1084 }
1085
1086 ir_type *
1087 get_SymConst_type(ir_node *node) {
1088         assert((node->op == op_SymConst) &&
1089                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1090         return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p);
1091 }
1092
1093 void
1094 set_SymConst_type(ir_node *node, ir_type *tp) {
1095         assert((node->op == op_SymConst) &&
1096                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1097         node->attr.symc.sym.type_p = tp;
1098 }
1099
1100 ident *
1101 get_SymConst_name(ir_node *node) {
1102         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1103         return node->attr.symc.sym.ident_p;
1104 }
1105
1106 void
1107 set_SymConst_name(ir_node *node, ident *name) {
1108         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1109         node->attr.symc.sym.ident_p = name;
1110 }
1111
1112
1113 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
1114 ir_entity *get_SymConst_entity(ir_node *node) {
1115         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1116         return node->attr.symc.sym.entity_p;
1117 }
1118
1119 void set_SymConst_entity(ir_node *node, ir_entity *ent) {
1120         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1121         node->attr.symc.sym.entity_p  = ent;
1122 }
1123
1124 ir_enum_const *get_SymConst_enum(ir_node *node) {
1125         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1126         return node->attr.symc.sym.enum_p;
1127 }
1128
1129 void set_SymConst_enum(ir_node *node, ir_enum_const *ec) {
1130         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1131         node->attr.symc.sym.enum_p  = ec;
1132 }
1133
1134 union symconst_symbol
1135 get_SymConst_symbol(ir_node *node) {
1136         assert(node->op == op_SymConst);
1137         return node->attr.symc.sym;
1138 }
1139
1140 void
1141 set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
1142         assert(node->op == op_SymConst);
1143         node->attr.symc.sym = sym;
1144 }
1145
1146 ir_type *
1147 get_SymConst_value_type(ir_node *node) {
1148         assert(node->op == op_SymConst);
1149         if (node->attr.symc.tp) node->attr.symc.tp = skip_tid(node->attr.symc.tp);
1150         return node->attr.symc.tp;
1151 }
1152
1153 void
1154 set_SymConst_value_type(ir_node *node, ir_type *tp) {
1155         assert(node->op == op_SymConst);
1156         node->attr.symc.tp = tp;
1157 }
1158
1159 ir_node *
1160 get_Sel_mem(ir_node *node) {
1161         assert(node->op == op_Sel);
1162         return get_irn_n(node, 0);
1163 }
1164
1165 void
1166 set_Sel_mem(ir_node *node, ir_node *mem) {
1167         assert(node->op == op_Sel);
1168         set_irn_n(node, 0, mem);
1169 }
1170
1171 ir_node *
1172 get_Sel_ptr(ir_node *node) {
1173         assert(node->op == op_Sel);
1174         return get_irn_n(node, 1);
1175 }
1176
1177 void
1178 set_Sel_ptr(ir_node *node, ir_node *ptr) {
1179         assert(node->op == op_Sel);
1180         set_irn_n(node, 1, ptr);
1181 }
1182
1183 int
1184 get_Sel_n_indexs(ir_node *node) {
1185         assert(node->op == op_Sel);
1186         return (get_irn_arity(node) - SEL_INDEX_OFFSET);
1187 }
1188
1189 ir_node **
1190 get_Sel_index_arr(ir_node *node) {
1191         assert((node->op == op_Sel));
1192         if (get_Sel_n_indexs(node) > 0)
1193                 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
1194         else
1195                 return NULL;
1196 }
1197
1198 ir_node *
1199 get_Sel_index(ir_node *node, int pos) {
1200         assert(node->op == op_Sel);
1201         return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1202 }
1203
1204 void
1205 set_Sel_index(ir_node *node, int pos, ir_node *index) {
1206         assert(node->op == op_Sel);
1207         set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1208 }
1209
1210 ir_entity *
1211 get_Sel_entity(ir_node *node) {
1212         assert(node->op == op_Sel);
1213         return node->attr.sel.ent;
1214 }
1215
1216 void
1217 set_Sel_entity(ir_node *node, ir_entity *ent) {
1218         assert(node->op == op_Sel);
1219         node->attr.sel.ent = ent;
1220 }
1221
1222
1223 /* For unary and binary arithmetic operations the access to the
1224    operands can be factored out.  Left is the first, right the
1225    second arithmetic value  as listed in tech report 0999-33.
1226    unops are: Minus, Abs, Not, Conv, Cast
1227    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1228    Shr, Shrs, Rotate, Cmp */
1229
1230
1231 ir_node *
1232 get_Call_mem(ir_node *node) {
1233         assert(node->op == op_Call);
1234         return get_irn_n(node, 0);
1235 }
1236
1237 void
1238 set_Call_mem(ir_node *node, ir_node *mem) {
1239         assert(node->op == op_Call);
1240         set_irn_n(node, 0, mem);
1241 }
1242
1243 ir_node *
1244 get_Call_ptr(ir_node *node) {
1245         assert(node->op == op_Call);
1246         return get_irn_n(node, 1);
1247 }
1248
1249 void
1250 set_Call_ptr(ir_node *node, ir_node *ptr) {
1251         assert(node->op == op_Call);
1252         set_irn_n(node, 1, ptr);
1253 }
1254
1255 ir_node **
1256 get_Call_param_arr(ir_node *node) {
1257         assert(node->op == op_Call);
1258         return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1259 }
1260
1261 int
1262 get_Call_n_params(ir_node *node)  {
1263         assert(node->op == op_Call);
1264         return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1265 }
1266
1267 int
1268 get_Call_arity(ir_node *node) {
1269         assert(node->op == op_Call);
1270         return get_Call_n_params(node);
1271 }
1272
1273 /* void
1274 set_Call_arity(ir_node *node, ir_node *arity) {
1275         assert(node->op == op_Call);
1276 }
1277 */
1278
1279 ir_node *
1280 get_Call_param(ir_node *node, int pos) {
1281         assert(node->op == op_Call);
1282         return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1283 }
1284
1285 void
1286 set_Call_param(ir_node *node, int pos, ir_node *param) {
1287         assert(node->op == op_Call);
1288         set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1289 }
1290
1291 ir_type *
1292 get_Call_type(ir_node *node) {
1293         assert(node->op == op_Call);
1294         return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1295 }
1296
1297 void
1298 set_Call_type(ir_node *node, ir_type *tp) {
1299         assert(node->op == op_Call);
1300         assert((get_unknown_type() == tp) || is_Method_type(tp));
1301         node->attr.call.cld_tp = tp;
1302 }
1303
1304 int Call_has_callees(ir_node *node) {
1305         assert(node && node->op == op_Call);
1306         return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1307                 (node->attr.call.callee_arr != NULL));
1308 }
1309
1310 int get_Call_n_callees(ir_node * node) {
1311   assert(node && node->op == op_Call && node->attr.call.callee_arr);
1312   return ARR_LEN(node->attr.call.callee_arr);
1313 }
1314
1315 ir_entity * get_Call_callee(ir_node * node, int pos) {
1316         assert(pos >= 0 && pos < get_Call_n_callees(node));
1317         return node->attr.call.callee_arr[pos];
1318 }
1319
1320 void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
1321         assert(node->op == op_Call);
1322         if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1323                 node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
1324         }
1325         memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
1326 }
1327
1328 void remove_Call_callee_arr(ir_node * node) {
1329         assert(node->op == op_Call);
1330         node->attr.call.callee_arr = NULL;
1331 }
1332
1333 ir_node * get_CallBegin_ptr(ir_node *node) {
1334         assert(node->op == op_CallBegin);
1335         return get_irn_n(node, 0);
1336 }
1337
1338 void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
1339         assert(node->op == op_CallBegin);
1340         set_irn_n(node, 0, ptr);
1341 }
1342
1343 ir_node * get_CallBegin_call(ir_node *node) {
1344         assert(node->op == op_CallBegin);
1345         return node->attr.callbegin.call;
1346 }
1347
1348 void  set_CallBegin_call(ir_node *node, ir_node *call) {
1349         assert(node->op == op_CallBegin);
1350         node->attr.callbegin.call = call;
1351 }
1352
1353
1354 #define BINOP(OP)                                      \
1355 ir_node * get_##OP##_left(ir_node *node) {             \
1356   assert(node->op == op_##OP);                         \
1357   return get_irn_n(node, node->op->op_index);          \
1358 }                                                      \
1359 void set_##OP##_left(ir_node *node, ir_node *left) {   \
1360   assert(node->op == op_##OP);                         \
1361   set_irn_n(node, node->op->op_index, left);           \
1362 }                                                      \
1363 ir_node *get_##OP##_right(ir_node *node) {             \
1364   assert(node->op == op_##OP);                         \
1365   return get_irn_n(node, node->op->op_index + 1);      \
1366 }                                                      \
1367 void set_##OP##_right(ir_node *node, ir_node *right) { \
1368   assert(node->op == op_##OP);                         \
1369   set_irn_n(node, node->op->op_index + 1, right);      \
1370 }
1371
1372 #define UNOP(OP)                                  \
1373 ir_node *get_##OP##_op(ir_node *node) {           \
1374   assert(node->op == op_##OP);                    \
1375   return get_irn_n(node, node->op->op_index);     \
1376 }                                                 \
1377 void set_##OP##_op (ir_node *node, ir_node *op) { \
1378   assert(node->op == op_##OP);                    \
1379   set_irn_n(node, node->op->op_index, op);        \
1380 }
1381
1382 #define BINOP_MEM(OP)                         \
1383 BINOP(OP)                                     \
1384                                               \
1385 ir_node *                                     \
1386 get_##OP##_mem(ir_node *node) {               \
1387   assert(node->op == op_##OP);                \
1388   return get_irn_n(node, 0);                  \
1389 }                                             \
1390                                               \
1391 void                                          \
1392 set_##OP##_mem(ir_node *node, ir_node *mem) { \
1393   assert(node->op == op_##OP);                \
1394   set_irn_n(node, 0, mem);                    \
1395 }
1396
1397 BINOP(Add)
1398 BINOP(Sub)
1399 UNOP(Minus)
1400 BINOP(Mul)
1401 BINOP_MEM(Quot)
1402 BINOP_MEM(DivMod)
1403 BINOP_MEM(Div)
1404 BINOP_MEM(Mod)
1405 UNOP(Abs)
1406 BINOP(And)
1407 BINOP(Or)
1408 BINOP(Eor)
1409 UNOP(Not)
1410 BINOP(Shl)
1411 BINOP(Shr)
1412 BINOP(Shrs)
1413 BINOP(Rot)
1414 BINOP(Cmp)
1415 UNOP(Conv)
1416 UNOP(Cast)
1417
1418 int get_Conv_strict(ir_node *node) {
1419         assert(node->op == op_Conv);
1420         return node->attr.conv.strict;
1421 }
1422
1423 void set_Conv_strict(ir_node *node, int strict_flag) {
1424         assert(node->op == op_Conv);
1425         node->attr.conv.strict = (char)strict_flag;
1426 }
1427
1428 ir_type *
1429 get_Cast_type(ir_node *node) {
1430         assert(node->op == op_Cast);
1431         return node->attr.cast.totype;
1432 }
1433
1434 void
1435 set_Cast_type(ir_node *node, ir_type *to_tp) {
1436         assert(node->op == op_Cast);
1437         node->attr.cast.totype = to_tp;
1438 }
1439
1440
1441 /* Checks for upcast.
1442  *
1443  * Returns true if the Cast node casts a class type to a super type.
1444  */
1445 int is_Cast_upcast(ir_node *node) {
1446         ir_type *totype   = get_Cast_type(node);
1447         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1448         ir_graph *myirg = get_irn_irg(node);
1449
1450         assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
1451         assert(fromtype);
1452
1453         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1454                 totype   = get_pointer_points_to_type(totype);
1455                 fromtype = get_pointer_points_to_type(fromtype);
1456         }
1457
1458         assert(fromtype);
1459
1460         if (!is_Class_type(totype)) return 0;
1461         return is_SubClass_of(fromtype, totype);
1462 }
1463
1464 /* Checks for downcast.
1465  *
1466  * Returns true if the Cast node casts a class type to a sub type.
1467  */
1468 int is_Cast_downcast(ir_node *node) {
1469         ir_type *totype   = get_Cast_type(node);
1470         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1471
1472         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1473         assert(fromtype);
1474
1475         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1476                 totype   = get_pointer_points_to_type(totype);
1477                 fromtype = get_pointer_points_to_type(fromtype);
1478         }
1479
1480         assert(fromtype);
1481
1482         if (!is_Class_type(totype)) return 0;
1483         return is_SubClass_of(totype, fromtype);
1484 }
1485
1486 int
1487 (is_unop)(const ir_node *node) {
1488         return _is_unop(node);
1489 }
1490
1491 ir_node *
1492 get_unop_op(ir_node *node) {
1493         if (node->op->opar == oparity_unary)
1494                 return get_irn_n(node, node->op->op_index);
1495
1496         assert(node->op->opar == oparity_unary);
1497         return NULL;
1498 }
1499
1500 void
1501 set_unop_op(ir_node *node, ir_node *op) {
1502         if (node->op->opar == oparity_unary)
1503                 set_irn_n(node, node->op->op_index, op);
1504
1505         assert(node->op->opar == oparity_unary);
1506 }
1507
1508 int
1509 (is_binop)(const ir_node *node) {
1510         return _is_binop(node);
1511 }
1512
1513 ir_node *
1514 get_binop_left(ir_node *node) {
1515         assert(node->op->opar == oparity_binary);
1516         return get_irn_n(node, node->op->op_index);
1517 }
1518
1519 void
1520 set_binop_left(ir_node *node, ir_node *left) {
1521         assert(node->op->opar == oparity_binary);
1522         set_irn_n(node, node->op->op_index, left);
1523 }
1524
1525 ir_node *
1526 get_binop_right(ir_node *node) {
1527         assert(node->op->opar == oparity_binary);
1528         return get_irn_n(node, node->op->op_index + 1);
1529 }
1530
1531 void
1532 set_binop_right(ir_node *node, ir_node *right) {
1533         assert(node->op->opar == oparity_binary);
1534         set_irn_n(node, node->op->op_index + 1, right);
1535 }
1536
1537 int is_Phi(const ir_node *n) {
1538         ir_op *op;
1539
1540         assert(n);
1541         op = get_irn_op(n);
1542
1543         if (op == op_Filter) return get_interprocedural_view();
1544
1545         if (op == op_Phi)
1546                 return ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
1547                         (get_irn_arity(n) > 0));
1548
1549         return 0;
1550 }
1551
1552 int is_Phi0(const ir_node *n) {
1553         assert(n);
1554
1555         return ((get_irn_op(n) == op_Phi) &&
1556                 (get_irn_arity(n) == 0) &&
1557                 (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1558 }
1559
1560 ir_node **
1561 get_Phi_preds_arr(ir_node *node) {
1562   assert(node->op == op_Phi);
1563   return (ir_node **)&(get_irn_in(node)[1]);
1564 }
1565
1566 int
1567 get_Phi_n_preds(ir_node *node) {
1568         assert(is_Phi(node) || is_Phi0(node));
1569         return (get_irn_arity(node));
1570 }
1571
1572 /*
1573 void set_Phi_n_preds(ir_node *node, int n_preds) {
1574         assert(node->op == op_Phi);
1575 }
1576 */
1577
1578 ir_node *
1579 get_Phi_pred(ir_node *node, int pos) {
1580         assert(is_Phi(node) || is_Phi0(node));
1581         return get_irn_n(node, pos);
1582 }
1583
1584 void
1585 set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
1586         assert(is_Phi(node) || is_Phi0(node));
1587         set_irn_n(node, pos, pred);
1588 }
1589
1590
1591 int is_memop(ir_node *node) {
1592         return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
1593 }
1594
1595 ir_node *get_memop_mem(ir_node *node) {
1596         assert(is_memop(node));
1597         return get_irn_n(node, 0);
1598 }
1599
1600 void set_memop_mem(ir_node *node, ir_node *mem) {
1601         assert(is_memop(node));
1602         set_irn_n(node, 0, mem);
1603 }
1604
1605 ir_node *get_memop_ptr(ir_node *node) {
1606         assert(is_memop(node));
1607         return get_irn_n(node, 1);
1608 }
1609
1610 void set_memop_ptr(ir_node *node, ir_node *ptr) {
1611         assert(is_memop(node));
1612         set_irn_n(node, 1, ptr);
1613 }
1614
1615 ir_node *
1616 get_Load_mem(ir_node *node) {
1617         assert(node->op == op_Load);
1618         return get_irn_n(node, 0);
1619 }
1620
1621 void
1622 set_Load_mem(ir_node *node, ir_node *mem) {
1623         assert(node->op == op_Load);
1624         set_irn_n(node, 0, mem);
1625 }
1626
1627 ir_node *
1628 get_Load_ptr(ir_node *node) {
1629         assert(node->op == op_Load);
1630         return get_irn_n(node, 1);
1631 }
1632
1633 void
1634 set_Load_ptr(ir_node *node, ir_node *ptr) {
1635         assert(node->op == op_Load);
1636         set_irn_n(node, 1, ptr);
1637 }
1638
1639 ir_mode *
1640 get_Load_mode(ir_node *node) {
1641         assert(node->op == op_Load);
1642         return node->attr.load.load_mode;
1643 }
1644
1645 void
1646 set_Load_mode(ir_node *node, ir_mode *mode) {
1647         assert(node->op == op_Load);
1648         node->attr.load.load_mode = mode;
1649 }
1650
1651 ir_volatility
1652 get_Load_volatility(ir_node *node) {
1653         assert(node->op == op_Load);
1654         return node->attr.load.volatility;
1655 }
1656
1657 void
1658 set_Load_volatility(ir_node *node, ir_volatility volatility) {
1659         assert(node->op == op_Load);
1660         node->attr.load.volatility = volatility;
1661 }
1662
1663
1664 ir_node *
1665 get_Store_mem(ir_node *node) {
1666         assert(node->op == op_Store);
1667         return get_irn_n(node, 0);
1668 }
1669
1670 void
1671 set_Store_mem(ir_node *node, ir_node *mem) {
1672         assert(node->op == op_Store);
1673         set_irn_n(node, 0, mem);
1674 }
1675
1676 ir_node *
1677 get_Store_ptr(ir_node *node) {
1678         assert(node->op == op_Store);
1679         return get_irn_n(node, 1);
1680 }
1681
1682 void
1683 set_Store_ptr(ir_node *node, ir_node *ptr) {
1684         assert(node->op == op_Store);
1685         set_irn_n(node, 1, ptr);
1686 }
1687
1688 ir_node *
1689 get_Store_value(ir_node *node) {
1690         assert(node->op == op_Store);
1691         return get_irn_n(node, 2);
1692 }
1693
1694 void
1695 set_Store_value(ir_node *node, ir_node *value) {
1696         assert(node->op == op_Store);
1697         set_irn_n(node, 2, value);
1698 }
1699
1700 ir_volatility
1701 get_Store_volatility(ir_node *node) {
1702         assert(node->op == op_Store);
1703         return node->attr.store.volatility;
1704 }
1705
1706 void
1707 set_Store_volatility(ir_node *node, ir_volatility volatility) {
1708         assert(node->op == op_Store);
1709         node->attr.store.volatility = volatility;
1710 }
1711
1712
1713 ir_node *
1714 get_Alloc_mem(ir_node *node) {
1715         assert(node->op == op_Alloc);
1716         return get_irn_n(node, 0);
1717 }
1718
1719 void
1720 set_Alloc_mem(ir_node *node, ir_node *mem) {
1721         assert(node->op == op_Alloc);
1722         set_irn_n(node, 0, mem);
1723 }
1724
1725 ir_node *
1726 get_Alloc_size(ir_node *node) {
1727         assert(node->op == op_Alloc);
1728         return get_irn_n(node, 1);
1729 }
1730
1731 void
1732 set_Alloc_size(ir_node *node, ir_node *size) {
1733         assert(node->op == op_Alloc);
1734         set_irn_n(node, 1, size);
1735 }
1736
1737 ir_type *
1738 get_Alloc_type(ir_node *node) {
1739         assert(node->op == op_Alloc);
1740         return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
1741 }
1742
1743 void
1744 set_Alloc_type(ir_node *node, ir_type *tp) {
1745         assert(node->op == op_Alloc);
1746         node->attr.alloc.type = tp;
1747 }
1748
1749 where_alloc
1750 get_Alloc_where(ir_node *node) {
1751         assert(node->op == op_Alloc);
1752         return node->attr.alloc.where;
1753 }
1754
1755 void
1756 set_Alloc_where(ir_node *node, where_alloc where) {
1757         assert(node->op == op_Alloc);
1758         node->attr.alloc.where = where;
1759 }
1760
1761
1762 ir_node *
1763 get_Free_mem(ir_node *node) {
1764         assert(node->op == op_Free);
1765         return get_irn_n(node, 0);
1766 }
1767
1768 void
1769 set_Free_mem(ir_node *node, ir_node *mem) {
1770         assert(node->op == op_Free);
1771         set_irn_n(node, 0, mem);
1772 }
1773
1774 ir_node *
1775 get_Free_ptr(ir_node *node) {
1776         assert(node->op == op_Free);
1777         return get_irn_n(node, 1);
1778 }
1779
1780 void
1781 set_Free_ptr(ir_node *node, ir_node *ptr) {
1782         assert(node->op == op_Free);
1783         set_irn_n(node, 1, ptr);
1784 }
1785
1786 ir_node *
1787 get_Free_size(ir_node *node) {
1788         assert(node->op == op_Free);
1789         return get_irn_n(node, 2);
1790 }
1791
1792 void
1793 set_Free_size(ir_node *node, ir_node *size) {
1794         assert(node->op == op_Free);
1795         set_irn_n(node, 2, size);
1796 }
1797
1798 ir_type *
1799 get_Free_type(ir_node *node) {
1800         assert(node->op == op_Free);
1801         return node->attr.free.type = skip_tid(node->attr.free.type);
1802 }
1803
1804 void
1805 set_Free_type(ir_node *node, ir_type *tp) {
1806         assert(node->op == op_Free);
1807         node->attr.free.type = tp;
1808 }
1809
1810 where_alloc
1811 get_Free_where(ir_node *node) {
1812         assert(node->op == op_Free);
1813         return node->attr.free.where;
1814 }
1815
1816 void
1817 set_Free_where(ir_node *node, where_alloc where) {
1818         assert(node->op == op_Free);
1819         node->attr.free.where = where;
1820 }
1821
1822 ir_node **get_Sync_preds_arr(ir_node *node) {
1823         assert(node->op == op_Sync);
1824         return (ir_node **)&(get_irn_in(node)[1]);
1825 }
1826
1827 int get_Sync_n_preds(ir_node *node) {
1828         assert(node->op == op_Sync);
1829         return (get_irn_arity(node));
1830 }
1831
1832 /*
1833 void set_Sync_n_preds(ir_node *node, int n_preds) {
1834         assert(node->op == op_Sync);
1835 }
1836 */
1837
1838 ir_node *get_Sync_pred(ir_node *node, int pos) {
1839         assert(node->op == op_Sync);
1840         return get_irn_n(node, pos);
1841 }
1842
1843 void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
1844         assert(node->op == op_Sync);
1845         set_irn_n(node, pos, pred);
1846 }
1847
1848 /* Add a new Sync predecessor */
1849 void add_Sync_pred(ir_node *node, ir_node *pred) {
1850         assert(node->op == op_Sync);
1851         add_irn_n(node, pred);
1852 }
1853
1854 /* Returns the source language type of a Proj node. */
1855 ir_type *get_Proj_type(ir_node *n) {
1856         ir_type *tp   = firm_unknown_type;
1857         ir_node *pred = get_Proj_pred(n);
1858
1859         switch (get_irn_opcode(pred)) {
1860         case iro_Proj: {
1861                 ir_node *pred_pred;
1862                 /* Deal with Start / Call here: we need to know the Proj Nr. */
1863                 assert(get_irn_mode(pred) == mode_T);
1864                 pred_pred = get_Proj_pred(pred);
1865                 if (get_irn_op(pred_pred) == op_Start)  {
1866                         ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
1867                         tp = get_method_param_type(mtp, get_Proj_proj(n));
1868                 } else if (get_irn_op(pred_pred) == op_Call) {
1869                         ir_type *mtp = get_Call_type(pred_pred);
1870                         tp = get_method_res_type(mtp, get_Proj_proj(n));
1871                 }
1872         } break;
1873         case iro_Start: break;
1874         case iro_Call: break;
1875         case iro_Load: {
1876                 ir_node *a = get_Load_ptr(pred);
1877                 if (is_Sel(a))
1878                         tp = get_entity_type(get_Sel_entity(a));
1879         } break;
1880         default:
1881                 break;
1882         }
1883         return tp;
1884 }
1885
1886 ir_node *
1887 get_Proj_pred(const ir_node *node) {
1888         assert(is_Proj(node));
1889         return get_irn_n(node, 0);
1890 }
1891
1892 void
1893 set_Proj_pred(ir_node *node, ir_node *pred) {
1894         assert(is_Proj(node));
1895         set_irn_n(node, 0, pred);
1896 }
1897
1898 long get_VProj_proj(const ir_node *node)
1899 {
1900         return node->attr.proj;
1901 }
1902
1903 void set_VProj_proj(ir_node *node, long value)
1904 {
1905         node->attr.proj = value;
1906 }
1907
1908 long
1909 get_Proj_proj(const ir_node *node) {
1910         assert(is_Proj(node));
1911         if (get_irn_opcode(node) == iro_Proj) {
1912                 return node->attr.proj;
1913         } else {
1914                 assert(get_irn_opcode(node) == iro_Filter);
1915                 return node->attr.filter.proj;
1916         }
1917 }
1918
1919 void
1920 set_Proj_proj(ir_node *node, long proj) {
1921         assert(node->op == op_Proj);
1922         node->attr.proj = proj;
1923 }
1924
1925 ir_node **
1926 get_Tuple_preds_arr(ir_node *node) {
1927         assert(node->op == op_Tuple);
1928         return (ir_node **)&(get_irn_in(node)[1]);
1929 }
1930
1931 int
1932 get_Tuple_n_preds(ir_node *node) {
1933         assert(node->op == op_Tuple);
1934         return (get_irn_arity(node));
1935 }
1936
1937 /*
1938 void
1939 set_Tuple_n_preds(ir_node *node, int n_preds) {
1940         assert(node->op == op_Tuple);
1941 }
1942 */
1943
1944 ir_node *
1945 get_Tuple_pred (ir_node *node, int pos) {
1946   assert(node->op == op_Tuple);
1947   return get_irn_n(node, pos);
1948 }
1949
1950 void
1951 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
1952         assert(node->op == op_Tuple);
1953         set_irn_n(node, pos, pred);
1954 }
1955
1956 ir_node *
1957 get_Id_pred(ir_node *node) {
1958         assert(node->op == op_Id);
1959         return get_irn_n(node, 0);
1960 }
1961
1962 void
1963 set_Id_pred(ir_node *node, ir_node *pred) {
1964         assert(node->op == op_Id);
1965         set_irn_n(node, 0, pred);
1966 }
1967
1968 ir_node *get_Confirm_value(ir_node *node) {
1969         assert(node->op == op_Confirm);
1970         return get_irn_n(node, 0);
1971 }
1972
1973 void set_Confirm_value(ir_node *node, ir_node *value) {
1974         assert(node->op == op_Confirm);
1975         set_irn_n(node, 0, value);
1976 }
1977
1978 ir_node *get_Confirm_bound(ir_node *node) {
1979         assert(node->op == op_Confirm);
1980         return get_irn_n(node, 1);
1981 }
1982
1983 void set_Confirm_bound(ir_node *node, ir_node *bound) {
1984         assert(node->op == op_Confirm);
1985         set_irn_n(node, 0, bound);
1986 }
1987
1988 pn_Cmp get_Confirm_cmp(ir_node *node) {
1989         assert(node->op == op_Confirm);
1990         return node->attr.confirm_cmp;
1991 }
1992
1993 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
1994         assert(node->op == op_Confirm);
1995         node->attr.confirm_cmp = cmp;
1996 }
1997
1998
1999 ir_node *
2000 get_Filter_pred(ir_node *node) {
2001         assert(node->op == op_Filter);
2002         return node->in[1];
2003 }
2004
2005 void
2006 set_Filter_pred(ir_node *node, ir_node *pred) {
2007         assert(node->op == op_Filter);
2008         node->in[1] = pred;
2009 }
2010
2011 long
2012 get_Filter_proj(ir_node *node) {
2013         assert(node->op == op_Filter);
2014         return node->attr.filter.proj;
2015 }
2016
2017 void
2018 set_Filter_proj(ir_node *node, long proj) {
2019         assert(node->op == op_Filter);
2020         node->attr.filter.proj = proj;
2021 }
2022
2023 /* Don't use get_irn_arity, get_irn_n in implementation as access
2024    shall work independent of view!!! */
2025 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2026         assert(node->op == op_Filter);
2027         if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2028                 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2029                 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2030                 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2031                 node->attr.filter.in_cg[0] = node->in[0];
2032         }
2033         memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2034 }
2035
2036 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2037         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2038                0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2039         node->attr.filter.in_cg[pos + 1] = pred;
2040 }
2041
2042 int get_Filter_n_cg_preds(ir_node *node) {
2043         assert(node->op == op_Filter && node->attr.filter.in_cg);
2044         return (ARR_LEN(node->attr.filter.in_cg) - 1);
2045 }
2046
2047 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2048         int arity;
2049         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2050                0 <= pos);
2051         arity = ARR_LEN(node->attr.filter.in_cg);
2052         assert(pos < arity - 1);
2053         return node->attr.filter.in_cg[pos + 1];
2054 }
2055
2056 /* Mux support */
2057 ir_node *get_Mux_sel(ir_node *node) {
2058         if (node->op == op_Psi) {
2059                 assert(get_irn_arity(node) == 3);
2060                 return get_Psi_cond(node, 0);
2061         }
2062         assert(node->op == op_Mux);
2063         return node->in[1];
2064 }
2065
2066 void set_Mux_sel(ir_node *node, ir_node *sel) {
2067         if (node->op == op_Psi) {
2068                 assert(get_irn_arity(node) == 3);
2069                 set_Psi_cond(node, 0, sel);
2070         } else {
2071                 assert(node->op == op_Mux);
2072                 node->in[1] = sel;
2073         }
2074 }
2075
2076 ir_node *get_Mux_false(ir_node *node) {
2077         if (node->op == op_Psi) {
2078                 assert(get_irn_arity(node) == 3);
2079                 return get_Psi_default(node);
2080         }
2081         assert(node->op == op_Mux);
2082         return node->in[2];
2083 }
2084
2085 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2086         if (node->op == op_Psi) {
2087                 assert(get_irn_arity(node) == 3);
2088                 set_Psi_default(node, ir_false);
2089         } else {
2090                 assert(node->op == op_Mux);
2091                 node->in[2] = ir_false;
2092         }
2093 }
2094
2095 ir_node *get_Mux_true(ir_node *node) {
2096         if (node->op == op_Psi) {
2097                 assert(get_irn_arity(node) == 3);
2098                 return get_Psi_val(node, 0);
2099         }
2100         assert(node->op == op_Mux);
2101         return node->in[3];
2102 }
2103
2104 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2105         if (node->op == op_Psi) {
2106                 assert(get_irn_arity(node) == 3);
2107                 set_Psi_val(node, 0, ir_true);
2108         } else {
2109                 assert(node->op == op_Mux);
2110                 node->in[3] = ir_true;
2111         }
2112 }
2113
2114 /* Psi support */
2115 ir_node *get_Psi_cond(ir_node *node, int pos) {
2116         int num_conds = get_Psi_n_conds(node);
2117         assert(node->op == op_Psi);
2118         assert(pos < num_conds);
2119         return get_irn_n(node, 2 * pos);
2120 }
2121
2122 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
2123         int num_conds = get_Psi_n_conds(node);
2124         assert(node->op == op_Psi);
2125         assert(pos < num_conds);
2126         set_irn_n(node, 2 * pos, cond);
2127 }
2128
2129 ir_node *get_Psi_val(ir_node *node, int pos) {
2130         int num_vals = get_Psi_n_conds(node);
2131         assert(node->op == op_Psi);
2132         assert(pos < num_vals);
2133         return get_irn_n(node, 2 * pos + 1);
2134 }
2135
2136 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
2137         int num_vals = get_Psi_n_conds(node);
2138         assert(node->op == op_Psi);
2139         assert(pos < num_vals);
2140         set_irn_n(node, 2 * pos + 1, val);
2141 }
2142
2143 ir_node *get_Psi_default(ir_node *node) {
2144         int def_pos = get_irn_arity(node) - 1;
2145         assert(node->op == op_Psi);
2146         return get_irn_n(node, def_pos);
2147 }
2148
2149 void set_Psi_default(ir_node *node, ir_node *val) {
2150         int def_pos = get_irn_arity(node);
2151         assert(node->op == op_Psi);
2152         set_irn_n(node, def_pos, val);
2153 }
2154
2155 int (get_Psi_n_conds)(ir_node *node) {
2156         return _get_Psi_n_conds(node);
2157 }
2158
2159 /* CopyB support */
2160 ir_node *get_CopyB_mem(ir_node *node) {
2161         assert(node->op == op_CopyB);
2162         return get_irn_n(node, 0);
2163 }
2164
2165 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2166         assert(node->op == op_CopyB);
2167         set_irn_n(node, 0, mem);
2168 }
2169
2170 ir_node *get_CopyB_dst(ir_node *node) {
2171         assert(node->op == op_CopyB);
2172         return get_irn_n(node, 1);
2173 }
2174
2175 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2176         assert(node->op == op_CopyB);
2177         set_irn_n(node, 1, dst);
2178 }
2179
2180 ir_node *get_CopyB_src (ir_node *node) {
2181   assert(node->op == op_CopyB);
2182   return get_irn_n(node, 2);
2183 }
2184
2185 void set_CopyB_src(ir_node *node, ir_node *src) {
2186         assert(node->op == op_CopyB);
2187         set_irn_n(node, 2, src);
2188 }
2189
2190 ir_type *get_CopyB_type(ir_node *node) {
2191         assert(node->op == op_CopyB);
2192         return node->attr.copyb.data_type;
2193 }
2194
2195 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2196         assert(node->op == op_CopyB && data_type);
2197         node->attr.copyb.data_type = data_type;
2198 }
2199
2200
2201 ir_type *
2202 get_InstOf_type(ir_node *node) {
2203         assert(node->op = op_InstOf);
2204         return node->attr.instof.type;
2205 }
2206
2207 void
2208 set_InstOf_type(ir_node *node, ir_type *type) {
2209         assert(node->op = op_InstOf);
2210         node->attr.instof.type = type;
2211 }
2212
2213 ir_node *
2214 get_InstOf_store(ir_node *node) {
2215         assert(node->op = op_InstOf);
2216         return get_irn_n(node, 0);
2217 }
2218
2219 void
2220 set_InstOf_store(ir_node *node, ir_node *obj) {
2221         assert(node->op = op_InstOf);
2222         set_irn_n(node, 0, obj);
2223 }
2224
2225 ir_node *
2226 get_InstOf_obj(ir_node *node) {
2227         assert(node->op = op_InstOf);
2228         return get_irn_n(node, 1);
2229 }
2230
2231 void
2232 set_InstOf_obj(ir_node *node, ir_node *obj) {
2233         assert(node->op = op_InstOf);
2234         set_irn_n(node, 1, obj);
2235 }
2236
2237 /* Returns the memory input of a Raise operation. */
2238 ir_node *
2239 get_Raise_mem(ir_node *node) {
2240         assert(node->op == op_Raise);
2241         return get_irn_n(node, 0);
2242 }
2243
2244 void
2245 set_Raise_mem(ir_node *node, ir_node *mem) {
2246         assert(node->op == op_Raise);
2247         set_irn_n(node, 0, mem);
2248 }
2249
2250 ir_node *
2251 get_Raise_exo_ptr(ir_node *node) {
2252         assert(node->op == op_Raise);
2253         return get_irn_n(node, 1);
2254 }
2255
2256 void
2257 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2258         assert(node->op == op_Raise);
2259         set_irn_n(node, 1, exo_ptr);
2260 }
2261
2262 /* Bound support */
2263
2264 /* Returns the memory input of a Bound operation. */
2265 ir_node *get_Bound_mem(ir_node *bound) {
2266         assert(bound->op == op_Bound);
2267         return get_irn_n(bound, 0);
2268 }
2269
2270 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2271         assert(bound->op == op_Bound);
2272         set_irn_n(bound, 0, mem);
2273 }
2274
2275 /* Returns the index input of a Bound operation. */
2276 ir_node *get_Bound_index(ir_node *bound) {
2277         assert(bound->op == op_Bound);
2278         return get_irn_n(bound, 1);
2279 }
2280
2281 void set_Bound_index(ir_node *bound, ir_node *idx) {
2282         assert(bound->op == op_Bound);
2283         set_irn_n(bound, 1, idx);
2284 }
2285
2286 /* Returns the lower bound input of a Bound operation. */
2287 ir_node *get_Bound_lower(ir_node *bound) {
2288         assert(bound->op == op_Bound);
2289         return get_irn_n(bound, 2);
2290 }
2291
2292 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2293         assert(bound->op == op_Bound);
2294         set_irn_n(bound, 2, lower);
2295 }
2296
2297 /* Returns the upper bound input of a Bound operation. */
2298 ir_node *get_Bound_upper(ir_node *bound) {
2299         assert(bound->op == op_Bound);
2300         return get_irn_n(bound, 3);
2301 }
2302
2303 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2304         assert(bound->op == op_Bound);
2305         set_irn_n(bound, 3, upper);
2306 }
2307
2308 /* Return the operand of a Pin node. */
2309 ir_node *get_Pin_op(ir_node *pin) {
2310         assert(pin->op == op_Pin);
2311         return get_irn_n(pin, 0);
2312 }
2313
2314 void set_Pin_op(ir_node *pin, ir_node *node) {
2315         assert(pin->op == op_Pin);
2316         set_irn_n(pin, 0, node);
2317 }
2318
2319
2320 /* returns the graph of a node */
2321 ir_graph *
2322 get_irn_irg(const ir_node *node) {
2323         /*
2324          * Do not use get_nodes_Block() here, because this
2325          * will check the pinned state.
2326          * However even a 'wrong' block is always in the proper
2327          * irg.
2328          */
2329         if (! is_Block(node))
2330                 node = get_irn_n(node, -1);
2331         if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2332                 node = get_irn_n(node, -1);
2333         assert(get_irn_op(node) == op_Block);
2334         return node->attr.block.irg;
2335 }
2336
2337
2338 /*----------------------------------------------------------------*/
2339 /*  Auxiliary routines                                            */
2340 /*----------------------------------------------------------------*/
2341
2342 ir_node *
2343 skip_Proj(ir_node *node) {
2344         /* don't assert node !!! */
2345         if (node == NULL)
2346                 return NULL;
2347
2348         if (is_Proj(node))
2349                 node = get_Proj_pred(node);
2350
2351         return node;
2352 }
2353
2354 const ir_node *
2355 skip_Proj_const(const ir_node *node) {
2356         /* don't assert node !!! */
2357         if (node == NULL)
2358                 return NULL;
2359
2360         if (is_Proj(node))
2361                 node = get_Proj_pred(node);
2362
2363         return node;
2364 }
2365
2366 ir_node *
2367 skip_Tuple(ir_node *node) {
2368   ir_node *pred;
2369   ir_op   *op;
2370
2371   if (!get_opt_normalize()) return node;
2372
2373 restart:
2374         if (get_irn_op(node) == op_Proj) {
2375             pred = get_Proj_pred(node);
2376             op   = get_irn_op(pred);
2377
2378                 /*
2379                  * Looks strange but calls get_irn_op() only once
2380                  * in most often cases.
2381                  */
2382                 if (op == op_Proj) { /* nested Tuple ? */
2383                     pred = skip_Tuple(pred);
2384                     op   = get_irn_op(pred);
2385
2386                         if (op == op_Tuple) {
2387                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
2388                                 goto restart;
2389                         }
2390                 } else if (op == op_Tuple) {
2391                         node = get_Tuple_pred(pred, get_Proj_proj(node));
2392                         goto restart;
2393                 }
2394         }
2395         return node;
2396 }
2397
2398 /* returns operand of node if node is a Cast */
2399 ir_node *skip_Cast(ir_node *node) {
2400         if (get_irn_op(node) == op_Cast)
2401                 return get_Cast_op(node);
2402         return node;
2403 }
2404
2405 /* returns operand of node if node is a Confirm */
2406 ir_node *skip_Confirm(ir_node *node) {
2407         if (get_irn_op(node) == op_Confirm)
2408                 return get_Confirm_value(node);
2409         return node;
2410 }
2411
2412 /* skip all high-level ops */
2413 ir_node *skip_HighLevel(ir_node *node) {
2414         if (is_op_highlevel(get_irn_op(node)))
2415                 return get_irn_n(node, 0);
2416         return node;
2417 }
2418
2419
2420 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2421  * than any other approach, as Id chains are resolved and all point to the real node, or
2422  * all id's are self loops.
2423  *
2424  * Note: This function takes 10% of mostly ANY the compiler run, so it's
2425  * a little bit "hand optimized".
2426  *
2427  * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2428  */
2429 ir_node *
2430 skip_Id(ir_node *node) {
2431         ir_node *pred;
2432         /* don't assert node !!! */
2433
2434         if (!node || (node->op != op_Id)) return node;
2435
2436         /* Don't use get_Id_pred():  We get into an endless loop for
2437            self-referencing Ids. */
2438         pred = node->in[0+1];
2439
2440         if (pred->op != op_Id) return pred;
2441
2442         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2443                 ir_node *rem_pred, *res;
2444
2445                 if (pred->op != op_Id) return pred; /* shortcut */
2446                 rem_pred = pred;
2447
2448                 assert(get_irn_arity (node) > 0);
2449
2450                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2451                 res = skip_Id(rem_pred);
2452                 if (res->op == op_Id) /* self-loop */ return node;
2453
2454                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2455                 return res;
2456         } else {
2457                 return node;
2458         }
2459 }
2460
2461 void skip_Id_and_store(ir_node **node) {
2462         ir_node *n = *node;
2463
2464         if (!n || (n->op != op_Id)) return;
2465
2466         /* Don't use get_Id_pred():  We get into an endless loop for
2467            self-referencing Ids. */
2468         *node = skip_Id(n);
2469 }
2470
2471 int
2472 (is_Bad)(const ir_node *node) {
2473         return _is_Bad(node);
2474 }
2475
2476 int
2477 (is_NoMem)(const ir_node *node) {
2478         return _is_NoMem(node);
2479 }
2480
2481 int
2482 (is_Mod)(const ir_node *node) {
2483         return _is_Mod(node);
2484 }
2485
2486 int
2487 (is_Div)(const ir_node *node) {
2488         return _is_Div(node);
2489 }
2490
2491 int
2492 (is_DivMod)(const ir_node *node) {
2493         return _is_DivMod(node);
2494 }
2495
2496 int
2497 (is_Quot)(const ir_node *node) {
2498         return _is_Quot(node);
2499 }
2500
2501 int
2502 (is_Add)(const ir_node *node) {
2503         return _is_Add(node);
2504 }
2505
2506 int
2507 (is_Sub)(const ir_node *node) {
2508         return _is_Sub(node);
2509 }
2510
2511 int
2512 (is_Start)(const ir_node *node) {
2513   return _is_Start(node);
2514 }
2515
2516 int
2517 (is_End)(const ir_node *node) {
2518         return _is_End(node);
2519 }
2520
2521 int
2522 (is_Const)(const ir_node *node) {
2523         return _is_Const(node);
2524 }
2525
2526 int
2527 (is_Conv)(const ir_node *node) {
2528         return _is_Conv(node);
2529 }
2530
2531 int
2532 (is_no_Block)(const ir_node *node) {
2533         return _is_no_Block(node);
2534 }
2535
2536 int
2537 (is_Block)(const ir_node *node) {
2538         return _is_Block(node);
2539 }
2540
2541 /* returns true if node is an Unknown node. */
2542 int
2543 (is_Unknown)(const ir_node *node) {
2544         return _is_Unknown(node);
2545 }
2546
2547 /* returns true if node is a Return node. */
2548 int
2549 (is_Return)(const ir_node *node) {
2550         return _is_Return(node);
2551 }
2552
2553 /* returns true if node is a Call node. */
2554 int
2555 (is_Call)(const ir_node *node) {
2556         return _is_Call(node);
2557 }
2558
2559 /* returns true if node is a Sel node. */
2560 int
2561 (is_Sel)(const ir_node *node) {
2562         return _is_Sel(node);
2563 }
2564
2565 /* returns true if node is a Mux node or a Psi with only one condition. */
2566 int
2567 (is_Mux)(const ir_node *node) {
2568         return _is_Mux(node);
2569 }
2570
2571 /* returns true if node is a Load node. */
2572 int
2573 (is_Load)(const ir_node *node) {
2574         return _is_Load(node);
2575 }
2576
2577 /* returns true if node is a Load node. */
2578 int
2579 (is_Store)(const ir_node *node) {
2580         return _is_Store(node);
2581 }
2582
2583 /* returns true if node is a Sync node. */
2584 int
2585 (is_Sync)(const ir_node *node) {
2586         return _is_Sync(node);
2587 }
2588
2589 /* returns true if node is a Confirm node. */
2590 int
2591 (is_Confirm)(const ir_node *node) {
2592         return _is_Confirm(node);
2593 }
2594
2595 /* returns true if node is a Pin node. */
2596 int
2597 (is_Pin)(const ir_node *node) {
2598         return _is_Pin(node);
2599 }
2600
2601 /* returns true if node is a SymConst node. */
2602 int
2603 (is_SymConst)(const ir_node *node) {
2604         return _is_SymConst(node);
2605 }
2606
2607 /* returns true if node is a Cond node. */
2608 int
2609 (is_Cond)(const ir_node *node) {
2610         return _is_Cond(node);
2611 }
2612
2613 int
2614 (is_CopyB)(const ir_node *node) {
2615         return _is_CopyB(node);
2616 }
2617
2618 /* returns true if node is a Cmp node. */
2619 int
2620 (is_Cmp)(const ir_node *node) {
2621         return _is_Cmp(node);
2622 }
2623
2624 /* returns true if node is an Alloc node. */
2625 int
2626 (is_Alloc)(const ir_node *node) {
2627         return _is_Alloc(node);
2628 }
2629
2630 /* returns true if a node is a Jmp node. */
2631 int
2632 (is_Jmp)(const ir_node *node) {
2633         return _is_Jmp(node);
2634 }
2635
2636 /* returns true if a node is a Raise node. */
2637 int
2638 (is_Raise)(const ir_node *node) {
2639         return _is_Raise(node);
2640 }
2641
2642 int
2643 is_Proj(const ir_node *node) {
2644         assert(node);
2645         return node->op == op_Proj ||
2646                (!get_interprocedural_view() && node->op == op_Filter);
2647 }
2648
2649 /* Returns true if the operation manipulates control flow. */
2650 int
2651 is_cfop(const ir_node *node) {
2652         return is_cfopcode(get_irn_op(node));
2653 }
2654
2655 /* Returns true if the operation manipulates interprocedural control flow:
2656    CallBegin, EndReg, EndExcept */
2657 int is_ip_cfop(const ir_node *node) {
2658         return is_ip_cfopcode(get_irn_op(node));
2659 }
2660
2661 /* Returns true if the operation can change the control flow because
2662    of an exception. */
2663 int
2664 is_fragile_op(const ir_node *node) {
2665         return is_op_fragile(get_irn_op(node));
2666 }
2667
2668 /* Returns the memory operand of fragile operations. */
2669 ir_node *get_fragile_op_mem(ir_node *node) {
2670         assert(node && is_fragile_op(node));
2671
2672         switch (get_irn_opcode (node)) {
2673         case iro_Call  :
2674         case iro_Quot  :
2675         case iro_DivMod:
2676         case iro_Div   :
2677         case iro_Mod   :
2678         case iro_Load  :
2679         case iro_Store :
2680         case iro_Alloc :
2681         case iro_Bound :
2682                 return get_irn_n(node, 0);
2683         case iro_Bad   :
2684         case iro_Unknown:
2685                 return node;
2686         default: ;
2687                 assert(0 && "should not be reached");
2688                 return NULL;
2689         }
2690 }
2691
2692 /* Returns true if the operation is a forking control flow operation. */
2693 int (is_irn_forking)(const ir_node *node) {
2694         return _is_irn_forking(node);
2695 }
2696
2697 /* Return the type associated with the value produced by n
2698  * if the node remarks this type as it is the case for
2699  * Cast, Const, SymConst and some Proj nodes. */
2700 ir_type *(get_irn_type)(ir_node *node) {
2701         return _get_irn_type(node);
2702 }
2703
2704 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
2705    Cast) or NULL.*/
2706 ir_type *(get_irn_type_attr)(ir_node *node) {
2707         return _get_irn_type_attr(node);
2708 }
2709
2710 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
2711 ir_entity *(get_irn_entity_attr)(ir_node *node) {
2712         return _get_irn_entity_attr(node);
2713 }
2714
2715 /* Returns non-zero for constant-like nodes. */
2716 int (is_irn_constlike)(const ir_node *node) {
2717         return _is_irn_constlike(node);
2718 }
2719
2720 /*
2721  * Returns non-zero for nodes that are allowed to have keep-alives and
2722  * are neither Block nor PhiM.
2723  */
2724 int (is_irn_keep)(const ir_node *node) {
2725         return _is_irn_keep(node);
2726 }
2727
2728 /*
2729  * Returns non-zero for nodes that are always placed in the start block.
2730  */
2731 int (is_irn_start_block_placed)(const ir_node *node) {
2732         return _is_irn_start_block_placed(node);
2733 }
2734
2735 /* Returns non-zero for nodes that are machine operations. */
2736 int (is_irn_machine_op)(const ir_node *node) {
2737         return _is_irn_machine_op(node);
2738 }
2739
2740 /* Returns non-zero for nodes that are machine operands. */
2741 int (is_irn_machine_operand)(const ir_node *node) {
2742         return _is_irn_machine_operand(node);
2743 }
2744
2745 /* Returns non-zero for nodes that have the n'th user machine flag set. */
2746 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
2747         return _is_irn_machine_user(node, n);
2748 }
2749
2750
2751 /* Gets the string representation of the jump prediction .*/
2752 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
2753         switch (pred) {
2754         default:
2755         case COND_JMP_PRED_NONE:  return "no prediction";
2756         case COND_JMP_PRED_TRUE:  return "true taken";
2757         case COND_JMP_PRED_FALSE: return "false taken";
2758         }
2759 }
2760
2761 /* Returns the conditional jump prediction of a Cond node. */
2762 cond_jmp_predicate (get_Cond_jmp_pred)(ir_node *cond) {
2763         return _get_Cond_jmp_pred(cond);
2764 }
2765
2766 /* Sets a new conditional jump prediction. */
2767 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
2768         _set_Cond_jmp_pred(cond, pred);
2769 }
2770
2771 /** the get_type operation must be always implemented and return a firm type */
2772 static ir_type *get_Default_type(ir_node *n) {
2773         return get_unknown_type();
2774 }
2775
2776 /* Sets the get_type operation for an ir_op_ops. */
2777 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
2778         switch (code) {
2779         case iro_Const:    ops->get_type = get_Const_type; break;
2780         case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
2781         case iro_Cast:     ops->get_type = get_Cast_type; break;
2782         case iro_Proj:     ops->get_type = get_Proj_type; break;
2783         default:
2784                 /* not allowed to be NULL */
2785                 if (! ops->get_type)
2786                         ops->get_type = get_Default_type;
2787                 break;
2788         }
2789         return ops;
2790 }
2791
2792 /** Return the attribute type of a SymConst node if exists */
2793 static ir_type *get_SymConst_attr_type(ir_node *self) {
2794         symconst_kind kind = get_SymConst_kind(self);
2795         if (SYMCONST_HAS_TYPE(kind))
2796                 return get_SymConst_type(self);
2797         return NULL;
2798 }
2799
2800 /** Return the attribute entity of a SymConst node if exists */
2801 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
2802         symconst_kind kind = get_SymConst_kind(self);
2803         if (SYMCONST_HAS_ENT(kind))
2804                 return get_SymConst_entity(self);
2805         return NULL;
2806 }
2807
2808 /** the get_type_attr operation must be always implemented */
2809 static ir_type *get_Null_type(ir_node *n) {
2810         return firm_unknown_type;
2811 }
2812
2813 /* Sets the get_type operation for an ir_op_ops. */
2814 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
2815         switch (code) {
2816         case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
2817         case iro_Call:     ops->get_type_attr = get_Call_type; break;
2818         case iro_Alloc:    ops->get_type_attr = get_Alloc_type; break;
2819         case iro_Free:     ops->get_type_attr = get_Free_type; break;
2820         case iro_Cast:     ops->get_type_attr = get_Cast_type; break;
2821         default:
2822                 /* not allowed to be NULL */
2823                 if (! ops->get_type_attr)
2824                         ops->get_type_attr = get_Null_type;
2825                 break;
2826         }
2827         return ops;
2828 }
2829
2830 /** the get_entity_attr operation must be always implemented */
2831 static ir_entity *get_Null_ent(ir_node *n) {
2832         return NULL;
2833 }
2834
2835 /* Sets the get_type operation for an ir_op_ops. */
2836 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
2837         switch (code) {
2838         case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
2839         case iro_Sel:      ops->get_entity_attr = get_Sel_entity; break;
2840         default:
2841                 /* not allowed to be NULL */
2842                 if (! ops->get_entity_attr)
2843                         ops->get_entity_attr = get_Null_ent;
2844                 break;
2845         }
2846         return ops;
2847 }
2848
2849 #ifdef DEBUG_libfirm
2850 void dump_irn(ir_node *n) {
2851         int i, arity = get_irn_arity(n);
2852         printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
2853         if (!is_Block(n)) {
2854                 ir_node *pred = get_irn_n(n, -1);
2855                 printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2856                         get_irn_node_nr(pred), (void *)pred);
2857         }
2858         printf("  preds: \n");
2859         for (i = 0; i < arity; ++i) {
2860                 ir_node *pred = get_irn_n(n, i);
2861                 printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2862                         get_irn_node_nr(pred), (void *)pred);
2863         }
2864 }
2865
2866 #else  /* DEBUG_libfirm */
2867 void dump_irn(ir_node *n) {}
2868 #endif /* DEBUG_libfirm */