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