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 "typegmod.h"
  39 #include "irbackedge_t.h"
  40 #include "irdump.h"
  41 #include "irop_t.h"
  42 #include "irprog_t.h"
  43 #include "iredgekinds.h"
  44 #include "iredges_t.h"
  45
  46 #include "irhooks.h"
  47 #include "irtools.h"
  48
  49 /* some constants fixing the positions of nodes predecessors
  50    in the in array */
  51 #define CALL_PARAM_OFFSET     2
  52 #define FUNCCALL_PARAM_OFFSET 1
  53 #define SEL_INDEX_OFFSET      2
  54 #define RETURN_RESULT_OFFSET  1  /* mem is not a result */
  55 #define END_KEEPALIVE_OFFSET  0
  56
  57 static const char *pnc_name_arr [] = {
  58         "pn_Cmp_False", "pn_Cmp_Eq", "pn_Cmp_Lt", "pn_Cmp_Le",
  59         "pn_Cmp_Gt", "pn_Cmp_Ge", "pn_Cmp_Lg", "pn_Cmp_Leg",
  60         "pn_Cmp_Uo", "pn_Cmp_Ue", "pn_Cmp_Ul", "pn_Cmp_Ule",
  61         "pn_Cmp_Ug", "pn_Cmp_Uge", "pn_Cmp_Ne", "pn_Cmp_True"
  62 };
  63
  64 /**
  65  * returns the pnc name from an pnc constant
  66  */
  67 const char *get_pnc_string(int pnc) {
  68         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 ir_node *get_Block_MacroBlock(const ir_node *block) {
 850         assert(is_Block(block));
 851         return get_irn_n(block, -1);
 852 }
 853
 854 int
 855 get_End_n_keepalives(ir_node *end) {
 856         assert(end->op == op_End);
 857         return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
 858 }
 859
 860 ir_node *
 861 get_End_keepalive(ir_node *end, int pos) {
 862         assert(end->op == op_End);
 863         return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
 864 }
 865
 866 void
 867 add_End_keepalive(ir_node *end, ir_node *ka) {
 868         assert(end->op == op_End);
 869         assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!");
 870         add_irn_n(end, ka);
 871 }
 872
 873 void
 874 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
 875         assert(end->op == op_End);
 876         set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 877 }
 878
 879 /* Set new keep-alives */
 880 void set_End_keepalives(ir_node *end, int n, ir_node *in[]) {
 881         int i;
 882         ir_graph *irg = get_irn_irg(end);
 883
 884         /* notify that edges are deleted */
 885         for (i = END_KEEPALIVE_OFFSET; i < ARR_LEN(end->in) - 1; ++i) {
 886                 edges_notify_edge(end, i, NULL, end->in[i + 1], irg);
 887         }
 888         ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET);
 889
 890         for (i = 0; i < n; ++i) {
 891                 end->in[1 + END_KEEPALIVE_OFFSET + i] = in[i];
 892                 edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, end->in[1 + END_KEEPALIVE_OFFSET + i], NULL, irg);
 893         }
 894 }
 895
 896 /* Set new keep-alives from old keep-alives, skipping irn */
 897 void remove_End_keepalive(ir_node *end, ir_node *irn) {
 898         int     n = get_End_n_keepalives(end);
 899         ir_node **in;
 900         int     i, idx;
 901
 902         NEW_ARR_A(ir_node *, in, n);
 903
 904         for (idx = i = 0; i < n; ++i) {
 905                 ir_node *old_ka = get_End_keepalive(end, i);
 906
 907                 /* skip irn */
 908                 if (old_ka != irn)
 909                         in[idx++] = old_ka;
 910         }
 911
 912         /* set new keep-alives */
 913         set_End_keepalives(end, idx, in);
 914 }
 915
 916 void
 917 free_End (ir_node *end) {
 918         assert(end->op == op_End);
 919         end->kind = k_BAD;
 920         DEL_ARR_F(end->in);
 921         end->in = NULL;   /* @@@ make sure we get an error if we use the
 922                              in array afterwards ... */
 923 }
 924
 925 /* Return the target address of an IJmp */
 926 ir_node *get_IJmp_target(ir_node *ijmp) {
 927         assert(ijmp->op == op_IJmp);
 928         return get_irn_n(ijmp, 0);
 929 }
 930
 931 /** Sets the target address of an IJmp */
 932 void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
 933         assert(ijmp->op == op_IJmp);
 934         set_irn_n(ijmp, 0, tgt);
 935 }
 936
 937 /*
 938 > Implementing the case construct (which is where the constant Proj node is
 939 > important) involves far more than simply determining the constant values.
 940 > We could argue that this is more properly a function of the translator from
 941 > Firm to the target machine.  That could be done if there was some way of
 942 > projecting "default" out of the Cond node.
 943 I know it's complicated.
 944 Basically there are two proglems:
 945  - determining the gaps between the projs
 946  - determining the biggest case constant to know the proj number for
 947    the default node.
 948 I see several solutions:
 949 1. Introduce a ProjDefault node.  Solves both problems.
 950    This means to extend all optimizations executed during construction.
 951 2. Give the Cond node for switch two flavors:
 952    a) there are no gaps in the projs  (existing flavor)
 953    b) gaps may exist, default proj is still the Proj with the largest
 954       projection number.  This covers also the gaps.
 955 3. Fix the semantic of the Cond to that of 2b)
 956
 957 Solution 2 seems to be the best:
 958 Computing the gaps in the Firm representation is not too hard, i.e.,
 959 libFIRM can implement a routine that transforms between the two
 960 flavours.  This is also possible for 1) but 2) does not require to
 961 change any existing optimization.
 962 Further it should be far simpler to determine the biggest constant than
 963 to compute all gaps.
 964 I don't want to choose 3) as 2a) seems to have advantages for
 965 dataflow analysis and 3) does not allow to convert the representation to
 966 2a).
 967 */
 968 ir_node *
 969 get_Cond_selector(ir_node *node) {
 970         assert(node->op == op_Cond);
 971         return get_irn_n(node, 0);
 972 }
 973
 974 void
 975 set_Cond_selector(ir_node *node, ir_node *selector) {
 976         assert(node->op == op_Cond);
 977         set_irn_n(node, 0, selector);
 978 }
 979
 980 cond_kind
 981 get_Cond_kind(ir_node *node) {
 982         assert(node->op == op_Cond);
 983         return node->attr.cond.kind;
 984 }
 985
 986 void
 987 set_Cond_kind(ir_node *node, cond_kind kind) {
 988         assert(node->op == op_Cond);
 989         node->attr.cond.kind = kind;
 990 }
 991
 992 long
 993 get_Cond_defaultProj(ir_node *node) {
 994         assert(node->op == op_Cond);
 995         return node->attr.cond.default_proj;
 996 }
 997
 998 ir_node *
 999 get_Return_mem(ir_node *node) {
1000         assert(node->op == op_Return);
1001         return get_irn_n(node, 0);
1002 }
1003
1004 void
1005 set_Return_mem(ir_node *node, ir_node *mem) {
1006         assert(node->op == op_Return);
1007         set_irn_n(node, 0, mem);
1008 }
1009
1010 int
1011 get_Return_n_ress(ir_node *node) {
1012         assert(node->op == op_Return);
1013         return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
1014 }
1015
1016 ir_node **
1017 get_Return_res_arr (ir_node *node) {
1018         assert((node->op == op_Return));
1019         if (get_Return_n_ress(node) > 0)
1020                 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
1021         else
1022                 return NULL;
1023 }
1024
1025 /*
1026 void
1027 set_Return_n_res(ir_node *node, int results) {
1028         assert(node->op == op_Return);
1029 }
1030 */
1031
1032 ir_node *
1033 get_Return_res(ir_node *node, int pos) {
1034         assert(node->op == op_Return);
1035         assert(get_Return_n_ress(node) > pos);
1036         return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
1037 }
1038
1039 void
1040 set_Return_res(ir_node *node, int pos, ir_node *res){
1041         assert(node->op == op_Return);
1042         set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
1043 }
1044
1045 tarval *(get_Const_tarval)(const ir_node *node) {
1046         return _get_Const_tarval(node);
1047 }
1048
1049 void
1050 set_Const_tarval(ir_node *node, tarval *con) {
1051         assert(node->op == op_Const);
1052         node->attr.con.tv = con;
1053 }
1054
1055 cnst_classify_t (classify_Const)(ir_node *node) {
1056         return _classify_Const(node);
1057 }
1058
1059
1060 /* The source language type.  Must be an atomic type.  Mode of type must
1061    be mode of node. For tarvals from entities type must be pointer to
1062    entity type. */
1063 ir_type *
1064 get_Const_type(ir_node *node) {
1065         assert(node->op == op_Const);
1066         return node->attr.con.tp;
1067 }
1068
1069 void
1070 set_Const_type(ir_node *node, ir_type *tp) {
1071         assert(node->op == op_Const);
1072         if (tp != firm_unknown_type) {
1073                 assert(is_atomic_type(tp));
1074                 assert(get_type_mode(tp) == get_irn_mode(node));
1075         }
1076         node->attr.con.tp = tp;
1077 }
1078
1079
1080 symconst_kind
1081 get_SymConst_kind(const ir_node *node) {
1082         assert(node->op == op_SymConst);
1083         return node->attr.symc.num;
1084 }
1085
1086 void
1087 set_SymConst_kind(ir_node *node, symconst_kind num) {
1088         assert(node->op == op_SymConst);
1089         node->attr.symc.num = num;
1090 }
1091
1092 ir_type *
1093 get_SymConst_type(ir_node *node) {
1094         assert((node->op == op_SymConst) &&
1095                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1096         return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p);
1097 }
1098
1099 void
1100 set_SymConst_type(ir_node *node, ir_type *tp) {
1101         assert((node->op == op_SymConst) &&
1102                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1103         node->attr.symc.sym.type_p = tp;
1104 }
1105
1106 ident *
1107 get_SymConst_name(const ir_node *node) {
1108         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1109         return node->attr.symc.sym.ident_p;
1110 }
1111
1112 void
1113 set_SymConst_name(ir_node *node, ident *name) {
1114         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1115         node->attr.symc.sym.ident_p = name;
1116 }
1117
1118
1119 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
1120 ir_entity *get_SymConst_entity(const ir_node *node) {
1121         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1122         return node->attr.symc.sym.entity_p;
1123 }
1124
1125 void set_SymConst_entity(ir_node *node, ir_entity *ent) {
1126         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1127         node->attr.symc.sym.entity_p  = ent;
1128 }
1129
1130 ir_enum_const *get_SymConst_enum(const ir_node *node) {
1131         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1132         return node->attr.symc.sym.enum_p;
1133 }
1134
1135 void set_SymConst_enum(ir_node *node, ir_enum_const *ec) {
1136         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1137         node->attr.symc.sym.enum_p  = ec;
1138 }
1139
1140 union symconst_symbol
1141 get_SymConst_symbol(const ir_node *node) {
1142         assert(node->op == op_SymConst);
1143         return node->attr.symc.sym;
1144 }
1145
1146 void
1147 set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
1148         assert(node->op == op_SymConst);
1149         node->attr.symc.sym = sym;
1150 }
1151
1152 ir_type *
1153 get_SymConst_value_type(ir_node *node) {
1154         assert(node->op == op_SymConst);
1155         if (node->attr.symc.tp) node->attr.symc.tp = skip_tid(node->attr.symc.tp);
1156         return node->attr.symc.tp;
1157 }
1158
1159 void
1160 set_SymConst_value_type(ir_node *node, ir_type *tp) {
1161         assert(node->op == op_SymConst);
1162         node->attr.symc.tp = tp;
1163 }
1164
1165 ir_node *
1166 get_Sel_mem(ir_node *node) {
1167         assert(node->op == op_Sel);
1168         return get_irn_n(node, 0);
1169 }
1170
1171 void
1172 set_Sel_mem(ir_node *node, ir_node *mem) {
1173         assert(node->op == op_Sel);
1174         set_irn_n(node, 0, mem);
1175 }
1176
1177 ir_node *
1178 get_Sel_ptr(ir_node *node) {
1179         assert(node->op == op_Sel);
1180         return get_irn_n(node, 1);
1181 }
1182
1183 void
1184 set_Sel_ptr(ir_node *node, ir_node *ptr) {
1185         assert(node->op == op_Sel);
1186         set_irn_n(node, 1, ptr);
1187 }
1188
1189 int
1190 get_Sel_n_indexs(ir_node *node) {
1191         assert(node->op == op_Sel);
1192         return (get_irn_arity(node) - SEL_INDEX_OFFSET);
1193 }
1194
1195 ir_node **
1196 get_Sel_index_arr(ir_node *node) {
1197         assert((node->op == op_Sel));
1198         if (get_Sel_n_indexs(node) > 0)
1199                 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
1200         else
1201                 return NULL;
1202 }
1203
1204 ir_node *
1205 get_Sel_index(ir_node *node, int pos) {
1206         assert(node->op == op_Sel);
1207         return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1208 }
1209
1210 void
1211 set_Sel_index(ir_node *node, int pos, ir_node *index) {
1212         assert(node->op == op_Sel);
1213         set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1214 }
1215
1216 ir_entity *
1217 get_Sel_entity(ir_node *node) {
1218         assert(node->op == op_Sel);
1219         return node->attr.sel.ent;
1220 }
1221
1222 void
1223 set_Sel_entity(ir_node *node, ir_entity *ent) {
1224         assert(node->op == op_Sel);
1225         node->attr.sel.ent = ent;
1226 }
1227
1228
1229 /* For unary and binary arithmetic operations the access to the
1230    operands can be factored out.  Left is the first, right the
1231    second arithmetic value  as listed in tech report 0999-33.
1232    unops are: Minus, Abs, Not, Conv, Cast
1233    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1234    Shr, Shrs, Rotate, Cmp */
1235
1236
1237 ir_node *
1238 get_Call_mem(ir_node *node) {
1239         assert(node->op == op_Call);
1240         return get_irn_n(node, 0);
1241 }
1242
1243 void
1244 set_Call_mem(ir_node *node, ir_node *mem) {
1245         assert(node->op == op_Call);
1246         set_irn_n(node, 0, mem);
1247 }
1248
1249 ir_node *
1250 get_Call_ptr(ir_node *node) {
1251         assert(node->op == op_Call);
1252         return get_irn_n(node, 1);
1253 }
1254
1255 void
1256 set_Call_ptr(ir_node *node, ir_node *ptr) {
1257         assert(node->op == op_Call);
1258         set_irn_n(node, 1, ptr);
1259 }
1260
1261 ir_node **
1262 get_Call_param_arr(ir_node *node) {
1263         assert(node->op == op_Call);
1264         return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1265 }
1266
1267 int
1268 get_Call_n_params(ir_node *node)  {
1269         assert(node->op == op_Call);
1270         return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1271 }
1272
1273 int
1274 get_Call_arity(ir_node *node) {
1275         assert(node->op == op_Call);
1276         return get_Call_n_params(node);
1277 }
1278
1279 /* void
1280 set_Call_arity(ir_node *node, ir_node *arity) {
1281         assert(node->op == op_Call);
1282 }
1283 */
1284
1285 ir_node *
1286 get_Call_param(ir_node *node, int pos) {
1287         assert(node->op == op_Call);
1288         return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1289 }
1290
1291 void
1292 set_Call_param(ir_node *node, int pos, ir_node *param) {
1293         assert(node->op == op_Call);
1294         set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1295 }
1296
1297 ir_type *
1298 get_Call_type(ir_node *node) {
1299         assert(node->op == op_Call);
1300         return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1301 }
1302
1303 void
1304 set_Call_type(ir_node *node, ir_type *tp) {
1305         assert(node->op == op_Call);
1306         assert((get_unknown_type() == tp) || is_Method_type(tp));
1307         node->attr.call.cld_tp = tp;
1308 }
1309
1310 int Call_has_callees(ir_node *node) {
1311         assert(node && node->op == op_Call);
1312         return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1313                 (node->attr.call.callee_arr != NULL));
1314 }
1315
1316 int get_Call_n_callees(ir_node * node) {
1317   assert(node && node->op == op_Call && node->attr.call.callee_arr);
1318   return ARR_LEN(node->attr.call.callee_arr);
1319 }
1320
1321 ir_entity * get_Call_callee(ir_node * node, int pos) {
1322         assert(pos >= 0 && pos < get_Call_n_callees(node));
1323         return node->attr.call.callee_arr[pos];
1324 }
1325
1326 void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
1327         assert(node->op == op_Call);
1328         if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1329                 node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
1330         }
1331         memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
1332 }
1333
1334 void remove_Call_callee_arr(ir_node * node) {
1335         assert(node->op == op_Call);
1336         node->attr.call.callee_arr = NULL;
1337 }
1338
1339 ir_node * get_CallBegin_ptr(ir_node *node) {
1340         assert(node->op == op_CallBegin);
1341         return get_irn_n(node, 0);
1342 }
1343
1344 void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
1345         assert(node->op == op_CallBegin);
1346         set_irn_n(node, 0, ptr);
1347 }
1348
1349 ir_node * get_CallBegin_call(ir_node *node) {
1350         assert(node->op == op_CallBegin);
1351         return node->attr.callbegin.call;
1352 }
1353
1354 void  set_CallBegin_call(ir_node *node, ir_node *call) {
1355         assert(node->op == op_CallBegin);
1356         node->attr.callbegin.call = call;
1357 }
1358
1359
1360 #define BINOP(OP)                                      \
1361 ir_node * get_##OP##_left(const ir_node *node) {       \
1362   assert(node->op == op_##OP);                         \
1363   return get_irn_n(node, node->op->op_index);          \
1364 }                                                      \
1365 void set_##OP##_left(ir_node *node, ir_node *left) {   \
1366   assert(node->op == op_##OP);                         \
1367   set_irn_n(node, node->op->op_index, left);           \
1368 }                                                      \
1369 ir_node *get_##OP##_right(const ir_node *node) {       \
1370   assert(node->op == op_##OP);                         \
1371   return get_irn_n(node, node->op->op_index + 1);      \
1372 }                                                      \
1373 void set_##OP##_right(ir_node *node, ir_node *right) { \
1374   assert(node->op == op_##OP);                         \
1375   set_irn_n(node, node->op->op_index + 1, right);      \
1376 }
1377
1378 #define UNOP(OP)                                  \
1379 ir_node *get_##OP##_op(const ir_node *node) {     \
1380   assert(node->op == op_##OP);                    \
1381   return get_irn_n(node, node->op->op_index);     \
1382 }                                                 \
1383 void set_##OP##_op (ir_node *node, ir_node *op) { \
1384   assert(node->op == op_##OP);                    \
1385   set_irn_n(node, node->op->op_index, op);        \
1386 }
1387
1388 #define BINOP_MEM(OP)                         \
1389 BINOP(OP)                                     \
1390                                               \
1391 ir_node *                                     \
1392 get_##OP##_mem(ir_node *node) {               \
1393   assert(node->op == op_##OP);                \
1394   return get_irn_n(node, 0);                  \
1395 }                                             \
1396                                               \
1397 void                                          \
1398 set_##OP##_mem(ir_node *node, ir_node *mem) { \
1399   assert(node->op == op_##OP);                \
1400   set_irn_n(node, 0, mem);                    \
1401 }
1402
1403 #define DIVOP(OP)                                       \
1404 BINOP_MEM(OP)                                           \
1405                                                         \
1406 ir_mode *get_##OP##_resmode(const ir_node *node) {      \
1407   assert(node->op == op_##OP);                          \
1408   return node->attr.divmod.res_mode;                    \
1409 }                                                       \
1410                                                         \
1411 void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \
1412   assert(node->op == op_##OP);                          \
1413   node->attr.divmod.res_mode = mode;                    \
1414 }
1415
1416
1417 BINOP(Add)
1418 BINOP(Sub)
1419 UNOP(Minus)
1420 BINOP(Mul)
1421 DIVOP(Quot)
1422 DIVOP(DivMod)
1423 DIVOP(Div)
1424 DIVOP(Mod)
1425 UNOP(Abs)
1426 BINOP(And)
1427 BINOP(Or)
1428 BINOP(Eor)
1429 UNOP(Not)
1430 BINOP(Shl)
1431 BINOP(Shr)
1432 BINOP(Shrs)
1433 BINOP(Rot)
1434 BINOP(Cmp)
1435 UNOP(Conv)
1436 UNOP(Cast)
1437
1438 int get_Conv_strict(ir_node *node) {
1439         assert(node->op == op_Conv);
1440         return node->attr.conv.strict;
1441 }
1442
1443 void set_Conv_strict(ir_node *node, int strict_flag) {
1444         assert(node->op == op_Conv);
1445         node->attr.conv.strict = (char)strict_flag;
1446 }
1447
1448 ir_type *
1449 get_Cast_type(ir_node *node) {
1450         assert(node->op == op_Cast);
1451         return node->attr.cast.totype;
1452 }
1453
1454 void
1455 set_Cast_type(ir_node *node, ir_type *to_tp) {
1456         assert(node->op == op_Cast);
1457         node->attr.cast.totype = to_tp;
1458 }
1459
1460
1461 /* Checks for upcast.
1462  *
1463  * Returns true if the Cast node casts a class type to a super type.
1464  */
1465 int is_Cast_upcast(ir_node *node) {
1466         ir_type *totype   = get_Cast_type(node);
1467         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1468         ir_graph *myirg = get_irn_irg(node);
1469
1470         assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
1471         assert(fromtype);
1472
1473         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1474                 totype   = get_pointer_points_to_type(totype);
1475                 fromtype = get_pointer_points_to_type(fromtype);
1476         }
1477
1478         assert(fromtype);
1479
1480         if (!is_Class_type(totype)) return 0;
1481         return is_SubClass_of(fromtype, totype);
1482 }
1483
1484 /* Checks for downcast.
1485  *
1486  * Returns true if the Cast node casts a class type to a sub type.
1487  */
1488 int is_Cast_downcast(ir_node *node) {
1489         ir_type *totype   = get_Cast_type(node);
1490         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1491
1492         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1493         assert(fromtype);
1494
1495         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1496                 totype   = get_pointer_points_to_type(totype);
1497                 fromtype = get_pointer_points_to_type(fromtype);
1498         }
1499
1500         assert(fromtype);
1501
1502         if (!is_Class_type(totype)) return 0;
1503         return is_SubClass_of(totype, fromtype);
1504 }
1505
1506 int
1507 (is_unop)(const ir_node *node) {
1508         return _is_unop(node);
1509 }
1510
1511 ir_node *
1512 get_unop_op(const ir_node *node) {
1513         if (node->op->opar == oparity_unary)
1514                 return get_irn_n(node, node->op->op_index);
1515
1516         assert(node->op->opar == oparity_unary);
1517         return NULL;
1518 }
1519
1520 void
1521 set_unop_op(ir_node *node, ir_node *op) {
1522         if (node->op->opar == oparity_unary)
1523                 set_irn_n(node, node->op->op_index, op);
1524
1525         assert(node->op->opar == oparity_unary);
1526 }
1527
1528 int
1529 (is_binop)(const ir_node *node) {
1530         return _is_binop(node);
1531 }
1532
1533 ir_node *
1534 get_binop_left(const ir_node *node) {
1535         assert(node->op->opar == oparity_binary);
1536         return get_irn_n(node, node->op->op_index);
1537 }
1538
1539 void
1540 set_binop_left(ir_node *node, ir_node *left) {
1541         assert(node->op->opar == oparity_binary);
1542         set_irn_n(node, node->op->op_index, left);
1543 }
1544
1545 ir_node *
1546 get_binop_right(const ir_node *node) {
1547         assert(node->op->opar == oparity_binary);
1548         return get_irn_n(node, node->op->op_index + 1);
1549 }
1550
1551 void
1552 set_binop_right(ir_node *node, ir_node *right) {
1553         assert(node->op->opar == oparity_binary);
1554         set_irn_n(node, node->op->op_index + 1, right);
1555 }
1556
1557 int is_Phi(const ir_node *n) {
1558         ir_op *op;
1559
1560         assert(n);
1561         op = get_irn_op(n);
1562
1563         if (op == op_Filter) return get_interprocedural_view();
1564
1565         if (op == op_Phi)
1566                 return ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
1567                         (get_irn_arity(n) > 0));
1568
1569         return 0;
1570 }
1571
1572 int is_Phi0(const ir_node *n) {
1573         assert(n);
1574
1575         return ((get_irn_op(n) == op_Phi) &&
1576                 (get_irn_arity(n) == 0) &&
1577                 (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1578 }
1579
1580 ir_node **
1581 get_Phi_preds_arr(ir_node *node) {
1582   assert(node->op == op_Phi);
1583   return (ir_node **)&(get_irn_in(node)[1]);
1584 }
1585
1586 int
1587 get_Phi_n_preds(const ir_node *node) {
1588         assert(is_Phi(node) || is_Phi0(node));
1589         return (get_irn_arity(node));
1590 }
1591
1592 /*
1593 void set_Phi_n_preds(ir_node *node, int n_preds) {
1594         assert(node->op == op_Phi);
1595 }
1596 */
1597
1598 ir_node *
1599 get_Phi_pred(const ir_node *node, int pos) {
1600         assert(is_Phi(node) || is_Phi0(node));
1601         return get_irn_n(node, pos);
1602 }
1603
1604 void
1605 set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
1606         assert(is_Phi(node) || is_Phi0(node));
1607         set_irn_n(node, pos, pred);
1608 }
1609
1610
1611 int is_memop(ir_node *node) {
1612         return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
1613 }
1614
1615 ir_node *get_memop_mem(ir_node *node) {
1616         assert(is_memop(node));
1617         return get_irn_n(node, 0);
1618 }
1619
1620 void set_memop_mem(ir_node *node, ir_node *mem) {
1621         assert(is_memop(node));
1622         set_irn_n(node, 0, mem);
1623 }
1624
1625 ir_node *get_memop_ptr(ir_node *node) {
1626         assert(is_memop(node));
1627         return get_irn_n(node, 1);
1628 }
1629
1630 void set_memop_ptr(ir_node *node, ir_node *ptr) {
1631         assert(is_memop(node));
1632         set_irn_n(node, 1, ptr);
1633 }
1634
1635 ir_node *
1636 get_Load_mem(ir_node *node) {
1637         assert(node->op == op_Load);
1638         return get_irn_n(node, 0);
1639 }
1640
1641 void
1642 set_Load_mem(ir_node *node, ir_node *mem) {
1643         assert(node->op == op_Load);
1644         set_irn_n(node, 0, mem);
1645 }
1646
1647 ir_node *
1648 get_Load_ptr(ir_node *node) {
1649         assert(node->op == op_Load);
1650         return get_irn_n(node, 1);
1651 }
1652
1653 void
1654 set_Load_ptr(ir_node *node, ir_node *ptr) {
1655         assert(node->op == op_Load);
1656         set_irn_n(node, 1, ptr);
1657 }
1658
1659 ir_mode *
1660 get_Load_mode(ir_node *node) {
1661         assert(node->op == op_Load);
1662         return node->attr.load.load_mode;
1663 }
1664
1665 void
1666 set_Load_mode(ir_node *node, ir_mode *mode) {
1667         assert(node->op == op_Load);
1668         node->attr.load.load_mode = mode;
1669 }
1670
1671 ir_volatility
1672 get_Load_volatility(ir_node *node) {
1673         assert(node->op == op_Load);
1674         return node->attr.load.volatility;
1675 }
1676
1677 void
1678 set_Load_volatility(ir_node *node, ir_volatility volatility) {
1679         assert(node->op == op_Load);
1680         node->attr.load.volatility = volatility;
1681 }
1682
1683
1684 ir_node *
1685 get_Store_mem(ir_node *node) {
1686         assert(node->op == op_Store);
1687         return get_irn_n(node, 0);
1688 }
1689
1690 void
1691 set_Store_mem(ir_node *node, ir_node *mem) {
1692         assert(node->op == op_Store);
1693         set_irn_n(node, 0, mem);
1694 }
1695
1696 ir_node *
1697 get_Store_ptr(ir_node *node) {
1698         assert(node->op == op_Store);
1699         return get_irn_n(node, 1);
1700 }
1701
1702 void
1703 set_Store_ptr(ir_node *node, ir_node *ptr) {
1704         assert(node->op == op_Store);
1705         set_irn_n(node, 1, ptr);
1706 }
1707
1708 ir_node *
1709 get_Store_value(ir_node *node) {
1710         assert(node->op == op_Store);
1711         return get_irn_n(node, 2);
1712 }
1713
1714 void
1715 set_Store_value(ir_node *node, ir_node *value) {
1716         assert(node->op == op_Store);
1717         set_irn_n(node, 2, value);
1718 }
1719
1720 ir_volatility
1721 get_Store_volatility(ir_node *node) {
1722         assert(node->op == op_Store);
1723         return node->attr.store.volatility;
1724 }
1725
1726 void
1727 set_Store_volatility(ir_node *node, ir_volatility volatility) {
1728         assert(node->op == op_Store);
1729         node->attr.store.volatility = volatility;
1730 }
1731
1732
1733 ir_node *
1734 get_Alloc_mem(ir_node *node) {
1735         assert(node->op == op_Alloc);
1736         return get_irn_n(node, 0);
1737 }
1738
1739 void
1740 set_Alloc_mem(ir_node *node, ir_node *mem) {
1741         assert(node->op == op_Alloc);
1742         set_irn_n(node, 0, mem);
1743 }
1744
1745 ir_node *
1746 get_Alloc_size(ir_node *node) {
1747         assert(node->op == op_Alloc);
1748         return get_irn_n(node, 1);
1749 }
1750
1751 void
1752 set_Alloc_size(ir_node *node, ir_node *size) {
1753         assert(node->op == op_Alloc);
1754         set_irn_n(node, 1, size);
1755 }
1756
1757 ir_type *
1758 get_Alloc_type(ir_node *node) {
1759         assert(node->op == op_Alloc);
1760         return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
1761 }
1762
1763 void
1764 set_Alloc_type(ir_node *node, ir_type *tp) {
1765         assert(node->op == op_Alloc);
1766         node->attr.alloc.type = tp;
1767 }
1768
1769 where_alloc
1770 get_Alloc_where(ir_node *node) {
1771         assert(node->op == op_Alloc);
1772         return node->attr.alloc.where;
1773 }
1774
1775 void
1776 set_Alloc_where(ir_node *node, where_alloc where) {
1777         assert(node->op == op_Alloc);
1778         node->attr.alloc.where = where;
1779 }
1780
1781
1782 ir_node *
1783 get_Free_mem(ir_node *node) {
1784         assert(node->op == op_Free);
1785         return get_irn_n(node, 0);
1786 }
1787
1788 void
1789 set_Free_mem(ir_node *node, ir_node *mem) {
1790         assert(node->op == op_Free);
1791         set_irn_n(node, 0, mem);
1792 }
1793
1794 ir_node *
1795 get_Free_ptr(ir_node *node) {
1796         assert(node->op == op_Free);
1797         return get_irn_n(node, 1);
1798 }
1799
1800 void
1801 set_Free_ptr(ir_node *node, ir_node *ptr) {
1802         assert(node->op == op_Free);
1803         set_irn_n(node, 1, ptr);
1804 }
1805
1806 ir_node *
1807 get_Free_size(ir_node *node) {
1808         assert(node->op == op_Free);
1809         return get_irn_n(node, 2);
1810 }
1811
1812 void
1813 set_Free_size(ir_node *node, ir_node *size) {
1814         assert(node->op == op_Free);
1815         set_irn_n(node, 2, size);
1816 }
1817
1818 ir_type *
1819 get_Free_type(ir_node *node) {
1820         assert(node->op == op_Free);
1821         return node->attr.free.type = skip_tid(node->attr.free.type);
1822 }
1823
1824 void
1825 set_Free_type(ir_node *node, ir_type *tp) {
1826         assert(node->op == op_Free);
1827         node->attr.free.type = tp;
1828 }
1829
1830 where_alloc
1831 get_Free_where(ir_node *node) {
1832         assert(node->op == op_Free);
1833         return node->attr.free.where;
1834 }
1835
1836 void
1837 set_Free_where(ir_node *node, where_alloc where) {
1838         assert(node->op == op_Free);
1839         node->attr.free.where = where;
1840 }
1841
1842 ir_node **get_Sync_preds_arr(ir_node *node) {
1843         assert(node->op == op_Sync);
1844         return (ir_node **)&(get_irn_in(node)[1]);
1845 }
1846
1847 int get_Sync_n_preds(ir_node *node) {
1848         assert(node->op == op_Sync);
1849         return (get_irn_arity(node));
1850 }
1851
1852 /*
1853 void set_Sync_n_preds(ir_node *node, int n_preds) {
1854         assert(node->op == op_Sync);
1855 }
1856 */
1857
1858 ir_node *get_Sync_pred(ir_node *node, int pos) {
1859         assert(node->op == op_Sync);
1860         return get_irn_n(node, pos);
1861 }
1862
1863 void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
1864         assert(node->op == op_Sync);
1865         set_irn_n(node, pos, pred);
1866 }
1867
1868 /* Add a new Sync predecessor */
1869 void add_Sync_pred(ir_node *node, ir_node *pred) {
1870         assert(node->op == op_Sync);
1871         add_irn_n(node, pred);
1872 }
1873
1874 /* Returns the source language type of a Proj node. */
1875 ir_type *get_Proj_type(ir_node *n) {
1876         ir_type *tp   = firm_unknown_type;
1877         ir_node *pred = get_Proj_pred(n);
1878
1879         switch (get_irn_opcode(pred)) {
1880         case iro_Proj: {
1881                 ir_node *pred_pred;
1882                 /* Deal with Start / Call here: we need to know the Proj Nr. */
1883                 assert(get_irn_mode(pred) == mode_T);
1884                 pred_pred = get_Proj_pred(pred);
1885                 if (get_irn_op(pred_pred) == op_Start)  {
1886                         ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
1887                         tp = get_method_param_type(mtp, get_Proj_proj(n));
1888                 } else if (get_irn_op(pred_pred) == op_Call) {
1889                         ir_type *mtp = get_Call_type(pred_pred);
1890                         tp = get_method_res_type(mtp, get_Proj_proj(n));
1891                 }
1892         } break;
1893         case iro_Start: break;
1894         case iro_Call: break;
1895         case iro_Load: {
1896                 ir_node *a = get_Load_ptr(pred);
1897                 if (is_Sel(a))
1898                         tp = get_entity_type(get_Sel_entity(a));
1899         } break;
1900         default:
1901                 break;
1902         }
1903         return tp;
1904 }
1905
1906 ir_node *
1907 get_Proj_pred(const ir_node *node) {
1908         assert(is_Proj(node));
1909         return get_irn_n(node, 0);
1910 }
1911
1912 void
1913 set_Proj_pred(ir_node *node, ir_node *pred) {
1914         assert(is_Proj(node));
1915         set_irn_n(node, 0, pred);
1916 }
1917
1918 long get_VProj_proj(const ir_node *node)
1919 {
1920         return node->attr.proj;
1921 }
1922
1923 void set_VProj_proj(ir_node *node, long value)
1924 {
1925         node->attr.proj = value;
1926 }
1927
1928 long
1929 get_Proj_proj(const ir_node *node) {
1930         assert(is_Proj(node));
1931         if (get_irn_opcode(node) == iro_Proj) {
1932                 return node->attr.proj;
1933         } else {
1934                 assert(get_irn_opcode(node) == iro_Filter);
1935                 return node->attr.filter.proj;
1936         }
1937 }
1938
1939 void
1940 set_Proj_proj(ir_node *node, long proj) {
1941         assert(node->op == op_Proj);
1942         node->attr.proj = proj;
1943 }
1944
1945 ir_node **
1946 get_Tuple_preds_arr(ir_node *node) {
1947         assert(node->op == op_Tuple);
1948         return (ir_node **)&(get_irn_in(node)[1]);
1949 }
1950
1951 int
1952 get_Tuple_n_preds(ir_node *node) {
1953         assert(node->op == op_Tuple);
1954         return (get_irn_arity(node));
1955 }
1956
1957 /*
1958 void
1959 set_Tuple_n_preds(ir_node *node, int n_preds) {
1960         assert(node->op == op_Tuple);
1961 }
1962 */
1963
1964 ir_node *
1965 get_Tuple_pred (ir_node *node, int pos) {
1966   assert(node->op == op_Tuple);
1967   return get_irn_n(node, pos);
1968 }
1969
1970 void
1971 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
1972         assert(node->op == op_Tuple);
1973         set_irn_n(node, pos, pred);
1974 }
1975
1976 ir_node *
1977 get_Id_pred(ir_node *node) {
1978         assert(node->op == op_Id);
1979         return get_irn_n(node, 0);
1980 }
1981
1982 void
1983 set_Id_pred(ir_node *node, ir_node *pred) {
1984         assert(node->op == op_Id);
1985         set_irn_n(node, 0, pred);
1986 }
1987
1988 ir_node *get_Confirm_value(ir_node *node) {
1989         assert(node->op == op_Confirm);
1990         return get_irn_n(node, 0);
1991 }
1992
1993 void set_Confirm_value(ir_node *node, ir_node *value) {
1994         assert(node->op == op_Confirm);
1995         set_irn_n(node, 0, value);
1996 }
1997
1998 ir_node *get_Confirm_bound(ir_node *node) {
1999         assert(node->op == op_Confirm);
2000         return get_irn_n(node, 1);
2001 }
2002
2003 void set_Confirm_bound(ir_node *node, ir_node *bound) {
2004         assert(node->op == op_Confirm);
2005         set_irn_n(node, 0, bound);
2006 }
2007
2008 pn_Cmp get_Confirm_cmp(ir_node *node) {
2009         assert(node->op == op_Confirm);
2010         return node->attr.confirm_cmp;
2011 }
2012
2013 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
2014         assert(node->op == op_Confirm);
2015         node->attr.confirm_cmp = cmp;
2016 }
2017
2018
2019 ir_node *
2020 get_Filter_pred(ir_node *node) {
2021         assert(node->op == op_Filter);
2022         return node->in[1];
2023 }
2024
2025 void
2026 set_Filter_pred(ir_node *node, ir_node *pred) {
2027         assert(node->op == op_Filter);
2028         node->in[1] = pred;
2029 }
2030
2031 long
2032 get_Filter_proj(ir_node *node) {
2033         assert(node->op == op_Filter);
2034         return node->attr.filter.proj;
2035 }
2036
2037 void
2038 set_Filter_proj(ir_node *node, long proj) {
2039         assert(node->op == op_Filter);
2040         node->attr.filter.proj = proj;
2041 }
2042
2043 /* Don't use get_irn_arity, get_irn_n in implementation as access
2044    shall work independent of view!!! */
2045 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2046         assert(node->op == op_Filter);
2047         if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2048                 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2049                 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2050                 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2051                 node->attr.filter.in_cg[0] = node->in[0];
2052         }
2053         memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2054 }
2055
2056 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2057         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2058                0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2059         node->attr.filter.in_cg[pos + 1] = pred;
2060 }
2061
2062 int get_Filter_n_cg_preds(ir_node *node) {
2063         assert(node->op == op_Filter && node->attr.filter.in_cg);
2064         return (ARR_LEN(node->attr.filter.in_cg) - 1);
2065 }
2066
2067 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2068         int arity;
2069         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2070                0 <= pos);
2071         arity = ARR_LEN(node->attr.filter.in_cg);
2072         assert(pos < arity - 1);
2073         return node->attr.filter.in_cg[pos + 1];
2074 }
2075
2076 /* Mux support */
2077 ir_node *get_Mux_sel(ir_node *node) {
2078         if (node->op == op_Psi) {
2079                 assert(get_irn_arity(node) == 3);
2080                 return get_Psi_cond(node, 0);
2081         }
2082         assert(node->op == op_Mux);
2083         return node->in[1];
2084 }
2085
2086 void set_Mux_sel(ir_node *node, ir_node *sel) {
2087         if (node->op == op_Psi) {
2088                 assert(get_irn_arity(node) == 3);
2089                 set_Psi_cond(node, 0, sel);
2090         } else {
2091                 assert(node->op == op_Mux);
2092                 node->in[1] = sel;
2093         }
2094 }
2095
2096 ir_node *get_Mux_false(ir_node *node) {
2097         if (node->op == op_Psi) {
2098                 assert(get_irn_arity(node) == 3);
2099                 return get_Psi_default(node);
2100         }
2101         assert(node->op == op_Mux);
2102         return node->in[2];
2103 }
2104
2105 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2106         if (node->op == op_Psi) {
2107                 assert(get_irn_arity(node) == 3);
2108                 set_Psi_default(node, ir_false);
2109         } else {
2110                 assert(node->op == op_Mux);
2111                 node->in[2] = ir_false;
2112         }
2113 }
2114
2115 ir_node *get_Mux_true(ir_node *node) {
2116         if (node->op == op_Psi) {
2117                 assert(get_irn_arity(node) == 3);
2118                 return get_Psi_val(node, 0);
2119         }
2120         assert(node->op == op_Mux);
2121         return node->in[3];
2122 }
2123
2124 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2125         if (node->op == op_Psi) {
2126                 assert(get_irn_arity(node) == 3);
2127                 set_Psi_val(node, 0, ir_true);
2128         } else {
2129                 assert(node->op == op_Mux);
2130                 node->in[3] = ir_true;
2131         }
2132 }
2133
2134 /* Psi support */
2135 ir_node *get_Psi_cond(ir_node *node, int pos) {
2136         int num_conds = get_Psi_n_conds(node);
2137         assert(node->op == op_Psi);
2138         assert(pos < num_conds);
2139         return get_irn_n(node, 2 * pos);
2140 }
2141
2142 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
2143         int num_conds = get_Psi_n_conds(node);
2144         assert(node->op == op_Psi);
2145         assert(pos < num_conds);
2146         set_irn_n(node, 2 * pos, cond);
2147 }
2148
2149 ir_node *get_Psi_val(ir_node *node, int pos) {
2150         int num_vals = get_Psi_n_conds(node);
2151         assert(node->op == op_Psi);
2152         assert(pos < num_vals);
2153         return get_irn_n(node, 2 * pos + 1);
2154 }
2155
2156 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
2157         int num_vals = get_Psi_n_conds(node);
2158         assert(node->op == op_Psi);
2159         assert(pos < num_vals);
2160         set_irn_n(node, 2 * pos + 1, val);
2161 }
2162
2163 ir_node *get_Psi_default(ir_node *node) {
2164         int def_pos = get_irn_arity(node) - 1;
2165         assert(node->op == op_Psi);
2166         return get_irn_n(node, def_pos);
2167 }
2168
2169 void set_Psi_default(ir_node *node, ir_node *val) {
2170         int def_pos = get_irn_arity(node);
2171         assert(node->op == op_Psi);
2172         set_irn_n(node, def_pos, val);
2173 }
2174
2175 int (get_Psi_n_conds)(ir_node *node) {
2176         return _get_Psi_n_conds(node);
2177 }
2178
2179 /* CopyB support */
2180 ir_node *get_CopyB_mem(ir_node *node) {
2181         assert(node->op == op_CopyB);
2182         return get_irn_n(node, 0);
2183 }
2184
2185 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2186         assert(node->op == op_CopyB);
2187         set_irn_n(node, 0, mem);
2188 }
2189
2190 ir_node *get_CopyB_dst(ir_node *node) {
2191         assert(node->op == op_CopyB);
2192         return get_irn_n(node, 1);
2193 }
2194
2195 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2196         assert(node->op == op_CopyB);
2197         set_irn_n(node, 1, dst);
2198 }
2199
2200 ir_node *get_CopyB_src (ir_node *node) {
2201   assert(node->op == op_CopyB);
2202   return get_irn_n(node, 2);
2203 }
2204
2205 void set_CopyB_src(ir_node *node, ir_node *src) {
2206         assert(node->op == op_CopyB);
2207         set_irn_n(node, 2, src);
2208 }
2209
2210 ir_type *get_CopyB_type(ir_node *node) {
2211         assert(node->op == op_CopyB);
2212         return node->attr.copyb.data_type;
2213 }
2214
2215 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2216         assert(node->op == op_CopyB && data_type);
2217         node->attr.copyb.data_type = data_type;
2218 }
2219
2220
2221 ir_type *
2222 get_InstOf_type(ir_node *node) {
2223         assert(node->op = op_InstOf);
2224         return node->attr.instof.type;
2225 }
2226
2227 void
2228 set_InstOf_type(ir_node *node, ir_type *type) {
2229         assert(node->op = op_InstOf);
2230         node->attr.instof.type = type;
2231 }
2232
2233 ir_node *
2234 get_InstOf_store(ir_node *node) {
2235         assert(node->op = op_InstOf);
2236         return get_irn_n(node, 0);
2237 }
2238
2239 void
2240 set_InstOf_store(ir_node *node, ir_node *obj) {
2241         assert(node->op = op_InstOf);
2242         set_irn_n(node, 0, obj);
2243 }
2244
2245 ir_node *
2246 get_InstOf_obj(ir_node *node) {
2247         assert(node->op = op_InstOf);
2248         return get_irn_n(node, 1);
2249 }
2250
2251 void
2252 set_InstOf_obj(ir_node *node, ir_node *obj) {
2253         assert(node->op = op_InstOf);
2254         set_irn_n(node, 1, obj);
2255 }
2256
2257 /* Returns the memory input of a Raise operation. */
2258 ir_node *
2259 get_Raise_mem(ir_node *node) {
2260         assert(node->op == op_Raise);
2261         return get_irn_n(node, 0);
2262 }
2263
2264 void
2265 set_Raise_mem(ir_node *node, ir_node *mem) {
2266         assert(node->op == op_Raise);
2267         set_irn_n(node, 0, mem);
2268 }
2269
2270 ir_node *
2271 get_Raise_exo_ptr(ir_node *node) {
2272         assert(node->op == op_Raise);
2273         return get_irn_n(node, 1);
2274 }
2275
2276 void
2277 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2278         assert(node->op == op_Raise);
2279         set_irn_n(node, 1, exo_ptr);
2280 }
2281
2282 /* Bound support */
2283
2284 /* Returns the memory input of a Bound operation. */
2285 ir_node *get_Bound_mem(ir_node *bound) {
2286         assert(bound->op == op_Bound);
2287         return get_irn_n(bound, 0);
2288 }
2289
2290 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2291         assert(bound->op == op_Bound);
2292         set_irn_n(bound, 0, mem);
2293 }
2294
2295 /* Returns the index input of a Bound operation. */
2296 ir_node *get_Bound_index(ir_node *bound) {
2297         assert(bound->op == op_Bound);
2298         return get_irn_n(bound, 1);
2299 }
2300
2301 void set_Bound_index(ir_node *bound, ir_node *idx) {
2302         assert(bound->op == op_Bound);
2303         set_irn_n(bound, 1, idx);
2304 }
2305
2306 /* Returns the lower bound input of a Bound operation. */
2307 ir_node *get_Bound_lower(ir_node *bound) {
2308         assert(bound->op == op_Bound);
2309         return get_irn_n(bound, 2);
2310 }
2311
2312 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2313         assert(bound->op == op_Bound);
2314         set_irn_n(bound, 2, lower);
2315 }
2316
2317 /* Returns the upper bound input of a Bound operation. */
2318 ir_node *get_Bound_upper(ir_node *bound) {
2319         assert(bound->op == op_Bound);
2320         return get_irn_n(bound, 3);
2321 }
2322
2323 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2324         assert(bound->op == op_Bound);
2325         set_irn_n(bound, 3, upper);
2326 }
2327
2328 /* Return the operand of a Pin node. */
2329 ir_node *get_Pin_op(const ir_node *pin) {
2330         assert(pin->op == op_Pin);
2331         return get_irn_n(pin, 0);
2332 }
2333
2334 void set_Pin_op(ir_node *pin, ir_node *node) {
2335         assert(pin->op == op_Pin);
2336         set_irn_n(pin, 0, node);
2337 }
2338
2339 /* Return the assembler text of an ASM pseudo node. */
2340 const char *get_ASM_text(const ir_node *node) {
2341         assert(node->op == op_ASM);
2342         return get_id_str(node->attr.asm.asm_text);
2343 }
2344
2345
2346 /* returns the graph of a node */
2347 ir_graph *
2348 get_irn_irg(const ir_node *node) {
2349         /*
2350          * Do not use get_nodes_Block() here, because this
2351          * will check the pinned state.
2352          * However even a 'wrong' block is always in the proper
2353          * irg.
2354          */
2355         if (! is_Block(node))
2356                 node = get_irn_n(node, -1);
2357         if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2358                 node = get_irn_n(node, -1);
2359         assert(get_irn_op(node) == op_Block);
2360         return node->attr.block.irg;
2361 }
2362
2363
2364 /*----------------------------------------------------------------*/
2365 /*  Auxiliary routines                                            */
2366 /*----------------------------------------------------------------*/
2367
2368 ir_node *
2369 skip_Proj(ir_node *node) {
2370         /* don't assert node !!! */
2371         if (node == NULL)
2372                 return NULL;
2373
2374         if (is_Proj(node))
2375                 node = get_Proj_pred(node);
2376
2377         return node;
2378 }
2379
2380 const ir_node *
2381 skip_Proj_const(const ir_node *node) {
2382         /* don't assert node !!! */
2383         if (node == NULL)
2384                 return NULL;
2385
2386         if (is_Proj(node))
2387                 node = get_Proj_pred(node);
2388
2389         return node;
2390 }
2391
2392 ir_node *
2393 skip_Tuple(ir_node *node) {
2394   ir_node *pred;
2395   ir_op   *op;
2396
2397   if (!get_opt_normalize()) return node;
2398
2399 restart:
2400         if (get_irn_op(node) == op_Proj) {
2401             pred = get_Proj_pred(node);
2402             op   = get_irn_op(pred);
2403
2404                 /*
2405                  * Looks strange but calls get_irn_op() only once
2406                  * in most often cases.
2407                  */
2408                 if (op == op_Proj) { /* nested Tuple ? */
2409                     pred = skip_Tuple(pred);
2410                     op   = get_irn_op(pred);
2411
2412                         if (op == op_Tuple) {
2413                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
2414                                 goto restart;
2415                         }
2416                 } else if (op == op_Tuple) {
2417                         node = get_Tuple_pred(pred, get_Proj_proj(node));
2418                         goto restart;
2419                 }
2420         }
2421         return node;
2422 }
2423
2424 /* returns operand of node if node is a Cast */
2425 ir_node *skip_Cast(ir_node *node) {
2426         if (get_irn_op(node) == op_Cast)
2427                 return get_Cast_op(node);
2428         return node;
2429 }
2430
2431 /* returns operand of node if node is a Confirm */
2432 ir_node *skip_Confirm(ir_node *node) {
2433         if (get_irn_op(node) == op_Confirm)
2434                 return get_Confirm_value(node);
2435         return node;
2436 }
2437
2438 /* skip all high-level ops */
2439 ir_node *skip_HighLevel(ir_node *node) {
2440         if (is_op_highlevel(get_irn_op(node)))
2441                 return get_irn_n(node, 0);
2442         return node;
2443 }
2444
2445
2446 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2447  * than any other approach, as Id chains are resolved and all point to the real node, or
2448  * all id's are self loops.
2449  *
2450  * Note: This function takes 10% of mostly ANY the compiler run, so it's
2451  * a little bit "hand optimized".
2452  *
2453  * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2454  */
2455 ir_node *
2456 skip_Id(ir_node *node) {
2457         ir_node *pred;
2458         /* don't assert node !!! */
2459
2460         if (!node || (node->op != op_Id)) return node;
2461
2462         /* Don't use get_Id_pred():  We get into an endless loop for
2463            self-referencing Ids. */
2464         pred = node->in[0+1];
2465
2466         if (pred->op != op_Id) return pred;
2467
2468         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2469                 ir_node *rem_pred, *res;
2470
2471                 if (pred->op != op_Id) return pred; /* shortcut */
2472                 rem_pred = pred;
2473
2474                 assert(get_irn_arity (node) > 0);
2475
2476                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2477                 res = skip_Id(rem_pred);
2478                 if (res->op == op_Id) /* self-loop */ return node;
2479
2480                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2481                 return res;
2482         } else {
2483                 return node;
2484         }
2485 }
2486
2487 void skip_Id_and_store(ir_node **node) {
2488         ir_node *n = *node;
2489
2490         if (!n || (n->op != op_Id)) return;
2491
2492         /* Don't use get_Id_pred():  We get into an endless loop for
2493            self-referencing Ids. */
2494         *node = skip_Id(n);
2495 }
2496
2497 int
2498 (is_Bad)(const ir_node *node) {
2499         return _is_Bad(node);
2500 }
2501
2502 int
2503 (is_NoMem)(const ir_node *node) {
2504         return _is_NoMem(node);
2505 }
2506
2507 int
2508 (is_Mod)(const ir_node *node) {
2509         return _is_Mod(node);
2510 }
2511
2512 int
2513 (is_Div)(const ir_node *node) {
2514         return _is_Div(node);
2515 }
2516
2517 int
2518 (is_DivMod)(const ir_node *node) {
2519         return _is_DivMod(node);
2520 }
2521
2522 int
2523 (is_Quot)(const ir_node *node) {
2524         return _is_Quot(node);
2525 }
2526
2527 int
2528 (is_Add)(const ir_node *node) {
2529         return _is_Add(node);
2530 }
2531
2532 int
2533 (is_Sub)(const ir_node *node) {
2534         return _is_Sub(node);
2535 }
2536
2537 int
2538 (is_Start)(const ir_node *node) {
2539   return _is_Start(node);
2540 }
2541
2542 int
2543 (is_End)(const ir_node *node) {
2544         return _is_End(node);
2545 }
2546
2547 int
2548 (is_Const)(const ir_node *node) {
2549         return _is_Const(node);
2550 }
2551
2552 int
2553 (is_Conv)(const ir_node *node) {
2554         return _is_Conv(node);
2555 }
2556
2557 int
2558 (is_no_Block)(const ir_node *node) {
2559         return _is_no_Block(node);
2560 }
2561
2562 int
2563 (is_Block)(const ir_node *node) {
2564         return _is_Block(node);
2565 }
2566
2567 /* returns true if node is an Unknown node. */
2568 int
2569 (is_Unknown)(const ir_node *node) {
2570         return _is_Unknown(node);
2571 }
2572
2573 /* returns true if node is a Return node. */
2574 int
2575 (is_Return)(const ir_node *node) {
2576         return _is_Return(node);
2577 }
2578
2579 /* returns true if node is a Call node. */
2580 int
2581 (is_Call)(const ir_node *node) {
2582         return _is_Call(node);
2583 }
2584
2585 /* returns true if node is a Sel node. */
2586 int
2587 (is_Sel)(const ir_node *node) {
2588         return _is_Sel(node);
2589 }
2590
2591 /* returns true if node is a Mux node or a Psi with only one condition. */
2592 int
2593 (is_Mux)(const ir_node *node) {
2594         return _is_Mux(node);
2595 }
2596
2597 /* returns true if node is a Load node. */
2598 int
2599 (is_Load)(const ir_node *node) {
2600         return _is_Load(node);
2601 }
2602
2603 /* returns true if node is a Load node. */
2604 int
2605 (is_Store)(const ir_node *node) {
2606         return _is_Store(node);
2607 }
2608
2609 /* returns true if node is a Sync node. */
2610 int
2611 (is_Sync)(const ir_node *node) {
2612         return _is_Sync(node);
2613 }
2614
2615 /* returns true if node is a Confirm node. */
2616 int
2617 (is_Confirm)(const ir_node *node) {
2618         return _is_Confirm(node);
2619 }
2620
2621 /* returns true if node is a Pin node. */
2622 int
2623 (is_Pin)(const ir_node *node) {
2624         return _is_Pin(node);
2625 }
2626
2627 /* returns true if node is a SymConst node. */
2628 int
2629 (is_SymConst)(const ir_node *node) {
2630         return _is_SymConst(node);
2631 }
2632
2633 /* returns true if node is a Cond node. */
2634 int
2635 (is_Cond)(const ir_node *node) {
2636         return _is_Cond(node);
2637 }
2638
2639 int
2640 (is_CopyB)(const ir_node *node) {
2641         return _is_CopyB(node);
2642 }
2643
2644 /* returns true if node is a Cmp node. */
2645 int
2646 (is_Cmp)(const ir_node *node) {
2647         return _is_Cmp(node);
2648 }
2649
2650 /* returns true if node is an Alloc node. */
2651 int
2652 (is_Alloc)(const ir_node *node) {
2653         return _is_Alloc(node);
2654 }
2655
2656 /* returns true if a node is a Jmp node. */
2657 int
2658 (is_Jmp)(const ir_node *node) {
2659         return _is_Jmp(node);
2660 }
2661
2662 /* returns true if a node is a Raise node. */
2663 int
2664 (is_Raise)(const ir_node *node) {
2665         return _is_Raise(node);
2666 }
2667
2668 int
2669 is_Proj(const ir_node *node) {
2670         assert(node);
2671         return node->op == op_Proj ||
2672                (!get_interprocedural_view() && node->op == op_Filter);
2673 }
2674
2675 /* Returns true if the operation manipulates control flow. */
2676 int
2677 is_cfop(const ir_node *node) {
2678         return is_cfopcode(get_irn_op(node));
2679 }
2680
2681 /* Returns true if the operation manipulates interprocedural control flow:
2682    CallBegin, EndReg, EndExcept */
2683 int is_ip_cfop(const ir_node *node) {
2684         return is_ip_cfopcode(get_irn_op(node));
2685 }
2686
2687 /* Returns true if the operation can change the control flow because
2688    of an exception. */
2689 int
2690 is_fragile_op(const ir_node *node) {
2691         return is_op_fragile(get_irn_op(node));
2692 }
2693
2694 /* Returns the memory operand of fragile operations. */
2695 ir_node *get_fragile_op_mem(ir_node *node) {
2696         assert(node && is_fragile_op(node));
2697
2698         switch (get_irn_opcode(node)) {
2699         case iro_Call  :
2700         case iro_Quot  :
2701         case iro_DivMod:
2702         case iro_Div   :
2703         case iro_Mod   :
2704         case iro_Load  :
2705         case iro_Store :
2706         case iro_Alloc :
2707         case iro_Bound :
2708                 return get_irn_n(node, 0);
2709         case iro_Bad   :
2710         case iro_Unknown:
2711                 return node;
2712         default: ;
2713                 assert(0 && "should not be reached");
2714                 return NULL;
2715         }
2716 }
2717
2718 /* Returns the result mode of a Div operation. */
2719 ir_mode *get_divop_resmod(const ir_node *node) {
2720         switch (get_irn_opcode(node)) {
2721         case iro_Quot  : return get_Quot_resmode(node);
2722         case iro_DivMod: return get_DivMod_resmode(node);
2723         case iro_Div   : return get_Div_resmode(node);
2724         case iro_Mod   : return get_Mod_resmode(node);
2725         default: ;
2726                 assert(0 && "should not be reached");
2727                 return NULL;
2728         }
2729 }
2730
2731 /* Returns true if the operation is a forking control flow operation. */
2732 int (is_irn_forking)(const ir_node *node) {
2733         return _is_irn_forking(node);
2734 }
2735
2736 /* Return the type associated with the value produced by n
2737  * if the node remarks this type as it is the case for
2738  * Cast, Const, SymConst and some Proj nodes. */
2739 ir_type *(get_irn_type)(ir_node *node) {
2740         return _get_irn_type(node);
2741 }
2742
2743 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
2744    Cast) or NULL.*/
2745 ir_type *(get_irn_type_attr)(ir_node *node) {
2746         return _get_irn_type_attr(node);
2747 }
2748
2749 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
2750 ir_entity *(get_irn_entity_attr)(ir_node *node) {
2751         return _get_irn_entity_attr(node);
2752 }
2753
2754 /* Returns non-zero for constant-like nodes. */
2755 int (is_irn_constlike)(const ir_node *node) {
2756         return _is_irn_constlike(node);
2757 }
2758
2759 /*
2760  * Returns non-zero for nodes that are allowed to have keep-alives and
2761  * are neither Block nor PhiM.
2762  */
2763 int (is_irn_keep)(const ir_node *node) {
2764         return _is_irn_keep(node);
2765 }
2766
2767 /*
2768  * Returns non-zero for nodes that are always placed in the start block.
2769  */
2770 int (is_irn_start_block_placed)(const ir_node *node) {
2771         return _is_irn_start_block_placed(node);
2772 }
2773
2774 /* Returns non-zero for nodes that are machine operations. */
2775 int (is_irn_machine_op)(const ir_node *node) {
2776         return _is_irn_machine_op(node);
2777 }
2778
2779 /* Returns non-zero for nodes that are machine operands. */
2780 int (is_irn_machine_operand)(const ir_node *node) {
2781         return _is_irn_machine_operand(node);
2782 }
2783
2784 /* Returns non-zero for nodes that have the n'th user machine flag set. */
2785 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
2786         return _is_irn_machine_user(node, n);
2787 }
2788
2789
2790 /* Gets the string representation of the jump prediction .*/
2791 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
2792         switch (pred) {
2793         default:
2794         case COND_JMP_PRED_NONE:  return "no prediction";
2795         case COND_JMP_PRED_TRUE:  return "true taken";
2796         case COND_JMP_PRED_FALSE: return "false taken";
2797         }
2798 }
2799
2800 /* Returns the conditional jump prediction of a Cond node. */
2801 cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *cond) {
2802         return _get_Cond_jmp_pred(cond);
2803 }
2804
2805 /* Sets a new conditional jump prediction. */
2806 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
2807         _set_Cond_jmp_pred(cond, pred);
2808 }
2809
2810 /** the get_type operation must be always implemented and return a firm type */
2811 static ir_type *get_Default_type(ir_node *n) {
2812         return get_unknown_type();
2813 }
2814
2815 /* Sets the get_type operation for an ir_op_ops. */
2816 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
2817         switch (code) {
2818         case iro_Const:    ops->get_type = get_Const_type; break;
2819         case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
2820         case iro_Cast:     ops->get_type = get_Cast_type; break;
2821         case iro_Proj:     ops->get_type = get_Proj_type; break;
2822         default:
2823                 /* not allowed to be NULL */
2824                 if (! ops->get_type)
2825                         ops->get_type = get_Default_type;
2826                 break;
2827         }
2828         return ops;
2829 }
2830
2831 /** Return the attribute type of a SymConst node if exists */
2832 static ir_type *get_SymConst_attr_type(ir_node *self) {
2833         symconst_kind kind = get_SymConst_kind(self);
2834         if (SYMCONST_HAS_TYPE(kind))
2835                 return get_SymConst_type(self);
2836         return NULL;
2837 }
2838
2839 /** Return the attribute entity of a SymConst node if exists */
2840 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
2841         symconst_kind kind = get_SymConst_kind(self);
2842         if (SYMCONST_HAS_ENT(kind))
2843                 return get_SymConst_entity(self);
2844         return NULL;
2845 }
2846
2847 /** the get_type_attr operation must be always implemented */
2848 static ir_type *get_Null_type(ir_node *n) {
2849         return firm_unknown_type;
2850 }
2851
2852 /* Sets the get_type operation for an ir_op_ops. */
2853 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
2854         switch (code) {
2855         case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
2856         case iro_Call:     ops->get_type_attr = get_Call_type; break;
2857         case iro_Alloc:    ops->get_type_attr = get_Alloc_type; break;
2858         case iro_Free:     ops->get_type_attr = get_Free_type; break;
2859         case iro_Cast:     ops->get_type_attr = get_Cast_type; break;
2860         default:
2861                 /* not allowed to be NULL */
2862                 if (! ops->get_type_attr)
2863                         ops->get_type_attr = get_Null_type;
2864                 break;
2865         }
2866         return ops;
2867 }
2868
2869 /** the get_entity_attr operation must be always implemented */
2870 static ir_entity *get_Null_ent(ir_node *n) {
2871         return NULL;
2872 }
2873
2874 /* Sets the get_type operation for an ir_op_ops. */
2875 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
2876         switch (code) {
2877         case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
2878         case iro_Sel:      ops->get_entity_attr = get_Sel_entity; break;
2879         default:
2880                 /* not allowed to be NULL */
2881                 if (! ops->get_entity_attr)
2882                         ops->get_entity_attr = get_Null_ent;
2883                 break;
2884         }
2885         return ops;
2886 }
2887
2888 #ifdef DEBUG_libfirm
2889 void dump_irn(ir_node *n) {
2890         int i, arity = get_irn_arity(n);
2891         printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
2892         if (!is_Block(n)) {
2893                 ir_node *pred = get_irn_n(n, -1);
2894                 printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2895                         get_irn_node_nr(pred), (void *)pred);
2896         }
2897         printf("  preds: \n");
2898         for (i = 0; i < arity; ++i) {
2899                 ir_node *pred = get_irn_n(n, i);
2900                 printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2901                         get_irn_node_nr(pred), (void *)pred);
2902         }
2903 }
2904
2905 #else  /* DEBUG_libfirm */
2906 void dump_irn(ir_node *n) {}
2907 #endif /* DEBUG_libfirm */