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

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