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

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