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