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

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