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