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

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