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

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