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