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