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