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

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