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