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

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