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 /* Returns non-zero if a node is a routine parameter. */
2068 int (is_arg_Proj)(const ir_node *node) {
2069         return _is_arg_Proj(node);
2070 }
2071
2072 ir_node **
2073 get_Tuple_preds_arr(ir_node *node) {
2074         assert(is_Tuple(node));
2075         return (ir_node **)&(get_irn_in(node)[1]);
2076 }
2077
2078 int
2079 get_Tuple_n_preds(const ir_node *node) {
2080         assert(is_Tuple(node));
2081         return get_irn_arity(node);
2082 }
2083
2084 /*
2085 void
2086 set_Tuple_n_preds(ir_node *node, int n_preds) {
2087         assert(is_Tuple(node));
2088 }
2089 */
2090
2091 ir_node *
2092 get_Tuple_pred(const ir_node *node, int pos) {
2093   assert(is_Tuple(node));
2094   return get_irn_n(node, pos);
2095 }
2096
2097 void
2098 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
2099         assert(is_Tuple(node));
2100         set_irn_n(node, pos, pred);
2101 }
2102
2103 ir_node *
2104 get_Id_pred(const ir_node *node) {
2105         assert(is_Id(node));
2106         return get_irn_n(node, 0);
2107 }
2108
2109 void
2110 set_Id_pred(ir_node *node, ir_node *pred) {
2111         assert(is_Id(node));
2112         set_irn_n(node, 0, pred);
2113 }
2114
2115 ir_node *get_Confirm_value(const ir_node *node) {
2116         assert(is_Confirm(node));
2117         return get_irn_n(node, 0);
2118 }
2119
2120 void set_Confirm_value(ir_node *node, ir_node *value) {
2121         assert(is_Confirm(node));
2122         set_irn_n(node, 0, value);
2123 }
2124
2125 ir_node *get_Confirm_bound(const ir_node *node) {
2126         assert(is_Confirm(node));
2127         return get_irn_n(node, 1);
2128 }
2129
2130 void set_Confirm_bound(ir_node *node, ir_node *bound) {
2131         assert(is_Confirm(node));
2132         set_irn_n(node, 0, bound);
2133 }
2134
2135 pn_Cmp get_Confirm_cmp(const ir_node *node) {
2136         assert(is_Confirm(node));
2137         return node->attr.confirm.cmp;
2138 }
2139
2140 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
2141         assert(is_Confirm(node));
2142         node->attr.confirm.cmp = cmp;
2143 }
2144
2145 ir_node *
2146 get_Filter_pred(ir_node *node) {
2147         assert(is_Filter(node));
2148         return node->in[1];
2149 }
2150
2151 void
2152 set_Filter_pred(ir_node *node, ir_node *pred) {
2153         assert(is_Filter(node));
2154         node->in[1] = pred;
2155 }
2156
2157 long
2158 get_Filter_proj(ir_node *node) {
2159         assert(is_Filter(node));
2160         return node->attr.filter.proj;
2161 }
2162
2163 void
2164 set_Filter_proj(ir_node *node, long proj) {
2165         assert(is_Filter(node));
2166         node->attr.filter.proj = proj;
2167 }
2168
2169 /* Don't use get_irn_arity, get_irn_n in implementation as access
2170    shall work independent of view!!! */
2171 void set_Filter_cg_pred_arr(ir_node *node, int arity, ir_node ** in) {
2172         assert(is_Filter(node));
2173         if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2174                 ir_graph *irg = get_irn_irg(node);
2175                 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2176                 node->attr.filter.backedge = new_backedge_arr(irg->obst, arity);
2177                 node->attr.filter.in_cg[0] = node->in[0];
2178         }
2179         memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2180 }
2181
2182 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2183         assert(is_Filter(node) && node->attr.filter.in_cg &&
2184                0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2185         node->attr.filter.in_cg[pos + 1] = pred;
2186 }
2187
2188 int get_Filter_n_cg_preds(ir_node *node) {
2189         assert(is_Filter(node) && node->attr.filter.in_cg);
2190         return (ARR_LEN(node->attr.filter.in_cg) - 1);
2191 }
2192
2193 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2194         int arity;
2195         assert(is_Filter(node) && node->attr.filter.in_cg &&
2196                0 <= pos);
2197         arity = ARR_LEN(node->attr.filter.in_cg);
2198         assert(pos < arity - 1);
2199         return node->attr.filter.in_cg[pos + 1];
2200 }
2201
2202 /* Mux support */
2203 ir_node *get_Mux_sel(const ir_node *node) {
2204         if (is_Psi(node)) {
2205                 assert(get_irn_arity(node) == 3);
2206                 return get_Psi_cond(node, 0);
2207         }
2208         assert(is_Mux(node));
2209         return node->in[1];
2210 }
2211
2212 void set_Mux_sel(ir_node *node, ir_node *sel) {
2213         if (is_Psi(node)) {
2214                 assert(get_irn_arity(node) == 3);
2215                 set_Psi_cond(node, 0, sel);
2216         } else {
2217                 assert(is_Mux(node));
2218                 node->in[1] = sel;
2219         }
2220 }
2221
2222 ir_node *get_Mux_false(const ir_node *node) {
2223         if (is_Psi(node)) {
2224                 assert(get_irn_arity(node) == 3);
2225                 return get_Psi_default(node);
2226         }
2227         assert(is_Mux(node));
2228         return node->in[2];
2229 }
2230
2231 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2232         if (is_Psi(node)) {
2233                 assert(get_irn_arity(node) == 3);
2234                 set_Psi_default(node, ir_false);
2235         } else {
2236                 assert(is_Mux(node));
2237                 node->in[2] = ir_false;
2238         }
2239 }
2240
2241 ir_node *get_Mux_true(const ir_node *node) {
2242         if (is_Psi(node)) {
2243                 assert(get_irn_arity(node) == 3);
2244                 return get_Psi_val(node, 0);
2245         }
2246         assert(is_Mux(node));
2247         return node->in[3];
2248 }
2249
2250 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2251         if (is_Psi(node)) {
2252                 assert(get_irn_arity(node) == 3);
2253                 set_Psi_val(node, 0, ir_true);
2254         } else {
2255                 assert(is_Mux(node));
2256                 node->in[3] = ir_true;
2257         }
2258 }
2259
2260 /* Psi support */
2261 ir_node *get_Psi_cond(const ir_node *node, int pos) {
2262         assert(is_Psi(node));
2263         assert(pos < get_Psi_n_conds(node));
2264         return get_irn_n(node, 2 * pos);
2265 }
2266
2267 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
2268         assert(is_Psi(node));
2269         assert(pos < get_Psi_n_conds(node));
2270         set_irn_n(node, 2 * pos, cond);
2271 }
2272
2273 ir_node *get_Psi_val(const ir_node *node, int pos) {
2274         assert(is_Psi(node));
2275         assert(pos < get_Psi_n_conds(node));
2276         return get_irn_n(node, 2 * pos + 1);
2277 }
2278
2279 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
2280         assert(is_Psi(node));
2281         assert(pos < get_Psi_n_conds(node));
2282         set_irn_n(node, 2 * pos + 1, val);
2283 }
2284
2285 ir_node *get_Psi_default(const ir_node *node) {
2286         int def_pos = get_irn_arity(node) - 1;
2287         assert(is_Psi(node));
2288         return get_irn_n(node, def_pos);
2289 }
2290
2291 void set_Psi_default(ir_node *node, ir_node *val) {
2292         int def_pos = get_irn_arity(node);
2293         assert(is_Psi(node));
2294         set_irn_n(node, def_pos, val);
2295 }
2296
2297 int (get_Psi_n_conds)(const ir_node *node) {
2298         return _get_Psi_n_conds(node);
2299 }
2300
2301 /* CopyB support */
2302 ir_node *get_CopyB_mem(const ir_node *node) {
2303         assert(is_CopyB(node));
2304         return get_irn_n(node, 0);
2305 }
2306
2307 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2308         assert(node->op == op_CopyB);
2309         set_irn_n(node, 0, mem);
2310 }
2311
2312 ir_node *get_CopyB_dst(const ir_node *node) {
2313         assert(is_CopyB(node));
2314         return get_irn_n(node, 1);
2315 }
2316
2317 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2318         assert(is_CopyB(node));
2319         set_irn_n(node, 1, dst);
2320 }
2321
2322 ir_node *get_CopyB_src(const ir_node *node) {
2323   assert(is_CopyB(node));
2324   return get_irn_n(node, 2);
2325 }
2326
2327 void set_CopyB_src(ir_node *node, ir_node *src) {
2328         assert(is_CopyB(node));
2329         set_irn_n(node, 2, src);
2330 }
2331
2332 ir_type *get_CopyB_type(ir_node *node) {
2333         assert(is_CopyB(node));
2334         return node->attr.copyb.data_type = skip_tid(node->attr.copyb.data_type);
2335 }
2336
2337 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2338         assert(is_CopyB(node) && data_type);
2339         node->attr.copyb.data_type = data_type;
2340 }
2341
2342
2343 ir_type *
2344 get_InstOf_type(ir_node *node) {
2345         assert(node->op == op_InstOf);
2346         return node->attr.instof.type = skip_tid(node->attr.instof.type);
2347 }
2348
2349 void
2350 set_InstOf_type(ir_node *node, ir_type *type) {
2351         assert(node->op == op_InstOf);
2352         node->attr.instof.type = type;
2353 }
2354
2355 ir_node *
2356 get_InstOf_store(const ir_node *node) {
2357         assert(node->op == op_InstOf);
2358         return get_irn_n(node, 0);
2359 }
2360
2361 void
2362 set_InstOf_store(ir_node *node, ir_node *obj) {
2363         assert(node->op == op_InstOf);
2364         set_irn_n(node, 0, obj);
2365 }
2366
2367 ir_node *
2368 get_InstOf_obj(const ir_node *node) {
2369         assert(node->op == op_InstOf);
2370         return get_irn_n(node, 1);
2371 }
2372
2373 void
2374 set_InstOf_obj(ir_node *node, ir_node *obj) {
2375         assert(node->op == op_InstOf);
2376         set_irn_n(node, 1, obj);
2377 }
2378
2379 /* Returns the memory input of a Raise operation. */
2380 ir_node *
2381 get_Raise_mem(const ir_node *node) {
2382         assert(is_Raise(node));
2383         return get_irn_n(node, 0);
2384 }
2385
2386 void
2387 set_Raise_mem(ir_node *node, ir_node *mem) {
2388         assert(is_Raise(node));
2389         set_irn_n(node, 0, mem);
2390 }
2391
2392 ir_node *
2393 get_Raise_exo_ptr(const ir_node *node) {
2394         assert(is_Raise(node));
2395         return get_irn_n(node, 1);
2396 }
2397
2398 void
2399 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2400         assert(is_Raise(node));
2401         set_irn_n(node, 1, exo_ptr);
2402 }
2403
2404 /* Bound support */
2405
2406 /* Returns the memory input of a Bound operation. */
2407 ir_node *get_Bound_mem(const ir_node *bound) {
2408         assert(is_Bound(bound));
2409         return get_irn_n(bound, 0);
2410 }
2411
2412 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2413         assert(is_Bound(bound));
2414         set_irn_n(bound, 0, mem);
2415 }
2416
2417 /* Returns the index input of a Bound operation. */
2418 ir_node *get_Bound_index(const ir_node *bound) {
2419         assert(is_Bound(bound));
2420         return get_irn_n(bound, 1);
2421 }
2422
2423 void set_Bound_index(ir_node *bound, ir_node *idx) {
2424         assert(is_Bound(bound));
2425         set_irn_n(bound, 1, idx);
2426 }
2427
2428 /* Returns the lower bound input of a Bound operation. */
2429 ir_node *get_Bound_lower(const ir_node *bound) {
2430         assert(is_Bound(bound));
2431         return get_irn_n(bound, 2);
2432 }
2433
2434 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2435         assert(is_Bound(bound));
2436         set_irn_n(bound, 2, lower);
2437 }
2438
2439 /* Returns the upper bound input of a Bound operation. */
2440 ir_node *get_Bound_upper(const ir_node *bound) {
2441         assert(is_Bound(bound));
2442         return get_irn_n(bound, 3);
2443 }
2444
2445 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2446         assert(is_Bound(bound));
2447         set_irn_n(bound, 3, upper);
2448 }
2449
2450 /* Return the operand of a Pin node. */
2451 ir_node *get_Pin_op(const ir_node *pin) {
2452         assert(is_Pin(pin));
2453         return get_irn_n(pin, 0);
2454 }
2455
2456 void set_Pin_op(ir_node *pin, ir_node *node) {
2457         assert(is_Pin(pin));
2458         set_irn_n(pin, 0, node);
2459 }
2460
2461 /* Return the assembler text of an ASM pseudo node. */
2462 ident *get_ASM_text(const ir_node *node) {
2463         assert(is_ASM(node));
2464         return node->attr.assem.asm_text;
2465 }
2466
2467 /* Return the number of input constraints for an ASM node. */
2468 int get_ASM_n_input_constraints(const ir_node *node) {
2469         assert(is_ASM(node));
2470         return ARR_LEN(node->attr.assem.inputs);
2471 }
2472
2473 /* Return the input constraints for an ASM node. This is a flexible array. */
2474 const ir_asm_constraint *get_ASM_input_constraints(const ir_node *node) {
2475         assert(is_ASM(node));
2476         return node->attr.assem.inputs;
2477 }
2478
2479 /* Return the number of output constraints for an ASM node.  */
2480 int get_ASM_n_output_constraints(const ir_node *node) {
2481         assert(is_ASM(node));
2482         return ARR_LEN(node->attr.assem.outputs);
2483 }
2484
2485 /* Return the output constraints for an ASM node. */
2486 const ir_asm_constraint *get_ASM_output_constraints(const ir_node *node) {
2487         assert(is_ASM(node));
2488         return node->attr.assem.outputs;
2489 }
2490
2491 /* Return the number of clobbered registers for an ASM node.  */
2492 int get_ASM_n_clobbers(const ir_node *node) {
2493         assert(is_ASM(node));
2494         return ARR_LEN(node->attr.assem.clobber);
2495 }
2496
2497 /* Return the list of clobbered registers for an ASM node. */
2498 ident **get_ASM_clobbers(const ir_node *node) {
2499         assert(is_ASM(node));
2500         return node->attr.assem.clobber;
2501 }
2502
2503 /* returns the graph of a node */
2504 ir_graph *
2505 get_irn_irg(const ir_node *node) {
2506         /*
2507          * Do not use get_nodes_Block() here, because this
2508          * will check the pinned state.
2509          * However even a 'wrong' block is always in the proper
2510          * irg.
2511          */
2512         if (! is_Block(node))
2513                 node = get_irn_n(node, -1);
2514         if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2515                 node = get_irn_n(node, -1);
2516         assert(get_irn_op(node) == op_Block);
2517         return node->attr.block.irg;
2518 }
2519
2520
2521 /*----------------------------------------------------------------*/
2522 /*  Auxiliary routines                                            */
2523 /*----------------------------------------------------------------*/
2524
2525 ir_node *
2526 skip_Proj(ir_node *node) {
2527         /* don't assert node !!! */
2528         if (node == NULL)
2529                 return NULL;
2530
2531         if (is_Proj(node))
2532                 node = get_Proj_pred(node);
2533
2534         return node;
2535 }
2536
2537 const ir_node *
2538 skip_Proj_const(const ir_node *node) {
2539         /* don't assert node !!! */
2540         if (node == NULL)
2541                 return NULL;
2542
2543         if (is_Proj(node))
2544                 node = get_Proj_pred(node);
2545
2546         return node;
2547 }
2548
2549 ir_node *
2550 skip_Tuple(ir_node *node) {
2551   ir_node *pred;
2552   ir_op   *op;
2553
2554   if (!get_opt_normalize()) return node;
2555
2556 restart:
2557         if (get_irn_op(node) == op_Proj) {
2558             pred = get_Proj_pred(node);
2559             op   = get_irn_op(pred);
2560
2561                 /*
2562                  * Looks strange but calls get_irn_op() only once
2563                  * in most often cases.
2564                  */
2565                 if (op == op_Proj) { /* nested Tuple ? */
2566                     pred = skip_Tuple(pred);
2567                     op   = get_irn_op(pred);
2568
2569                         if (op == op_Tuple) {
2570                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
2571                                 goto restart;
2572                         }
2573                 } else if (op == op_Tuple) {
2574                         node = get_Tuple_pred(pred, get_Proj_proj(node));
2575                         goto restart;
2576                 }
2577         }
2578         return node;
2579 }
2580
2581 /* returns operand of node if node is a Cast */
2582 ir_node *skip_Cast(ir_node *node) {
2583         if (get_irn_op(node) == op_Cast)
2584                 return get_Cast_op(node);
2585         return node;
2586 }
2587
2588 /* returns operand of node if node is a Confirm */
2589 ir_node *skip_Confirm(ir_node *node) {
2590         if (get_irn_op(node) == op_Confirm)
2591                 return get_Confirm_value(node);
2592         return node;
2593 }
2594
2595 /* skip all high-level ops */
2596 ir_node *skip_HighLevel_ops(ir_node *node) {
2597         while (is_op_highlevel(get_irn_op(node))) {
2598                 node = get_irn_n(node, 0);
2599         }
2600         return node;
2601 }
2602
2603
2604 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2605  * than any other approach, as Id chains are resolved and all point to the real node, or
2606  * all id's are self loops.
2607  *
2608  * Note: This function takes 10% of mostly ANY the compiler run, so it's
2609  * a little bit "hand optimized".
2610  *
2611  * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2612  */
2613 ir_node *
2614 skip_Id(ir_node *node) {
2615         ir_node *pred;
2616         /* don't assert node !!! */
2617
2618         if (!node || (node->op != op_Id)) return node;
2619
2620         /* Don't use get_Id_pred():  We get into an endless loop for
2621            self-referencing Ids. */
2622         pred = node->in[0+1];
2623
2624         if (pred->op != op_Id) return pred;
2625
2626         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2627                 ir_node *rem_pred, *res;
2628
2629                 if (pred->op != op_Id) return pred; /* shortcut */
2630                 rem_pred = pred;
2631
2632                 assert(get_irn_arity (node) > 0);
2633
2634                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2635                 res = skip_Id(rem_pred);
2636                 if (res->op == op_Id) /* self-loop */ return node;
2637
2638                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2639                 return res;
2640         } else {
2641                 return node;
2642         }
2643 }
2644
2645 void skip_Id_and_store(ir_node **node) {
2646         ir_node *n = *node;
2647
2648         if (!n || (n->op != op_Id)) return;
2649
2650         /* Don't use get_Id_pred():  We get into an endless loop for
2651            self-referencing Ids. */
2652         *node = skip_Id(n);
2653 }
2654
2655 int
2656 (is_Bad)(const ir_node *node) {
2657         return _is_Bad(node);
2658 }
2659
2660 int
2661 (is_NoMem)(const ir_node *node) {
2662         return _is_NoMem(node);
2663 }
2664
2665 int
2666 (is_Minus)(const ir_node *node) {
2667         return _is_Minus(node);
2668 }
2669
2670 int
2671 (is_Abs)(const ir_node *node) {
2672         return _is_Abs(node);
2673 }
2674
2675 int
2676 (is_Mod)(const ir_node *node) {
2677         return _is_Mod(node);
2678 }
2679
2680 int
2681 (is_Div)(const ir_node *node) {
2682         return _is_Div(node);
2683 }
2684
2685 int
2686 (is_DivMod)(const ir_node *node) {
2687         return _is_DivMod(node);
2688 }
2689
2690 int
2691 (is_Quot)(const ir_node *node) {
2692         return _is_Quot(node);
2693 }
2694
2695 int
2696 (is_Add)(const ir_node *node) {
2697         return _is_Add(node);
2698 }
2699
2700 int
2701 (is_And)(const ir_node *node) {
2702         return _is_And(node);
2703 }
2704
2705 int
2706 (is_Or)(const ir_node *node) {
2707         return _is_Or(node);
2708 }
2709
2710 int
2711 (is_Eor)(const ir_node *node) {
2712         return _is_Eor(node);
2713 }
2714
2715 int
2716 (is_Sub)(const ir_node *node) {
2717         return _is_Sub(node);
2718 }
2719
2720 int
2721 (is_Shl)(const ir_node *node) {
2722         return _is_Shl(node);
2723 }
2724
2725 int
2726 (is_Shr)(const ir_node *node) {
2727         return _is_Shr(node);
2728 }
2729
2730 int
2731 (is_Shrs)(const ir_node *node) {
2732         return _is_Shrs(node);
2733 }
2734
2735 int
2736 (is_Rotl)(const ir_node *node) {
2737         return _is_Rotl(node);
2738 }
2739
2740 int
2741 (is_Not)(const ir_node *node) {
2742         return _is_Not(node);
2743 }
2744
2745 int
2746 (is_Psi)(const ir_node *node) {
2747         return _is_Psi(node);
2748 }
2749
2750 int
2751 (is_Id)(const ir_node *node) {
2752         return _is_Id(node);
2753 }
2754
2755 int
2756 (is_Tuple)(const ir_node *node) {
2757         return _is_Tuple(node);
2758 }
2759
2760 int
2761 (is_Bound)(const ir_node *node) {
2762         return _is_Bound(node);
2763 }
2764
2765 int
2766 (is_Start)(const ir_node *node) {
2767   return _is_Start(node);
2768 }
2769
2770 int
2771 (is_End)(const ir_node *node) {
2772         return _is_End(node);
2773 }
2774
2775 int
2776 (is_Const)(const ir_node *node) {
2777         return _is_Const(node);
2778 }
2779
2780 int
2781 (is_Conv)(const ir_node *node) {
2782         return _is_Conv(node);
2783 }
2784
2785 int
2786 (is_strictConv)(const ir_node *node) {
2787         return _is_strictConv(node);
2788 }
2789
2790 int
2791 (is_Cast)(const ir_node *node) {
2792         return _is_Cast(node);
2793 }
2794
2795 int
2796 (is_no_Block)(const ir_node *node) {
2797         return _is_no_Block(node);
2798 }
2799
2800 int
2801 (is_Block)(const ir_node *node) {
2802         return _is_Block(node);
2803 }
2804
2805 /* returns true if node is an Unknown node. */
2806 int
2807 (is_Unknown)(const ir_node *node) {
2808         return _is_Unknown(node);
2809 }
2810
2811 /* returns true if node is a Return node. */
2812 int
2813 (is_Return)(const ir_node *node) {
2814         return _is_Return(node);
2815 }
2816
2817 /* returns true if node is a Call node. */
2818 int
2819 (is_Call)(const ir_node *node) {
2820         return _is_Call(node);
2821 }
2822
2823 /* returns true if node is a CallBegin node. */
2824 int
2825 (is_CallBegin)(const ir_node *node) {
2826         return _is_CallBegin(node);
2827 }
2828
2829 /* returns true if node is a Sel node. */
2830 int
2831 (is_Sel)(const ir_node *node) {
2832         return _is_Sel(node);
2833 }
2834
2835 /* returns true if node is a Mux node or a Psi with only one condition. */
2836 int
2837 (is_Mux)(const ir_node *node) {
2838         return _is_Mux(node);
2839 }
2840
2841 /* returns true if node is a Load node. */
2842 int
2843 (is_Load)(const ir_node *node) {
2844         return _is_Load(node);
2845 }
2846
2847 /* returns true if node is a Load node. */
2848 int
2849 (is_Store)(const ir_node *node) {
2850         return _is_Store(node);
2851 }
2852
2853 /* returns true if node is a Sync node. */
2854 int
2855 (is_Sync)(const ir_node *node) {
2856         return _is_Sync(node);
2857 }
2858
2859 /* Returns true if node is a Confirm node. */
2860 int
2861 (is_Confirm)(const ir_node *node) {
2862         return _is_Confirm(node);
2863 }
2864
2865 /* Returns true if node is a Pin node. */
2866 int
2867 (is_Pin)(const ir_node *node) {
2868         return _is_Pin(node);
2869 }
2870
2871 /* Returns true if node is a SymConst node. */
2872 int
2873 (is_SymConst)(const ir_node *node) {
2874         return _is_SymConst(node);
2875 }
2876
2877 /* Returns true if node is a SymConst node with kind symconst_addr_ent. */
2878 int
2879 (is_SymConst_addr_ent)(const ir_node *node) {
2880         return _is_SymConst_addr_ent(node);
2881 }
2882
2883 /* Returns true if node is a Cond node. */
2884 int
2885 (is_Cond)(const ir_node *node) {
2886         return _is_Cond(node);
2887 }
2888
2889 int
2890 (is_CopyB)(const ir_node *node) {
2891         return _is_CopyB(node);
2892 }
2893
2894 /* returns true if node is a Cmp node. */
2895 int
2896 (is_Cmp)(const ir_node *node) {
2897         return _is_Cmp(node);
2898 }
2899
2900 /* returns true if node is an Alloc node. */
2901 int
2902 (is_Alloc)(const ir_node *node) {
2903         return _is_Alloc(node);
2904 }
2905
2906 /* returns true if node is a Free node. */
2907 int
2908 (is_Free)(const ir_node *node) {
2909         return _is_Free(node);
2910 }
2911
2912 /* returns true if a node is a Jmp node. */
2913 int
2914 (is_Jmp)(const ir_node *node) {
2915         return _is_Jmp(node);
2916 }
2917
2918 /* returns true if a node is a IJmp node. */
2919 int
2920 (is_IJmp)(const ir_node *node) {
2921         return _is_IJmp(node);
2922 }
2923
2924 /* returns true if a node is a Raise node. */
2925 int
2926 (is_Raise)(const ir_node *node) {
2927         return _is_Raise(node);
2928 }
2929
2930 /* returns true if a node is an ASM node. */
2931 int
2932 (is_ASM)(const ir_node *node) {
2933         return _is_ASM(node);
2934 }
2935
2936 int
2937 (is_Proj)(const ir_node *node) {
2938         return _is_Proj(node);
2939 }
2940
2941 /* Returns true if node is a Filter node. */
2942 int
2943 (is_Filter)(const ir_node *node) {
2944         return _is_Filter(node);
2945 }
2946
2947 /* Returns true if the operation manipulates control flow. */
2948 int is_cfop(const ir_node *node) {
2949         return is_op_cfopcode(get_irn_op(node));
2950 }
2951
2952 /* Returns true if the operation manipulates interprocedural control flow:
2953    CallBegin, EndReg, EndExcept */
2954 int is_ip_cfop(const ir_node *node) {
2955         return is_ip_cfopcode(get_irn_op(node));
2956 }
2957
2958 /* Returns true if the operation can change the control flow because
2959    of an exception. */
2960 int
2961 is_fragile_op(const ir_node *node) {
2962         return is_op_fragile(get_irn_op(node));
2963 }
2964
2965 /* Returns the memory operand of fragile operations. */
2966 ir_node *get_fragile_op_mem(ir_node *node) {
2967         assert(node && is_fragile_op(node));
2968
2969         switch (get_irn_opcode(node)) {
2970         case iro_Call  :
2971         case iro_Quot  :
2972         case iro_DivMod:
2973         case iro_Div   :
2974         case iro_Mod   :
2975         case iro_Load  :
2976         case iro_Store :
2977         case iro_Alloc :
2978         case iro_Bound :
2979         case iro_CopyB :
2980                 return get_irn_n(node, pn_Generic_M_regular);
2981         case iro_Bad   :
2982         case iro_Unknown:
2983                 return node;
2984         default: ;
2985                 assert(0 && "should not be reached");
2986                 return NULL;
2987         }
2988 }
2989
2990 /* Returns the result mode of a Div operation. */
2991 ir_mode *get_divop_resmod(const ir_node *node) {
2992         switch (get_irn_opcode(node)) {
2993         case iro_Quot  : return get_Quot_resmode(node);
2994         case iro_DivMod: return get_DivMod_resmode(node);
2995         case iro_Div   : return get_Div_resmode(node);
2996         case iro_Mod   : return get_Mod_resmode(node);
2997         default: ;
2998                 assert(0 && "should not be reached");
2999                 return NULL;
3000         }
3001 }
3002
3003 /* Returns true if the operation is a forking control flow operation. */
3004 int (is_irn_forking)(const ir_node *node) {
3005         return _is_irn_forking(node);
3006 }
3007
3008 /* Return the type associated with the value produced by n
3009  * if the node remarks this type as it is the case for
3010  * Cast, Const, SymConst and some Proj nodes. */
3011 ir_type *(get_irn_type)(ir_node *node) {
3012         return _get_irn_type(node);
3013 }
3014
3015 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
3016    Cast) or NULL.*/
3017 ir_type *(get_irn_type_attr)(ir_node *node) {
3018         return _get_irn_type_attr(node);
3019 }
3020
3021 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
3022 ir_entity *(get_irn_entity_attr)(ir_node *node) {
3023         return _get_irn_entity_attr(node);
3024 }
3025
3026 /* Returns non-zero for constant-like nodes. */
3027 int (is_irn_constlike)(const ir_node *node) {
3028         return _is_irn_constlike(node);
3029 }
3030
3031 /*
3032  * Returns non-zero for nodes that are allowed to have keep-alives and
3033  * are neither Block nor PhiM.
3034  */
3035 int (is_irn_keep)(const ir_node *node) {
3036         return _is_irn_keep(node);
3037 }
3038
3039 /*
3040  * Returns non-zero for nodes that are always placed in the start block.
3041  */
3042 int (is_irn_start_block_placed)(const ir_node *node) {
3043         return _is_irn_start_block_placed(node);
3044 }
3045
3046 /* Returns non-zero for nodes that are machine operations. */
3047 int (is_irn_machine_op)(const ir_node *node) {
3048         return _is_irn_machine_op(node);
3049 }
3050
3051 /* Returns non-zero for nodes that are machine operands. */
3052 int (is_irn_machine_operand)(const ir_node *node) {
3053         return _is_irn_machine_operand(node);
3054 }
3055
3056 /* Returns non-zero for nodes that have the n'th user machine flag set. */
3057 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
3058         return _is_irn_machine_user(node, n);
3059 }
3060
3061
3062 /* Gets the string representation of the jump prediction .*/
3063 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
3064         switch (pred) {
3065         default:
3066         case COND_JMP_PRED_NONE:  return "no prediction";
3067         case COND_JMP_PRED_TRUE:  return "true taken";
3068         case COND_JMP_PRED_FALSE: return "false taken";
3069         }
3070 }
3071
3072 /* Returns the conditional jump prediction of a Cond node. */
3073 cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *cond) {
3074         return _get_Cond_jmp_pred(cond);
3075 }
3076
3077 /* Sets a new conditional jump prediction. */
3078 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
3079         _set_Cond_jmp_pred(cond, pred);
3080 }
3081
3082 /** the get_type operation must be always implemented and return a firm type */
3083 static ir_type *get_Default_type(ir_node *n) {
3084         (void) n;
3085         return get_unknown_type();
3086 }
3087
3088 /* Sets the get_type operation for an ir_op_ops. */
3089 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
3090         switch (code) {
3091         case iro_Const:    ops->get_type = get_Const_type; break;
3092         case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
3093         case iro_Cast:     ops->get_type = get_Cast_type; break;
3094         case iro_Proj:     ops->get_type = get_Proj_type; break;
3095         default:
3096                 /* not allowed to be NULL */
3097                 if (! ops->get_type)
3098                         ops->get_type = get_Default_type;
3099                 break;
3100         }
3101         return ops;
3102 }
3103
3104 /** Return the attribute type of a SymConst node if exists */
3105 static ir_type *get_SymConst_attr_type(ir_node *self) {
3106         symconst_kind kind = get_SymConst_kind(self);
3107         if (SYMCONST_HAS_TYPE(kind))
3108                 return get_SymConst_type(self);
3109         return NULL;
3110 }
3111
3112 /** Return the attribute entity of a SymConst node if exists */
3113 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
3114         symconst_kind kind = get_SymConst_kind(self);
3115         if (SYMCONST_HAS_ENT(kind))
3116                 return get_SymConst_entity(self);
3117         return NULL;
3118 }
3119
3120 /** the get_type_attr operation must be always implemented */
3121 static ir_type *get_Null_type(ir_node *n) {
3122         (void) n;
3123         return firm_unknown_type;
3124 }
3125
3126 /* Sets the get_type operation for an ir_op_ops. */
3127 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
3128         switch (code) {
3129         case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
3130         case iro_Call:     ops->get_type_attr = get_Call_type; break;
3131         case iro_Alloc:    ops->get_type_attr = get_Alloc_type; break;
3132         case iro_Free:     ops->get_type_attr = get_Free_type; break;
3133         case iro_Cast:     ops->get_type_attr = get_Cast_type; break;
3134         default:
3135                 /* not allowed to be NULL */
3136                 if (! ops->get_type_attr)
3137                         ops->get_type_attr = get_Null_type;
3138                 break;
3139         }
3140         return ops;
3141 }
3142
3143 /** the get_entity_attr operation must be always implemented */
3144 static ir_entity *get_Null_ent(ir_node *n) {
3145         (void) n;
3146         return NULL;
3147 }
3148
3149 /* Sets the get_type operation for an ir_op_ops. */
3150 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
3151         switch (code) {
3152         case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
3153         case iro_Sel:      ops->get_entity_attr = _get_Sel_entity; break;
3154         default:
3155                 /* not allowed to be NULL */
3156                 if (! ops->get_entity_attr)
3157                         ops->get_entity_attr = get_Null_ent;
3158                 break;
3159         }
3160         return ops;
3161 }
3162
3163 /* Sets the debug information of a node. */
3164 void (set_irn_dbg_info)(ir_node *n, dbg_info *db) {
3165         _set_irn_dbg_info(n, db);
3166 }
3167
3168 /**
3169  * Returns the debug information of an node.
3170  *
3171  * @param n   The node.
3172  */
3173 dbg_info *(get_irn_dbg_info)(const ir_node *n) {
3174         return _get_irn_dbg_info(n);
3175 }
3176
3177 #if 0 /* allow the global pointer */
3178
3179 /* checks whether a node represents a global address */
3180 int is_Global(const ir_node *node) {
3181         ir_node *ptr;
3182
3183         if (is_SymConst_addr_ent(node))
3184                 return 1;
3185         if (! is_Sel(node))
3186                 return 0;
3187
3188         ptr = get_Sel_ptr(node);
3189         return is_globals_pointer(ptr) != NULL;
3190 }
3191
3192 /* returns the entity of a global address */
3193 ir_entity *get_Global_entity(const ir_node *node) {
3194         if (is_SymConst(node))
3195                 return get_SymConst_entity(node);
3196         else
3197                 return get_Sel_entity(node);
3198 }
3199 #else
3200
3201 /* checks whether a node represents a global address */
3202 int is_Global(const ir_node *node) {
3203         return is_SymConst_addr_ent(node);
3204 }
3205
3206 /* returns the entity of a global address */
3207 ir_entity *get_Global_entity(const ir_node *node) {
3208         return get_SymConst_entity(node);
3209 }
3210 #endif
3211
3212 /*
3213  * Calculate a hash value of a node.
3214  */
3215 unsigned firm_default_hash(const ir_node *node) {
3216         unsigned h;
3217         int i, irn_arity;
3218
3219         /* hash table value = 9*(9*(9*(9*(9*arity+in[0])+in[1])+ ...)+mode)+code */
3220         h = irn_arity = get_irn_intra_arity(node);
3221
3222         /* consider all in nodes... except the block if not a control flow. */
3223         for (i = is_cfop(node) ? -1 : 0;  i < irn_arity;  ++i) {
3224                 h = 9*h + HASH_PTR(get_irn_intra_n(node, i));
3225         }
3226
3227         /* ...mode,... */
3228         h = 9*h + HASH_PTR(get_irn_mode(node));
3229         /* ...and code */
3230         h = 9*h + HASH_PTR(get_irn_op(node));
3231
3232         return h;
3233 }  /* firm_default_hash */