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 /* this works for all except Block */
 668 ir_node *
 669 get_nodes_MacroBlock(const ir_node *node) {
 670         assert(node->op != op_Block);
 671         return get_Block_MacroBlock(get_irn_n(node, -1));
 672 }
 673
 674 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
 675  * from Start.  If so returns frame type, else Null. */
 676 ir_type *is_frame_pointer(ir_node *n) {
 677         if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_frame_base)) {
 678                 ir_node *start = get_Proj_pred(n);
 679                 if (get_irn_op(start) == op_Start) {
 680                         return get_irg_frame_type(get_irn_irg(start));
 681                 }
 682         }
 683         return NULL;
 684 }
 685
 686 /* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
 687  * from Start.  If so returns global type, else Null. */
 688 ir_type *is_globals_pointer(ir_node *n) {
 689         if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
 690                 ir_node *start = get_Proj_pred(n);
 691                 if (get_irn_op(start) == op_Start) {
 692                         return get_glob_type();
 693                 }
 694         }
 695         return NULL;
 696 }
 697
 698 /* Test whether arbitrary node is tls pointer, i.e. Proj(pn_Start_P_tls)
 699  * from Start.  If so returns tls type, else Null. */
 700 ir_type *is_tls_pointer(ir_node *n) {
 701         if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
 702                 ir_node *start = get_Proj_pred(n);
 703                 if (get_irn_op(start) == op_Start) {
 704                         return get_tls_type();
 705                 }
 706         }
 707         return NULL;
 708 }
 709
 710 /* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
 711  * from Start.  If so returns 1, else 0. */
 712 int is_value_arg_pointer(ir_node *n) {
 713         if ((get_irn_op(n) == op_Proj) &&
 714                 (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
 715                 (get_irn_op(get_Proj_pred(n)) == op_Start))
 716                 return 1;
 717         return 0;
 718 }
 719
 720 /* Returns an array with the predecessors of the Block. Depending on
 721    the implementation of the graph data structure this can be a copy of
 722    the internal representation of predecessors as well as the internal
 723    array itself. Therefore writing to this array might obstruct the ir. */
 724 ir_node **
 725 get_Block_cfgpred_arr(ir_node *node) {
 726         assert((node->op == op_Block));
 727         return (ir_node **)&(get_irn_in(node)[1]);
 728 }
 729
 730 int
 731 (get_Block_n_cfgpreds)(const ir_node *node) {
 732         return _get_Block_n_cfgpreds(node);
 733 }
 734
 735 ir_node *
 736 (get_Block_cfgpred)(const ir_node *node, int pos) {
 737         return _get_Block_cfgpred(node, pos);
 738 }
 739
 740 void
 741 set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
 742         assert(node->op == op_Block);
 743         set_irn_n(node, pos, pred);
 744 }
 745
 746 ir_node  *
 747 (get_Block_cfgpred_block)(const ir_node *node, int pos) {
 748         return _get_Block_cfgpred_block(node, pos);
 749 }
 750
 751 int
 752 get_Block_matured(const ir_node *node) {
 753         assert(node->op == op_Block);
 754         return (int)node->attr.block.is_matured;
 755 }
 756
 757 void
 758 set_Block_matured(ir_node *node, int matured) {
 759         assert(node->op == op_Block);
 760         node->attr.block.is_matured = matured;
 761 }
 762
 763 unsigned long
 764 (get_Block_block_visited)(const ir_node *node) {
 765         return _get_Block_block_visited(node);
 766 }
 767
 768 void
 769 (set_Block_block_visited)(ir_node *node, unsigned long visit) {
 770         _set_Block_block_visited(node, visit);
 771 }
 772
 773 /* For this current_ir_graph must be set. */
 774 void
 775 (mark_Block_block_visited)(ir_node *node) {
 776         _mark_Block_block_visited(node);
 777 }
 778
 779 int
 780 (Block_not_block_visited)(const ir_node *node) {
 781         return _Block_not_block_visited(node);
 782 }
 783
 784 int
 785 (Block_block_visited)(const ir_node *node) {
 786         return _Block_block_visited(node);
 787 }
 788
 789 ir_node *
 790 get_Block_graph_arr (ir_node *node, int pos) {
 791         assert(node->op == op_Block);
 792         return node->attr.block.graph_arr[pos+1];
 793 }
 794
 795 void
 796 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
 797         assert(node->op == op_Block);
 798         node->attr.block.graph_arr[pos+1] = value;
 799 }
 800
 801 #ifdef INTERPROCEDURAL_VIEW
 802 void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]) {
 803         assert(node->op == op_Block);
 804         if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
 805                 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
 806                 node->attr.block.in_cg[0] = NULL;
 807                 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
 808                 {
 809                         /* Fix backedge array.  fix_backedges() operates depending on
 810                            interprocedural_view. */
 811                         int ipv = get_interprocedural_view();
 812                         set_interprocedural_view(1);
 813                         fix_backedges(current_ir_graph->obst, node);
 814                         set_interprocedural_view(ipv);
 815                 }
 816         }
 817         memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
 818 }
 819
 820 void set_Block_cg_cfgpred(ir_node *node, int pos, ir_node *pred) {
 821         assert(node->op == op_Block &&
 822                node->attr.block.in_cg &&
 823                0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
 824         node->attr.block.in_cg[pos + 1] = pred;
 825 }
 826
 827 ir_node **get_Block_cg_cfgpred_arr(ir_node *node) {
 828         assert(node->op == op_Block);
 829         return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg  + 1;
 830 }
 831
 832 int get_Block_cg_n_cfgpreds(ir_node *node) {
 833         assert(node->op == op_Block);
 834         return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
 835 }
 836
 837 ir_node *get_Block_cg_cfgpred(ir_node *node, int pos) {
 838         assert(node->op == op_Block && node->attr.block.in_cg);
 839         return node->attr.block.in_cg[pos + 1];
 840 }
 841
 842 void remove_Block_cg_cfgpred_arr(ir_node *node) {
 843         assert(node->op == op_Block);
 844         node->attr.block.in_cg = NULL;
 845 }
 846 #endif
 847
 848 ir_node *(set_Block_dead)(ir_node *block) {
 849         return _set_Block_dead(block);
 850 }
 851
 852 int (is_Block_dead)(const ir_node *block) {
 853         return _is_Block_dead(block);
 854 }
 855
 856 ir_extblk *get_Block_extbb(const ir_node *block) {
 857         ir_extblk *res;
 858         assert(is_Block(block));
 859         res = block->attr.block.extblk;
 860         assert(res == NULL || is_ir_extbb(res));
 861         return res;
 862 }
 863
 864 void set_Block_extbb(ir_node *block, ir_extblk *extblk) {
 865         assert(is_Block(block));
 866         assert(extblk == NULL || is_ir_extbb(extblk));
 867         block->attr.block.extblk = extblk;
 868 }
 869
 870 /* returns the macro block header of a block. */
 871 ir_node *get_Block_MacroBlock(const ir_node *block) {
 872         ir_node *mbh;
 873         assert(is_Block(block));
 874         mbh = get_irn_n(block, -1);
 875         /* once macro block header is respected by all optimizations,
 876            this assert can be removed */
 877         assert(mbh != NULL);
 878         return mbh;
 879 }
 880
 881 /* returns the graph of a Block. */
 882 ir_graph *get_Block_irg(const ir_node *block) {
 883         assert(is_Block(block));
 884         return block->attr.block.irg;
 885 }
 886
 887 int has_Block_label(const ir_node *block) {
 888         assert(is_Block(block));
 889         return block->attr.block.has_label;
 890 }
 891
 892 ir_label_t get_Block_label(const ir_node *block) {
 893         assert(is_Block(block));
 894         return block->attr.block.label;
 895 }
 896
 897 void set_Block_label(ir_node *block, ir_label_t label) {
 898         assert(is_Block(block));
 899         block->attr.block.has_label = 1;
 900         block->attr.block.label = label;
 901 }
 902
 903 int
 904 get_End_n_keepalives(ir_node *end) {
 905         assert(end->op == op_End);
 906         return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
 907 }
 908
 909 ir_node *
 910 get_End_keepalive(ir_node *end, int pos) {
 911         assert(end->op == op_End);
 912         return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
 913 }
 914
 915 void
 916 add_End_keepalive(ir_node *end, ir_node *ka) {
 917         assert(end->op == op_End);
 918         assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!");
 919         add_irn_n(end, ka);
 920 }
 921
 922 void
 923 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
 924         assert(end->op == op_End);
 925         set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 926 }
 927
 928 /* Set new keep-alives */
 929 void set_End_keepalives(ir_node *end, int n, ir_node *in[]) {
 930         int i;
 931         ir_graph *irg = get_irn_irg(end);
 932
 933         /* notify that edges are deleted */
 934         for (i = END_KEEPALIVE_OFFSET; i < ARR_LEN(end->in) - 1; ++i) {
 935                 edges_notify_edge(end, i, NULL, end->in[i + 1], irg);
 936         }
 937         ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET);
 938
 939         for (i = 0; i < n; ++i) {
 940                 end->in[1 + END_KEEPALIVE_OFFSET + i] = in[i];
 941                 edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, end->in[1 + END_KEEPALIVE_OFFSET + i], NULL, irg);
 942         }
 943 }
 944
 945 /* Set new keep-alives from old keep-alives, skipping irn */
 946 void remove_End_keepalive(ir_node *end, ir_node *irn) {
 947         int     n = get_End_n_keepalives(end);
 948         ir_node **in;
 949         int     i, idx;
 950
 951         NEW_ARR_A(ir_node *, in, n);
 952
 953         for (idx = i = 0; i < n; ++i) {
 954                 ir_node *old_ka = get_End_keepalive(end, i);
 955
 956                 /* skip irn */
 957                 if (old_ka != irn)
 958                         in[idx++] = old_ka;
 959         }
 960
 961         /* set new keep-alives */
 962         set_End_keepalives(end, idx, in);
 963 }
 964
 965 void
 966 free_End (ir_node *end) {
 967         assert(end->op == op_End);
 968         end->kind = k_BAD;
 969         DEL_ARR_F(end->in);
 970         end->in = NULL;   /* @@@ make sure we get an error if we use the
 971                              in array afterwards ... */
 972 }
 973
 974 /* Return the target address of an IJmp */
 975 ir_node *get_IJmp_target(ir_node *ijmp) {
 976         assert(ijmp->op == op_IJmp);
 977         return get_irn_n(ijmp, 0);
 978 }
 979
 980 /** Sets the target address of an IJmp */
 981 void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
 982         assert(ijmp->op == op_IJmp);
 983         set_irn_n(ijmp, 0, tgt);
 984 }
 985
 986 /*
 987 > Implementing the case construct (which is where the constant Proj node is
 988 > important) involves far more than simply determining the constant values.
 989 > We could argue that this is more properly a function of the translator from
 990 > Firm to the target machine.  That could be done if there was some way of
 991 > projecting "default" out of the Cond node.
 992 I know it's complicated.
 993 Basically there are two proglems:
 994  - determining the gaps between the projs
 995  - determining the biggest case constant to know the proj number for
 996    the default node.
 997 I see several solutions:
 998 1. Introduce a ProjDefault node.  Solves both problems.
 999    This means to extend all optimizations executed during construction.
1000 2. Give the Cond node for switch two flavors:
1001    a) there are no gaps in the projs  (existing flavor)
1002    b) gaps may exist, default proj is still the Proj with the largest
1003       projection number.  This covers also the gaps.
1004 3. Fix the semantic of the Cond to that of 2b)
1005
1006 Solution 2 seems to be the best:
1007 Computing the gaps in the Firm representation is not too hard, i.e.,
1008 libFIRM can implement a routine that transforms between the two
1009 flavours.  This is also possible for 1) but 2) does not require to
1010 change any existing optimization.
1011 Further it should be far simpler to determine the biggest constant than
1012 to compute all gaps.
1013 I don't want to choose 3) as 2a) seems to have advantages for
1014 dataflow analysis and 3) does not allow to convert the representation to
1015 2a).
1016 */
1017 ir_node *
1018 get_Cond_selector(ir_node *node) {
1019         assert(node->op == op_Cond);
1020         return get_irn_n(node, 0);
1021 }
1022
1023 void
1024 set_Cond_selector(ir_node *node, ir_node *selector) {
1025         assert(node->op == op_Cond);
1026         set_irn_n(node, 0, selector);
1027 }
1028
1029 cond_kind
1030 get_Cond_kind(ir_node *node) {
1031         assert(node->op == op_Cond);
1032         return node->attr.cond.kind;
1033 }
1034
1035 void
1036 set_Cond_kind(ir_node *node, cond_kind kind) {
1037         assert(node->op == op_Cond);
1038         node->attr.cond.kind = kind;
1039 }
1040
1041 long
1042 get_Cond_defaultProj(ir_node *node) {
1043         assert(node->op == op_Cond);
1044         return node->attr.cond.default_proj;
1045 }
1046
1047 ir_node *
1048 get_Return_mem(ir_node *node) {
1049         assert(node->op == op_Return);
1050         return get_irn_n(node, 0);
1051 }
1052
1053 void
1054 set_Return_mem(ir_node *node, ir_node *mem) {
1055         assert(node->op == op_Return);
1056         set_irn_n(node, 0, mem);
1057 }
1058
1059 int
1060 get_Return_n_ress(ir_node *node) {
1061         assert(node->op == op_Return);
1062         return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
1063 }
1064
1065 ir_node **
1066 get_Return_res_arr (ir_node *node) {
1067         assert((node->op == op_Return));
1068         if (get_Return_n_ress(node) > 0)
1069                 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
1070         else
1071                 return NULL;
1072 }
1073
1074 /*
1075 void
1076 set_Return_n_res(ir_node *node, int results) {
1077         assert(node->op == op_Return);
1078 }
1079 */
1080
1081 ir_node *
1082 get_Return_res(ir_node *node, int pos) {
1083         assert(node->op == op_Return);
1084         assert(get_Return_n_ress(node) > pos);
1085         return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
1086 }
1087
1088 void
1089 set_Return_res(ir_node *node, int pos, ir_node *res){
1090         assert(node->op == op_Return);
1091         set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
1092 }
1093
1094 tarval *(get_Const_tarval)(const ir_node *node) {
1095         return _get_Const_tarval(node);
1096 }
1097
1098 void
1099 set_Const_tarval(ir_node *node, tarval *con) {
1100         assert(node->op == op_Const);
1101         node->attr.con.tv = con;
1102 }
1103
1104 int (is_Const_null)(const ir_node *node) {
1105         return _is_Const_null(node);
1106 }
1107
1108 int (is_Const_one)(const ir_node *node) {
1109         return _is_Const_one(node);
1110 }
1111
1112 int (is_Const_all_one)(const ir_node *node) {
1113         return _is_Const_all_one(node);
1114 }
1115
1116
1117 /* The source language type.  Must be an atomic type.  Mode of type must
1118    be mode of node. For tarvals from entities type must be pointer to
1119    entity type. */
1120 ir_type *
1121 get_Const_type(ir_node *node) {
1122         assert(node->op == op_Const);
1123         node->attr.con.tp = skip_tid(node->attr.con.tp);
1124         return node->attr.con.tp;
1125 }
1126
1127 void
1128 set_Const_type(ir_node *node, ir_type *tp) {
1129         assert(node->op == op_Const);
1130         if (tp != firm_unknown_type) {
1131                 assert(is_atomic_type(tp));
1132                 assert(get_type_mode(tp) == get_irn_mode(node));
1133         }
1134         node->attr.con.tp = tp;
1135 }
1136
1137
1138 symconst_kind
1139 get_SymConst_kind(const ir_node *node) {
1140         assert(node->op == op_SymConst);
1141         return node->attr.symc.num;
1142 }
1143
1144 void
1145 set_SymConst_kind(ir_node *node, symconst_kind num) {
1146         assert(node->op == op_SymConst);
1147         node->attr.symc.num = num;
1148 }
1149
1150 ir_type *
1151 get_SymConst_type(ir_node *node) {
1152         assert((node->op == op_SymConst) &&
1153                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1154         return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p);
1155 }
1156
1157 void
1158 set_SymConst_type(ir_node *node, ir_type *tp) {
1159         assert((node->op == op_SymConst) &&
1160                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1161         node->attr.symc.sym.type_p = tp;
1162 }
1163
1164 ident *
1165 get_SymConst_name(const ir_node *node) {
1166         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1167         return node->attr.symc.sym.ident_p;
1168 }
1169
1170 void
1171 set_SymConst_name(ir_node *node, ident *name) {
1172         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1173         node->attr.symc.sym.ident_p = name;
1174 }
1175
1176
1177 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
1178 ir_entity *get_SymConst_entity(const ir_node *node) {
1179         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1180         return node->attr.symc.sym.entity_p;
1181 }
1182
1183 void set_SymConst_entity(ir_node *node, ir_entity *ent) {
1184         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1185         node->attr.symc.sym.entity_p  = ent;
1186 }
1187
1188 ir_enum_const *get_SymConst_enum(const ir_node *node) {
1189         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1190         return node->attr.symc.sym.enum_p;
1191 }
1192
1193 void set_SymConst_enum(ir_node *node, ir_enum_const *ec) {
1194         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1195         node->attr.symc.sym.enum_p  = ec;
1196 }
1197
1198 union symconst_symbol
1199 get_SymConst_symbol(const ir_node *node) {
1200         assert(node->op == op_SymConst);
1201         return node->attr.symc.sym;
1202 }
1203
1204 void
1205 set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
1206         assert(node->op == op_SymConst);
1207         node->attr.symc.sym = sym;
1208 }
1209
1210 ir_label_t get_SymConst_label(const ir_node *node) {
1211         assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
1212         return node->attr.symc.sym.label;
1213 }
1214
1215 void set_SymConst_label(ir_node *node, ir_label_t label) {
1216         assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
1217         node->attr.symc.sym.label = label;
1218 }
1219
1220 ir_type *
1221 get_SymConst_value_type(ir_node *node) {
1222         assert(node->op == op_SymConst);
1223         if (node->attr.symc.tp) node->attr.symc.tp = skip_tid(node->attr.symc.tp);
1224         return node->attr.symc.tp;
1225 }
1226
1227 void
1228 set_SymConst_value_type(ir_node *node, ir_type *tp) {
1229         assert(node->op == op_SymConst);
1230         node->attr.symc.tp = tp;
1231 }
1232
1233 ir_node *
1234 get_Sel_mem(ir_node *node) {
1235         assert(node->op == op_Sel);
1236         return get_irn_n(node, 0);
1237 }
1238
1239 void
1240 set_Sel_mem(ir_node *node, ir_node *mem) {
1241         assert(node->op == op_Sel);
1242         set_irn_n(node, 0, mem);
1243 }
1244
1245 ir_node *
1246 get_Sel_ptr(ir_node *node) {
1247         assert(node->op == op_Sel);
1248         return get_irn_n(node, 1);
1249 }
1250
1251 void
1252 set_Sel_ptr(ir_node *node, ir_node *ptr) {
1253         assert(node->op == op_Sel);
1254         set_irn_n(node, 1, ptr);
1255 }
1256
1257 int
1258 get_Sel_n_indexs(ir_node *node) {
1259         assert(node->op == op_Sel);
1260         return (get_irn_arity(node) - SEL_INDEX_OFFSET);
1261 }
1262
1263 ir_node **
1264 get_Sel_index_arr(ir_node *node) {
1265         assert((node->op == op_Sel));
1266         if (get_Sel_n_indexs(node) > 0)
1267                 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
1268         else
1269                 return NULL;
1270 }
1271
1272 ir_node *
1273 get_Sel_index(ir_node *node, int pos) {
1274         assert(node->op == op_Sel);
1275         return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1276 }
1277
1278 void
1279 set_Sel_index(ir_node *node, int pos, ir_node *index) {
1280         assert(node->op == op_Sel);
1281         set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1282 }
1283
1284 ir_entity *
1285 get_Sel_entity(ir_node *node) {
1286         assert(node->op == op_Sel);
1287         return node->attr.sel.ent;
1288 }
1289
1290 void
1291 set_Sel_entity(ir_node *node, ir_entity *ent) {
1292         assert(node->op == op_Sel);
1293         node->attr.sel.ent = ent;
1294 }
1295
1296
1297 /* For unary and binary arithmetic operations the access to the
1298    operands can be factored out.  Left is the first, right the
1299    second arithmetic value  as listed in tech report 0999-33.
1300    unops are: Minus, Abs, Not, Conv, Cast
1301    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1302    Shr, Shrs, Rotate, Cmp */
1303
1304
1305 ir_node *
1306 get_Call_mem(ir_node *node) {
1307         assert(node->op == op_Call);
1308         return get_irn_n(node, 0);
1309 }
1310
1311 void
1312 set_Call_mem(ir_node *node, ir_node *mem) {
1313         assert(node->op == op_Call);
1314         set_irn_n(node, 0, mem);
1315 }
1316
1317 ir_node *
1318 get_Call_ptr(ir_node *node) {
1319         assert(node->op == op_Call);
1320         return get_irn_n(node, 1);
1321 }
1322
1323 void
1324 set_Call_ptr(ir_node *node, ir_node *ptr) {
1325         assert(node->op == op_Call);
1326         set_irn_n(node, 1, ptr);
1327 }
1328
1329 ir_node **
1330 get_Call_param_arr(ir_node *node) {
1331         assert(node->op == op_Call);
1332         return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1333 }
1334
1335 int
1336 get_Call_n_params(ir_node *node)  {
1337         assert(node->op == op_Call);
1338         return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1339 }
1340
1341 int
1342 get_Call_arity(ir_node *node) {
1343         assert(node->op == op_Call);
1344         return get_Call_n_params(node);
1345 }
1346
1347 /* void
1348 set_Call_arity(ir_node *node, ir_node *arity) {
1349         assert(node->op == op_Call);
1350 }
1351 */
1352
1353 ir_node *
1354 get_Call_param(ir_node *node, int pos) {
1355         assert(node->op == op_Call);
1356         return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1357 }
1358
1359 void
1360 set_Call_param(ir_node *node, int pos, ir_node *param) {
1361         assert(node->op == op_Call);
1362         set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1363 }
1364
1365 ir_type *
1366 get_Call_type(ir_node *node) {
1367         assert(node->op == op_Call);
1368         return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1369 }
1370
1371 void
1372 set_Call_type(ir_node *node, ir_type *tp) {
1373         assert(node->op == op_Call);
1374         assert((get_unknown_type() == tp) || is_Method_type(tp));
1375         node->attr.call.cld_tp = tp;
1376 }
1377
1378 int Call_has_callees(ir_node *node) {
1379         assert(node && node->op == op_Call);
1380         return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1381                 (node->attr.call.callee_arr != NULL));
1382 }
1383
1384 int get_Call_n_callees(ir_node * node) {
1385   assert(node && node->op == op_Call && node->attr.call.callee_arr);
1386   return ARR_LEN(node->attr.call.callee_arr);
1387 }
1388
1389 ir_entity * get_Call_callee(ir_node * node, int pos) {
1390         assert(pos >= 0 && pos < get_Call_n_callees(node));
1391         return node->attr.call.callee_arr[pos];
1392 }
1393
1394 void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
1395         assert(node->op == op_Call);
1396         if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1397                 node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
1398         }
1399         memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
1400 }
1401
1402 void remove_Call_callee_arr(ir_node * node) {
1403         assert(node->op == op_Call);
1404         node->attr.call.callee_arr = NULL;
1405 }
1406
1407 ir_node * get_CallBegin_ptr(ir_node *node) {
1408         assert(node->op == op_CallBegin);
1409         return get_irn_n(node, 0);
1410 }
1411
1412 void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
1413         assert(node->op == op_CallBegin);
1414         set_irn_n(node, 0, ptr);
1415 }
1416
1417 ir_node * get_CallBegin_call(ir_node *node) {
1418         assert(node->op == op_CallBegin);
1419         return node->attr.callbegin.call;
1420 }
1421
1422 void  set_CallBegin_call(ir_node *node, ir_node *call) {
1423         assert(node->op == op_CallBegin);
1424         node->attr.callbegin.call = call;
1425 }
1426
1427
1428 #define BINOP(OP)                                      \
1429 ir_node * get_##OP##_left(const ir_node *node) {       \
1430   assert(node->op == op_##OP);                         \
1431   return get_irn_n(node, node->op->op_index);          \
1432 }                                                      \
1433 void set_##OP##_left(ir_node *node, ir_node *left) {   \
1434   assert(node->op == op_##OP);                         \
1435   set_irn_n(node, node->op->op_index, left);           \
1436 }                                                      \
1437 ir_node *get_##OP##_right(const ir_node *node) {       \
1438   assert(node->op == op_##OP);                         \
1439   return get_irn_n(node, node->op->op_index + 1);      \
1440 }                                                      \
1441 void set_##OP##_right(ir_node *node, ir_node *right) { \
1442   assert(node->op == op_##OP);                         \
1443   set_irn_n(node, node->op->op_index + 1, right);      \
1444 }
1445
1446 #define UNOP(OP)                                  \
1447 ir_node *get_##OP##_op(const ir_node *node) {     \
1448   assert(node->op == op_##OP);                    \
1449   return get_irn_n(node, node->op->op_index);     \
1450 }                                                 \
1451 void set_##OP##_op (ir_node *node, ir_node *op) { \
1452   assert(node->op == op_##OP);                    \
1453   set_irn_n(node, node->op->op_index, op);        \
1454 }
1455
1456 #define BINOP_MEM(OP)                         \
1457 BINOP(OP)                                     \
1458                                               \
1459 ir_node *                                     \
1460 get_##OP##_mem(ir_node *node) {               \
1461   assert(node->op == op_##OP);                \
1462   return get_irn_n(node, 0);                  \
1463 }                                             \
1464                                               \
1465 void                                          \
1466 set_##OP##_mem(ir_node *node, ir_node *mem) { \
1467   assert(node->op == op_##OP);                \
1468   set_irn_n(node, 0, mem);                    \
1469 }
1470
1471 #define DIVOP(OP)                                       \
1472 BINOP_MEM(OP)                                           \
1473                                                         \
1474 ir_mode *get_##OP##_resmode(const ir_node *node) {      \
1475   assert(node->op == op_##OP);                          \
1476   return node->attr.divmod.res_mode;                    \
1477 }                                                       \
1478                                                         \
1479 void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \
1480   assert(node->op == op_##OP);                          \
1481   node->attr.divmod.res_mode = mode;                    \
1482 }
1483
1484
1485 BINOP(Add)
1486 BINOP(Sub)
1487 UNOP(Minus)
1488 BINOP(Mul)
1489 BINOP(Mulh)
1490 DIVOP(Quot)
1491 DIVOP(DivMod)
1492 DIVOP(Div)
1493 DIVOP(Mod)
1494 UNOP(Abs)
1495 BINOP(And)
1496 BINOP(Or)
1497 BINOP(Eor)
1498 UNOP(Not)
1499 BINOP(Shl)
1500 BINOP(Shr)
1501 BINOP(Shrs)
1502 BINOP(Rot)
1503 BINOP(Cmp)
1504 UNOP(Conv)
1505 UNOP(Cast)
1506
1507 int get_Conv_strict(const ir_node *node) {
1508         assert(node->op == op_Conv);
1509         return node->attr.conv.strict;
1510 }
1511
1512 void set_Conv_strict(ir_node *node, int strict_flag) {
1513         assert(node->op == op_Conv);
1514         node->attr.conv.strict = (char)strict_flag;
1515 }
1516
1517 ir_type *
1518 get_Cast_type(ir_node *node) {
1519         assert(node->op == op_Cast);
1520         node->attr.cast.totype = skip_tid(node->attr.cast.totype);
1521         return node->attr.cast.totype;
1522 }
1523
1524 void
1525 set_Cast_type(ir_node *node, ir_type *to_tp) {
1526         assert(node->op == op_Cast);
1527         node->attr.cast.totype = to_tp;
1528 }
1529
1530
1531 /* Checks for upcast.
1532  *
1533  * Returns true if the Cast node casts a class type to a super type.
1534  */
1535 int is_Cast_upcast(ir_node *node) {
1536         ir_type *totype   = get_Cast_type(node);
1537         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1538
1539         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1540         assert(fromtype);
1541
1542         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1543                 totype   = get_pointer_points_to_type(totype);
1544                 fromtype = get_pointer_points_to_type(fromtype);
1545         }
1546
1547         assert(fromtype);
1548
1549         if (!is_Class_type(totype)) return 0;
1550         return is_SubClass_of(fromtype, totype);
1551 }
1552
1553 /* Checks for downcast.
1554  *
1555  * Returns true if the Cast node casts a class type to a sub type.
1556  */
1557 int is_Cast_downcast(ir_node *node) {
1558         ir_type *totype   = get_Cast_type(node);
1559         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1560
1561         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1562         assert(fromtype);
1563
1564         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1565                 totype   = get_pointer_points_to_type(totype);
1566                 fromtype = get_pointer_points_to_type(fromtype);
1567         }
1568
1569         assert(fromtype);
1570
1571         if (!is_Class_type(totype)) return 0;
1572         return is_SubClass_of(totype, fromtype);
1573 }
1574
1575 int
1576 (is_unop)(const ir_node *node) {
1577         return _is_unop(node);
1578 }
1579
1580 ir_node *
1581 get_unop_op(const ir_node *node) {
1582         if (node->op->opar == oparity_unary)
1583                 return get_irn_n(node, node->op->op_index);
1584
1585         assert(node->op->opar == oparity_unary);
1586         return NULL;
1587 }
1588
1589 void
1590 set_unop_op(ir_node *node, ir_node *op) {
1591         if (node->op->opar == oparity_unary)
1592                 set_irn_n(node, node->op->op_index, op);
1593
1594         assert(node->op->opar == oparity_unary);
1595 }
1596
1597 int
1598 (is_binop)(const ir_node *node) {
1599         return _is_binop(node);
1600 }
1601
1602 ir_node *
1603 get_binop_left(const ir_node *node) {
1604         assert(node->op->opar == oparity_binary);
1605         return get_irn_n(node, node->op->op_index);
1606 }
1607
1608 void
1609 set_binop_left(ir_node *node, ir_node *left) {
1610         assert(node->op->opar == oparity_binary);
1611         set_irn_n(node, node->op->op_index, left);
1612 }
1613
1614 ir_node *
1615 get_binop_right(const ir_node *node) {
1616         assert(node->op->opar == oparity_binary);
1617         return get_irn_n(node, node->op->op_index + 1);
1618 }
1619
1620 void
1621 set_binop_right(ir_node *node, ir_node *right) {
1622         assert(node->op->opar == oparity_binary);
1623         set_irn_n(node, node->op->op_index + 1, right);
1624 }
1625
1626 int
1627 (is_Phi)(const ir_node *n) {
1628         return _is_Phi(n);
1629 }
1630
1631 int is_Phi0(const ir_node *n) {
1632         assert(n);
1633
1634         return ((get_irn_op(n) == op_Phi) &&
1635                 (get_irn_arity(n) == 0) &&
1636                 (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1637 }
1638
1639 ir_node **
1640 get_Phi_preds_arr(ir_node *node) {
1641   assert(node->op == op_Phi);
1642   return (ir_node **)&(get_irn_in(node)[1]);
1643 }
1644
1645 int
1646 get_Phi_n_preds(const ir_node *node) {
1647         assert(is_Phi(node) || is_Phi0(node));
1648         return (get_irn_arity(node));
1649 }
1650
1651 /*
1652 void set_Phi_n_preds(ir_node *node, int n_preds) {
1653         assert(node->op == op_Phi);
1654 }
1655 */
1656
1657 ir_node *
1658 get_Phi_pred(const ir_node *node, int pos) {
1659         assert(is_Phi(node) || is_Phi0(node));
1660         return get_irn_n(node, pos);
1661 }
1662
1663 void
1664 set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
1665         assert(is_Phi(node) || is_Phi0(node));
1666         set_irn_n(node, pos, pred);
1667 }
1668
1669
1670 int is_memop(ir_node *node) {
1671         return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
1672 }
1673
1674 ir_node *get_memop_mem(ir_node *node) {
1675         assert(is_memop(node));
1676         return get_irn_n(node, 0);
1677 }
1678
1679 void set_memop_mem(ir_node *node, ir_node *mem) {
1680         assert(is_memop(node));
1681         set_irn_n(node, 0, mem);
1682 }
1683
1684 ir_node *get_memop_ptr(ir_node *node) {
1685         assert(is_memop(node));
1686         return get_irn_n(node, 1);
1687 }
1688
1689 void set_memop_ptr(ir_node *node, ir_node *ptr) {
1690         assert(is_memop(node));
1691         set_irn_n(node, 1, ptr);
1692 }
1693
1694 ir_node *
1695 get_Load_mem(ir_node *node) {
1696         assert(node->op == op_Load);
1697         return get_irn_n(node, 0);
1698 }
1699
1700 void
1701 set_Load_mem(ir_node *node, ir_node *mem) {
1702         assert(node->op == op_Load);
1703         set_irn_n(node, 0, mem);
1704 }
1705
1706 ir_node *
1707 get_Load_ptr(ir_node *node) {
1708         assert(node->op == op_Load);
1709         return get_irn_n(node, 1);
1710 }
1711
1712 void
1713 set_Load_ptr(ir_node *node, ir_node *ptr) {
1714         assert(node->op == op_Load);
1715         set_irn_n(node, 1, ptr);
1716 }
1717
1718 ir_mode *
1719 get_Load_mode(ir_node *node) {
1720         assert(node->op == op_Load);
1721         return node->attr.load.load_mode;
1722 }
1723
1724 void
1725 set_Load_mode(ir_node *node, ir_mode *mode) {
1726         assert(node->op == op_Load);
1727         node->attr.load.load_mode = mode;
1728 }
1729
1730 ir_volatility
1731 get_Load_volatility(ir_node *node) {
1732         assert(node->op == op_Load);
1733         return node->attr.load.volatility;
1734 }
1735
1736 void
1737 set_Load_volatility(ir_node *node, ir_volatility volatility) {
1738         assert(node->op == op_Load);
1739         node->attr.load.volatility = volatility;
1740 }
1741
1742 ir_align
1743 get_Load_align(ir_node *node) {
1744         assert(node->op == op_Load);
1745         return node->attr.load.aligned;
1746 }
1747
1748 void
1749 set_Load_align(ir_node *node, ir_align align) {
1750         assert(node->op == op_Load);
1751         node->attr.load.aligned = align;
1752 }
1753
1754
1755 ir_node *
1756 get_Store_mem(ir_node *node) {
1757         assert(node->op == op_Store);
1758         return get_irn_n(node, 0);
1759 }
1760
1761 void
1762 set_Store_mem(ir_node *node, ir_node *mem) {
1763         assert(node->op == op_Store);
1764         set_irn_n(node, 0, mem);
1765 }
1766
1767 ir_node *
1768 get_Store_ptr(ir_node *node) {
1769         assert(node->op == op_Store);
1770         return get_irn_n(node, 1);
1771 }
1772
1773 void
1774 set_Store_ptr(ir_node *node, ir_node *ptr) {
1775         assert(node->op == op_Store);
1776         set_irn_n(node, 1, ptr);
1777 }
1778
1779 ir_node *
1780 get_Store_value(ir_node *node) {
1781         assert(node->op == op_Store);
1782         return get_irn_n(node, 2);
1783 }
1784
1785 void
1786 set_Store_value(ir_node *node, ir_node *value) {
1787         assert(node->op == op_Store);
1788         set_irn_n(node, 2, value);
1789 }
1790
1791 ir_volatility
1792 get_Store_volatility(ir_node *node) {
1793         assert(node->op == op_Store);
1794         return node->attr.store.volatility;
1795 }
1796
1797 void
1798 set_Store_volatility(ir_node *node, ir_volatility volatility) {
1799         assert(node->op == op_Store);
1800         node->attr.store.volatility = volatility;
1801 }
1802
1803 ir_align
1804 get_Store_align(ir_node *node) {
1805         assert(node->op == op_Store);
1806         return node->attr.store.aligned;
1807 }
1808
1809 void
1810 set_Store_align(ir_node *node, ir_align align) {
1811         assert(node->op == op_Store);
1812         node->attr.store.aligned = align;
1813 }
1814
1815
1816 ir_node *
1817 get_Alloc_mem(ir_node *node) {
1818         assert(node->op == op_Alloc);
1819         return get_irn_n(node, 0);
1820 }
1821
1822 void
1823 set_Alloc_mem(ir_node *node, ir_node *mem) {
1824         assert(node->op == op_Alloc);
1825         set_irn_n(node, 0, mem);
1826 }
1827
1828 ir_node *
1829 get_Alloc_size(ir_node *node) {
1830         assert(node->op == op_Alloc);
1831         return get_irn_n(node, 1);
1832 }
1833
1834 void
1835 set_Alloc_size(ir_node *node, ir_node *size) {
1836         assert(node->op == op_Alloc);
1837         set_irn_n(node, 1, size);
1838 }
1839
1840 ir_type *
1841 get_Alloc_type(ir_node *node) {
1842         assert(node->op == op_Alloc);
1843         return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
1844 }
1845
1846 void
1847 set_Alloc_type(ir_node *node, ir_type *tp) {
1848         assert(node->op == op_Alloc);
1849         node->attr.alloc.type = tp;
1850 }
1851
1852 where_alloc
1853 get_Alloc_where(ir_node *node) {
1854         assert(node->op == op_Alloc);
1855         return node->attr.alloc.where;
1856 }
1857
1858 void
1859 set_Alloc_where(ir_node *node, where_alloc where) {
1860         assert(node->op == op_Alloc);
1861         node->attr.alloc.where = where;
1862 }
1863
1864
1865 ir_node *
1866 get_Free_mem(ir_node *node) {
1867         assert(node->op == op_Free);
1868         return get_irn_n(node, 0);
1869 }
1870
1871 void
1872 set_Free_mem(ir_node *node, ir_node *mem) {
1873         assert(node->op == op_Free);
1874         set_irn_n(node, 0, mem);
1875 }
1876
1877 ir_node *
1878 get_Free_ptr(ir_node *node) {
1879         assert(node->op == op_Free);
1880         return get_irn_n(node, 1);
1881 }
1882
1883 void
1884 set_Free_ptr(ir_node *node, ir_node *ptr) {
1885         assert(node->op == op_Free);
1886         set_irn_n(node, 1, ptr);
1887 }
1888
1889 ir_node *
1890 get_Free_size(ir_node *node) {
1891         assert(node->op == op_Free);
1892         return get_irn_n(node, 2);
1893 }
1894
1895 void
1896 set_Free_size(ir_node *node, ir_node *size) {
1897         assert(node->op == op_Free);
1898         set_irn_n(node, 2, size);
1899 }
1900
1901 ir_type *
1902 get_Free_type(ir_node *node) {
1903         assert(node->op == op_Free);
1904         return node->attr.free.type = skip_tid(node->attr.free.type);
1905 }
1906
1907 void
1908 set_Free_type(ir_node *node, ir_type *tp) {
1909         assert(node->op == op_Free);
1910         node->attr.free.type = tp;
1911 }
1912
1913 where_alloc
1914 get_Free_where(ir_node *node) {
1915         assert(node->op == op_Free);
1916         return node->attr.free.where;
1917 }
1918
1919 void
1920 set_Free_where(ir_node *node, where_alloc where) {
1921         assert(node->op == op_Free);
1922         node->attr.free.where = where;
1923 }
1924
1925 ir_node **get_Sync_preds_arr(ir_node *node) {
1926         assert(node->op == op_Sync);
1927         return (ir_node **)&(get_irn_in(node)[1]);
1928 }
1929
1930 int get_Sync_n_preds(ir_node *node) {
1931         assert(node->op == op_Sync);
1932         return (get_irn_arity(node));
1933 }
1934
1935 /*
1936 void set_Sync_n_preds(ir_node *node, int n_preds) {
1937         assert(node->op == op_Sync);
1938 }
1939 */
1940
1941 ir_node *get_Sync_pred(ir_node *node, int pos) {
1942         assert(node->op == op_Sync);
1943         return get_irn_n(node, pos);
1944 }
1945
1946 void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
1947         assert(node->op == op_Sync);
1948         set_irn_n(node, pos, pred);
1949 }
1950
1951 /* Add a new Sync predecessor */
1952 void add_Sync_pred(ir_node *node, ir_node *pred) {
1953         assert(node->op == op_Sync);
1954         add_irn_n(node, pred);
1955 }
1956
1957 /* Returns the source language type of a Proj node. */
1958 ir_type *get_Proj_type(ir_node *n) {
1959         ir_type *tp   = firm_unknown_type;
1960         ir_node *pred = get_Proj_pred(n);
1961
1962         switch (get_irn_opcode(pred)) {
1963         case iro_Proj: {
1964                 ir_node *pred_pred;
1965                 /* Deal with Start / Call here: we need to know the Proj Nr. */
1966                 assert(get_irn_mode(pred) == mode_T);
1967                 pred_pred = get_Proj_pred(pred);
1968                 if (get_irn_op(pred_pred) == op_Start)  {
1969                         ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
1970                         tp = get_method_param_type(mtp, get_Proj_proj(n));
1971                 } else if (get_irn_op(pred_pred) == op_Call) {
1972                         ir_type *mtp = get_Call_type(pred_pred);
1973                         tp = get_method_res_type(mtp, get_Proj_proj(n));
1974                 }
1975         } break;
1976         case iro_Start: break;
1977         case iro_Call: break;
1978         case iro_Load: {
1979                 ir_node *a = get_Load_ptr(pred);
1980                 if (is_Sel(a))
1981                         tp = get_entity_type(get_Sel_entity(a));
1982         } break;
1983         default:
1984                 break;
1985         }
1986         return tp;
1987 }
1988
1989 ir_node *
1990 get_Proj_pred(const ir_node *node) {
1991         assert(is_Proj(node));
1992         return get_irn_n(node, 0);
1993 }
1994
1995 void
1996 set_Proj_pred(ir_node *node, ir_node *pred) {
1997         assert(is_Proj(node));
1998         set_irn_n(node, 0, pred);
1999 }
2000
2001 long
2002 get_Proj_proj(const ir_node *node) {
2003         assert(is_Proj(node));
2004         if (get_irn_opcode(node) == iro_Proj) {
2005                 return node->attr.proj;
2006         } else {
2007                 assert(get_irn_opcode(node) == iro_Filter);
2008                 return node->attr.filter.proj;
2009         }
2010 }
2011
2012 void
2013 set_Proj_proj(ir_node *node, long proj) {
2014         assert(node->op == op_Proj);
2015         node->attr.proj = proj;
2016 }
2017
2018 ir_node **
2019 get_Tuple_preds_arr(ir_node *node) {
2020         assert(node->op == op_Tuple);
2021         return (ir_node **)&(get_irn_in(node)[1]);
2022 }
2023
2024 int
2025 get_Tuple_n_preds(ir_node *node) {
2026         assert(node->op == op_Tuple);
2027         return (get_irn_arity(node));
2028 }
2029
2030 /*
2031 void
2032 set_Tuple_n_preds(ir_node *node, int n_preds) {
2033         assert(node->op == op_Tuple);
2034 }
2035 */
2036
2037 ir_node *
2038 get_Tuple_pred (ir_node *node, int pos) {
2039   assert(node->op == op_Tuple);
2040   return get_irn_n(node, pos);
2041 }
2042
2043 void
2044 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
2045         assert(node->op == op_Tuple);
2046         set_irn_n(node, pos, pred);
2047 }
2048
2049 ir_node *
2050 get_Id_pred(ir_node *node) {
2051         assert(node->op == op_Id);
2052         return get_irn_n(node, 0);
2053 }
2054
2055 void
2056 set_Id_pred(ir_node *node, ir_node *pred) {
2057         assert(node->op == op_Id);
2058         set_irn_n(node, 0, pred);
2059 }
2060
2061 ir_node *get_Confirm_value(ir_node *node) {
2062         assert(node->op == op_Confirm);
2063         return get_irn_n(node, 0);
2064 }
2065
2066 void set_Confirm_value(ir_node *node, ir_node *value) {
2067         assert(node->op == op_Confirm);
2068         set_irn_n(node, 0, value);
2069 }
2070
2071 ir_node *get_Confirm_bound(ir_node *node) {
2072         assert(node->op == op_Confirm);
2073         return get_irn_n(node, 1);
2074 }
2075
2076 void set_Confirm_bound(ir_node *node, ir_node *bound) {
2077         assert(node->op == op_Confirm);
2078         set_irn_n(node, 0, bound);
2079 }
2080
2081 pn_Cmp get_Confirm_cmp(const ir_node *node) {
2082         assert(node->op == op_Confirm);
2083         return node->attr.confirm.cmp;
2084 }
2085
2086 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
2087         assert(node->op == op_Confirm);
2088         node->attr.confirm.cmp = cmp;
2089 }
2090
2091 ir_node *
2092 get_Filter_pred(ir_node *node) {
2093         assert(node->op == op_Filter);
2094         return node->in[1];
2095 }
2096
2097 void
2098 set_Filter_pred(ir_node *node, ir_node *pred) {
2099         assert(node->op == op_Filter);
2100         node->in[1] = pred;
2101 }
2102
2103 long
2104 get_Filter_proj(ir_node *node) {
2105         assert(node->op == op_Filter);
2106         return node->attr.filter.proj;
2107 }
2108
2109 void
2110 set_Filter_proj(ir_node *node, long proj) {
2111         assert(node->op == op_Filter);
2112         node->attr.filter.proj = proj;
2113 }
2114
2115 /* Don't use get_irn_arity, get_irn_n in implementation as access
2116    shall work independent of view!!! */
2117 void set_Filter_cg_pred_arr(ir_node *node, int arity, ir_node ** in) {
2118         assert(node->op == op_Filter);
2119         if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2120                 ir_graph *irg = get_irn_irg(node);
2121                 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2122                 node->attr.filter.backedge = new_backedge_arr(irg->obst, arity);
2123                 node->attr.filter.in_cg[0] = node->in[0];
2124         }
2125         memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2126 }
2127
2128 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2129         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2130                0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2131         node->attr.filter.in_cg[pos + 1] = pred;
2132 }
2133
2134 int get_Filter_n_cg_preds(ir_node *node) {
2135         assert(node->op == op_Filter && node->attr.filter.in_cg);
2136         return (ARR_LEN(node->attr.filter.in_cg) - 1);
2137 }
2138
2139 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2140         int arity;
2141         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2142                0 <= pos);
2143         arity = ARR_LEN(node->attr.filter.in_cg);
2144         assert(pos < arity - 1);
2145         return node->attr.filter.in_cg[pos + 1];
2146 }
2147
2148 /* Mux support */
2149 ir_node *get_Mux_sel(ir_node *node) {
2150         if (node->op == op_Psi) {
2151                 assert(get_irn_arity(node) == 3);
2152                 return get_Psi_cond(node, 0);
2153         }
2154         assert(node->op == op_Mux);
2155         return node->in[1];
2156 }
2157
2158 void set_Mux_sel(ir_node *node, ir_node *sel) {
2159         if (node->op == op_Psi) {
2160                 assert(get_irn_arity(node) == 3);
2161                 set_Psi_cond(node, 0, sel);
2162         } else {
2163                 assert(node->op == op_Mux);
2164                 node->in[1] = sel;
2165         }
2166 }
2167
2168 ir_node *get_Mux_false(ir_node *node) {
2169         if (node->op == op_Psi) {
2170                 assert(get_irn_arity(node) == 3);
2171                 return get_Psi_default(node);
2172         }
2173         assert(node->op == op_Mux);
2174         return node->in[2];
2175 }
2176
2177 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2178         if (node->op == op_Psi) {
2179                 assert(get_irn_arity(node) == 3);
2180                 set_Psi_default(node, ir_false);
2181         } else {
2182                 assert(node->op == op_Mux);
2183                 node->in[2] = ir_false;
2184         }
2185 }
2186
2187 ir_node *get_Mux_true(ir_node *node) {
2188         if (node->op == op_Psi) {
2189                 assert(get_irn_arity(node) == 3);
2190                 return get_Psi_val(node, 0);
2191         }
2192         assert(node->op == op_Mux);
2193         return node->in[3];
2194 }
2195
2196 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2197         if (node->op == op_Psi) {
2198                 assert(get_irn_arity(node) == 3);
2199                 set_Psi_val(node, 0, ir_true);
2200         } else {
2201                 assert(node->op == op_Mux);
2202                 node->in[3] = ir_true;
2203         }
2204 }
2205
2206 /* Psi support */
2207 ir_node *get_Psi_cond(ir_node *node, int pos) {
2208         assert(node->op == op_Psi);
2209         assert(pos < get_Psi_n_conds(node));
2210         return get_irn_n(node, 2 * pos);
2211 }
2212
2213 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
2214         assert(node->op == op_Psi);
2215         assert(pos < get_Psi_n_conds(node));
2216         set_irn_n(node, 2 * pos, cond);
2217 }
2218
2219 ir_node *get_Psi_val(ir_node *node, int pos) {
2220         assert(node->op == op_Psi);
2221         assert(pos < get_Psi_n_conds(node));
2222         return get_irn_n(node, 2 * pos + 1);
2223 }
2224
2225 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
2226         assert(node->op == op_Psi);
2227         assert(pos < get_Psi_n_conds(node));
2228         set_irn_n(node, 2 * pos + 1, val);
2229 }
2230
2231 ir_node *get_Psi_default(ir_node *node) {
2232         int def_pos = get_irn_arity(node) - 1;
2233         assert(node->op == op_Psi);
2234         return get_irn_n(node, def_pos);
2235 }
2236
2237 void set_Psi_default(ir_node *node, ir_node *val) {
2238         int def_pos = get_irn_arity(node);
2239         assert(node->op == op_Psi);
2240         set_irn_n(node, def_pos, val);
2241 }
2242
2243 int (get_Psi_n_conds)(ir_node *node) {
2244         return _get_Psi_n_conds(node);
2245 }
2246
2247 /* CopyB support */
2248 ir_node *get_CopyB_mem(ir_node *node) {
2249         assert(node->op == op_CopyB);
2250         return get_irn_n(node, 0);
2251 }
2252
2253 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2254         assert(node->op == op_CopyB);
2255         set_irn_n(node, 0, mem);
2256 }
2257
2258 ir_node *get_CopyB_dst(ir_node *node) {
2259         assert(node->op == op_CopyB);
2260         return get_irn_n(node, 1);
2261 }
2262
2263 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2264         assert(node->op == op_CopyB);
2265         set_irn_n(node, 1, dst);
2266 }
2267
2268 ir_node *get_CopyB_src (ir_node *node) {
2269   assert(node->op == op_CopyB);
2270   return get_irn_n(node, 2);
2271 }
2272
2273 void set_CopyB_src(ir_node *node, ir_node *src) {
2274         assert(node->op == op_CopyB);
2275         set_irn_n(node, 2, src);
2276 }
2277
2278 ir_type *get_CopyB_type(ir_node *node) {
2279         assert(node->op == op_CopyB);
2280         return node->attr.copyb.data_type;
2281 }
2282
2283 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2284         assert(node->op == op_CopyB && data_type);
2285         node->attr.copyb.data_type = data_type;
2286 }
2287
2288
2289 ir_type *
2290 get_InstOf_type(ir_node *node) {
2291         assert(node->op = op_InstOf);
2292         return node->attr.instof.type;
2293 }
2294
2295 void
2296 set_InstOf_type(ir_node *node, ir_type *type) {
2297         assert(node->op = op_InstOf);
2298         node->attr.instof.type = type;
2299 }
2300
2301 ir_node *
2302 get_InstOf_store(ir_node *node) {
2303         assert(node->op = op_InstOf);
2304         return get_irn_n(node, 0);
2305 }
2306
2307 void
2308 set_InstOf_store(ir_node *node, ir_node *obj) {
2309         assert(node->op = op_InstOf);
2310         set_irn_n(node, 0, obj);
2311 }
2312
2313 ir_node *
2314 get_InstOf_obj(ir_node *node) {
2315         assert(node->op = op_InstOf);
2316         return get_irn_n(node, 1);
2317 }
2318
2319 void
2320 set_InstOf_obj(ir_node *node, ir_node *obj) {
2321         assert(node->op = op_InstOf);
2322         set_irn_n(node, 1, obj);
2323 }
2324
2325 /* Returns the memory input of a Raise operation. */
2326 ir_node *
2327 get_Raise_mem(ir_node *node) {
2328         assert(node->op == op_Raise);
2329         return get_irn_n(node, 0);
2330 }
2331
2332 void
2333 set_Raise_mem(ir_node *node, ir_node *mem) {
2334         assert(node->op == op_Raise);
2335         set_irn_n(node, 0, mem);
2336 }
2337
2338 ir_node *
2339 get_Raise_exo_ptr(ir_node *node) {
2340         assert(node->op == op_Raise);
2341         return get_irn_n(node, 1);
2342 }
2343
2344 void
2345 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2346         assert(node->op == op_Raise);
2347         set_irn_n(node, 1, exo_ptr);
2348 }
2349
2350 /* Bound support */
2351
2352 /* Returns the memory input of a Bound operation. */
2353 ir_node *get_Bound_mem(ir_node *bound) {
2354         assert(bound->op == op_Bound);
2355         return get_irn_n(bound, 0);
2356 }
2357
2358 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2359         assert(bound->op == op_Bound);
2360         set_irn_n(bound, 0, mem);
2361 }
2362
2363 /* Returns the index input of a Bound operation. */
2364 ir_node *get_Bound_index(ir_node *bound) {
2365         assert(bound->op == op_Bound);
2366         return get_irn_n(bound, 1);
2367 }
2368
2369 void set_Bound_index(ir_node *bound, ir_node *idx) {
2370         assert(bound->op == op_Bound);
2371         set_irn_n(bound, 1, idx);
2372 }
2373
2374 /* Returns the lower bound input of a Bound operation. */
2375 ir_node *get_Bound_lower(ir_node *bound) {
2376         assert(bound->op == op_Bound);
2377         return get_irn_n(bound, 2);
2378 }
2379
2380 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2381         assert(bound->op == op_Bound);
2382         set_irn_n(bound, 2, lower);
2383 }
2384
2385 /* Returns the upper bound input of a Bound operation. */
2386 ir_node *get_Bound_upper(ir_node *bound) {
2387         assert(bound->op == op_Bound);
2388         return get_irn_n(bound, 3);
2389 }
2390
2391 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2392         assert(bound->op == op_Bound);
2393         set_irn_n(bound, 3, upper);
2394 }
2395
2396 /* Return the operand of a Pin node. */
2397 ir_node *get_Pin_op(const ir_node *pin) {
2398         assert(pin->op == op_Pin);
2399         return get_irn_n(pin, 0);
2400 }
2401
2402 void set_Pin_op(ir_node *pin, ir_node *node) {
2403         assert(pin->op == op_Pin);
2404         set_irn_n(pin, 0, node);
2405 }
2406
2407 /* Return the assembler text of an ASM pseudo node. */
2408 ident *get_ASM_text(const ir_node *node) {
2409         assert(node->op == op_ASM);
2410         return node->attr.assem.asm_text;
2411 }
2412
2413 /* Return the number of input constraints for an ASM node. */
2414 int get_ASM_n_input_constraints(const ir_node *node) {
2415         assert(node->op == op_ASM);
2416         return ARR_LEN(node->attr.assem.inputs);
2417 }
2418
2419 /* Return the input constraints for an ASM node. This is a flexible array. */
2420 const ir_asm_constraint *get_ASM_input_constraints(const ir_node *node) {
2421         assert(node->op == op_ASM);
2422         return node->attr.assem.inputs;
2423 }
2424
2425 /* Return the number of output constraints for an ASM node.  */
2426 int get_ASM_n_output_constraints(const ir_node *node) {
2427         assert(node->op == op_ASM);
2428         return ARR_LEN(node->attr.assem.outputs);
2429 }
2430
2431 /* Return the output constraints for an ASM node. */
2432 const ir_asm_constraint *get_ASM_output_constraints(const ir_node *node) {
2433         assert(node->op == op_ASM);
2434         return node->attr.assem.outputs;
2435 }
2436
2437 /* Return the number of clobbered registers for an ASM node.  */
2438 int get_ASM_n_clobbers(const ir_node *node) {
2439         assert(node->op == op_ASM);
2440         return ARR_LEN(node->attr.assem.clobber);
2441 }
2442
2443 /* Return the list of clobbered registers for an ASM node. */
2444 ident **get_ASM_clobbers(const ir_node *node) {
2445         assert(node->op == op_ASM);
2446         return node->attr.assem.clobber;
2447 }
2448
2449 /* returns the graph of a node */
2450 ir_graph *
2451 get_irn_irg(const ir_node *node) {
2452         /*
2453          * Do not use get_nodes_Block() here, because this
2454          * will check the pinned state.
2455          * However even a 'wrong' block is always in the proper
2456          * irg.
2457          */
2458         if (! is_Block(node))
2459                 node = get_irn_n(node, -1);
2460         if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2461                 node = get_irn_n(node, -1);
2462         assert(get_irn_op(node) == op_Block);
2463         return node->attr.block.irg;
2464 }
2465
2466
2467 /*----------------------------------------------------------------*/
2468 /*  Auxiliary routines                                            */
2469 /*----------------------------------------------------------------*/
2470
2471 ir_node *
2472 skip_Proj(ir_node *node) {
2473         /* don't assert node !!! */
2474         if (node == NULL)
2475                 return NULL;
2476
2477         if (is_Proj(node))
2478                 node = get_Proj_pred(node);
2479
2480         return node;
2481 }
2482
2483 const ir_node *
2484 skip_Proj_const(const ir_node *node) {
2485         /* don't assert node !!! */
2486         if (node == NULL)
2487                 return NULL;
2488
2489         if (is_Proj(node))
2490                 node = get_Proj_pred(node);
2491
2492         return node;
2493 }
2494
2495 ir_node *
2496 skip_Tuple(ir_node *node) {
2497   ir_node *pred;
2498   ir_op   *op;
2499
2500   if (!get_opt_normalize()) return node;
2501
2502 restart:
2503         if (get_irn_op(node) == op_Proj) {
2504             pred = get_Proj_pred(node);
2505             op   = get_irn_op(pred);
2506
2507                 /*
2508                  * Looks strange but calls get_irn_op() only once
2509                  * in most often cases.
2510                  */
2511                 if (op == op_Proj) { /* nested Tuple ? */
2512                     pred = skip_Tuple(pred);
2513                     op   = get_irn_op(pred);
2514
2515                         if (op == op_Tuple) {
2516                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
2517                                 goto restart;
2518                         }
2519                 } else if (op == op_Tuple) {
2520                         node = get_Tuple_pred(pred, get_Proj_proj(node));
2521                         goto restart;
2522                 }
2523         }
2524         return node;
2525 }
2526
2527 /* returns operand of node if node is a Cast */
2528 ir_node *skip_Cast(ir_node *node) {
2529         if (get_irn_op(node) == op_Cast)
2530                 return get_Cast_op(node);
2531         return node;
2532 }
2533
2534 /* returns operand of node if node is a Confirm */
2535 ir_node *skip_Confirm(ir_node *node) {
2536         if (get_irn_op(node) == op_Confirm)
2537                 return get_Confirm_value(node);
2538         return node;
2539 }
2540
2541 /* skip all high-level ops */
2542 ir_node *skip_HighLevel(ir_node *node) {
2543         if (is_op_highlevel(get_irn_op(node)))
2544                 return get_irn_n(node, 0);
2545         return node;
2546 }
2547
2548
2549 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2550  * than any other approach, as Id chains are resolved and all point to the real node, or
2551  * all id's are self loops.
2552  *
2553  * Note: This function takes 10% of mostly ANY the compiler run, so it's
2554  * a little bit "hand optimized".
2555  *
2556  * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2557  */
2558 ir_node *
2559 skip_Id(ir_node *node) {
2560         ir_node *pred;
2561         /* don't assert node !!! */
2562
2563         if (!node || (node->op != op_Id)) return node;
2564
2565         /* Don't use get_Id_pred():  We get into an endless loop for
2566            self-referencing Ids. */
2567         pred = node->in[0+1];
2568
2569         if (pred->op != op_Id) return pred;
2570
2571         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2572                 ir_node *rem_pred, *res;
2573
2574                 if (pred->op != op_Id) return pred; /* shortcut */
2575                 rem_pred = pred;
2576
2577                 assert(get_irn_arity (node) > 0);
2578
2579                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2580                 res = skip_Id(rem_pred);
2581                 if (res->op == op_Id) /* self-loop */ return node;
2582
2583                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2584                 return res;
2585         } else {
2586                 return node;
2587         }
2588 }
2589
2590 void skip_Id_and_store(ir_node **node) {
2591         ir_node *n = *node;
2592
2593         if (!n || (n->op != op_Id)) return;
2594
2595         /* Don't use get_Id_pred():  We get into an endless loop for
2596            self-referencing Ids. */
2597         *node = skip_Id(n);
2598 }
2599
2600 int
2601 (is_Bad)(const ir_node *node) {
2602         return _is_Bad(node);
2603 }
2604
2605 int
2606 (is_NoMem)(const ir_node *node) {
2607         return _is_NoMem(node);
2608 }
2609
2610 int
2611 (is_Minus)(const ir_node *node) {
2612         return _is_Minus(node);
2613 }
2614
2615 int
2616 (is_Mod)(const ir_node *node) {
2617         return _is_Mod(node);
2618 }
2619
2620 int
2621 (is_Div)(const ir_node *node) {
2622         return _is_Div(node);
2623 }
2624
2625 int
2626 (is_DivMod)(const ir_node *node) {
2627         return _is_DivMod(node);
2628 }
2629
2630 int
2631 (is_Quot)(const ir_node *node) {
2632         return _is_Quot(node);
2633 }
2634
2635 int
2636 (is_Add)(const ir_node *node) {
2637         return _is_Add(node);
2638 }
2639
2640 int
2641 (is_And)(const ir_node *node) {
2642         return _is_And(node);
2643 }
2644
2645 int
2646 (is_Or)(const ir_node *node) {
2647         return _is_Or(node);
2648 }
2649
2650 int
2651 (is_Eor)(const ir_node *node) {
2652         return _is_Eor(node);
2653 }
2654
2655 int
2656 (is_Sub)(const ir_node *node) {
2657         return _is_Sub(node);
2658 }
2659
2660 int
2661 (is_Shl)(const ir_node *node) {
2662         return _is_Shl(node);
2663 }
2664
2665 int
2666 (is_Shr)(const ir_node *node) {
2667         return _is_Shr(node);
2668 }
2669
2670 int
2671 (is_Shrs)(const ir_node *node) {
2672         return _is_Shrs(node);
2673 }
2674
2675 int
2676 (is_Rot)(const ir_node *node) {
2677         return _is_Rot(node);
2678 }
2679
2680 int
2681 (is_Not)(const ir_node *node) {
2682         return _is_Not(node);
2683 }
2684
2685 int
2686 (is_Psi)(const ir_node *node) {
2687         return _is_Psi(node);
2688 }
2689
2690 int
2691 (is_Tuple)(const ir_node *node) {
2692         return _is_Tuple(node);
2693 }
2694
2695 int
2696 (is_Start)(const ir_node *node) {
2697   return _is_Start(node);
2698 }
2699
2700 int
2701 (is_End)(const ir_node *node) {
2702         return _is_End(node);
2703 }
2704
2705 int
2706 (is_Const)(const ir_node *node) {
2707         return _is_Const(node);
2708 }
2709
2710 int
2711 (is_Conv)(const ir_node *node) {
2712         return _is_Conv(node);
2713 }
2714
2715 int
2716 (is_strictConv)(const ir_node *node) {
2717         return _is_strictConv(node);
2718 }
2719
2720 int
2721 (is_Cast)(const ir_node *node) {
2722         return _is_Cast(node);
2723 }
2724
2725 int
2726 (is_no_Block)(const ir_node *node) {
2727         return _is_no_Block(node);
2728 }
2729
2730 int
2731 (is_Block)(const ir_node *node) {
2732         return _is_Block(node);
2733 }
2734
2735 /* returns true if node is an Unknown node. */
2736 int
2737 (is_Unknown)(const ir_node *node) {
2738         return _is_Unknown(node);
2739 }
2740
2741 /* returns true if node is a Return node. */
2742 int
2743 (is_Return)(const ir_node *node) {
2744         return _is_Return(node);
2745 }
2746
2747 /* returns true if node is a Call node. */
2748 int
2749 (is_Call)(const ir_node *node) {
2750         return _is_Call(node);
2751 }
2752
2753 /* returns true if node is a Sel node. */
2754 int
2755 (is_Sel)(const ir_node *node) {
2756         return _is_Sel(node);
2757 }
2758
2759 /* returns true if node is a Mux node or a Psi with only one condition. */
2760 int
2761 (is_Mux)(const ir_node *node) {
2762         return _is_Mux(node);
2763 }
2764
2765 /* returns true if node is a Load node. */
2766 int
2767 (is_Load)(const ir_node *node) {
2768         return _is_Load(node);
2769 }
2770
2771 /* returns true if node is a Load node. */
2772 int
2773 (is_Store)(const ir_node *node) {
2774         return _is_Store(node);
2775 }
2776
2777 /* returns true if node is a Sync node. */
2778 int
2779 (is_Sync)(const ir_node *node) {
2780         return _is_Sync(node);
2781 }
2782
2783 /* returns true if node is a Confirm node. */
2784 int
2785 (is_Confirm)(const ir_node *node) {
2786         return _is_Confirm(node);
2787 }
2788
2789 /* returns true if node is a Pin node. */
2790 int
2791 (is_Pin)(const ir_node *node) {
2792         return _is_Pin(node);
2793 }
2794
2795 /* returns true if node is a SymConst node. */
2796 int
2797 (is_SymConst)(const ir_node *node) {
2798         return _is_SymConst(node);
2799 }
2800
2801 /* returns true if node is a Cond node. */
2802 int
2803 (is_Cond)(const ir_node *node) {
2804         return _is_Cond(node);
2805 }
2806
2807 int
2808 (is_CopyB)(const ir_node *node) {
2809         return _is_CopyB(node);
2810 }
2811
2812 /* returns true if node is a Cmp node. */
2813 int
2814 (is_Cmp)(const ir_node *node) {
2815         return _is_Cmp(node);
2816 }
2817
2818 /* returns true if node is an Alloc node. */
2819 int
2820 (is_Alloc)(const ir_node *node) {
2821         return _is_Alloc(node);
2822 }
2823
2824 /* returns true if a node is a Jmp node. */
2825 int
2826 (is_Jmp)(const ir_node *node) {
2827         return _is_Jmp(node);
2828 }
2829
2830 /* returns true if a node is a Raise node. */
2831 int
2832 (is_Raise)(const ir_node *node) {
2833         return _is_Raise(node);
2834 }
2835
2836 /* returns true if a node is an ASM node. */
2837 int
2838 (is_ASM)(const ir_node *node) {
2839         return _is_ASM(node);
2840 }
2841
2842 int
2843 (is_Proj)(const ir_node *node) {
2844         assert(node);
2845         return node->op == op_Proj ||
2846                (!get_interprocedural_view() && node->op == op_Filter);
2847 }
2848
2849 /* Returns true if the operation manipulates control flow. */
2850 int is_cfop(const ir_node *node) {
2851         return is_op_cfopcode(get_irn_op(node));
2852 }
2853
2854 /* Returns true if the operation manipulates interprocedural control flow:
2855    CallBegin, EndReg, EndExcept */
2856 int is_ip_cfop(const ir_node *node) {
2857         return is_ip_cfopcode(get_irn_op(node));
2858 }
2859
2860 /* Returns true if the operation can change the control flow because
2861    of an exception. */
2862 int
2863 is_fragile_op(const ir_node *node) {
2864         return is_op_fragile(get_irn_op(node));
2865 }
2866
2867 /* Returns the memory operand of fragile operations. */
2868 ir_node *get_fragile_op_mem(ir_node *node) {
2869         assert(node && is_fragile_op(node));
2870
2871         switch (get_irn_opcode(node)) {
2872         case iro_Call  :
2873         case iro_Quot  :
2874         case iro_DivMod:
2875         case iro_Div   :
2876         case iro_Mod   :
2877         case iro_Load  :
2878         case iro_Store :
2879         case iro_Alloc :
2880         case iro_Bound :
2881         case iro_CopyB :
2882                 return get_irn_n(node, pn_Generic_M_regular);
2883         case iro_Bad   :
2884         case iro_Unknown:
2885                 return node;
2886         default: ;
2887                 assert(0 && "should not be reached");
2888                 return NULL;
2889         }
2890 }
2891
2892 /* Returns the result mode of a Div operation. */
2893 ir_mode *get_divop_resmod(const ir_node *node) {
2894         switch (get_irn_opcode(node)) {
2895         case iro_Quot  : return get_Quot_resmode(node);
2896         case iro_DivMod: return get_DivMod_resmode(node);
2897         case iro_Div   : return get_Div_resmode(node);
2898         case iro_Mod   : return get_Mod_resmode(node);
2899         default: ;
2900                 assert(0 && "should not be reached");
2901                 return NULL;
2902         }
2903 }
2904
2905 /* Returns true if the operation is a forking control flow operation. */
2906 int (is_irn_forking)(const ir_node *node) {
2907         return _is_irn_forking(node);
2908 }
2909
2910 /* Return the type associated with the value produced by n
2911  * if the node remarks this type as it is the case for
2912  * Cast, Const, SymConst and some Proj nodes. */
2913 ir_type *(get_irn_type)(ir_node *node) {
2914         return _get_irn_type(node);
2915 }
2916
2917 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
2918    Cast) or NULL.*/
2919 ir_type *(get_irn_type_attr)(ir_node *node) {
2920         return _get_irn_type_attr(node);
2921 }
2922
2923 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
2924 ir_entity *(get_irn_entity_attr)(ir_node *node) {
2925         return _get_irn_entity_attr(node);
2926 }
2927
2928 /* Returns non-zero for constant-like nodes. */
2929 int (is_irn_constlike)(const ir_node *node) {
2930         return _is_irn_constlike(node);
2931 }
2932
2933 /*
2934  * Returns non-zero for nodes that are allowed to have keep-alives and
2935  * are neither Block nor PhiM.
2936  */
2937 int (is_irn_keep)(const ir_node *node) {
2938         return _is_irn_keep(node);
2939 }
2940
2941 /*
2942  * Returns non-zero for nodes that are always placed in the start block.
2943  */
2944 int (is_irn_start_block_placed)(const ir_node *node) {
2945         return _is_irn_start_block_placed(node);
2946 }
2947
2948 /* Returns non-zero for nodes that are machine operations. */
2949 int (is_irn_machine_op)(const ir_node *node) {
2950         return _is_irn_machine_op(node);
2951 }
2952
2953 /* Returns non-zero for nodes that are machine operands. */
2954 int (is_irn_machine_operand)(const ir_node *node) {
2955         return _is_irn_machine_operand(node);
2956 }
2957
2958 /* Returns non-zero for nodes that have the n'th user machine flag set. */
2959 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
2960         return _is_irn_machine_user(node, n);
2961 }
2962
2963
2964 /* Gets the string representation of the jump prediction .*/
2965 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
2966         switch (pred) {
2967         default:
2968         case COND_JMP_PRED_NONE:  return "no prediction";
2969         case COND_JMP_PRED_TRUE:  return "true taken";
2970         case COND_JMP_PRED_FALSE: return "false taken";
2971         }
2972 }
2973
2974 /* Returns the conditional jump prediction of a Cond node. */
2975 cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *cond) {
2976         return _get_Cond_jmp_pred(cond);
2977 }
2978
2979 /* Sets a new conditional jump prediction. */
2980 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
2981         _set_Cond_jmp_pred(cond, pred);
2982 }
2983
2984 /** the get_type operation must be always implemented and return a firm type */
2985 static ir_type *get_Default_type(ir_node *n) {
2986         (void) n;
2987         return get_unknown_type();
2988 }
2989
2990 /* Sets the get_type operation for an ir_op_ops. */
2991 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
2992         switch (code) {
2993         case iro_Const:    ops->get_type = get_Const_type; break;
2994         case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
2995         case iro_Cast:     ops->get_type = get_Cast_type; break;
2996         case iro_Proj:     ops->get_type = get_Proj_type; break;
2997         default:
2998                 /* not allowed to be NULL */
2999                 if (! ops->get_type)
3000                         ops->get_type = get_Default_type;
3001                 break;
3002         }
3003         return ops;
3004 }
3005
3006 /** Return the attribute type of a SymConst node if exists */
3007 static ir_type *get_SymConst_attr_type(ir_node *self) {
3008         symconst_kind kind = get_SymConst_kind(self);
3009         if (SYMCONST_HAS_TYPE(kind))
3010                 return get_SymConst_type(self);
3011         return NULL;
3012 }
3013
3014 /** Return the attribute entity of a SymConst node if exists */
3015 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
3016         symconst_kind kind = get_SymConst_kind(self);
3017         if (SYMCONST_HAS_ENT(kind))
3018                 return get_SymConst_entity(self);
3019         return NULL;
3020 }
3021
3022 /** the get_type_attr operation must be always implemented */
3023 static ir_type *get_Null_type(ir_node *n) {
3024         (void) n;
3025         return firm_unknown_type;
3026 }
3027
3028 /* Sets the get_type operation for an ir_op_ops. */
3029 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
3030         switch (code) {
3031         case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
3032         case iro_Call:     ops->get_type_attr = get_Call_type; break;
3033         case iro_Alloc:    ops->get_type_attr = get_Alloc_type; break;
3034         case iro_Free:     ops->get_type_attr = get_Free_type; break;
3035         case iro_Cast:     ops->get_type_attr = get_Cast_type; break;
3036         default:
3037                 /* not allowed to be NULL */
3038                 if (! ops->get_type_attr)
3039                         ops->get_type_attr = get_Null_type;
3040                 break;
3041         }
3042         return ops;
3043 }
3044
3045 /** the get_entity_attr operation must be always implemented */
3046 static ir_entity *get_Null_ent(ir_node *n) {
3047         (void) n;
3048         return NULL;
3049 }
3050
3051 /* Sets the get_type operation for an ir_op_ops. */
3052 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
3053         switch (code) {
3054         case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
3055         case iro_Sel:      ops->get_entity_attr = get_Sel_entity; break;
3056         default:
3057                 /* not allowed to be NULL */
3058                 if (! ops->get_entity_attr)
3059                         ops->get_entity_attr = get_Null_ent;
3060                 break;
3061         }
3062         return ops;
3063 }
3064
3065 /* Sets the debug information of a node. */
3066 void (set_irn_dbg_info)(ir_node *n, dbg_info *db) {
3067         _set_irn_dbg_info(n, db);
3068 }
3069
3070 /**
3071  * Returns the debug information of an node.
3072  *
3073  * @param n   The node.
3074  */
3075 dbg_info *(get_irn_dbg_info)(const ir_node *n) {
3076         return _get_irn_dbg_info(n);
3077 }
3078
3079
3080
3081 #ifdef DEBUG_libfirm
3082 void dump_irn(ir_node *n) {
3083         int i, arity = get_irn_arity(n);
3084         printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
3085         if (!is_Block(n)) {
3086                 ir_node *pred = get_irn_n(n, -1);
3087                 printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
3088                         get_irn_node_nr(pred), (void *)pred);
3089         }
3090         printf("  preds: \n");
3091         for (i = 0; i < arity; ++i) {
3092                 ir_node *pred = get_irn_n(n, i);
3093                 printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
3094                         get_irn_node_nr(pred), (void *)pred);
3095         }
3096 }
3097
3098 #else  /* DEBUG_libfirm */
3099 void dump_irn(ir_node *n) { (void) n; }
3100 #endif /* DEBUG_libfirm */