nsz Git - libfirm/blob - ir/ir/irnode.c

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