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

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