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