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

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