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 &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(Carry)
1508 BINOP(Sub)
1509 UNOP(Minus)
1510 BINOP(Mul)
1511 BINOP(Mulh)
1512 DIVOP(Quot)
1513 DIVOP(DivMod)
1514 DIVOP(Div)
1515 DIVOP(Mod)
1516 UNOP(Abs)
1517 BINOP(And)
1518 BINOP(Or)
1519 BINOP(Eor)
1520 UNOP(Not)
1521 BINOP(Shl)
1522 BINOP(Shr)
1523 BINOP(Shrs)
1524 BINOP(Rotl)
1525 BINOP(Cmp)
1526 UNOP(Conv)
1527 UNOP(Cast)
1528
1529 int is_Div_remainderless(const ir_node *node) {
1530         assert(is_Div(node));
1531         return node->attr.divmod.no_remainder;
1532 }
1533
1534 int get_Conv_strict(const ir_node *node) {
1535         assert(is_Conv(node));
1536         return node->attr.conv.strict;
1537 }
1538
1539 void set_Conv_strict(ir_node *node, int strict_flag) {
1540         assert(is_Conv(node));
1541         node->attr.conv.strict = (char)strict_flag;
1542 }
1543
1544 ir_type *
1545 get_Cast_type(ir_node *node) {
1546         assert(is_Cast(node));
1547         node->attr.cast.totype = skip_tid(node->attr.cast.totype);
1548         return node->attr.cast.totype;
1549 }
1550
1551 void
1552 set_Cast_type(ir_node *node, ir_type *to_tp) {
1553         assert(is_Cast(node));
1554         node->attr.cast.totype = to_tp;
1555 }
1556
1557
1558 /* Checks for upcast.
1559  *
1560  * Returns true if the Cast node casts a class type to a super type.
1561  */
1562 int is_Cast_upcast(ir_node *node) {
1563         ir_type *totype   = get_Cast_type(node);
1564         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1565
1566         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1567         assert(fromtype);
1568
1569         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1570                 totype   = get_pointer_points_to_type(totype);
1571                 fromtype = get_pointer_points_to_type(fromtype);
1572         }
1573
1574         assert(fromtype);
1575
1576         if (!is_Class_type(totype)) return 0;
1577         return is_SubClass_of(fromtype, totype);
1578 }
1579
1580 /* Checks for downcast.
1581  *
1582  * Returns true if the Cast node casts a class type to a sub type.
1583  */
1584 int is_Cast_downcast(ir_node *node) {
1585         ir_type *totype   = get_Cast_type(node);
1586         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1587
1588         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1589         assert(fromtype);
1590
1591         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1592                 totype   = get_pointer_points_to_type(totype);
1593                 fromtype = get_pointer_points_to_type(fromtype);
1594         }
1595
1596         assert(fromtype);
1597
1598         if (!is_Class_type(totype)) return 0;
1599         return is_SubClass_of(totype, fromtype);
1600 }
1601
1602 int
1603 (is_unop)(const ir_node *node) {
1604         return _is_unop(node);
1605 }
1606
1607 ir_node *
1608 get_unop_op(const ir_node *node) {
1609         if (node->op->opar == oparity_unary)
1610                 return get_irn_n(node, node->op->op_index);
1611
1612         assert(node->op->opar == oparity_unary);
1613         return NULL;
1614 }
1615
1616 void
1617 set_unop_op(ir_node *node, ir_node *op) {
1618         if (node->op->opar == oparity_unary)
1619                 set_irn_n(node, node->op->op_index, op);
1620
1621         assert(node->op->opar == oparity_unary);
1622 }
1623
1624 int
1625 (is_binop)(const ir_node *node) {
1626         return _is_binop(node);
1627 }
1628
1629 ir_node *
1630 get_binop_left(const ir_node *node) {
1631         assert(node->op->opar == oparity_binary);
1632         return get_irn_n(node, node->op->op_index);
1633 }
1634
1635 void
1636 set_binop_left(ir_node *node, ir_node *left) {
1637         assert(node->op->opar == oparity_binary);
1638         set_irn_n(node, node->op->op_index, left);
1639 }
1640
1641 ir_node *
1642 get_binop_right(const ir_node *node) {
1643         assert(node->op->opar == oparity_binary);
1644         return get_irn_n(node, node->op->op_index + 1);
1645 }
1646
1647 void
1648 set_binop_right(ir_node *node, ir_node *right) {
1649         assert(node->op->opar == oparity_binary);
1650         set_irn_n(node, node->op->op_index + 1, right);
1651 }
1652
1653 int
1654 (is_Phi)(const ir_node *n) {
1655         return _is_Phi(n);
1656 }
1657
1658 int is_Phi0(const ir_node *n) {
1659         assert(n);
1660
1661         return ((get_irn_op(n) == op_Phi) &&
1662                 (get_irn_arity(n) == 0) &&
1663                 (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1664 }
1665
1666 ir_node **
1667 get_Phi_preds_arr(ir_node *node) {
1668   assert(node->op == op_Phi);
1669   return (ir_node **)&(get_irn_in(node)[1]);
1670 }
1671
1672 int
1673 get_Phi_n_preds(const ir_node *node) {
1674         assert(is_Phi(node) || is_Phi0(node));
1675         return (get_irn_arity(node));
1676 }
1677
1678 /*
1679 void set_Phi_n_preds(ir_node *node, int n_preds) {
1680         assert(node->op == op_Phi);
1681 }
1682 */
1683
1684 ir_node *
1685 get_Phi_pred(const ir_node *node, int pos) {
1686         assert(is_Phi(node) || is_Phi0(node));
1687         return get_irn_n(node, pos);
1688 }
1689
1690 void
1691 set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
1692         assert(is_Phi(node) || is_Phi0(node));
1693         set_irn_n(node, pos, pred);
1694 }
1695
1696 ir_node *(get_Phi_next)(const ir_node *phi) {
1697         return _get_Phi_next(phi);
1698 }
1699
1700 void (set_Phi_next)(ir_node *phi, ir_node *next) {
1701         _set_Phi_next(phi, next);
1702 }
1703
1704 int is_memop(const ir_node *node) {
1705         ir_opcode code = get_irn_opcode(node);
1706         return (code == iro_Load || code == iro_Store);
1707 }
1708
1709 ir_node *get_memop_mem(const ir_node *node) {
1710         assert(is_memop(node));
1711         return get_irn_n(node, 0);
1712 }
1713
1714 void set_memop_mem(ir_node *node, ir_node *mem) {
1715         assert(is_memop(node));
1716         set_irn_n(node, 0, mem);
1717 }
1718
1719 ir_node *get_memop_ptr(const ir_node *node) {
1720         assert(is_memop(node));
1721         return get_irn_n(node, 1);
1722 }
1723
1724 void set_memop_ptr(ir_node *node, ir_node *ptr) {
1725         assert(is_memop(node));
1726         set_irn_n(node, 1, ptr);
1727 }
1728
1729 ir_node *
1730 get_Load_mem(const ir_node *node) {
1731         assert(is_Load(node));
1732         return get_irn_n(node, 0);
1733 }
1734
1735 void
1736 set_Load_mem(ir_node *node, ir_node *mem) {
1737         assert(is_Load(node));
1738         set_irn_n(node, 0, mem);
1739 }
1740
1741 ir_node *
1742 get_Load_ptr(const ir_node *node) {
1743         assert(is_Load(node));
1744         return get_irn_n(node, 1);
1745 }
1746
1747 void
1748 set_Load_ptr(ir_node *node, ir_node *ptr) {
1749         assert(is_Load(node));
1750         set_irn_n(node, 1, ptr);
1751 }
1752
1753 ir_mode *
1754 get_Load_mode(const ir_node *node) {
1755         assert(is_Load(node));
1756         return node->attr.load.load_mode;
1757 }
1758
1759 void
1760 set_Load_mode(ir_node *node, ir_mode *mode) {
1761         assert(is_Load(node));
1762         node->attr.load.load_mode = mode;
1763 }
1764
1765 ir_volatility
1766 get_Load_volatility(const ir_node *node) {
1767         assert(is_Load(node));
1768         return node->attr.load.volatility;
1769 }
1770
1771 void
1772 set_Load_volatility(ir_node *node, ir_volatility volatility) {
1773         assert(is_Load(node));
1774         node->attr.load.volatility = volatility;
1775 }
1776
1777 ir_align
1778 get_Load_align(const ir_node *node) {
1779         assert(is_Load(node));
1780         return node->attr.load.aligned;
1781 }
1782
1783 void
1784 set_Load_align(ir_node *node, ir_align align) {
1785         assert(is_Load(node));
1786         node->attr.load.aligned = align;
1787 }
1788
1789
1790 ir_node *
1791 get_Store_mem(const ir_node *node) {
1792         assert(is_Store(node));
1793         return get_irn_n(node, 0);
1794 }
1795
1796 void
1797 set_Store_mem(ir_node *node, ir_node *mem) {
1798         assert(is_Store(node));
1799         set_irn_n(node, 0, mem);
1800 }
1801
1802 ir_node *
1803 get_Store_ptr(const ir_node *node) {
1804         assert(is_Store(node));
1805         return get_irn_n(node, 1);
1806 }
1807
1808 void
1809 set_Store_ptr(ir_node *node, ir_node *ptr) {
1810         assert(is_Store(node));
1811         set_irn_n(node, 1, ptr);
1812 }
1813
1814 ir_node *
1815 get_Store_value(const ir_node *node) {
1816         assert(is_Store(node));
1817         return get_irn_n(node, 2);
1818 }
1819
1820 void
1821 set_Store_value(ir_node *node, ir_node *value) {
1822         assert(is_Store(node));
1823         set_irn_n(node, 2, value);
1824 }
1825
1826 ir_volatility
1827 get_Store_volatility(const ir_node *node) {
1828         assert(is_Store(node));
1829         return node->attr.store.volatility;
1830 }
1831
1832 void
1833 set_Store_volatility(ir_node *node, ir_volatility volatility) {
1834         assert(is_Store(node));
1835         node->attr.store.volatility = volatility;
1836 }
1837
1838 ir_align
1839 get_Store_align(const ir_node *node) {
1840         assert(is_Store(node));
1841         return node->attr.store.aligned;
1842 }
1843
1844 void
1845 set_Store_align(ir_node *node, ir_align align) {
1846         assert(is_Store(node));
1847         node->attr.store.aligned = align;
1848 }
1849
1850
1851 ir_node *
1852 get_Alloc_mem(const ir_node *node) {
1853         assert(is_Alloc(node));
1854         return get_irn_n(node, 0);
1855 }
1856
1857 void
1858 set_Alloc_mem(ir_node *node, ir_node *mem) {
1859         assert(is_Alloc(node));
1860         set_irn_n(node, 0, mem);
1861 }
1862
1863 ir_node *
1864 get_Alloc_size(const ir_node *node) {
1865         assert(is_Alloc(node));
1866         return get_irn_n(node, 1);
1867 }
1868
1869 void
1870 set_Alloc_size(ir_node *node, ir_node *size) {
1871         assert(is_Alloc(node));
1872         set_irn_n(node, 1, size);
1873 }
1874
1875 ir_type *
1876 get_Alloc_type(ir_node *node) {
1877         assert(is_Alloc(node));
1878         return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
1879 }
1880
1881 void
1882 set_Alloc_type(ir_node *node, ir_type *tp) {
1883         assert(is_Alloc(node));
1884         node->attr.alloc.type = tp;
1885 }
1886
1887 ir_where_alloc
1888 get_Alloc_where(const ir_node *node) {
1889         assert(is_Alloc(node));
1890         return node->attr.alloc.where;
1891 }
1892
1893 void
1894 set_Alloc_where(ir_node *node, ir_where_alloc where) {
1895         assert(is_Alloc(node));
1896         node->attr.alloc.where = where;
1897 }
1898
1899
1900 ir_node *
1901 get_Free_mem(const ir_node *node) {
1902         assert(is_Free(node));
1903         return get_irn_n(node, 0);
1904 }
1905
1906 void
1907 set_Free_mem(ir_node *node, ir_node *mem) {
1908         assert(is_Free(node));
1909         set_irn_n(node, 0, mem);
1910 }
1911
1912 ir_node *
1913 get_Free_ptr(const ir_node *node) {
1914         assert(is_Free(node));
1915         return get_irn_n(node, 1);
1916 }
1917
1918 void
1919 set_Free_ptr(ir_node *node, ir_node *ptr) {
1920         assert(is_Free(node));
1921         set_irn_n(node, 1, ptr);
1922 }
1923
1924 ir_node *
1925 get_Free_size(const ir_node *node) {
1926         assert(is_Free(node));
1927         return get_irn_n(node, 2);
1928 }
1929
1930 void
1931 set_Free_size(ir_node *node, ir_node *size) {
1932         assert(is_Free(node));
1933         set_irn_n(node, 2, size);
1934 }
1935
1936 ir_type *
1937 get_Free_type(ir_node *node) {
1938         assert(is_Free(node));
1939         return node->attr.free.type = skip_tid(node->attr.free.type);
1940 }
1941
1942 void
1943 set_Free_type(ir_node *node, ir_type *tp) {
1944         assert(is_Free(node));
1945         node->attr.free.type = tp;
1946 }
1947
1948 ir_where_alloc
1949 get_Free_where(const ir_node *node) {
1950         assert(is_Free(node));
1951         return node->attr.free.where;
1952 }
1953
1954 void
1955 set_Free_where(ir_node *node, ir_where_alloc where) {
1956         assert(is_Free(node));
1957         node->attr.free.where = where;
1958 }
1959
1960 ir_node **get_Sync_preds_arr(ir_node *node) {
1961         assert(is_Sync(node));
1962         return (ir_node **)&(get_irn_in(node)[1]);
1963 }
1964
1965 int get_Sync_n_preds(const ir_node *node) {
1966         assert(is_Sync(node));
1967         return (get_irn_arity(node));
1968 }
1969
1970 /*
1971 void set_Sync_n_preds(ir_node *node, int n_preds) {
1972         assert(is_Sync(node));
1973 }
1974 */
1975
1976 ir_node *get_Sync_pred(const ir_node *node, int pos) {
1977         assert(is_Sync(node));
1978         return get_irn_n(node, pos);
1979 }
1980
1981 void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
1982         assert(is_Sync(node));
1983         set_irn_n(node, pos, pred);
1984 }
1985
1986 /* Add a new Sync predecessor */
1987 void add_Sync_pred(ir_node *node, ir_node *pred) {
1988         assert(is_Sync(node));
1989         add_irn_n(node, pred);
1990 }
1991
1992 /* Returns the source language type of a Proj node. */
1993 ir_type *get_Proj_type(ir_node *n) {
1994         ir_type *tp   = firm_unknown_type;
1995         ir_node *pred = get_Proj_pred(n);
1996
1997         switch (get_irn_opcode(pred)) {
1998         case iro_Proj: {
1999                 ir_node *pred_pred;
2000                 /* Deal with Start / Call here: we need to know the Proj Nr. */
2001                 assert(get_irn_mode(pred) == mode_T);
2002                 pred_pred = get_Proj_pred(pred);
2003
2004                 if (is_Start(pred_pred))  {
2005                         ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
2006                         tp = get_method_param_type(mtp, get_Proj_proj(n));
2007                 } else if (is_Call(pred_pred)) {
2008                         ir_type *mtp = get_Call_type(pred_pred);
2009                         tp = get_method_res_type(mtp, get_Proj_proj(n));
2010                 }
2011         } break;
2012         case iro_Start: break;
2013         case iro_Call: break;
2014         case iro_Load: {
2015                 ir_node *a = get_Load_ptr(pred);
2016                 if (is_Sel(a))
2017                         tp = get_entity_type(get_Sel_entity(a));
2018         } break;
2019         default:
2020                 break;
2021         }
2022         return tp;
2023 }
2024
2025 ir_node *
2026 get_Proj_pred(const ir_node *node) {
2027         assert(is_Proj(node));
2028         return get_irn_n(node, 0);
2029 }
2030
2031 void
2032 set_Proj_pred(ir_node *node, ir_node *pred) {
2033         assert(is_Proj(node));
2034         set_irn_n(node, 0, pred);
2035 }
2036
2037 long
2038 get_Proj_proj(const ir_node *node) {
2039 #ifdef INTERPROCEDURAL_VIEW
2040         ir_opcode code = get_irn_opcode(node);
2041
2042         if (code == iro_Proj) {
2043                 return node->attr.proj;
2044         }
2045         else {
2046                 assert(code == iro_Filter);
2047                 return node->attr.filter.proj;
2048         }
2049 #else
2050         assert(is_Proj(node));
2051         return node->attr.proj;
2052 #endif /* INTERPROCEDURAL_VIEW */
2053 }
2054
2055 void
2056 set_Proj_proj(ir_node *node, long proj) {
2057 #ifdef INTERPROCEDURAL_VIEW
2058         ir_opcode code = get_irn_opcode(node);
2059
2060         if (code == iro_Proj) {
2061                 node->attr.proj = proj;
2062         }
2063         else {
2064                 assert(code == iro_Filter);
2065                 node->attr.filter.proj = proj;
2066         }
2067 #else
2068         assert(is_Proj(node));
2069         node->attr.proj = proj;
2070 #endif /* INTERPROCEDURAL_VIEW */
2071 }
2072
2073 /* Returns non-zero if a node is a routine parameter. */
2074 int (is_arg_Proj)(const ir_node *node) {
2075         return _is_arg_Proj(node);
2076 }
2077
2078 ir_node **
2079 get_Tuple_preds_arr(ir_node *node) {
2080         assert(is_Tuple(node));
2081         return (ir_node **)&(get_irn_in(node)[1]);
2082 }
2083
2084 int
2085 get_Tuple_n_preds(const ir_node *node) {
2086         assert(is_Tuple(node));
2087         return get_irn_arity(node);
2088 }
2089
2090 /*
2091 void
2092 set_Tuple_n_preds(ir_node *node, int n_preds) {
2093         assert(is_Tuple(node));
2094 }
2095 */
2096
2097 ir_node *
2098 get_Tuple_pred(const ir_node *node, int pos) {
2099   assert(is_Tuple(node));
2100   return get_irn_n(node, pos);
2101 }
2102
2103 void
2104 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
2105         assert(is_Tuple(node));
2106         set_irn_n(node, pos, pred);
2107 }
2108
2109 ir_node *
2110 get_Id_pred(const ir_node *node) {
2111         assert(is_Id(node));
2112         return get_irn_n(node, 0);
2113 }
2114
2115 void
2116 set_Id_pred(ir_node *node, ir_node *pred) {
2117         assert(is_Id(node));
2118         set_irn_n(node, 0, pred);
2119 }
2120
2121 ir_node *get_Confirm_value(const ir_node *node) {
2122         assert(is_Confirm(node));
2123         return get_irn_n(node, 0);
2124 }
2125
2126 void set_Confirm_value(ir_node *node, ir_node *value) {
2127         assert(is_Confirm(node));
2128         set_irn_n(node, 0, value);
2129 }
2130
2131 ir_node *get_Confirm_bound(const ir_node *node) {
2132         assert(is_Confirm(node));
2133         return get_irn_n(node, 1);
2134 }
2135
2136 void set_Confirm_bound(ir_node *node, ir_node *bound) {
2137         assert(is_Confirm(node));
2138         set_irn_n(node, 0, bound);
2139 }
2140
2141 pn_Cmp get_Confirm_cmp(const ir_node *node) {
2142         assert(is_Confirm(node));
2143         return node->attr.confirm.cmp;
2144 }
2145
2146 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
2147         assert(is_Confirm(node));
2148         node->attr.confirm.cmp = cmp;
2149 }
2150
2151 ir_node *
2152 get_Filter_pred(ir_node *node) {
2153         assert(is_Filter(node));
2154         return node->in[1];
2155 }
2156
2157 void
2158 set_Filter_pred(ir_node *node, ir_node *pred) {
2159         assert(is_Filter(node));
2160         node->in[1] = pred;
2161 }
2162
2163 long
2164 get_Filter_proj(ir_node *node) {
2165         assert(is_Filter(node));
2166         return node->attr.filter.proj;
2167 }
2168
2169 void
2170 set_Filter_proj(ir_node *node, long proj) {
2171         assert(is_Filter(node));
2172         node->attr.filter.proj = proj;
2173 }
2174
2175 /* Don't use get_irn_arity, get_irn_n in implementation as access
2176    shall work independent of view!!! */
2177 void set_Filter_cg_pred_arr(ir_node *node, int arity, ir_node ** in) {
2178         assert(is_Filter(node));
2179         if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2180                 ir_graph *irg = get_irn_irg(node);
2181                 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2182                 node->attr.filter.backedge = new_backedge_arr(irg->obst, arity);
2183                 node->attr.filter.in_cg[0] = node->in[0];
2184         }
2185         memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2186 }
2187
2188 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2189         assert(is_Filter(node) && node->attr.filter.in_cg &&
2190                0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2191         node->attr.filter.in_cg[pos + 1] = pred;
2192 }
2193
2194 int get_Filter_n_cg_preds(ir_node *node) {
2195         assert(is_Filter(node) && node->attr.filter.in_cg);
2196         return (ARR_LEN(node->attr.filter.in_cg) - 1);
2197 }
2198
2199 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2200         int arity;
2201         assert(is_Filter(node) && node->attr.filter.in_cg &&
2202                0 <= pos);
2203         arity = ARR_LEN(node->attr.filter.in_cg);
2204         assert(pos < arity - 1);
2205         return node->attr.filter.in_cg[pos + 1];
2206 }
2207
2208 /* Mux support */
2209 ir_node *get_Mux_sel(const ir_node *node) {
2210         assert(is_Mux(node));
2211         return node->in[1];
2212 }
2213
2214 void set_Mux_sel(ir_node *node, ir_node *sel) {
2215         assert(is_Mux(node));
2216         node->in[1] = sel;
2217 }
2218
2219 ir_node *get_Mux_false(const ir_node *node) {
2220         assert(is_Mux(node));
2221         return node->in[2];
2222 }
2223
2224 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2225         assert(is_Mux(node));
2226         node->in[2] = ir_false;
2227 }
2228
2229 ir_node *get_Mux_true(const ir_node *node) {
2230         assert(is_Mux(node));
2231         return node->in[3];
2232 }
2233
2234 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2235         assert(is_Mux(node));
2236         node->in[3] = ir_true;
2237 }
2238
2239 /* CopyB support */
2240 ir_node *get_CopyB_mem(const ir_node *node) {
2241         assert(is_CopyB(node));
2242         return get_irn_n(node, 0);
2243 }
2244
2245 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2246         assert(node->op == op_CopyB);
2247         set_irn_n(node, 0, mem);
2248 }
2249
2250 ir_node *get_CopyB_dst(const ir_node *node) {
2251         assert(is_CopyB(node));
2252         return get_irn_n(node, 1);
2253 }
2254
2255 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2256         assert(is_CopyB(node));
2257         set_irn_n(node, 1, dst);
2258 }
2259
2260 ir_node *get_CopyB_src(const ir_node *node) {
2261   assert(is_CopyB(node));
2262   return get_irn_n(node, 2);
2263 }
2264
2265 void set_CopyB_src(ir_node *node, ir_node *src) {
2266         assert(is_CopyB(node));
2267         set_irn_n(node, 2, src);
2268 }
2269
2270 ir_type *get_CopyB_type(ir_node *node) {
2271         assert(is_CopyB(node));
2272         return node->attr.copyb.data_type = skip_tid(node->attr.copyb.data_type);
2273 }
2274
2275 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2276         assert(is_CopyB(node) && data_type);
2277         node->attr.copyb.data_type = data_type;
2278 }
2279
2280
2281 ir_type *
2282 get_InstOf_type(ir_node *node) {
2283         assert(node->op == op_InstOf);
2284         return node->attr.instof.type = skip_tid(node->attr.instof.type);
2285 }
2286
2287 void
2288 set_InstOf_type(ir_node *node, ir_type *type) {
2289         assert(node->op == op_InstOf);
2290         node->attr.instof.type = type;
2291 }
2292
2293 ir_node *
2294 get_InstOf_store(const ir_node *node) {
2295         assert(node->op == op_InstOf);
2296         return get_irn_n(node, 0);
2297 }
2298
2299 void
2300 set_InstOf_store(ir_node *node, ir_node *obj) {
2301         assert(node->op == op_InstOf);
2302         set_irn_n(node, 0, obj);
2303 }
2304
2305 ir_node *
2306 get_InstOf_obj(const ir_node *node) {
2307         assert(node->op == op_InstOf);
2308         return get_irn_n(node, 1);
2309 }
2310
2311 void
2312 set_InstOf_obj(ir_node *node, ir_node *obj) {
2313         assert(node->op == op_InstOf);
2314         set_irn_n(node, 1, obj);
2315 }
2316
2317 /* Returns the memory input of a Raise operation. */
2318 ir_node *
2319 get_Raise_mem(const ir_node *node) {
2320         assert(is_Raise(node));
2321         return get_irn_n(node, 0);
2322 }
2323
2324 void
2325 set_Raise_mem(ir_node *node, ir_node *mem) {
2326         assert(is_Raise(node));
2327         set_irn_n(node, 0, mem);
2328 }
2329
2330 ir_node *
2331 get_Raise_exo_ptr(const ir_node *node) {
2332         assert(is_Raise(node));
2333         return get_irn_n(node, 1);
2334 }
2335
2336 void
2337 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2338         assert(is_Raise(node));
2339         set_irn_n(node, 1, exo_ptr);
2340 }
2341
2342 /* Bound support */
2343
2344 /* Returns the memory input of a Bound operation. */
2345 ir_node *get_Bound_mem(const ir_node *bound) {
2346         assert(is_Bound(bound));
2347         return get_irn_n(bound, 0);
2348 }
2349
2350 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2351         assert(is_Bound(bound));
2352         set_irn_n(bound, 0, mem);
2353 }
2354
2355 /* Returns the index input of a Bound operation. */
2356 ir_node *get_Bound_index(const ir_node *bound) {
2357         assert(is_Bound(bound));
2358         return get_irn_n(bound, 1);
2359 }
2360
2361 void set_Bound_index(ir_node *bound, ir_node *idx) {
2362         assert(is_Bound(bound));
2363         set_irn_n(bound, 1, idx);
2364 }
2365
2366 /* Returns the lower bound input of a Bound operation. */
2367 ir_node *get_Bound_lower(const ir_node *bound) {
2368         assert(is_Bound(bound));
2369         return get_irn_n(bound, 2);
2370 }
2371
2372 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2373         assert(is_Bound(bound));
2374         set_irn_n(bound, 2, lower);
2375 }
2376
2377 /* Returns the upper bound input of a Bound operation. */
2378 ir_node *get_Bound_upper(const ir_node *bound) {
2379         assert(is_Bound(bound));
2380         return get_irn_n(bound, 3);
2381 }
2382
2383 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2384         assert(is_Bound(bound));
2385         set_irn_n(bound, 3, upper);
2386 }
2387
2388 /* Return the operand of a Pin node. */
2389 ir_node *get_Pin_op(const ir_node *pin) {
2390         assert(is_Pin(pin));
2391         return get_irn_n(pin, 0);
2392 }
2393
2394 void set_Pin_op(ir_node *pin, ir_node *node) {
2395         assert(is_Pin(pin));
2396         set_irn_n(pin, 0, node);
2397 }
2398
2399 /* Return the assembler text of an ASM pseudo node. */
2400 ident *get_ASM_text(const ir_node *node) {
2401         assert(is_ASM(node));
2402         return node->attr.assem.asm_text;
2403 }
2404
2405 /* Return the number of input constraints for an ASM node. */
2406 int get_ASM_n_input_constraints(const ir_node *node) {
2407         assert(is_ASM(node));
2408         return ARR_LEN(node->attr.assem.inputs);
2409 }
2410
2411 /* Return the input constraints for an ASM node. This is a flexible array. */
2412 const ir_asm_constraint *get_ASM_input_constraints(const ir_node *node) {
2413         assert(is_ASM(node));
2414         return node->attr.assem.inputs;
2415 }
2416
2417 /* Return the number of output constraints for an ASM node.  */
2418 int get_ASM_n_output_constraints(const ir_node *node) {
2419         assert(is_ASM(node));
2420         return ARR_LEN(node->attr.assem.outputs);
2421 }
2422
2423 /* Return the output constraints for an ASM node. */
2424 const ir_asm_constraint *get_ASM_output_constraints(const ir_node *node) {
2425         assert(is_ASM(node));
2426         return node->attr.assem.outputs;
2427 }
2428
2429 /* Return the number of clobbered registers for an ASM node.  */
2430 int get_ASM_n_clobbers(const ir_node *node) {
2431         assert(is_ASM(node));
2432         return ARR_LEN(node->attr.assem.clobber);
2433 }
2434
2435 /* Return the list of clobbered registers for an ASM node. */
2436 ident **get_ASM_clobbers(const ir_node *node) {
2437         assert(is_ASM(node));
2438         return node->attr.assem.clobber;
2439 }
2440
2441 /* returns the graph of a node */
2442 ir_graph *
2443 get_irn_irg(const ir_node *node) {
2444         /*
2445          * Do not use get_nodes_Block() here, because this
2446          * will check the pinned state.
2447          * However even a 'wrong' block is always in the proper
2448          * irg.
2449          */
2450         if (! is_Block(node))
2451                 node = get_irn_n(node, -1);
2452         if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2453                 node = get_irn_n(node, -1);
2454         assert(get_irn_op(node) == op_Block);
2455         return node->attr.block.irg;
2456 }
2457
2458
2459 /*----------------------------------------------------------------*/
2460 /*  Auxiliary routines                                            */
2461 /*----------------------------------------------------------------*/
2462
2463 ir_node *
2464 skip_Proj(ir_node *node) {
2465         /* don't assert node !!! */
2466         if (node == NULL)
2467                 return NULL;
2468
2469         if (is_Proj(node))
2470                 node = get_Proj_pred(node);
2471
2472         return node;
2473 }
2474
2475 const ir_node *
2476 skip_Proj_const(const ir_node *node) {
2477         /* don't assert node !!! */
2478         if (node == NULL)
2479                 return NULL;
2480
2481         if (is_Proj(node))
2482                 node = get_Proj_pred(node);
2483
2484         return node;
2485 }
2486
2487 ir_node *
2488 skip_Tuple(ir_node *node) {
2489   ir_node *pred;
2490   ir_op   *op;
2491
2492   if (!get_opt_normalize()) return node;
2493
2494 restart:
2495         if (get_irn_op(node) == op_Proj) {
2496             pred = get_Proj_pred(node);
2497             op   = get_irn_op(pred);
2498
2499                 /*
2500                  * Looks strange but calls get_irn_op() only once
2501                  * in most often cases.
2502                  */
2503                 if (op == op_Proj) { /* nested Tuple ? */
2504                     pred = skip_Tuple(pred);
2505                     op   = get_irn_op(pred);
2506
2507                         if (op == op_Tuple) {
2508                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
2509                                 goto restart;
2510                         }
2511                 } else if (op == op_Tuple) {
2512                         node = get_Tuple_pred(pred, get_Proj_proj(node));
2513                         goto restart;
2514                 }
2515         }
2516         return node;
2517 }
2518
2519 /* returns operand of node if node is a Cast */
2520 ir_node *skip_Cast(ir_node *node) {
2521         if (is_Cast(node))
2522                 return get_Cast_op(node);
2523         return node;
2524 }
2525
2526 /* returns operand of node if node is a Cast */
2527 const ir_node *skip_Cast_const(const ir_node *node) {
2528         if (is_Cast(node))
2529                 return get_Cast_op(node);
2530         return node;
2531 }
2532
2533 /* returns operand of node if node is a Pin */
2534 ir_node *skip_Pin(ir_node *node) {
2535         if (is_Pin(node))
2536                 return get_Pin_op(node);
2537         return node;
2538 }
2539
2540 /* returns operand of node if node is a Confirm */
2541 ir_node *skip_Confirm(ir_node *node) {
2542         if (get_irn_op(node) == op_Confirm)
2543                 return get_Confirm_value(node);
2544         return node;
2545 }
2546
2547 /* skip all high-level ops */
2548 ir_node *skip_HighLevel_ops(ir_node *node) {
2549         while (is_op_highlevel(get_irn_op(node))) {
2550                 node = get_irn_n(node, 0);
2551         }
2552         return node;
2553 }
2554
2555
2556 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2557  * than any other approach, as Id chains are resolved and all point to the real node, or
2558  * all id's are self loops.
2559  *
2560  * Note: This function takes 10% of mostly ANY the compiler run, so it's
2561  * a little bit "hand optimized".
2562  *
2563  * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2564  */
2565 ir_node *
2566 skip_Id(ir_node *node) {
2567         ir_node *pred;
2568         /* don't assert node !!! */
2569
2570         if (!node || (node->op != op_Id)) return node;
2571
2572         /* Don't use get_Id_pred():  We get into an endless loop for
2573            self-referencing Ids. */
2574         pred = node->in[0+1];
2575
2576         if (pred->op != op_Id) return pred;
2577
2578         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2579                 ir_node *rem_pred, *res;
2580
2581                 if (pred->op != op_Id) return pred; /* shortcut */
2582                 rem_pred = pred;
2583
2584                 assert(get_irn_arity (node) > 0);
2585
2586                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2587                 res = skip_Id(rem_pred);
2588                 if (res->op == op_Id) /* self-loop */ return node;
2589
2590                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2591                 return res;
2592         } else {
2593                 return node;
2594         }
2595 }
2596
2597 void skip_Id_and_store(ir_node **node) {
2598         ir_node *n = *node;
2599
2600         if (!n || (n->op != op_Id)) return;
2601
2602         /* Don't use get_Id_pred():  We get into an endless loop for
2603            self-referencing Ids. */
2604         *node = skip_Id(n);
2605 }
2606
2607 int
2608 (is_Bad)(const ir_node *node) {
2609         return _is_Bad(node);
2610 }
2611
2612 int
2613 (is_NoMem)(const ir_node *node) {
2614         return _is_NoMem(node);
2615 }
2616
2617 int
2618 (is_Minus)(const ir_node *node) {
2619         return _is_Minus(node);
2620 }
2621
2622 int
2623 (is_Abs)(const ir_node *node) {
2624         return _is_Abs(node);
2625 }
2626
2627 int
2628 (is_Mod)(const ir_node *node) {
2629         return _is_Mod(node);
2630 }
2631
2632 int
2633 (is_Div)(const ir_node *node) {
2634         return _is_Div(node);
2635 }
2636
2637 int
2638 (is_DivMod)(const ir_node *node) {
2639         return _is_DivMod(node);
2640 }
2641
2642 int
2643 (is_Quot)(const ir_node *node) {
2644         return _is_Quot(node);
2645 }
2646
2647 int
2648 (is_Add)(const ir_node *node) {
2649         return _is_Add(node);
2650 }
2651
2652 int
2653 (is_Carry)(const ir_node *node) {
2654         return _is_Carry(node);
2655 }
2656
2657 int
2658 (is_And)(const ir_node *node) {
2659         return _is_And(node);
2660 }
2661
2662 int
2663 (is_Or)(const ir_node *node) {
2664         return _is_Or(node);
2665 }
2666
2667 int
2668 (is_Eor)(const ir_node *node) {
2669         return _is_Eor(node);
2670 }
2671
2672 int
2673 (is_Sub)(const ir_node *node) {
2674         return _is_Sub(node);
2675 }
2676
2677 int
2678 (is_Shl)(const ir_node *node) {
2679         return _is_Shl(node);
2680 }
2681
2682 int
2683 (is_Shr)(const ir_node *node) {
2684         return _is_Shr(node);
2685 }
2686
2687 int
2688 (is_Shrs)(const ir_node *node) {
2689         return _is_Shrs(node);
2690 }
2691
2692 int
2693 (is_Rotl)(const ir_node *node) {
2694         return _is_Rotl(node);
2695 }
2696
2697 int
2698 (is_Not)(const ir_node *node) {
2699         return _is_Not(node);
2700 }
2701
2702 int
2703 (is_Id)(const ir_node *node) {
2704         return _is_Id(node);
2705 }
2706
2707 int
2708 (is_Tuple)(const ir_node *node) {
2709         return _is_Tuple(node);
2710 }
2711
2712 int
2713 (is_Bound)(const ir_node *node) {
2714         return _is_Bound(node);
2715 }
2716
2717 int
2718 (is_Start)(const ir_node *node) {
2719   return _is_Start(node);
2720 }
2721
2722 int
2723 (is_End)(const ir_node *node) {
2724         return _is_End(node);
2725 }
2726
2727 int
2728 (is_Const)(const ir_node *node) {
2729         return _is_Const(node);
2730 }
2731
2732 int
2733 (is_Conv)(const ir_node *node) {
2734         return _is_Conv(node);
2735 }
2736
2737 int
2738 (is_strictConv)(const ir_node *node) {
2739         return _is_strictConv(node);
2740 }
2741
2742 int
2743 (is_Cast)(const ir_node *node) {
2744         return _is_Cast(node);
2745 }
2746
2747 int
2748 (is_no_Block)(const ir_node *node) {
2749         return _is_no_Block(node);
2750 }
2751
2752 int
2753 (is_Block)(const ir_node *node) {
2754         return _is_Block(node);
2755 }
2756
2757 /* returns true if node is an Unknown node. */
2758 int
2759 (is_Unknown)(const ir_node *node) {
2760         return _is_Unknown(node);
2761 }
2762
2763 /* returns true if node is a Return node. */
2764 int
2765 (is_Return)(const ir_node *node) {
2766         return _is_Return(node);
2767 }
2768
2769 /* returns true if node is a Call node. */
2770 int
2771 (is_Call)(const ir_node *node) {
2772         return _is_Call(node);
2773 }
2774
2775 /* returns true if node is a CallBegin node. */
2776 int
2777 (is_CallBegin)(const ir_node *node) {
2778         return _is_CallBegin(node);
2779 }
2780
2781 /* returns true if node is a Sel node. */
2782 int
2783 (is_Sel)(const ir_node *node) {
2784         return _is_Sel(node);
2785 }
2786
2787 /* returns true if node is a Mux node. */
2788 int
2789 (is_Mux)(const ir_node *node) {
2790         return _is_Mux(node);
2791 }
2792
2793 /* returns true if node is a Load node. */
2794 int
2795 (is_Load)(const ir_node *node) {
2796         return _is_Load(node);
2797 }
2798
2799 /* returns true if node is a Load node. */
2800 int
2801 (is_Store)(const ir_node *node) {
2802         return _is_Store(node);
2803 }
2804
2805 /* returns true if node is a Sync node. */
2806 int
2807 (is_Sync)(const ir_node *node) {
2808         return _is_Sync(node);
2809 }
2810
2811 /* Returns true if node is a Confirm node. */
2812 int
2813 (is_Confirm)(const ir_node *node) {
2814         return _is_Confirm(node);
2815 }
2816
2817 /* Returns true if node is a Pin node. */
2818 int
2819 (is_Pin)(const ir_node *node) {
2820         return _is_Pin(node);
2821 }
2822
2823 /* Returns true if node is a SymConst node. */
2824 int
2825 (is_SymConst)(const ir_node *node) {
2826         return _is_SymConst(node);
2827 }
2828
2829 /* Returns true if node is a SymConst node with kind symconst_addr_ent. */
2830 int
2831 (is_SymConst_addr_ent)(const ir_node *node) {
2832         return _is_SymConst_addr_ent(node);
2833 }
2834
2835 /* Returns true if node is a Cond node. */
2836 int
2837 (is_Cond)(const ir_node *node) {
2838         return _is_Cond(node);
2839 }
2840
2841 int
2842 (is_CopyB)(const ir_node *node) {
2843         return _is_CopyB(node);
2844 }
2845
2846 /* returns true if node is a Cmp node. */
2847 int
2848 (is_Cmp)(const ir_node *node) {
2849         return _is_Cmp(node);
2850 }
2851
2852 /* returns true if node is an Alloc node. */
2853 int
2854 (is_Alloc)(const ir_node *node) {
2855         return _is_Alloc(node);
2856 }
2857
2858 /* returns true if node is a Free node. */
2859 int
2860 (is_Free)(const ir_node *node) {
2861         return _is_Free(node);
2862 }
2863
2864 /* returns true if a node is a Jmp node. */
2865 int
2866 (is_Jmp)(const ir_node *node) {
2867         return _is_Jmp(node);
2868 }
2869
2870 /* returns true if a node is a IJmp node. */
2871 int
2872 (is_IJmp)(const ir_node *node) {
2873         return _is_IJmp(node);
2874 }
2875
2876 /* returns true if a node is a Raise node. */
2877 int
2878 (is_Raise)(const ir_node *node) {
2879         return _is_Raise(node);
2880 }
2881
2882 /* returns true if a node is an ASM node. */
2883 int
2884 (is_ASM)(const ir_node *node) {
2885         return _is_ASM(node);
2886 }
2887
2888 int
2889 (is_Proj)(const ir_node *node) {
2890         return _is_Proj(node);
2891 }
2892
2893 /* Returns true if node is a Filter node. */
2894 int
2895 (is_Filter)(const ir_node *node) {
2896         return _is_Filter(node);
2897 }
2898
2899 /* Returns true if the operation manipulates control flow. */
2900 int is_cfop(const ir_node *node) {
2901         return is_op_cfopcode(get_irn_op(node));
2902 }
2903
2904 /* Returns true if the operation manipulates interprocedural control flow:
2905    CallBegin, EndReg, EndExcept */
2906 int is_ip_cfop(const ir_node *node) {
2907         return is_ip_cfopcode(get_irn_op(node));
2908 }
2909
2910 /* Returns true if the operation can change the control flow because
2911    of an exception. */
2912 int
2913 is_fragile_op(const ir_node *node) {
2914         return is_op_fragile(get_irn_op(node));
2915 }
2916
2917 /* Returns the memory operand of fragile operations. */
2918 ir_node *get_fragile_op_mem(ir_node *node) {
2919         assert(node && is_fragile_op(node));
2920
2921         switch (get_irn_opcode(node)) {
2922         case iro_Call  :
2923         case iro_Quot  :
2924         case iro_DivMod:
2925         case iro_Div   :
2926         case iro_Mod   :
2927         case iro_Load  :
2928         case iro_Store :
2929         case iro_Alloc :
2930         case iro_Bound :
2931         case iro_CopyB :
2932                 return get_irn_n(node, pn_Generic_M_regular);
2933         case iro_Bad   :
2934         case iro_Unknown:
2935                 return node;
2936         default: ;
2937                 assert(0 && "should not be reached");
2938                 return NULL;
2939         }
2940 }
2941
2942 /* Returns the result mode of a Div operation. */
2943 ir_mode *get_divop_resmod(const ir_node *node) {
2944         switch (get_irn_opcode(node)) {
2945         case iro_Quot  : return get_Quot_resmode(node);
2946         case iro_DivMod: return get_DivMod_resmode(node);
2947         case iro_Div   : return get_Div_resmode(node);
2948         case iro_Mod   : return get_Mod_resmode(node);
2949         default: ;
2950                 assert(0 && "should not be reached");
2951                 return NULL;
2952         }
2953 }
2954
2955 /* Returns true if the operation is a forking control flow operation. */
2956 int (is_irn_forking)(const ir_node *node) {
2957         return _is_irn_forking(node);
2958 }
2959
2960 /* Return the type associated with the value produced by n
2961  * if the node remarks this type as it is the case for
2962  * Cast, Const, SymConst and some Proj nodes. */
2963 ir_type *(get_irn_type)(ir_node *node) {
2964         return _get_irn_type(node);
2965 }
2966
2967 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
2968    Cast) or NULL.*/
2969 ir_type *(get_irn_type_attr)(ir_node *node) {
2970         return _get_irn_type_attr(node);
2971 }
2972
2973 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
2974 ir_entity *(get_irn_entity_attr)(ir_node *node) {
2975         return _get_irn_entity_attr(node);
2976 }
2977
2978 /* Returns non-zero for constant-like nodes. */
2979 int (is_irn_constlike)(const ir_node *node) {
2980         return _is_irn_constlike(node);
2981 }
2982
2983 /*
2984  * Returns non-zero for nodes that are allowed to have keep-alives and
2985  * are neither Block nor PhiM.
2986  */
2987 int (is_irn_keep)(const ir_node *node) {
2988         return _is_irn_keep(node);
2989 }
2990
2991 /*
2992  * Returns non-zero for nodes that are always placed in the start block.
2993  */
2994 int (is_irn_start_block_placed)(const ir_node *node) {
2995         return _is_irn_start_block_placed(node);
2996 }
2997
2998 /* Returns non-zero for nodes that are machine operations. */
2999 int (is_irn_machine_op)(const ir_node *node) {
3000         return _is_irn_machine_op(node);
3001 }
3002
3003 /* Returns non-zero for nodes that are machine operands. */
3004 int (is_irn_machine_operand)(const ir_node *node) {
3005         return _is_irn_machine_operand(node);
3006 }
3007
3008 /* Returns non-zero for nodes that have the n'th user machine flag set. */
3009 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
3010         return _is_irn_machine_user(node, n);
3011 }
3012
3013
3014 /* Gets the string representation of the jump prediction .*/
3015 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
3016         switch (pred) {
3017         default:
3018         case COND_JMP_PRED_NONE:  return "no prediction";
3019         case COND_JMP_PRED_TRUE:  return "true taken";
3020         case COND_JMP_PRED_FALSE: return "false taken";
3021         }
3022 }
3023
3024 /* Returns the conditional jump prediction of a Cond node. */
3025 cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *cond) {
3026         return _get_Cond_jmp_pred(cond);
3027 }
3028
3029 /* Sets a new conditional jump prediction. */
3030 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
3031         _set_Cond_jmp_pred(cond, pred);
3032 }
3033
3034 /** the get_type operation must be always implemented and return a firm type */
3035 static ir_type *get_Default_type(ir_node *n) {
3036         (void) n;
3037         return get_unknown_type();
3038 }
3039
3040 /* Sets the get_type operation for an ir_op_ops. */
3041 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
3042         switch (code) {
3043         case iro_Const:    ops->get_type = get_Const_type; break;
3044         case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
3045         case iro_Cast:     ops->get_type = get_Cast_type; break;
3046         case iro_Proj:     ops->get_type = get_Proj_type; break;
3047         default:
3048                 /* not allowed to be NULL */
3049                 if (! ops->get_type)
3050                         ops->get_type = get_Default_type;
3051                 break;
3052         }
3053         return ops;
3054 }
3055
3056 /** Return the attribute type of a SymConst node if exists */
3057 static ir_type *get_SymConst_attr_type(ir_node *self) {
3058         symconst_kind kind = get_SymConst_kind(self);
3059         if (SYMCONST_HAS_TYPE(kind))
3060                 return get_SymConst_type(self);
3061         return NULL;
3062 }
3063
3064 /** Return the attribute entity of a SymConst node if exists */
3065 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
3066         symconst_kind kind = get_SymConst_kind(self);
3067         if (SYMCONST_HAS_ENT(kind))
3068                 return get_SymConst_entity(self);
3069         return NULL;
3070 }
3071
3072 /** the get_type_attr operation must be always implemented */
3073 static ir_type *get_Null_type(ir_node *n) {
3074         (void) n;
3075         return firm_unknown_type;
3076 }
3077
3078 /* Sets the get_type operation for an ir_op_ops. */
3079 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
3080         switch (code) {
3081         case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
3082         case iro_Call:     ops->get_type_attr = get_Call_type; break;
3083         case iro_Alloc:    ops->get_type_attr = get_Alloc_type; break;
3084         case iro_Free:     ops->get_type_attr = get_Free_type; break;
3085         case iro_Cast:     ops->get_type_attr = get_Cast_type; break;
3086         default:
3087                 /* not allowed to be NULL */
3088                 if (! ops->get_type_attr)
3089                         ops->get_type_attr = get_Null_type;
3090                 break;
3091         }
3092         return ops;
3093 }
3094
3095 /** the get_entity_attr operation must be always implemented */
3096 static ir_entity *get_Null_ent(ir_node *n) {
3097         (void) n;
3098         return NULL;
3099 }
3100
3101 /* Sets the get_type operation for an ir_op_ops. */
3102 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
3103         switch (code) {
3104         case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
3105         case iro_Sel:      ops->get_entity_attr = _get_Sel_entity; break;
3106         default:
3107                 /* not allowed to be NULL */
3108                 if (! ops->get_entity_attr)
3109                         ops->get_entity_attr = get_Null_ent;
3110                 break;
3111         }
3112         return ops;
3113 }
3114
3115 /* Sets the debug information of a node. */
3116 void (set_irn_dbg_info)(ir_node *n, dbg_info *db) {
3117         _set_irn_dbg_info(n, db);
3118 }
3119
3120 /**
3121  * Returns the debug information of an node.
3122  *
3123  * @param n   The node.
3124  */
3125 dbg_info *(get_irn_dbg_info)(const ir_node *n) {
3126         return _get_irn_dbg_info(n);
3127 }
3128
3129 #if 0 /* allow the global pointer */
3130
3131 /* checks whether a node represents a global address */
3132 int is_Global(const ir_node *node) {
3133         ir_node *ptr;
3134
3135         if (is_SymConst_addr_ent(node))
3136                 return 1;
3137         if (! is_Sel(node))
3138                 return 0;
3139
3140         ptr = get_Sel_ptr(node);
3141         return is_globals_pointer(ptr) != NULL;
3142 }
3143
3144 /* returns the entity of a global address */
3145 ir_entity *get_Global_entity(const ir_node *node) {
3146         if (is_SymConst(node))
3147                 return get_SymConst_entity(node);
3148         else
3149                 return get_Sel_entity(node);
3150 }
3151 #else
3152
3153 /* checks whether a node represents a global address */
3154 int is_Global(const ir_node *node) {
3155         return is_SymConst_addr_ent(node);
3156 }
3157
3158 /* returns the entity of a global address */
3159 ir_entity *get_Global_entity(const ir_node *node) {
3160         return get_SymConst_entity(node);
3161 }
3162 #endif
3163
3164 /*
3165  * Calculate a hash value of a node.
3166  */
3167 unsigned firm_default_hash(const ir_node *node) {
3168         unsigned h;
3169         int i, irn_arity;
3170
3171         /* hash table value = 9*(9*(9*(9*(9*arity+in[0])+in[1])+ ...)+mode)+code */
3172         h = irn_arity = get_irn_intra_arity(node);
3173
3174         /* consider all in nodes... except the block if not a control flow. */
3175         for (i = is_cfop(node) ? -1 : 0;  i < irn_arity;  ++i) {
3176                 h = 9*h + HASH_PTR(get_irn_intra_n(node, i));
3177         }
3178
3179         /* ...mode,... */
3180         h = 9*h + HASH_PTR(get_irn_mode(node));
3181         /* ...and code */
3182         h = 9*h + HASH_PTR(get_irn_op(node));
3183
3184         return h;
3185 }  /* firm_default_hash */