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         int i, n;
 387
 388         for (i = 0, n = get_irn_deps(src); i < n; ++i)
 389                 add_irn_dep(tgt, get_irn_dep(src, i));
 390 }
 391
 392
 393 ir_mode *
 394 (get_irn_mode)(const ir_node *node) {
 395         return _get_irn_mode(node);
 396 }
 397
 398 void
 399 (set_irn_mode)(ir_node *node, ir_mode *mode) {
 400         _set_irn_mode(node, mode);
 401 }
 402
 403 modecode
 404 get_irn_modecode(const ir_node *node) {
 405         assert(node);
 406         return node->mode->code;
 407 }
 408
 409 /** Gets the string representation of the mode .*/
 410 const char *
 411 get_irn_modename(const ir_node *node) {
 412         assert(node);
 413         return get_mode_name(node->mode);
 414 }
 415
 416 ident *
 417 get_irn_modeident(const ir_node *node) {
 418         assert(node);
 419         return get_mode_ident(node->mode);
 420 }
 421
 422 ir_op *
 423 (get_irn_op)(const ir_node *node) {
 424         return _get_irn_op(node);
 425 }
 426
 427 /* should be private to the library: */
 428 void
 429 (set_irn_op)(ir_node *node, ir_op *op) {
 430         _set_irn_op(node, op);
 431 }
 432
 433 ir_opcode
 434 (get_irn_opcode)(const ir_node *node) {
 435         return _get_irn_opcode(node);
 436 }
 437
 438 const char *
 439 get_irn_opname(const ir_node *node) {
 440         assert(node);
 441         if (is_Phi0(node)) return "Phi0";
 442         return get_id_str(node->op->name);
 443 }
 444
 445 ident *
 446 get_irn_opident(const ir_node *node) {
 447         assert(node);
 448         return node->op->name;
 449 }
 450
 451 unsigned long
 452 (get_irn_visited)(const ir_node *node) {
 453         return _get_irn_visited(node);
 454 }
 455
 456 void
 457 (set_irn_visited)(ir_node *node, unsigned long visited) {
 458         _set_irn_visited(node, visited);
 459 }
 460
 461 void
 462 (mark_irn_visited)(ir_node *node) {
 463         _mark_irn_visited(node);
 464 }
 465
 466 int
 467 (irn_not_visited)(const ir_node *node) {
 468         return _irn_not_visited(node);
 469 }
 470
 471 int
 472 (irn_visited)(const ir_node *node) {
 473         return _irn_visited(node);
 474 }
 475
 476 void
 477 (set_irn_link)(ir_node *node, void *link) {
 478         _set_irn_link(node, link);
 479 }
 480
 481 void *
 482 (get_irn_link)(const ir_node *node) {
 483         return _get_irn_link(node);
 484 }
 485
 486 op_pin_state
 487 (get_irn_pinned)(const ir_node *node) {
 488         return _get_irn_pinned(node);
 489 }
 490
 491 op_pin_state
 492 (is_irn_pinned_in_irg) (const ir_node *node) {
 493         return _is_irn_pinned_in_irg(node);
 494 }
 495
 496 void set_irn_pinned(ir_node *node, op_pin_state state) {
 497         /* due to optimization an opt may be turned into a Tuple */
 498         if (get_irn_op(node) == op_Tuple)
 499                 return;
 500
 501         assert(node && get_op_pinned(get_irn_op(node)) >= op_pin_state_exc_pinned);
 502         assert(state == op_pin_state_pinned || state == op_pin_state_floats);
 503
 504         node->attr.except.pin_state = state;
 505 }
 506
 507 #ifdef DO_HEAPANALYSIS
 508 /* Access the abstract interpretation information of a node.
 509    Returns NULL if no such information is available. */
 510 struct abstval *get_irn_abst_value(ir_node *n) {
 511         return n->av;
 512 }
 513 /* Set the abstract interpretation information of a node. */
 514 void set_irn_abst_value(ir_node *n, struct abstval *os) {
 515         n->av = os;
 516 }
 517 struct section *firm_get_irn_section(ir_node *n) {
 518         return n->sec;
 519 }
 520 void firm_set_irn_section(ir_node *n, struct section *s) {
 521         n->sec = s;
 522 }
 523 #else
 524 /* Dummies needed for firmjni. */
 525 struct abstval *get_irn_abst_value(ir_node *n) { return NULL; }
 526 void set_irn_abst_value(ir_node *n, struct abstval *os) {}
 527 struct section *firm_get_irn_section(ir_node *n) { return NULL; }
 528 void firm_set_irn_section(ir_node *n, struct section *s) {}
 529 #endif /* DO_HEAPANALYSIS */
 530
 531
 532 /* Outputs a unique number for this node */
 533 long get_irn_node_nr(const ir_node *node) {
 534         assert(node);
 535 #ifdef DEBUG_libfirm
 536         return node->node_nr;
 537 #else
 538         return (long)PTR_TO_INT(node);
 539 #endif
 540 }
 541
 542 const_attr
 543 get_irn_const_attr(ir_node *node) {
 544         assert(node->op == op_Const);
 545         return node->attr.con;
 546 }
 547
 548 long
 549 get_irn_proj_attr(ir_node *node) {
 550         assert(node->op == op_Proj);
 551         return node->attr.proj;
 552 }
 553
 554 alloc_attr
 555 get_irn_alloc_attr(ir_node *node) {
 556         assert(node->op == op_Alloc);
 557         return node->attr.alloc;
 558 }
 559
 560 free_attr
 561 get_irn_free_attr(ir_node *node) {
 562         assert(node->op == op_Free);
 563         return node->attr.free;
 564 }
 565
 566 symconst_attr
 567 get_irn_symconst_attr(ir_node *node) {
 568         assert(node->op == op_SymConst);
 569         return node->attr.symc;
 570 }
 571
 572 ir_type *
 573 get_irn_call_attr(ir_node *node) {
 574         assert(node->op == op_Call);
 575         return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 576 }
 577
 578 sel_attr
 579 get_irn_sel_attr(ir_node *node) {
 580         assert(node->op == op_Sel);
 581         return node->attr.sel;
 582 }
 583
 584 int
 585 get_irn_phi0_attr(ir_node *node) {
 586         assert(is_Phi0(node));
 587         return node->attr.phi0.pos;
 588 }
 589
 590 block_attr
 591 get_irn_block_attr(ir_node *node) {
 592         assert(node->op == op_Block);
 593         return node->attr.block;
 594 }
 595
 596 load_attr
 597 get_irn_load_attr(ir_node *node) {
 598         assert(node->op == op_Load);
 599         return node->attr.load;
 600 }
 601
 602 store_attr
 603 get_irn_store_attr(ir_node *node) {
 604         assert(node->op == op_Store);
 605         return node->attr.store;
 606 }
 607
 608 except_attr
 609 get_irn_except_attr(ir_node *node) {
 610         assert(node->op == op_Div || node->op == op_Quot ||
 611                node->op == op_DivMod || node->op == op_Mod || node->op == op_Call || node->op == op_Alloc);
 612         return node->attr.except;
 613 }
 614
 615 void *(get_irn_generic_attr)(ir_node *node) {
 616         assert(is_ir_node(node));
 617         return _get_irn_generic_attr(node);
 618 }
 619
 620 const void *(get_irn_generic_attr_const)(const ir_node *node) {
 621         assert(is_ir_node(node));
 622         return _get_irn_generic_attr_const(node);
 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         assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!");
 865         add_irn_n(end, ka);
 866 }
 867
 868 void
 869 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
 870         assert(end->op == op_End);
 871         set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 872 }
 873
 874 /* Set new keep-alives */
 875 void set_End_keepalives(ir_node *end, int n, ir_node *in[]) {
 876         int i;
 877         ir_graph *irg = get_irn_irg(end);
 878
 879         /* notify that edges are deleted */
 880         for (i = END_KEEPALIVE_OFFSET; i < ARR_LEN(end->in) - 1; ++i) {
 881                 edges_notify_edge(end, i, NULL, end->in[i + 1], irg);
 882         }
 883         ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET);
 884
 885         for (i = 0; i < n; ++i) {
 886                 end->in[1 + END_KEEPALIVE_OFFSET + i] = in[i];
 887                 edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, end->in[1 + END_KEEPALIVE_OFFSET + i], NULL, irg);
 888         }
 889 }
 890
 891 /* Set new keep-alives from old keep-alives, skipping irn */
 892 void remove_End_keepalive(ir_node *end, ir_node *irn) {
 893         int     n = get_End_n_keepalives(end);
 894         ir_node **in;
 895         int     i, idx;
 896
 897         NEW_ARR_A(ir_node *, in, n);
 898
 899         for (idx = i = 0; i < n; ++i) {
 900                 ir_node *old_ka = get_End_keepalive(end, i);
 901
 902                 /* skip irn */
 903                 if (old_ka != irn)
 904                         in[idx++] = old_ka;
 905         }
 906
 907         /* set new keep-alives */
 908         set_End_keepalives(end, idx, in);
 909 }
 910
 911 void
 912 free_End (ir_node *end) {
 913         assert(end->op == op_End);
 914         end->kind = k_BAD;
 915         DEL_ARR_F(end->in);
 916         end->in = NULL;   /* @@@ make sure we get an error if we use the
 917                              in array afterwards ... */
 918 }
 919
 920 /* Return the target address of an IJmp */
 921 ir_node *get_IJmp_target(ir_node *ijmp) {
 922         assert(ijmp->op == op_IJmp);
 923         return get_irn_n(ijmp, 0);
 924 }
 925
 926 /** Sets the target address of an IJmp */
 927 void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
 928         assert(ijmp->op == op_IJmp);
 929         set_irn_n(ijmp, 0, tgt);
 930 }
 931
 932 /*
 933 > Implementing the case construct (which is where the constant Proj node is
 934 > important) involves far more than simply determining the constant values.
 935 > We could argue that this is more properly a function of the translator from
 936 > Firm to the target machine.  That could be done if there was some way of
 937 > projecting "default" out of the Cond node.
 938 I know it's complicated.
 939 Basically there are two proglems:
 940  - determining the gaps between the projs
 941  - determining the biggest case constant to know the proj number for
 942    the default node.
 943 I see several solutions:
 944 1. Introduce a ProjDefault node.  Solves both problems.
 945    This means to extend all optimizations executed during construction.
 946 2. Give the Cond node for switch two flavors:
 947    a) there are no gaps in the projs  (existing flavor)
 948    b) gaps may exist, default proj is still the Proj with the largest
 949       projection number.  This covers also the gaps.
 950 3. Fix the semantic of the Cond to that of 2b)
 951
 952 Solution 2 seems to be the best:
 953 Computing the gaps in the Firm representation is not too hard, i.e.,
 954 libFIRM can implement a routine that transforms between the two
 955 flavours.  This is also possible for 1) but 2) does not require to
 956 change any existing optimization.
 957 Further it should be far simpler to determine the biggest constant than
 958 to compute all gaps.
 959 I don't want to choose 3) as 2a) seems to have advantages for
 960 dataflow analysis and 3) does not allow to convert the representation to
 961 2a).
 962 */
 963 ir_node *
 964 get_Cond_selector(ir_node *node) {
 965         assert(node->op == op_Cond);
 966         return get_irn_n(node, 0);
 967 }
 968
 969 void
 970 set_Cond_selector(ir_node *node, ir_node *selector) {
 971         assert(node->op == op_Cond);
 972         set_irn_n(node, 0, selector);
 973 }
 974
 975 cond_kind
 976 get_Cond_kind(ir_node *node) {
 977         assert(node->op == op_Cond);
 978         return node->attr.cond.kind;
 979 }
 980
 981 void
 982 set_Cond_kind(ir_node *node, cond_kind kind) {
 983         assert(node->op == op_Cond);
 984         node->attr.cond.kind = kind;
 985 }
 986
 987 long
 988 get_Cond_defaultProj(ir_node *node) {
 989         assert(node->op == op_Cond);
 990         return node->attr.cond.default_proj;
 991 }
 992
 993 ir_node *
 994 get_Return_mem(ir_node *node) {
 995         assert(node->op == op_Return);
 996         return get_irn_n(node, 0);
 997 }
 998
 999 void
1000 set_Return_mem(ir_node *node, ir_node *mem) {
1001         assert(node->op == op_Return);
1002         set_irn_n(node, 0, mem);
1003 }
1004
1005 int
1006 get_Return_n_ress(ir_node *node) {
1007         assert(node->op == op_Return);
1008         return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
1009 }
1010
1011 ir_node **
1012 get_Return_res_arr (ir_node *node) {
1013         assert((node->op == op_Return));
1014         if (get_Return_n_ress(node) > 0)
1015                 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
1016         else
1017                 return NULL;
1018 }
1019
1020 /*
1021 void
1022 set_Return_n_res(ir_node *node, int results) {
1023         assert(node->op == op_Return);
1024 }
1025 */
1026
1027 ir_node *
1028 get_Return_res(ir_node *node, int pos) {
1029         assert(node->op == op_Return);
1030         assert(get_Return_n_ress(node) > pos);
1031         return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
1032 }
1033
1034 void
1035 set_Return_res(ir_node *node, int pos, ir_node *res){
1036         assert(node->op == op_Return);
1037         set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
1038 }
1039
1040 tarval *(get_Const_tarval)(const ir_node *node) {
1041         return _get_Const_tarval(node);
1042 }
1043
1044 void
1045 set_Const_tarval(ir_node *node, tarval *con) {
1046         assert(node->op == op_Const);
1047         node->attr.con.tv = con;
1048 }
1049
1050 cnst_classify_t (classify_Const)(ir_node *node) {
1051         return _classify_Const(node);
1052 }
1053
1054
1055 /* The source language type.  Must be an atomic type.  Mode of type must
1056    be mode of node. For tarvals from entities type must be pointer to
1057    entity type. */
1058 ir_type *
1059 get_Const_type(ir_node *node) {
1060         assert(node->op == op_Const);
1061         return node->attr.con.tp;
1062 }
1063
1064 void
1065 set_Const_type(ir_node *node, ir_type *tp) {
1066         assert(node->op == op_Const);
1067         if (tp != firm_unknown_type) {
1068                 assert(is_atomic_type(tp));
1069                 assert(get_type_mode(tp) == get_irn_mode(node));
1070         }
1071         node->attr.con.tp = tp;
1072 }
1073
1074
1075 symconst_kind
1076 get_SymConst_kind(const ir_node *node) {
1077         assert(node->op == op_SymConst);
1078         return node->attr.symc.num;
1079 }
1080
1081 void
1082 set_SymConst_kind(ir_node *node, symconst_kind num) {
1083         assert(node->op == op_SymConst);
1084         node->attr.symc.num = num;
1085 }
1086
1087 ir_type *
1088 get_SymConst_type(ir_node *node) {
1089         assert((node->op == op_SymConst) &&
1090                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1091         return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p);
1092 }
1093
1094 void
1095 set_SymConst_type(ir_node *node, ir_type *tp) {
1096         assert((node->op == op_SymConst) &&
1097                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1098         node->attr.symc.sym.type_p = tp;
1099 }
1100
1101 ident *
1102 get_SymConst_name(const ir_node *node) {
1103         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1104         return node->attr.symc.sym.ident_p;
1105 }
1106
1107 void
1108 set_SymConst_name(ir_node *node, ident *name) {
1109         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1110         node->attr.symc.sym.ident_p = name;
1111 }
1112
1113
1114 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
1115 ir_entity *get_SymConst_entity(const ir_node *node) {
1116         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1117         return node->attr.symc.sym.entity_p;
1118 }
1119
1120 void set_SymConst_entity(ir_node *node, ir_entity *ent) {
1121         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1122         node->attr.symc.sym.entity_p  = ent;
1123 }
1124
1125 ir_enum_const *get_SymConst_enum(const ir_node *node) {
1126         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1127         return node->attr.symc.sym.enum_p;
1128 }
1129
1130 void set_SymConst_enum(ir_node *node, ir_enum_const *ec) {
1131         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1132         node->attr.symc.sym.enum_p  = ec;
1133 }
1134
1135 union symconst_symbol
1136 get_SymConst_symbol(const ir_node *node) {
1137         assert(node->op == op_SymConst);
1138         return node->attr.symc.sym;
1139 }
1140
1141 void
1142 set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
1143         assert(node->op == op_SymConst);
1144         node->attr.symc.sym = sym;
1145 }
1146
1147 ir_type *
1148 get_SymConst_value_type(ir_node *node) {
1149         assert(node->op == op_SymConst);
1150         if (node->attr.symc.tp) node->attr.symc.tp = skip_tid(node->attr.symc.tp);
1151         return node->attr.symc.tp;
1152 }
1153
1154 void
1155 set_SymConst_value_type(ir_node *node, ir_type *tp) {
1156         assert(node->op == op_SymConst);
1157         node->attr.symc.tp = tp;
1158 }
1159
1160 ir_node *
1161 get_Sel_mem(ir_node *node) {
1162         assert(node->op == op_Sel);
1163         return get_irn_n(node, 0);
1164 }
1165
1166 void
1167 set_Sel_mem(ir_node *node, ir_node *mem) {
1168         assert(node->op == op_Sel);
1169         set_irn_n(node, 0, mem);
1170 }
1171
1172 ir_node *
1173 get_Sel_ptr(ir_node *node) {
1174         assert(node->op == op_Sel);
1175         return get_irn_n(node, 1);
1176 }
1177
1178 void
1179 set_Sel_ptr(ir_node *node, ir_node *ptr) {
1180         assert(node->op == op_Sel);
1181         set_irn_n(node, 1, ptr);
1182 }
1183
1184 int
1185 get_Sel_n_indexs(ir_node *node) {
1186         assert(node->op == op_Sel);
1187         return (get_irn_arity(node) - SEL_INDEX_OFFSET);
1188 }
1189
1190 ir_node **
1191 get_Sel_index_arr(ir_node *node) {
1192         assert((node->op == op_Sel));
1193         if (get_Sel_n_indexs(node) > 0)
1194                 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
1195         else
1196                 return NULL;
1197 }
1198
1199 ir_node *
1200 get_Sel_index(ir_node *node, int pos) {
1201         assert(node->op == op_Sel);
1202         return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1203 }
1204
1205 void
1206 set_Sel_index(ir_node *node, int pos, ir_node *index) {
1207         assert(node->op == op_Sel);
1208         set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1209 }
1210
1211 ir_entity *
1212 get_Sel_entity(ir_node *node) {
1213         assert(node->op == op_Sel);
1214         return node->attr.sel.ent;
1215 }
1216
1217 void
1218 set_Sel_entity(ir_node *node, ir_entity *ent) {
1219         assert(node->op == op_Sel);
1220         node->attr.sel.ent = ent;
1221 }
1222
1223
1224 /* For unary and binary arithmetic operations the access to the
1225    operands can be factored out.  Left is the first, right the
1226    second arithmetic value  as listed in tech report 0999-33.
1227    unops are: Minus, Abs, Not, Conv, Cast
1228    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1229    Shr, Shrs, Rotate, Cmp */
1230
1231
1232 ir_node *
1233 get_Call_mem(ir_node *node) {
1234         assert(node->op == op_Call);
1235         return get_irn_n(node, 0);
1236 }
1237
1238 void
1239 set_Call_mem(ir_node *node, ir_node *mem) {
1240         assert(node->op == op_Call);
1241         set_irn_n(node, 0, mem);
1242 }
1243
1244 ir_node *
1245 get_Call_ptr(ir_node *node) {
1246         assert(node->op == op_Call);
1247         return get_irn_n(node, 1);
1248 }
1249
1250 void
1251 set_Call_ptr(ir_node *node, ir_node *ptr) {
1252         assert(node->op == op_Call);
1253         set_irn_n(node, 1, ptr);
1254 }
1255
1256 ir_node **
1257 get_Call_param_arr(ir_node *node) {
1258         assert(node->op == op_Call);
1259         return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1260 }
1261
1262 int
1263 get_Call_n_params(ir_node *node)  {
1264         assert(node->op == op_Call);
1265         return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1266 }
1267
1268 int
1269 get_Call_arity(ir_node *node) {
1270         assert(node->op == op_Call);
1271         return get_Call_n_params(node);
1272 }
1273
1274 /* void
1275 set_Call_arity(ir_node *node, ir_node *arity) {
1276         assert(node->op == op_Call);
1277 }
1278 */
1279
1280 ir_node *
1281 get_Call_param(ir_node *node, int pos) {
1282         assert(node->op == op_Call);
1283         return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1284 }
1285
1286 void
1287 set_Call_param(ir_node *node, int pos, ir_node *param) {
1288         assert(node->op == op_Call);
1289         set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1290 }
1291
1292 ir_type *
1293 get_Call_type(ir_node *node) {
1294         assert(node->op == op_Call);
1295         return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1296 }
1297
1298 void
1299 set_Call_type(ir_node *node, ir_type *tp) {
1300         assert(node->op == op_Call);
1301         assert((get_unknown_type() == tp) || is_Method_type(tp));
1302         node->attr.call.cld_tp = tp;
1303 }
1304
1305 int Call_has_callees(ir_node *node) {
1306         assert(node && node->op == op_Call);
1307         return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1308                 (node->attr.call.callee_arr != NULL));
1309 }
1310
1311 int get_Call_n_callees(ir_node * node) {
1312   assert(node && node->op == op_Call && node->attr.call.callee_arr);
1313   return ARR_LEN(node->attr.call.callee_arr);
1314 }
1315
1316 ir_entity * get_Call_callee(ir_node * node, int pos) {
1317         assert(pos >= 0 && pos < get_Call_n_callees(node));
1318         return node->attr.call.callee_arr[pos];
1319 }
1320
1321 void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
1322         assert(node->op == op_Call);
1323         if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1324                 node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
1325         }
1326         memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
1327 }
1328
1329 void remove_Call_callee_arr(ir_node * node) {
1330         assert(node->op == op_Call);
1331         node->attr.call.callee_arr = NULL;
1332 }
1333
1334 ir_node * get_CallBegin_ptr(ir_node *node) {
1335         assert(node->op == op_CallBegin);
1336         return get_irn_n(node, 0);
1337 }
1338
1339 void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
1340         assert(node->op == op_CallBegin);
1341         set_irn_n(node, 0, ptr);
1342 }
1343
1344 ir_node * get_CallBegin_call(ir_node *node) {
1345         assert(node->op == op_CallBegin);
1346         return node->attr.callbegin.call;
1347 }
1348
1349 void  set_CallBegin_call(ir_node *node, ir_node *call) {
1350         assert(node->op == op_CallBegin);
1351         node->attr.callbegin.call = call;
1352 }
1353
1354
1355 #define BINOP(OP)                                      \
1356 ir_node * get_##OP##_left(const ir_node *node) {       \
1357   assert(node->op == op_##OP);                         \
1358   return get_irn_n(node, node->op->op_index);          \
1359 }                                                      \
1360 void set_##OP##_left(ir_node *node, ir_node *left) {   \
1361   assert(node->op == op_##OP);                         \
1362   set_irn_n(node, node->op->op_index, left);           \
1363 }                                                      \
1364 ir_node *get_##OP##_right(const ir_node *node) {       \
1365   assert(node->op == op_##OP);                         \
1366   return get_irn_n(node, node->op->op_index + 1);      \
1367 }                                                      \
1368 void set_##OP##_right(ir_node *node, ir_node *right) { \
1369   assert(node->op == op_##OP);                         \
1370   set_irn_n(node, node->op->op_index + 1, right);      \
1371 }
1372
1373 #define UNOP(OP)                                  \
1374 ir_node *get_##OP##_op(const ir_node *node) {     \
1375   assert(node->op == op_##OP);                    \
1376   return get_irn_n(node, node->op->op_index);     \
1377 }                                                 \
1378 void set_##OP##_op (ir_node *node, ir_node *op) { \
1379   assert(node->op == op_##OP);                    \
1380   set_irn_n(node, node->op->op_index, op);        \
1381 }
1382
1383 #define BINOP_MEM(OP)                         \
1384 BINOP(OP)                                     \
1385                                               \
1386 ir_node *                                     \
1387 get_##OP##_mem(ir_node *node) {               \
1388   assert(node->op == op_##OP);                \
1389   return get_irn_n(node, 0);                  \
1390 }                                             \
1391                                               \
1392 void                                          \
1393 set_##OP##_mem(ir_node *node, ir_node *mem) { \
1394   assert(node->op == op_##OP);                \
1395   set_irn_n(node, 0, mem);                    \
1396 }
1397
1398 #define DIVOP(OP)                                       \
1399 BINOP_MEM(OP)                                           \
1400                                                         \
1401 ir_mode *get_##OP##_resmode(const ir_node *node) {      \
1402   assert(node->op == op_##OP);                          \
1403   return node->attr.divmod.res_mode;                    \
1404 }                                                       \
1405                                                         \
1406 void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \
1407   assert(node->op == op_##OP);                          \
1408   node->attr.divmod.res_mode = mode;                    \
1409 }
1410
1411
1412 BINOP(Add)
1413 BINOP(Sub)
1414 UNOP(Minus)
1415 BINOP(Mul)
1416 DIVOP(Quot)
1417 DIVOP(DivMod)
1418 DIVOP(Div)
1419 DIVOP(Mod)
1420 UNOP(Abs)
1421 BINOP(And)
1422 BINOP(Or)
1423 BINOP(Eor)
1424 UNOP(Not)
1425 BINOP(Shl)
1426 BINOP(Shr)
1427 BINOP(Shrs)
1428 BINOP(Rot)
1429 BINOP(Cmp)
1430 UNOP(Conv)
1431 UNOP(Cast)
1432
1433 int get_Conv_strict(ir_node *node) {
1434         assert(node->op == op_Conv);
1435         return node->attr.conv.strict;
1436 }
1437
1438 void set_Conv_strict(ir_node *node, int strict_flag) {
1439         assert(node->op == op_Conv);
1440         node->attr.conv.strict = (char)strict_flag;
1441 }
1442
1443 ir_type *
1444 get_Cast_type(ir_node *node) {
1445         assert(node->op == op_Cast);
1446         return node->attr.cast.totype;
1447 }
1448
1449 void
1450 set_Cast_type(ir_node *node, ir_type *to_tp) {
1451         assert(node->op == op_Cast);
1452         node->attr.cast.totype = to_tp;
1453 }
1454
1455
1456 /* Checks for upcast.
1457  *
1458  * Returns true if the Cast node casts a class type to a super type.
1459  */
1460 int is_Cast_upcast(ir_node *node) {
1461         ir_type *totype   = get_Cast_type(node);
1462         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1463         ir_graph *myirg = get_irn_irg(node);
1464
1465         assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
1466         assert(fromtype);
1467
1468         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1469                 totype   = get_pointer_points_to_type(totype);
1470                 fromtype = get_pointer_points_to_type(fromtype);
1471         }
1472
1473         assert(fromtype);
1474
1475         if (!is_Class_type(totype)) return 0;
1476         return is_SubClass_of(fromtype, totype);
1477 }
1478
1479 /* Checks for downcast.
1480  *
1481  * Returns true if the Cast node casts a class type to a sub type.
1482  */
1483 int is_Cast_downcast(ir_node *node) {
1484         ir_type *totype   = get_Cast_type(node);
1485         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1486
1487         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1488         assert(fromtype);
1489
1490         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1491                 totype   = get_pointer_points_to_type(totype);
1492                 fromtype = get_pointer_points_to_type(fromtype);
1493         }
1494
1495         assert(fromtype);
1496
1497         if (!is_Class_type(totype)) return 0;
1498         return is_SubClass_of(totype, fromtype);
1499 }
1500
1501 int
1502 (is_unop)(const ir_node *node) {
1503         return _is_unop(node);
1504 }
1505
1506 ir_node *
1507 get_unop_op(const ir_node *node) {
1508         if (node->op->opar == oparity_unary)
1509                 return get_irn_n(node, node->op->op_index);
1510
1511         assert(node->op->opar == oparity_unary);
1512         return NULL;
1513 }
1514
1515 void
1516 set_unop_op(ir_node *node, ir_node *op) {
1517         if (node->op->opar == oparity_unary)
1518                 set_irn_n(node, node->op->op_index, op);
1519
1520         assert(node->op->opar == oparity_unary);
1521 }
1522
1523 int
1524 (is_binop)(const ir_node *node) {
1525         return _is_binop(node);
1526 }
1527
1528 ir_node *
1529 get_binop_left(const ir_node *node) {
1530         assert(node->op->opar == oparity_binary);
1531         return get_irn_n(node, node->op->op_index);
1532 }
1533
1534 void
1535 set_binop_left(ir_node *node, ir_node *left) {
1536         assert(node->op->opar == oparity_binary);
1537         set_irn_n(node, node->op->op_index, left);
1538 }
1539
1540 ir_node *
1541 get_binop_right(const ir_node *node) {
1542         assert(node->op->opar == oparity_binary);
1543         return get_irn_n(node, node->op->op_index + 1);
1544 }
1545
1546 void
1547 set_binop_right(ir_node *node, ir_node *right) {
1548         assert(node->op->opar == oparity_binary);
1549         set_irn_n(node, node->op->op_index + 1, right);
1550 }
1551
1552 int is_Phi(const ir_node *n) {
1553         ir_op *op;
1554
1555         assert(n);
1556         op = get_irn_op(n);
1557
1558         if (op == op_Filter) return get_interprocedural_view();
1559
1560         if (op == op_Phi)
1561                 return ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
1562                         (get_irn_arity(n) > 0));
1563
1564         return 0;
1565 }
1566
1567 int is_Phi0(const ir_node *n) {
1568         assert(n);
1569
1570         return ((get_irn_op(n) == op_Phi) &&
1571                 (get_irn_arity(n) == 0) &&
1572                 (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1573 }
1574
1575 ir_node **
1576 get_Phi_preds_arr(ir_node *node) {
1577   assert(node->op == op_Phi);
1578   return (ir_node **)&(get_irn_in(node)[1]);
1579 }
1580
1581 int
1582 get_Phi_n_preds(const ir_node *node) {
1583         assert(is_Phi(node) || is_Phi0(node));
1584         return (get_irn_arity(node));
1585 }
1586
1587 /*
1588 void set_Phi_n_preds(ir_node *node, int n_preds) {
1589         assert(node->op == op_Phi);
1590 }
1591 */
1592
1593 ir_node *
1594 get_Phi_pred(const ir_node *node, int pos) {
1595         assert(is_Phi(node) || is_Phi0(node));
1596         return get_irn_n(node, pos);
1597 }
1598
1599 void
1600 set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
1601         assert(is_Phi(node) || is_Phi0(node));
1602         set_irn_n(node, pos, pred);
1603 }
1604
1605
1606 int is_memop(ir_node *node) {
1607         return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
1608 }
1609
1610 ir_node *get_memop_mem(ir_node *node) {
1611         assert(is_memop(node));
1612         return get_irn_n(node, 0);
1613 }
1614
1615 void set_memop_mem(ir_node *node, ir_node *mem) {
1616         assert(is_memop(node));
1617         set_irn_n(node, 0, mem);
1618 }
1619
1620 ir_node *get_memop_ptr(ir_node *node) {
1621         assert(is_memop(node));
1622         return get_irn_n(node, 1);
1623 }
1624
1625 void set_memop_ptr(ir_node *node, ir_node *ptr) {
1626         assert(is_memop(node));
1627         set_irn_n(node, 1, ptr);
1628 }
1629
1630 ir_node *
1631 get_Load_mem(ir_node *node) {
1632         assert(node->op == op_Load);
1633         return get_irn_n(node, 0);
1634 }
1635
1636 void
1637 set_Load_mem(ir_node *node, ir_node *mem) {
1638         assert(node->op == op_Load);
1639         set_irn_n(node, 0, mem);
1640 }
1641
1642 ir_node *
1643 get_Load_ptr(ir_node *node) {
1644         assert(node->op == op_Load);
1645         return get_irn_n(node, 1);
1646 }
1647
1648 void
1649 set_Load_ptr(ir_node *node, ir_node *ptr) {
1650         assert(node->op == op_Load);
1651         set_irn_n(node, 1, ptr);
1652 }
1653
1654 ir_mode *
1655 get_Load_mode(ir_node *node) {
1656         assert(node->op == op_Load);
1657         return node->attr.load.load_mode;
1658 }
1659
1660 void
1661 set_Load_mode(ir_node *node, ir_mode *mode) {
1662         assert(node->op == op_Load);
1663         node->attr.load.load_mode = mode;
1664 }
1665
1666 ir_volatility
1667 get_Load_volatility(ir_node *node) {
1668         assert(node->op == op_Load);
1669         return node->attr.load.volatility;
1670 }
1671
1672 void
1673 set_Load_volatility(ir_node *node, ir_volatility volatility) {
1674         assert(node->op == op_Load);
1675         node->attr.load.volatility = volatility;
1676 }
1677
1678
1679 ir_node *
1680 get_Store_mem(ir_node *node) {
1681         assert(node->op == op_Store);
1682         return get_irn_n(node, 0);
1683 }
1684
1685 void
1686 set_Store_mem(ir_node *node, ir_node *mem) {
1687         assert(node->op == op_Store);
1688         set_irn_n(node, 0, mem);
1689 }
1690
1691 ir_node *
1692 get_Store_ptr(ir_node *node) {
1693         assert(node->op == op_Store);
1694         return get_irn_n(node, 1);
1695 }
1696
1697 void
1698 set_Store_ptr(ir_node *node, ir_node *ptr) {
1699         assert(node->op == op_Store);
1700         set_irn_n(node, 1, ptr);
1701 }
1702
1703 ir_node *
1704 get_Store_value(ir_node *node) {
1705         assert(node->op == op_Store);
1706         return get_irn_n(node, 2);
1707 }
1708
1709 void
1710 set_Store_value(ir_node *node, ir_node *value) {
1711         assert(node->op == op_Store);
1712         set_irn_n(node, 2, value);
1713 }
1714
1715 ir_volatility
1716 get_Store_volatility(ir_node *node) {
1717         assert(node->op == op_Store);
1718         return node->attr.store.volatility;
1719 }
1720
1721 void
1722 set_Store_volatility(ir_node *node, ir_volatility volatility) {
1723         assert(node->op == op_Store);
1724         node->attr.store.volatility = volatility;
1725 }
1726
1727
1728 ir_node *
1729 get_Alloc_mem(ir_node *node) {
1730         assert(node->op == op_Alloc);
1731         return get_irn_n(node, 0);
1732 }
1733
1734 void
1735 set_Alloc_mem(ir_node *node, ir_node *mem) {
1736         assert(node->op == op_Alloc);
1737         set_irn_n(node, 0, mem);
1738 }
1739
1740 ir_node *
1741 get_Alloc_size(ir_node *node) {
1742         assert(node->op == op_Alloc);
1743         return get_irn_n(node, 1);
1744 }
1745
1746 void
1747 set_Alloc_size(ir_node *node, ir_node *size) {
1748         assert(node->op == op_Alloc);
1749         set_irn_n(node, 1, size);
1750 }
1751
1752 ir_type *
1753 get_Alloc_type(ir_node *node) {
1754         assert(node->op == op_Alloc);
1755         return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
1756 }
1757
1758 void
1759 set_Alloc_type(ir_node *node, ir_type *tp) {
1760         assert(node->op == op_Alloc);
1761         node->attr.alloc.type = tp;
1762 }
1763
1764 where_alloc
1765 get_Alloc_where(ir_node *node) {
1766         assert(node->op == op_Alloc);
1767         return node->attr.alloc.where;
1768 }
1769
1770 void
1771 set_Alloc_where(ir_node *node, where_alloc where) {
1772         assert(node->op == op_Alloc);
1773         node->attr.alloc.where = where;
1774 }
1775
1776
1777 ir_node *
1778 get_Free_mem(ir_node *node) {
1779         assert(node->op == op_Free);
1780         return get_irn_n(node, 0);
1781 }
1782
1783 void
1784 set_Free_mem(ir_node *node, ir_node *mem) {
1785         assert(node->op == op_Free);
1786         set_irn_n(node, 0, mem);
1787 }
1788
1789 ir_node *
1790 get_Free_ptr(ir_node *node) {
1791         assert(node->op == op_Free);
1792         return get_irn_n(node, 1);
1793 }
1794
1795 void
1796 set_Free_ptr(ir_node *node, ir_node *ptr) {
1797         assert(node->op == op_Free);
1798         set_irn_n(node, 1, ptr);
1799 }
1800
1801 ir_node *
1802 get_Free_size(ir_node *node) {
1803         assert(node->op == op_Free);
1804         return get_irn_n(node, 2);
1805 }
1806
1807 void
1808 set_Free_size(ir_node *node, ir_node *size) {
1809         assert(node->op == op_Free);
1810         set_irn_n(node, 2, size);
1811 }
1812
1813 ir_type *
1814 get_Free_type(ir_node *node) {
1815         assert(node->op == op_Free);
1816         return node->attr.free.type = skip_tid(node->attr.free.type);
1817 }
1818
1819 void
1820 set_Free_type(ir_node *node, ir_type *tp) {
1821         assert(node->op == op_Free);
1822         node->attr.free.type = tp;
1823 }
1824
1825 where_alloc
1826 get_Free_where(ir_node *node) {
1827         assert(node->op == op_Free);
1828         return node->attr.free.where;
1829 }
1830
1831 void
1832 set_Free_where(ir_node *node, where_alloc where) {
1833         assert(node->op == op_Free);
1834         node->attr.free.where = where;
1835 }
1836
1837 ir_node **get_Sync_preds_arr(ir_node *node) {
1838         assert(node->op == op_Sync);
1839         return (ir_node **)&(get_irn_in(node)[1]);
1840 }
1841
1842 int get_Sync_n_preds(ir_node *node) {
1843         assert(node->op == op_Sync);
1844         return (get_irn_arity(node));
1845 }
1846
1847 /*
1848 void set_Sync_n_preds(ir_node *node, int n_preds) {
1849         assert(node->op == op_Sync);
1850 }
1851 */
1852
1853 ir_node *get_Sync_pred(ir_node *node, int pos) {
1854         assert(node->op == op_Sync);
1855         return get_irn_n(node, pos);
1856 }
1857
1858 void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
1859         assert(node->op == op_Sync);
1860         set_irn_n(node, pos, pred);
1861 }
1862
1863 /* Add a new Sync predecessor */
1864 void add_Sync_pred(ir_node *node, ir_node *pred) {
1865         assert(node->op == op_Sync);
1866         add_irn_n(node, pred);
1867 }
1868
1869 /* Returns the source language type of a Proj node. */
1870 ir_type *get_Proj_type(ir_node *n) {
1871         ir_type *tp   = firm_unknown_type;
1872         ir_node *pred = get_Proj_pred(n);
1873
1874         switch (get_irn_opcode(pred)) {
1875         case iro_Proj: {
1876                 ir_node *pred_pred;
1877                 /* Deal with Start / Call here: we need to know the Proj Nr. */
1878                 assert(get_irn_mode(pred) == mode_T);
1879                 pred_pred = get_Proj_pred(pred);
1880                 if (get_irn_op(pred_pred) == op_Start)  {
1881                         ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
1882                         tp = get_method_param_type(mtp, get_Proj_proj(n));
1883                 } else if (get_irn_op(pred_pred) == op_Call) {
1884                         ir_type *mtp = get_Call_type(pred_pred);
1885                         tp = get_method_res_type(mtp, get_Proj_proj(n));
1886                 }
1887         } break;
1888         case iro_Start: break;
1889         case iro_Call: break;
1890         case iro_Load: {
1891                 ir_node *a = get_Load_ptr(pred);
1892                 if (is_Sel(a))
1893                         tp = get_entity_type(get_Sel_entity(a));
1894         } break;
1895         default:
1896                 break;
1897         }
1898         return tp;
1899 }
1900
1901 ir_node *
1902 get_Proj_pred(const ir_node *node) {
1903         assert(is_Proj(node));
1904         return get_irn_n(node, 0);
1905 }
1906
1907 void
1908 set_Proj_pred(ir_node *node, ir_node *pred) {
1909         assert(is_Proj(node));
1910         set_irn_n(node, 0, pred);
1911 }
1912
1913 long get_VProj_proj(const ir_node *node)
1914 {
1915         return node->attr.proj;
1916 }
1917
1918 void set_VProj_proj(ir_node *node, long value)
1919 {
1920         node->attr.proj = value;
1921 }
1922
1923 long
1924 get_Proj_proj(const ir_node *node) {
1925         assert(is_Proj(node));
1926         if (get_irn_opcode(node) == iro_Proj) {
1927                 return node->attr.proj;
1928         } else {
1929                 assert(get_irn_opcode(node) == iro_Filter);
1930                 return node->attr.filter.proj;
1931         }
1932 }
1933
1934 void
1935 set_Proj_proj(ir_node *node, long proj) {
1936         assert(node->op == op_Proj);
1937         node->attr.proj = proj;
1938 }
1939
1940 ir_node **
1941 get_Tuple_preds_arr(ir_node *node) {
1942         assert(node->op == op_Tuple);
1943         return (ir_node **)&(get_irn_in(node)[1]);
1944 }
1945
1946 int
1947 get_Tuple_n_preds(ir_node *node) {
1948         assert(node->op == op_Tuple);
1949         return (get_irn_arity(node));
1950 }
1951
1952 /*
1953 void
1954 set_Tuple_n_preds(ir_node *node, int n_preds) {
1955         assert(node->op == op_Tuple);
1956 }
1957 */
1958
1959 ir_node *
1960 get_Tuple_pred (ir_node *node, int pos) {
1961   assert(node->op == op_Tuple);
1962   return get_irn_n(node, pos);
1963 }
1964
1965 void
1966 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
1967         assert(node->op == op_Tuple);
1968         set_irn_n(node, pos, pred);
1969 }
1970
1971 ir_node *
1972 get_Id_pred(ir_node *node) {
1973         assert(node->op == op_Id);
1974         return get_irn_n(node, 0);
1975 }
1976
1977 void
1978 set_Id_pred(ir_node *node, ir_node *pred) {
1979         assert(node->op == op_Id);
1980         set_irn_n(node, 0, pred);
1981 }
1982
1983 ir_node *get_Confirm_value(ir_node *node) {
1984         assert(node->op == op_Confirm);
1985         return get_irn_n(node, 0);
1986 }
1987
1988 void set_Confirm_value(ir_node *node, ir_node *value) {
1989         assert(node->op == op_Confirm);
1990         set_irn_n(node, 0, value);
1991 }
1992
1993 ir_node *get_Confirm_bound(ir_node *node) {
1994         assert(node->op == op_Confirm);
1995         return get_irn_n(node, 1);
1996 }
1997
1998 void set_Confirm_bound(ir_node *node, ir_node *bound) {
1999         assert(node->op == op_Confirm);
2000         set_irn_n(node, 0, bound);
2001 }
2002
2003 pn_Cmp get_Confirm_cmp(ir_node *node) {
2004         assert(node->op == op_Confirm);
2005         return node->attr.confirm_cmp;
2006 }
2007
2008 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
2009         assert(node->op == op_Confirm);
2010         node->attr.confirm_cmp = cmp;
2011 }
2012
2013
2014 ir_node *
2015 get_Filter_pred(ir_node *node) {
2016         assert(node->op == op_Filter);
2017         return node->in[1];
2018 }
2019
2020 void
2021 set_Filter_pred(ir_node *node, ir_node *pred) {
2022         assert(node->op == op_Filter);
2023         node->in[1] = pred;
2024 }
2025
2026 long
2027 get_Filter_proj(ir_node *node) {
2028         assert(node->op == op_Filter);
2029         return node->attr.filter.proj;
2030 }
2031
2032 void
2033 set_Filter_proj(ir_node *node, long proj) {
2034         assert(node->op == op_Filter);
2035         node->attr.filter.proj = proj;
2036 }
2037
2038 /* Don't use get_irn_arity, get_irn_n in implementation as access
2039    shall work independent of view!!! */
2040 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2041         assert(node->op == op_Filter);
2042         if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2043                 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2044                 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2045                 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2046                 node->attr.filter.in_cg[0] = node->in[0];
2047         }
2048         memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2049 }
2050
2051 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2052         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2053                0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2054         node->attr.filter.in_cg[pos + 1] = pred;
2055 }
2056
2057 int get_Filter_n_cg_preds(ir_node *node) {
2058         assert(node->op == op_Filter && node->attr.filter.in_cg);
2059         return (ARR_LEN(node->attr.filter.in_cg) - 1);
2060 }
2061
2062 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2063         int arity;
2064         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2065                0 <= pos);
2066         arity = ARR_LEN(node->attr.filter.in_cg);
2067         assert(pos < arity - 1);
2068         return node->attr.filter.in_cg[pos + 1];
2069 }
2070
2071 /* Mux support */
2072 ir_node *get_Mux_sel(ir_node *node) {
2073         if (node->op == op_Psi) {
2074                 assert(get_irn_arity(node) == 3);
2075                 return get_Psi_cond(node, 0);
2076         }
2077         assert(node->op == op_Mux);
2078         return node->in[1];
2079 }
2080
2081 void set_Mux_sel(ir_node *node, ir_node *sel) {
2082         if (node->op == op_Psi) {
2083                 assert(get_irn_arity(node) == 3);
2084                 set_Psi_cond(node, 0, sel);
2085         } else {
2086                 assert(node->op == op_Mux);
2087                 node->in[1] = sel;
2088         }
2089 }
2090
2091 ir_node *get_Mux_false(ir_node *node) {
2092         if (node->op == op_Psi) {
2093                 assert(get_irn_arity(node) == 3);
2094                 return get_Psi_default(node);
2095         }
2096         assert(node->op == op_Mux);
2097         return node->in[2];
2098 }
2099
2100 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2101         if (node->op == op_Psi) {
2102                 assert(get_irn_arity(node) == 3);
2103                 set_Psi_default(node, ir_false);
2104         } else {
2105                 assert(node->op == op_Mux);
2106                 node->in[2] = ir_false;
2107         }
2108 }
2109
2110 ir_node *get_Mux_true(ir_node *node) {
2111         if (node->op == op_Psi) {
2112                 assert(get_irn_arity(node) == 3);
2113                 return get_Psi_val(node, 0);
2114         }
2115         assert(node->op == op_Mux);
2116         return node->in[3];
2117 }
2118
2119 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2120         if (node->op == op_Psi) {
2121                 assert(get_irn_arity(node) == 3);
2122                 set_Psi_val(node, 0, ir_true);
2123         } else {
2124                 assert(node->op == op_Mux);
2125                 node->in[3] = ir_true;
2126         }
2127 }
2128
2129 /* Psi support */
2130 ir_node *get_Psi_cond(ir_node *node, int pos) {
2131         int num_conds = get_Psi_n_conds(node);
2132         assert(node->op == op_Psi);
2133         assert(pos < num_conds);
2134         return get_irn_n(node, 2 * pos);
2135 }
2136
2137 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
2138         int num_conds = get_Psi_n_conds(node);
2139         assert(node->op == op_Psi);
2140         assert(pos < num_conds);
2141         set_irn_n(node, 2 * pos, cond);
2142 }
2143
2144 ir_node *get_Psi_val(ir_node *node, int pos) {
2145         int num_vals = get_Psi_n_conds(node);
2146         assert(node->op == op_Psi);
2147         assert(pos < num_vals);
2148         return get_irn_n(node, 2 * pos + 1);
2149 }
2150
2151 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
2152         int num_vals = get_Psi_n_conds(node);
2153         assert(node->op == op_Psi);
2154         assert(pos < num_vals);
2155         set_irn_n(node, 2 * pos + 1, val);
2156 }
2157
2158 ir_node *get_Psi_default(ir_node *node) {
2159         int def_pos = get_irn_arity(node) - 1;
2160         assert(node->op == op_Psi);
2161         return get_irn_n(node, def_pos);
2162 }
2163
2164 void set_Psi_default(ir_node *node, ir_node *val) {
2165         int def_pos = get_irn_arity(node);
2166         assert(node->op == op_Psi);
2167         set_irn_n(node, def_pos, val);
2168 }
2169
2170 int (get_Psi_n_conds)(ir_node *node) {
2171         return _get_Psi_n_conds(node);
2172 }
2173
2174 /* CopyB support */
2175 ir_node *get_CopyB_mem(ir_node *node) {
2176         assert(node->op == op_CopyB);
2177         return get_irn_n(node, 0);
2178 }
2179
2180 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2181         assert(node->op == op_CopyB);
2182         set_irn_n(node, 0, mem);
2183 }
2184
2185 ir_node *get_CopyB_dst(ir_node *node) {
2186         assert(node->op == op_CopyB);
2187         return get_irn_n(node, 1);
2188 }
2189
2190 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2191         assert(node->op == op_CopyB);
2192         set_irn_n(node, 1, dst);
2193 }
2194
2195 ir_node *get_CopyB_src (ir_node *node) {
2196   assert(node->op == op_CopyB);
2197   return get_irn_n(node, 2);
2198 }
2199
2200 void set_CopyB_src(ir_node *node, ir_node *src) {
2201         assert(node->op == op_CopyB);
2202         set_irn_n(node, 2, src);
2203 }
2204
2205 ir_type *get_CopyB_type(ir_node *node) {
2206         assert(node->op == op_CopyB);
2207         return node->attr.copyb.data_type;
2208 }
2209
2210 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2211         assert(node->op == op_CopyB && data_type);
2212         node->attr.copyb.data_type = data_type;
2213 }
2214
2215
2216 ir_type *
2217 get_InstOf_type(ir_node *node) {
2218         assert(node->op = op_InstOf);
2219         return node->attr.instof.type;
2220 }
2221
2222 void
2223 set_InstOf_type(ir_node *node, ir_type *type) {
2224         assert(node->op = op_InstOf);
2225         node->attr.instof.type = type;
2226 }
2227
2228 ir_node *
2229 get_InstOf_store(ir_node *node) {
2230         assert(node->op = op_InstOf);
2231         return get_irn_n(node, 0);
2232 }
2233
2234 void
2235 set_InstOf_store(ir_node *node, ir_node *obj) {
2236         assert(node->op = op_InstOf);
2237         set_irn_n(node, 0, obj);
2238 }
2239
2240 ir_node *
2241 get_InstOf_obj(ir_node *node) {
2242         assert(node->op = op_InstOf);
2243         return get_irn_n(node, 1);
2244 }
2245
2246 void
2247 set_InstOf_obj(ir_node *node, ir_node *obj) {
2248         assert(node->op = op_InstOf);
2249         set_irn_n(node, 1, obj);
2250 }
2251
2252 /* Returns the memory input of a Raise operation. */
2253 ir_node *
2254 get_Raise_mem(ir_node *node) {
2255         assert(node->op == op_Raise);
2256         return get_irn_n(node, 0);
2257 }
2258
2259 void
2260 set_Raise_mem(ir_node *node, ir_node *mem) {
2261         assert(node->op == op_Raise);
2262         set_irn_n(node, 0, mem);
2263 }
2264
2265 ir_node *
2266 get_Raise_exo_ptr(ir_node *node) {
2267         assert(node->op == op_Raise);
2268         return get_irn_n(node, 1);
2269 }
2270
2271 void
2272 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2273         assert(node->op == op_Raise);
2274         set_irn_n(node, 1, exo_ptr);
2275 }
2276
2277 /* Bound support */
2278
2279 /* Returns the memory input of a Bound operation. */
2280 ir_node *get_Bound_mem(ir_node *bound) {
2281         assert(bound->op == op_Bound);
2282         return get_irn_n(bound, 0);
2283 }
2284
2285 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2286         assert(bound->op == op_Bound);
2287         set_irn_n(bound, 0, mem);
2288 }
2289
2290 /* Returns the index input of a Bound operation. */
2291 ir_node *get_Bound_index(ir_node *bound) {
2292         assert(bound->op == op_Bound);
2293         return get_irn_n(bound, 1);
2294 }
2295
2296 void set_Bound_index(ir_node *bound, ir_node *idx) {
2297         assert(bound->op == op_Bound);
2298         set_irn_n(bound, 1, idx);
2299 }
2300
2301 /* Returns the lower bound input of a Bound operation. */
2302 ir_node *get_Bound_lower(ir_node *bound) {
2303         assert(bound->op == op_Bound);
2304         return get_irn_n(bound, 2);
2305 }
2306
2307 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2308         assert(bound->op == op_Bound);
2309         set_irn_n(bound, 2, lower);
2310 }
2311
2312 /* Returns the upper bound input of a Bound operation. */
2313 ir_node *get_Bound_upper(ir_node *bound) {
2314         assert(bound->op == op_Bound);
2315         return get_irn_n(bound, 3);
2316 }
2317
2318 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2319         assert(bound->op == op_Bound);
2320         set_irn_n(bound, 3, upper);
2321 }
2322
2323 /* Return the operand of a Pin node. */
2324 ir_node *get_Pin_op(const ir_node *pin) {
2325         assert(pin->op == op_Pin);
2326         return get_irn_n(pin, 0);
2327 }
2328
2329 void set_Pin_op(ir_node *pin, ir_node *node) {
2330         assert(pin->op == op_Pin);
2331         set_irn_n(pin, 0, node);
2332 }
2333
2334
2335 /* returns the graph of a node */
2336 ir_graph *
2337 get_irn_irg(const ir_node *node) {
2338         /*
2339          * Do not use get_nodes_Block() here, because this
2340          * will check the pinned state.
2341          * However even a 'wrong' block is always in the proper
2342          * irg.
2343          */
2344         if (! is_Block(node))
2345                 node = get_irn_n(node, -1);
2346         if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2347                 node = get_irn_n(node, -1);
2348         assert(get_irn_op(node) == op_Block);
2349         return node->attr.block.irg;
2350 }
2351
2352
2353 /*----------------------------------------------------------------*/
2354 /*  Auxiliary routines                                            */
2355 /*----------------------------------------------------------------*/
2356
2357 ir_node *
2358 skip_Proj(ir_node *node) {
2359         /* don't assert node !!! */
2360         if (node == NULL)
2361                 return NULL;
2362
2363         if (is_Proj(node))
2364                 node = get_Proj_pred(node);
2365
2366         return node;
2367 }
2368
2369 const ir_node *
2370 skip_Proj_const(const ir_node *node) {
2371         /* don't assert node !!! */
2372         if (node == NULL)
2373                 return NULL;
2374
2375         if (is_Proj(node))
2376                 node = get_Proj_pred(node);
2377
2378         return node;
2379 }
2380
2381 ir_node *
2382 skip_Tuple(ir_node *node) {
2383   ir_node *pred;
2384   ir_op   *op;
2385
2386   if (!get_opt_normalize()) return node;
2387
2388 restart:
2389         if (get_irn_op(node) == op_Proj) {
2390             pred = get_Proj_pred(node);
2391             op   = get_irn_op(pred);
2392
2393                 /*
2394                  * Looks strange but calls get_irn_op() only once
2395                  * in most often cases.
2396                  */
2397                 if (op == op_Proj) { /* nested Tuple ? */
2398                     pred = skip_Tuple(pred);
2399                     op   = get_irn_op(pred);
2400
2401                         if (op == op_Tuple) {
2402                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
2403                                 goto restart;
2404                         }
2405                 } else if (op == op_Tuple) {
2406                         node = get_Tuple_pred(pred, get_Proj_proj(node));
2407                         goto restart;
2408                 }
2409         }
2410         return node;
2411 }
2412
2413 /* returns operand of node if node is a Cast */
2414 ir_node *skip_Cast(ir_node *node) {
2415         if (get_irn_op(node) == op_Cast)
2416                 return get_Cast_op(node);
2417         return node;
2418 }
2419
2420 /* returns operand of node if node is a Confirm */
2421 ir_node *skip_Confirm(ir_node *node) {
2422         if (get_irn_op(node) == op_Confirm)
2423                 return get_Confirm_value(node);
2424         return node;
2425 }
2426
2427 /* skip all high-level ops */
2428 ir_node *skip_HighLevel(ir_node *node) {
2429         if (is_op_highlevel(get_irn_op(node)))
2430                 return get_irn_n(node, 0);
2431         return node;
2432 }
2433
2434
2435 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2436  * than any other approach, as Id chains are resolved and all point to the real node, or
2437  * all id's are self loops.
2438  *
2439  * Note: This function takes 10% of mostly ANY the compiler run, so it's
2440  * a little bit "hand optimized".
2441  *
2442  * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2443  */
2444 ir_node *
2445 skip_Id(ir_node *node) {
2446         ir_node *pred;
2447         /* don't assert node !!! */
2448
2449         if (!node || (node->op != op_Id)) return node;
2450
2451         /* Don't use get_Id_pred():  We get into an endless loop for
2452            self-referencing Ids. */
2453         pred = node->in[0+1];
2454
2455         if (pred->op != op_Id) return pred;
2456
2457         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2458                 ir_node *rem_pred, *res;
2459
2460                 if (pred->op != op_Id) return pred; /* shortcut */
2461                 rem_pred = pred;
2462
2463                 assert(get_irn_arity (node) > 0);
2464
2465                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2466                 res = skip_Id(rem_pred);
2467                 if (res->op == op_Id) /* self-loop */ return node;
2468
2469                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2470                 return res;
2471         } else {
2472                 return node;
2473         }
2474 }
2475
2476 void skip_Id_and_store(ir_node **node) {
2477         ir_node *n = *node;
2478
2479         if (!n || (n->op != op_Id)) return;
2480
2481         /* Don't use get_Id_pred():  We get into an endless loop for
2482            self-referencing Ids. */
2483         *node = skip_Id(n);
2484 }
2485
2486 int
2487 (is_Bad)(const ir_node *node) {
2488         return _is_Bad(node);
2489 }
2490
2491 int
2492 (is_NoMem)(const ir_node *node) {
2493         return _is_NoMem(node);
2494 }
2495
2496 int
2497 (is_Mod)(const ir_node *node) {
2498         return _is_Mod(node);
2499 }
2500
2501 int
2502 (is_Div)(const ir_node *node) {
2503         return _is_Div(node);
2504 }
2505
2506 int
2507 (is_DivMod)(const ir_node *node) {
2508         return _is_DivMod(node);
2509 }
2510
2511 int
2512 (is_Quot)(const ir_node *node) {
2513         return _is_Quot(node);
2514 }
2515
2516 int
2517 (is_Add)(const ir_node *node) {
2518         return _is_Add(node);
2519 }
2520
2521 int
2522 (is_Sub)(const ir_node *node) {
2523         return _is_Sub(node);
2524 }
2525
2526 int
2527 (is_Start)(const ir_node *node) {
2528   return _is_Start(node);
2529 }
2530
2531 int
2532 (is_End)(const ir_node *node) {
2533         return _is_End(node);
2534 }
2535
2536 int
2537 (is_Const)(const ir_node *node) {
2538         return _is_Const(node);
2539 }
2540
2541 int
2542 (is_Conv)(const ir_node *node) {
2543         return _is_Conv(node);
2544 }
2545
2546 int
2547 (is_no_Block)(const ir_node *node) {
2548         return _is_no_Block(node);
2549 }
2550
2551 int
2552 (is_Block)(const ir_node *node) {
2553         return _is_Block(node);
2554 }
2555
2556 /* returns true if node is an Unknown node. */
2557 int
2558 (is_Unknown)(const ir_node *node) {
2559         return _is_Unknown(node);
2560 }
2561
2562 /* returns true if node is a Return node. */
2563 int
2564 (is_Return)(const ir_node *node) {
2565         return _is_Return(node);
2566 }
2567
2568 /* returns true if node is a Call node. */
2569 int
2570 (is_Call)(const ir_node *node) {
2571         return _is_Call(node);
2572 }
2573
2574 /* returns true if node is a Sel node. */
2575 int
2576 (is_Sel)(const ir_node *node) {
2577         return _is_Sel(node);
2578 }
2579
2580 /* returns true if node is a Mux node or a Psi with only one condition. */
2581 int
2582 (is_Mux)(const ir_node *node) {
2583         return _is_Mux(node);
2584 }
2585
2586 /* returns true if node is a Load node. */
2587 int
2588 (is_Load)(const ir_node *node) {
2589         return _is_Load(node);
2590 }
2591
2592 /* returns true if node is a Load node. */
2593 int
2594 (is_Store)(const ir_node *node) {
2595         return _is_Store(node);
2596 }
2597
2598 /* returns true if node is a Sync node. */
2599 int
2600 (is_Sync)(const ir_node *node) {
2601         return _is_Sync(node);
2602 }
2603
2604 /* returns true if node is a Confirm node. */
2605 int
2606 (is_Confirm)(const ir_node *node) {
2607         return _is_Confirm(node);
2608 }
2609
2610 /* returns true if node is a Pin node. */
2611 int
2612 (is_Pin)(const ir_node *node) {
2613         return _is_Pin(node);
2614 }
2615
2616 /* returns true if node is a SymConst node. */
2617 int
2618 (is_SymConst)(const ir_node *node) {
2619         return _is_SymConst(node);
2620 }
2621
2622 /* returns true if node is a Cond node. */
2623 int
2624 (is_Cond)(const ir_node *node) {
2625         return _is_Cond(node);
2626 }
2627
2628 int
2629 (is_CopyB)(const ir_node *node) {
2630         return _is_CopyB(node);
2631 }
2632
2633 /* returns true if node is a Cmp node. */
2634 int
2635 (is_Cmp)(const ir_node *node) {
2636         return _is_Cmp(node);
2637 }
2638
2639 /* returns true if node is an Alloc node. */
2640 int
2641 (is_Alloc)(const ir_node *node) {
2642         return _is_Alloc(node);
2643 }
2644
2645 /* returns true if a node is a Jmp node. */
2646 int
2647 (is_Jmp)(const ir_node *node) {
2648         return _is_Jmp(node);
2649 }
2650
2651 /* returns true if a node is a Raise node. */
2652 int
2653 (is_Raise)(const ir_node *node) {
2654         return _is_Raise(node);
2655 }
2656
2657 int
2658 is_Proj(const ir_node *node) {
2659         assert(node);
2660         return node->op == op_Proj ||
2661                (!get_interprocedural_view() && node->op == op_Filter);
2662 }
2663
2664 /* Returns true if the operation manipulates control flow. */
2665 int
2666 is_cfop(const ir_node *node) {
2667         return is_cfopcode(get_irn_op(node));
2668 }
2669
2670 /* Returns true if the operation manipulates interprocedural control flow:
2671    CallBegin, EndReg, EndExcept */
2672 int is_ip_cfop(const ir_node *node) {
2673         return is_ip_cfopcode(get_irn_op(node));
2674 }
2675
2676 /* Returns true if the operation can change the control flow because
2677    of an exception. */
2678 int
2679 is_fragile_op(const ir_node *node) {
2680         return is_op_fragile(get_irn_op(node));
2681 }
2682
2683 /* Returns the memory operand of fragile operations. */
2684 ir_node *get_fragile_op_mem(ir_node *node) {
2685         assert(node && is_fragile_op(node));
2686
2687         switch (get_irn_opcode (node)) {
2688         case iro_Call  :
2689         case iro_Quot  :
2690         case iro_DivMod:
2691         case iro_Div   :
2692         case iro_Mod   :
2693         case iro_Load  :
2694         case iro_Store :
2695         case iro_Alloc :
2696         case iro_Bound :
2697                 return get_irn_n(node, 0);
2698         case iro_Bad   :
2699         case iro_Unknown:
2700                 return node;
2701         default: ;
2702                 assert(0 && "should not be reached");
2703                 return NULL;
2704         }
2705 }
2706
2707 /* Returns true if the operation is a forking control flow operation. */
2708 int (is_irn_forking)(const ir_node *node) {
2709         return _is_irn_forking(node);
2710 }
2711
2712 /* Return the type associated with the value produced by n
2713  * if the node remarks this type as it is the case for
2714  * Cast, Const, SymConst and some Proj nodes. */
2715 ir_type *(get_irn_type)(ir_node *node) {
2716         return _get_irn_type(node);
2717 }
2718
2719 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
2720    Cast) or NULL.*/
2721 ir_type *(get_irn_type_attr)(ir_node *node) {
2722         return _get_irn_type_attr(node);
2723 }
2724
2725 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
2726 ir_entity *(get_irn_entity_attr)(ir_node *node) {
2727         return _get_irn_entity_attr(node);
2728 }
2729
2730 /* Returns non-zero for constant-like nodes. */
2731 int (is_irn_constlike)(const ir_node *node) {
2732         return _is_irn_constlike(node);
2733 }
2734
2735 /*
2736  * Returns non-zero for nodes that are allowed to have keep-alives and
2737  * are neither Block nor PhiM.
2738  */
2739 int (is_irn_keep)(const ir_node *node) {
2740         return _is_irn_keep(node);
2741 }
2742
2743 /*
2744  * Returns non-zero for nodes that are always placed in the start block.
2745  */
2746 int (is_irn_start_block_placed)(const ir_node *node) {
2747         return _is_irn_start_block_placed(node);
2748 }
2749
2750 /* Returns non-zero for nodes that are machine operations. */
2751 int (is_irn_machine_op)(const ir_node *node) {
2752         return _is_irn_machine_op(node);
2753 }
2754
2755 /* Returns non-zero for nodes that are machine operands. */
2756 int (is_irn_machine_operand)(const ir_node *node) {
2757         return _is_irn_machine_operand(node);
2758 }
2759
2760 /* Returns non-zero for nodes that have the n'th user machine flag set. */
2761 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
2762         return _is_irn_machine_user(node, n);
2763 }
2764
2765
2766 /* Gets the string representation of the jump prediction .*/
2767 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
2768         switch (pred) {
2769         default:
2770         case COND_JMP_PRED_NONE:  return "no prediction";
2771         case COND_JMP_PRED_TRUE:  return "true taken";
2772         case COND_JMP_PRED_FALSE: return "false taken";
2773         }
2774 }
2775
2776 /* Returns the conditional jump prediction of a Cond node. */
2777 cond_jmp_predicate (get_Cond_jmp_pred)(ir_node *cond) {
2778         return _get_Cond_jmp_pred(cond);
2779 }
2780
2781 /* Sets a new conditional jump prediction. */
2782 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
2783         _set_Cond_jmp_pred(cond, pred);
2784 }
2785
2786 /** the get_type operation must be always implemented and return a firm type */
2787 static ir_type *get_Default_type(ir_node *n) {
2788         return get_unknown_type();
2789 }
2790
2791 /* Sets the get_type operation for an ir_op_ops. */
2792 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
2793         switch (code) {
2794         case iro_Const:    ops->get_type = get_Const_type; break;
2795         case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
2796         case iro_Cast:     ops->get_type = get_Cast_type; break;
2797         case iro_Proj:     ops->get_type = get_Proj_type; break;
2798         default:
2799                 /* not allowed to be NULL */
2800                 if (! ops->get_type)
2801                         ops->get_type = get_Default_type;
2802                 break;
2803         }
2804         return ops;
2805 }
2806
2807 /** Return the attribute type of a SymConst node if exists */
2808 static ir_type *get_SymConst_attr_type(ir_node *self) {
2809         symconst_kind kind = get_SymConst_kind(self);
2810         if (SYMCONST_HAS_TYPE(kind))
2811                 return get_SymConst_type(self);
2812         return NULL;
2813 }
2814
2815 /** Return the attribute entity of a SymConst node if exists */
2816 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
2817         symconst_kind kind = get_SymConst_kind(self);
2818         if (SYMCONST_HAS_ENT(kind))
2819                 return get_SymConst_entity(self);
2820         return NULL;
2821 }
2822
2823 /** the get_type_attr operation must be always implemented */
2824 static ir_type *get_Null_type(ir_node *n) {
2825         return firm_unknown_type;
2826 }
2827
2828 /* Sets the get_type operation for an ir_op_ops. */
2829 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
2830         switch (code) {
2831         case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
2832         case iro_Call:     ops->get_type_attr = get_Call_type; break;
2833         case iro_Alloc:    ops->get_type_attr = get_Alloc_type; break;
2834         case iro_Free:     ops->get_type_attr = get_Free_type; break;
2835         case iro_Cast:     ops->get_type_attr = get_Cast_type; break;
2836         default:
2837                 /* not allowed to be NULL */
2838                 if (! ops->get_type_attr)
2839                         ops->get_type_attr = get_Null_type;
2840                 break;
2841         }
2842         return ops;
2843 }
2844
2845 /** the get_entity_attr operation must be always implemented */
2846 static ir_entity *get_Null_ent(ir_node *n) {
2847         return NULL;
2848 }
2849
2850 /* Sets the get_type operation for an ir_op_ops. */
2851 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
2852         switch (code) {
2853         case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
2854         case iro_Sel:      ops->get_entity_attr = get_Sel_entity; break;
2855         default:
2856                 /* not allowed to be NULL */
2857                 if (! ops->get_entity_attr)
2858                         ops->get_entity_attr = get_Null_ent;
2859                 break;
2860         }
2861         return ops;
2862 }
2863
2864 #ifdef DEBUG_libfirm
2865 void dump_irn(ir_node *n) {
2866         int i, arity = get_irn_arity(n);
2867         printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
2868         if (!is_Block(n)) {
2869                 ir_node *pred = get_irn_n(n, -1);
2870                 printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2871                         get_irn_node_nr(pred), (void *)pred);
2872         }
2873         printf("  preds: \n");
2874         for (i = 0; i < arity; ++i) {
2875                 ir_node *pred = get_irn_n(n, i);
2876                 printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2877                         get_irn_node_nr(pred), (void *)pred);
2878         }
2879 }
2880
2881 #else  /* DEBUG_libfirm */
2882 void dump_irn(ir_node *n) {}
2883 #endif /* DEBUG_libfirm */