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