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