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

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