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