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 BINOP(Add)
1401 BINOP(Sub)
1402 UNOP(Minus)
1403 BINOP(Mul)
1404 BINOP_MEM(Quot)
1405 BINOP_MEM(DivMod)
1406 BINOP_MEM(Div)
1407 BINOP_MEM(Mod)
1408 UNOP(Abs)
1409 BINOP(And)
1410 BINOP(Or)
1411 BINOP(Eor)
1412 UNOP(Not)
1413 BINOP(Shl)
1414 BINOP(Shr)
1415 BINOP(Shrs)
1416 BINOP(Rot)
1417 BINOP(Cmp)
1418 UNOP(Conv)
1419 UNOP(Cast)
1420
1421 int get_Conv_strict(ir_node *node) {
1422         assert(node->op == op_Conv);
1423         return node->attr.conv.strict;
1424 }
1425
1426 void set_Conv_strict(ir_node *node, int strict_flag) {
1427         assert(node->op == op_Conv);
1428         node->attr.conv.strict = (char)strict_flag;
1429 }
1430
1431 ir_type *
1432 get_Cast_type(ir_node *node) {
1433         assert(node->op == op_Cast);
1434         return node->attr.cast.totype;
1435 }
1436
1437 void
1438 set_Cast_type(ir_node *node, ir_type *to_tp) {
1439         assert(node->op == op_Cast);
1440         node->attr.cast.totype = to_tp;
1441 }
1442
1443
1444 /* Checks for upcast.
1445  *
1446  * Returns true if the Cast node casts a class type to a super type.
1447  */
1448 int is_Cast_upcast(ir_node *node) {
1449         ir_type *totype   = get_Cast_type(node);
1450         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1451         ir_graph *myirg = get_irn_irg(node);
1452
1453         assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
1454         assert(fromtype);
1455
1456         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1457                 totype   = get_pointer_points_to_type(totype);
1458                 fromtype = get_pointer_points_to_type(fromtype);
1459         }
1460
1461         assert(fromtype);
1462
1463         if (!is_Class_type(totype)) return 0;
1464         return is_SubClass_of(fromtype, totype);
1465 }
1466
1467 /* Checks for downcast.
1468  *
1469  * Returns true if the Cast node casts a class type to a sub type.
1470  */
1471 int is_Cast_downcast(ir_node *node) {
1472         ir_type *totype   = get_Cast_type(node);
1473         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1474
1475         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1476         assert(fromtype);
1477
1478         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1479                 totype   = get_pointer_points_to_type(totype);
1480                 fromtype = get_pointer_points_to_type(fromtype);
1481         }
1482
1483         assert(fromtype);
1484
1485         if (!is_Class_type(totype)) return 0;
1486         return is_SubClass_of(totype, fromtype);
1487 }
1488
1489 int
1490 (is_unop)(const ir_node *node) {
1491         return _is_unop(node);
1492 }
1493
1494 ir_node *
1495 get_unop_op(const ir_node *node) {
1496         if (node->op->opar == oparity_unary)
1497                 return get_irn_n(node, node->op->op_index);
1498
1499         assert(node->op->opar == oparity_unary);
1500         return NULL;
1501 }
1502
1503 void
1504 set_unop_op(ir_node *node, ir_node *op) {
1505         if (node->op->opar == oparity_unary)
1506                 set_irn_n(node, node->op->op_index, op);
1507
1508         assert(node->op->opar == oparity_unary);
1509 }
1510
1511 int
1512 (is_binop)(const ir_node *node) {
1513         return _is_binop(node);
1514 }
1515
1516 ir_node *
1517 get_binop_left(const ir_node *node) {
1518         assert(node->op->opar == oparity_binary);
1519         return get_irn_n(node, node->op->op_index);
1520 }
1521
1522 void
1523 set_binop_left(ir_node *node, ir_node *left) {
1524         assert(node->op->opar == oparity_binary);
1525         set_irn_n(node, node->op->op_index, left);
1526 }
1527
1528 ir_node *
1529 get_binop_right(const ir_node *node) {
1530         assert(node->op->opar == oparity_binary);
1531         return get_irn_n(node, node->op->op_index + 1);
1532 }
1533
1534 void
1535 set_binop_right(ir_node *node, ir_node *right) {
1536         assert(node->op->opar == oparity_binary);
1537         set_irn_n(node, node->op->op_index + 1, right);
1538 }
1539
1540 int is_Phi(const ir_node *n) {
1541         ir_op *op;
1542
1543         assert(n);
1544         op = get_irn_op(n);
1545
1546         if (op == op_Filter) return get_interprocedural_view();
1547
1548         if (op == op_Phi)
1549                 return ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
1550                         (get_irn_arity(n) > 0));
1551
1552         return 0;
1553 }
1554
1555 int is_Phi0(const ir_node *n) {
1556         assert(n);
1557
1558         return ((get_irn_op(n) == op_Phi) &&
1559                 (get_irn_arity(n) == 0) &&
1560                 (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1561 }
1562
1563 ir_node **
1564 get_Phi_preds_arr(ir_node *node) {
1565   assert(node->op == op_Phi);
1566   return (ir_node **)&(get_irn_in(node)[1]);
1567 }
1568
1569 int
1570 get_Phi_n_preds(ir_node *node) {
1571         assert(is_Phi(node) || is_Phi0(node));
1572         return (get_irn_arity(node));
1573 }
1574
1575 /*
1576 void set_Phi_n_preds(ir_node *node, int n_preds) {
1577         assert(node->op == op_Phi);
1578 }
1579 */
1580
1581 ir_node *
1582 get_Phi_pred(ir_node *node, int pos) {
1583         assert(is_Phi(node) || is_Phi0(node));
1584         return get_irn_n(node, pos);
1585 }
1586
1587 void
1588 set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
1589         assert(is_Phi(node) || is_Phi0(node));
1590         set_irn_n(node, pos, pred);
1591 }
1592
1593
1594 int is_memop(ir_node *node) {
1595         return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
1596 }
1597
1598 ir_node *get_memop_mem(ir_node *node) {
1599         assert(is_memop(node));
1600         return get_irn_n(node, 0);
1601 }
1602
1603 void set_memop_mem(ir_node *node, ir_node *mem) {
1604         assert(is_memop(node));
1605         set_irn_n(node, 0, mem);
1606 }
1607
1608 ir_node *get_memop_ptr(ir_node *node) {
1609         assert(is_memop(node));
1610         return get_irn_n(node, 1);
1611 }
1612
1613 void set_memop_ptr(ir_node *node, ir_node *ptr) {
1614         assert(is_memop(node));
1615         set_irn_n(node, 1, ptr);
1616 }
1617
1618 ir_node *
1619 get_Load_mem(ir_node *node) {
1620         assert(node->op == op_Load);
1621         return get_irn_n(node, 0);
1622 }
1623
1624 void
1625 set_Load_mem(ir_node *node, ir_node *mem) {
1626         assert(node->op == op_Load);
1627         set_irn_n(node, 0, mem);
1628 }
1629
1630 ir_node *
1631 get_Load_ptr(ir_node *node) {
1632         assert(node->op == op_Load);
1633         return get_irn_n(node, 1);
1634 }
1635
1636 void
1637 set_Load_ptr(ir_node *node, ir_node *ptr) {
1638         assert(node->op == op_Load);
1639         set_irn_n(node, 1, ptr);
1640 }
1641
1642 ir_mode *
1643 get_Load_mode(ir_node *node) {
1644         assert(node->op == op_Load);
1645         return node->attr.load.load_mode;
1646 }
1647
1648 void
1649 set_Load_mode(ir_node *node, ir_mode *mode) {
1650         assert(node->op == op_Load);
1651         node->attr.load.load_mode = mode;
1652 }
1653
1654 ir_volatility
1655 get_Load_volatility(ir_node *node) {
1656         assert(node->op == op_Load);
1657         return node->attr.load.volatility;
1658 }
1659
1660 void
1661 set_Load_volatility(ir_node *node, ir_volatility volatility) {
1662         assert(node->op == op_Load);
1663         node->attr.load.volatility = volatility;
1664 }
1665
1666
1667 ir_node *
1668 get_Store_mem(ir_node *node) {
1669         assert(node->op == op_Store);
1670         return get_irn_n(node, 0);
1671 }
1672
1673 void
1674 set_Store_mem(ir_node *node, ir_node *mem) {
1675         assert(node->op == op_Store);
1676         set_irn_n(node, 0, mem);
1677 }
1678
1679 ir_node *
1680 get_Store_ptr(ir_node *node) {
1681         assert(node->op == op_Store);
1682         return get_irn_n(node, 1);
1683 }
1684
1685 void
1686 set_Store_ptr(ir_node *node, ir_node *ptr) {
1687         assert(node->op == op_Store);
1688         set_irn_n(node, 1, ptr);
1689 }
1690
1691 ir_node *
1692 get_Store_value(ir_node *node) {
1693         assert(node->op == op_Store);
1694         return get_irn_n(node, 2);
1695 }
1696
1697 void
1698 set_Store_value(ir_node *node, ir_node *value) {
1699         assert(node->op == op_Store);
1700         set_irn_n(node, 2, value);
1701 }
1702
1703 ir_volatility
1704 get_Store_volatility(ir_node *node) {
1705         assert(node->op == op_Store);
1706         return node->attr.store.volatility;
1707 }
1708
1709 void
1710 set_Store_volatility(ir_node *node, ir_volatility volatility) {
1711         assert(node->op == op_Store);
1712         node->attr.store.volatility = volatility;
1713 }
1714
1715
1716 ir_node *
1717 get_Alloc_mem(ir_node *node) {
1718         assert(node->op == op_Alloc);
1719         return get_irn_n(node, 0);
1720 }
1721
1722 void
1723 set_Alloc_mem(ir_node *node, ir_node *mem) {
1724         assert(node->op == op_Alloc);
1725         set_irn_n(node, 0, mem);
1726 }
1727
1728 ir_node *
1729 get_Alloc_size(ir_node *node) {
1730         assert(node->op == op_Alloc);
1731         return get_irn_n(node, 1);
1732 }
1733
1734 void
1735 set_Alloc_size(ir_node *node, ir_node *size) {
1736         assert(node->op == op_Alloc);
1737         set_irn_n(node, 1, size);
1738 }
1739
1740 ir_type *
1741 get_Alloc_type(ir_node *node) {
1742         assert(node->op == op_Alloc);
1743         return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
1744 }
1745
1746 void
1747 set_Alloc_type(ir_node *node, ir_type *tp) {
1748         assert(node->op == op_Alloc);
1749         node->attr.alloc.type = tp;
1750 }
1751
1752 where_alloc
1753 get_Alloc_where(ir_node *node) {
1754         assert(node->op == op_Alloc);
1755         return node->attr.alloc.where;
1756 }
1757
1758 void
1759 set_Alloc_where(ir_node *node, where_alloc where) {
1760         assert(node->op == op_Alloc);
1761         node->attr.alloc.where = where;
1762 }
1763
1764
1765 ir_node *
1766 get_Free_mem(ir_node *node) {
1767         assert(node->op == op_Free);
1768         return get_irn_n(node, 0);
1769 }
1770
1771 void
1772 set_Free_mem(ir_node *node, ir_node *mem) {
1773         assert(node->op == op_Free);
1774         set_irn_n(node, 0, mem);
1775 }
1776
1777 ir_node *
1778 get_Free_ptr(ir_node *node) {
1779         assert(node->op == op_Free);
1780         return get_irn_n(node, 1);
1781 }
1782
1783 void
1784 set_Free_ptr(ir_node *node, ir_node *ptr) {
1785         assert(node->op == op_Free);
1786         set_irn_n(node, 1, ptr);
1787 }
1788
1789 ir_node *
1790 get_Free_size(ir_node *node) {
1791         assert(node->op == op_Free);
1792         return get_irn_n(node, 2);
1793 }
1794
1795 void
1796 set_Free_size(ir_node *node, ir_node *size) {
1797         assert(node->op == op_Free);
1798         set_irn_n(node, 2, size);
1799 }
1800
1801 ir_type *
1802 get_Free_type(ir_node *node) {
1803         assert(node->op == op_Free);
1804         return node->attr.free.type = skip_tid(node->attr.free.type);
1805 }
1806
1807 void
1808 set_Free_type(ir_node *node, ir_type *tp) {
1809         assert(node->op == op_Free);
1810         node->attr.free.type = tp;
1811 }
1812
1813 where_alloc
1814 get_Free_where(ir_node *node) {
1815         assert(node->op == op_Free);
1816         return node->attr.free.where;
1817 }
1818
1819 void
1820 set_Free_where(ir_node *node, where_alloc where) {
1821         assert(node->op == op_Free);
1822         node->attr.free.where = where;
1823 }
1824
1825 ir_node **get_Sync_preds_arr(ir_node *node) {
1826         assert(node->op == op_Sync);
1827         return (ir_node **)&(get_irn_in(node)[1]);
1828 }
1829
1830 int get_Sync_n_preds(ir_node *node) {
1831         assert(node->op == op_Sync);
1832         return (get_irn_arity(node));
1833 }
1834
1835 /*
1836 void set_Sync_n_preds(ir_node *node, int n_preds) {
1837         assert(node->op == op_Sync);
1838 }
1839 */
1840
1841 ir_node *get_Sync_pred(ir_node *node, int pos) {
1842         assert(node->op == op_Sync);
1843         return get_irn_n(node, pos);
1844 }
1845
1846 void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
1847         assert(node->op == op_Sync);
1848         set_irn_n(node, pos, pred);
1849 }
1850
1851 /* Add a new Sync predecessor */
1852 void add_Sync_pred(ir_node *node, ir_node *pred) {
1853         assert(node->op == op_Sync);
1854         add_irn_n(node, pred);
1855 }
1856
1857 /* Returns the source language type of a Proj node. */
1858 ir_type *get_Proj_type(ir_node *n) {
1859         ir_type *tp   = firm_unknown_type;
1860         ir_node *pred = get_Proj_pred(n);
1861
1862         switch (get_irn_opcode(pred)) {
1863         case iro_Proj: {
1864                 ir_node *pred_pred;
1865                 /* Deal with Start / Call here: we need to know the Proj Nr. */
1866                 assert(get_irn_mode(pred) == mode_T);
1867                 pred_pred = get_Proj_pred(pred);
1868                 if (get_irn_op(pred_pred) == op_Start)  {
1869                         ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
1870                         tp = get_method_param_type(mtp, get_Proj_proj(n));
1871                 } else if (get_irn_op(pred_pred) == op_Call) {
1872                         ir_type *mtp = get_Call_type(pred_pred);
1873                         tp = get_method_res_type(mtp, get_Proj_proj(n));
1874                 }
1875         } break;
1876         case iro_Start: break;
1877         case iro_Call: break;
1878         case iro_Load: {
1879                 ir_node *a = get_Load_ptr(pred);
1880                 if (is_Sel(a))
1881                         tp = get_entity_type(get_Sel_entity(a));
1882         } break;
1883         default:
1884                 break;
1885         }
1886         return tp;
1887 }
1888
1889 ir_node *
1890 get_Proj_pred(const ir_node *node) {
1891         assert(is_Proj(node));
1892         return get_irn_n(node, 0);
1893 }
1894
1895 void
1896 set_Proj_pred(ir_node *node, ir_node *pred) {
1897         assert(is_Proj(node));
1898         set_irn_n(node, 0, pred);
1899 }
1900
1901 long get_VProj_proj(const ir_node *node)
1902 {
1903         return node->attr.proj;
1904 }
1905
1906 void set_VProj_proj(ir_node *node, long value)
1907 {
1908         node->attr.proj = value;
1909 }
1910
1911 long
1912 get_Proj_proj(const ir_node *node) {
1913         assert(is_Proj(node));
1914         if (get_irn_opcode(node) == iro_Proj) {
1915                 return node->attr.proj;
1916         } else {
1917                 assert(get_irn_opcode(node) == iro_Filter);
1918                 return node->attr.filter.proj;
1919         }
1920 }
1921
1922 void
1923 set_Proj_proj(ir_node *node, long proj) {
1924         assert(node->op == op_Proj);
1925         node->attr.proj = proj;
1926 }
1927
1928 ir_node **
1929 get_Tuple_preds_arr(ir_node *node) {
1930         assert(node->op == op_Tuple);
1931         return (ir_node **)&(get_irn_in(node)[1]);
1932 }
1933
1934 int
1935 get_Tuple_n_preds(ir_node *node) {
1936         assert(node->op == op_Tuple);
1937         return (get_irn_arity(node));
1938 }
1939
1940 /*
1941 void
1942 set_Tuple_n_preds(ir_node *node, int n_preds) {
1943         assert(node->op == op_Tuple);
1944 }
1945 */
1946
1947 ir_node *
1948 get_Tuple_pred (ir_node *node, int pos) {
1949   assert(node->op == op_Tuple);
1950   return get_irn_n(node, pos);
1951 }
1952
1953 void
1954 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
1955         assert(node->op == op_Tuple);
1956         set_irn_n(node, pos, pred);
1957 }
1958
1959 ir_node *
1960 get_Id_pred(ir_node *node) {
1961         assert(node->op == op_Id);
1962         return get_irn_n(node, 0);
1963 }
1964
1965 void
1966 set_Id_pred(ir_node *node, ir_node *pred) {
1967         assert(node->op == op_Id);
1968         set_irn_n(node, 0, pred);
1969 }
1970
1971 ir_node *get_Confirm_value(ir_node *node) {
1972         assert(node->op == op_Confirm);
1973         return get_irn_n(node, 0);
1974 }
1975
1976 void set_Confirm_value(ir_node *node, ir_node *value) {
1977         assert(node->op == op_Confirm);
1978         set_irn_n(node, 0, value);
1979 }
1980
1981 ir_node *get_Confirm_bound(ir_node *node) {
1982         assert(node->op == op_Confirm);
1983         return get_irn_n(node, 1);
1984 }
1985
1986 void set_Confirm_bound(ir_node *node, ir_node *bound) {
1987         assert(node->op == op_Confirm);
1988         set_irn_n(node, 0, bound);
1989 }
1990
1991 pn_Cmp get_Confirm_cmp(ir_node *node) {
1992         assert(node->op == op_Confirm);
1993         return node->attr.confirm_cmp;
1994 }
1995
1996 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
1997         assert(node->op == op_Confirm);
1998         node->attr.confirm_cmp = cmp;
1999 }
2000
2001
2002 ir_node *
2003 get_Filter_pred(ir_node *node) {
2004         assert(node->op == op_Filter);
2005         return node->in[1];
2006 }
2007
2008 void
2009 set_Filter_pred(ir_node *node, ir_node *pred) {
2010         assert(node->op == op_Filter);
2011         node->in[1] = pred;
2012 }
2013
2014 long
2015 get_Filter_proj(ir_node *node) {
2016         assert(node->op == op_Filter);
2017         return node->attr.filter.proj;
2018 }
2019
2020 void
2021 set_Filter_proj(ir_node *node, long proj) {
2022         assert(node->op == op_Filter);
2023         node->attr.filter.proj = proj;
2024 }
2025
2026 /* Don't use get_irn_arity, get_irn_n in implementation as access
2027    shall work independent of view!!! */
2028 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2029         assert(node->op == op_Filter);
2030         if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2031                 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2032                 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2033                 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2034                 node->attr.filter.in_cg[0] = node->in[0];
2035         }
2036         memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2037 }
2038
2039 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2040         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2041                0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2042         node->attr.filter.in_cg[pos + 1] = pred;
2043 }
2044
2045 int get_Filter_n_cg_preds(ir_node *node) {
2046         assert(node->op == op_Filter && node->attr.filter.in_cg);
2047         return (ARR_LEN(node->attr.filter.in_cg) - 1);
2048 }
2049
2050 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2051         int arity;
2052         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2053                0 <= pos);
2054         arity = ARR_LEN(node->attr.filter.in_cg);
2055         assert(pos < arity - 1);
2056         return node->attr.filter.in_cg[pos + 1];
2057 }
2058
2059 /* Mux support */
2060 ir_node *get_Mux_sel(ir_node *node) {
2061         if (node->op == op_Psi) {
2062                 assert(get_irn_arity(node) == 3);
2063                 return get_Psi_cond(node, 0);
2064         }
2065         assert(node->op == op_Mux);
2066         return node->in[1];
2067 }
2068
2069 void set_Mux_sel(ir_node *node, ir_node *sel) {
2070         if (node->op == op_Psi) {
2071                 assert(get_irn_arity(node) == 3);
2072                 set_Psi_cond(node, 0, sel);
2073         } else {
2074                 assert(node->op == op_Mux);
2075                 node->in[1] = sel;
2076         }
2077 }
2078
2079 ir_node *get_Mux_false(ir_node *node) {
2080         if (node->op == op_Psi) {
2081                 assert(get_irn_arity(node) == 3);
2082                 return get_Psi_default(node);
2083         }
2084         assert(node->op == op_Mux);
2085         return node->in[2];
2086 }
2087
2088 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2089         if (node->op == op_Psi) {
2090                 assert(get_irn_arity(node) == 3);
2091                 set_Psi_default(node, ir_false);
2092         } else {
2093                 assert(node->op == op_Mux);
2094                 node->in[2] = ir_false;
2095         }
2096 }
2097
2098 ir_node *get_Mux_true(ir_node *node) {
2099         if (node->op == op_Psi) {
2100                 assert(get_irn_arity(node) == 3);
2101                 return get_Psi_val(node, 0);
2102         }
2103         assert(node->op == op_Mux);
2104         return node->in[3];
2105 }
2106
2107 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2108         if (node->op == op_Psi) {
2109                 assert(get_irn_arity(node) == 3);
2110                 set_Psi_val(node, 0, ir_true);
2111         } else {
2112                 assert(node->op == op_Mux);
2113                 node->in[3] = ir_true;
2114         }
2115 }
2116
2117 /* Psi support */
2118 ir_node *get_Psi_cond(ir_node *node, int pos) {
2119         int num_conds = get_Psi_n_conds(node);
2120         assert(node->op == op_Psi);
2121         assert(pos < num_conds);
2122         return get_irn_n(node, 2 * pos);
2123 }
2124
2125 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
2126         int num_conds = get_Psi_n_conds(node);
2127         assert(node->op == op_Psi);
2128         assert(pos < num_conds);
2129         set_irn_n(node, 2 * pos, cond);
2130 }
2131
2132 ir_node *get_Psi_val(ir_node *node, int pos) {
2133         int num_vals = get_Psi_n_conds(node);
2134         assert(node->op == op_Psi);
2135         assert(pos < num_vals);
2136         return get_irn_n(node, 2 * pos + 1);
2137 }
2138
2139 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
2140         int num_vals = get_Psi_n_conds(node);
2141         assert(node->op == op_Psi);
2142         assert(pos < num_vals);
2143         set_irn_n(node, 2 * pos + 1, val);
2144 }
2145
2146 ir_node *get_Psi_default(ir_node *node) {
2147         int def_pos = get_irn_arity(node) - 1;
2148         assert(node->op == op_Psi);
2149         return get_irn_n(node, def_pos);
2150 }
2151
2152 void set_Psi_default(ir_node *node, ir_node *val) {
2153         int def_pos = get_irn_arity(node);
2154         assert(node->op == op_Psi);
2155         set_irn_n(node, def_pos, val);
2156 }
2157
2158 int (get_Psi_n_conds)(ir_node *node) {
2159         return _get_Psi_n_conds(node);
2160 }
2161
2162 /* CopyB support */
2163 ir_node *get_CopyB_mem(ir_node *node) {
2164         assert(node->op == op_CopyB);
2165         return get_irn_n(node, 0);
2166 }
2167
2168 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2169         assert(node->op == op_CopyB);
2170         set_irn_n(node, 0, mem);
2171 }
2172
2173 ir_node *get_CopyB_dst(ir_node *node) {
2174         assert(node->op == op_CopyB);
2175         return get_irn_n(node, 1);
2176 }
2177
2178 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2179         assert(node->op == op_CopyB);
2180         set_irn_n(node, 1, dst);
2181 }
2182
2183 ir_node *get_CopyB_src (ir_node *node) {
2184   assert(node->op == op_CopyB);
2185   return get_irn_n(node, 2);
2186 }
2187
2188 void set_CopyB_src(ir_node *node, ir_node *src) {
2189         assert(node->op == op_CopyB);
2190         set_irn_n(node, 2, src);
2191 }
2192
2193 ir_type *get_CopyB_type(ir_node *node) {
2194         assert(node->op == op_CopyB);
2195         return node->attr.copyb.data_type;
2196 }
2197
2198 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2199         assert(node->op == op_CopyB && data_type);
2200         node->attr.copyb.data_type = data_type;
2201 }
2202
2203
2204 ir_type *
2205 get_InstOf_type(ir_node *node) {
2206         assert(node->op = op_InstOf);
2207         return node->attr.instof.type;
2208 }
2209
2210 void
2211 set_InstOf_type(ir_node *node, ir_type *type) {
2212         assert(node->op = op_InstOf);
2213         node->attr.instof.type = type;
2214 }
2215
2216 ir_node *
2217 get_InstOf_store(ir_node *node) {
2218         assert(node->op = op_InstOf);
2219         return get_irn_n(node, 0);
2220 }
2221
2222 void
2223 set_InstOf_store(ir_node *node, ir_node *obj) {
2224         assert(node->op = op_InstOf);
2225         set_irn_n(node, 0, obj);
2226 }
2227
2228 ir_node *
2229 get_InstOf_obj(ir_node *node) {
2230         assert(node->op = op_InstOf);
2231         return get_irn_n(node, 1);
2232 }
2233
2234 void
2235 set_InstOf_obj(ir_node *node, ir_node *obj) {
2236         assert(node->op = op_InstOf);
2237         set_irn_n(node, 1, obj);
2238 }
2239
2240 /* Returns the memory input of a Raise operation. */
2241 ir_node *
2242 get_Raise_mem(ir_node *node) {
2243         assert(node->op == op_Raise);
2244         return get_irn_n(node, 0);
2245 }
2246
2247 void
2248 set_Raise_mem(ir_node *node, ir_node *mem) {
2249         assert(node->op == op_Raise);
2250         set_irn_n(node, 0, mem);
2251 }
2252
2253 ir_node *
2254 get_Raise_exo_ptr(ir_node *node) {
2255         assert(node->op == op_Raise);
2256         return get_irn_n(node, 1);
2257 }
2258
2259 void
2260 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2261         assert(node->op == op_Raise);
2262         set_irn_n(node, 1, exo_ptr);
2263 }
2264
2265 /* Bound support */
2266
2267 /* Returns the memory input of a Bound operation. */
2268 ir_node *get_Bound_mem(ir_node *bound) {
2269         assert(bound->op == op_Bound);
2270         return get_irn_n(bound, 0);
2271 }
2272
2273 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2274         assert(bound->op == op_Bound);
2275         set_irn_n(bound, 0, mem);
2276 }
2277
2278 /* Returns the index input of a Bound operation. */
2279 ir_node *get_Bound_index(ir_node *bound) {
2280         assert(bound->op == op_Bound);
2281         return get_irn_n(bound, 1);
2282 }
2283
2284 void set_Bound_index(ir_node *bound, ir_node *idx) {
2285         assert(bound->op == op_Bound);
2286         set_irn_n(bound, 1, idx);
2287 }
2288
2289 /* Returns the lower bound input of a Bound operation. */
2290 ir_node *get_Bound_lower(ir_node *bound) {
2291         assert(bound->op == op_Bound);
2292         return get_irn_n(bound, 2);
2293 }
2294
2295 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2296         assert(bound->op == op_Bound);
2297         set_irn_n(bound, 2, lower);
2298 }
2299
2300 /* Returns the upper bound input of a Bound operation. */
2301 ir_node *get_Bound_upper(ir_node *bound) {
2302         assert(bound->op == op_Bound);
2303         return get_irn_n(bound, 3);
2304 }
2305
2306 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2307         assert(bound->op == op_Bound);
2308         set_irn_n(bound, 3, upper);
2309 }
2310
2311 /* Return the operand of a Pin node. */
2312 ir_node *get_Pin_op(const ir_node *pin) {
2313         assert(pin->op == op_Pin);
2314         return get_irn_n(pin, 0);
2315 }
2316
2317 void set_Pin_op(ir_node *pin, ir_node *node) {
2318         assert(pin->op == op_Pin);
2319         set_irn_n(pin, 0, node);
2320 }
2321
2322
2323 /* returns the graph of a node */
2324 ir_graph *
2325 get_irn_irg(const ir_node *node) {
2326         /*
2327          * Do not use get_nodes_Block() here, because this
2328          * will check the pinned state.
2329          * However even a 'wrong' block is always in the proper
2330          * irg.
2331          */
2332         if (! is_Block(node))
2333                 node = get_irn_n(node, -1);
2334         if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2335                 node = get_irn_n(node, -1);
2336         assert(get_irn_op(node) == op_Block);
2337         return node->attr.block.irg;
2338 }
2339
2340
2341 /*----------------------------------------------------------------*/
2342 /*  Auxiliary routines                                            */
2343 /*----------------------------------------------------------------*/
2344
2345 ir_node *
2346 skip_Proj(ir_node *node) {
2347         /* don't assert node !!! */
2348         if (node == NULL)
2349                 return NULL;
2350
2351         if (is_Proj(node))
2352                 node = get_Proj_pred(node);
2353
2354         return node;
2355 }
2356
2357 const ir_node *
2358 skip_Proj_const(const ir_node *node) {
2359         /* don't assert node !!! */
2360         if (node == NULL)
2361                 return NULL;
2362
2363         if (is_Proj(node))
2364                 node = get_Proj_pred(node);
2365
2366         return node;
2367 }
2368
2369 ir_node *
2370 skip_Tuple(ir_node *node) {
2371   ir_node *pred;
2372   ir_op   *op;
2373
2374   if (!get_opt_normalize()) return node;
2375
2376 restart:
2377         if (get_irn_op(node) == op_Proj) {
2378             pred = get_Proj_pred(node);
2379             op   = get_irn_op(pred);
2380
2381                 /*
2382                  * Looks strange but calls get_irn_op() only once
2383                  * in most often cases.
2384                  */
2385                 if (op == op_Proj) { /* nested Tuple ? */
2386                     pred = skip_Tuple(pred);
2387                     op   = get_irn_op(pred);
2388
2389                         if (op == op_Tuple) {
2390                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
2391                                 goto restart;
2392                         }
2393                 } else if (op == op_Tuple) {
2394                         node = get_Tuple_pred(pred, get_Proj_proj(node));
2395                         goto restart;
2396                 }
2397         }
2398         return node;
2399 }
2400
2401 /* returns operand of node if node is a Cast */
2402 ir_node *skip_Cast(ir_node *node) {
2403         if (get_irn_op(node) == op_Cast)
2404                 return get_Cast_op(node);
2405         return node;
2406 }
2407
2408 /* returns operand of node if node is a Confirm */
2409 ir_node *skip_Confirm(ir_node *node) {
2410         if (get_irn_op(node) == op_Confirm)
2411                 return get_Confirm_value(node);
2412         return node;
2413 }
2414
2415 /* skip all high-level ops */
2416 ir_node *skip_HighLevel(ir_node *node) {
2417         if (is_op_highlevel(get_irn_op(node)))
2418                 return get_irn_n(node, 0);
2419         return node;
2420 }
2421
2422
2423 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2424  * than any other approach, as Id chains are resolved and all point to the real node, or
2425  * all id's are self loops.
2426  *
2427  * Note: This function takes 10% of mostly ANY the compiler run, so it's
2428  * a little bit "hand optimized".
2429  *
2430  * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2431  */
2432 ir_node *
2433 skip_Id(ir_node *node) {
2434         ir_node *pred;
2435         /* don't assert node !!! */
2436
2437         if (!node || (node->op != op_Id)) return node;
2438
2439         /* Don't use get_Id_pred():  We get into an endless loop for
2440            self-referencing Ids. */
2441         pred = node->in[0+1];
2442
2443         if (pred->op != op_Id) return pred;
2444
2445         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2446                 ir_node *rem_pred, *res;
2447
2448                 if (pred->op != op_Id) return pred; /* shortcut */
2449                 rem_pred = pred;
2450
2451                 assert(get_irn_arity (node) > 0);
2452
2453                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2454                 res = skip_Id(rem_pred);
2455                 if (res->op == op_Id) /* self-loop */ return node;
2456
2457                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2458                 return res;
2459         } else {
2460                 return node;
2461         }
2462 }
2463
2464 void skip_Id_and_store(ir_node **node) {
2465         ir_node *n = *node;
2466
2467         if (!n || (n->op != op_Id)) return;
2468
2469         /* Don't use get_Id_pred():  We get into an endless loop for
2470            self-referencing Ids. */
2471         *node = skip_Id(n);
2472 }
2473
2474 int
2475 (is_Bad)(const ir_node *node) {
2476         return _is_Bad(node);
2477 }
2478
2479 int
2480 (is_NoMem)(const ir_node *node) {
2481         return _is_NoMem(node);
2482 }
2483
2484 int
2485 (is_Mod)(const ir_node *node) {
2486         return _is_Mod(node);
2487 }
2488
2489 int
2490 (is_Div)(const ir_node *node) {
2491         return _is_Div(node);
2492 }
2493
2494 int
2495 (is_DivMod)(const ir_node *node) {
2496         return _is_DivMod(node);
2497 }
2498
2499 int
2500 (is_Quot)(const ir_node *node) {
2501         return _is_Quot(node);
2502 }
2503
2504 int
2505 (is_Add)(const ir_node *node) {
2506         return _is_Add(node);
2507 }
2508
2509 int
2510 (is_Sub)(const ir_node *node) {
2511         return _is_Sub(node);
2512 }
2513
2514 int
2515 (is_Start)(const ir_node *node) {
2516   return _is_Start(node);
2517 }
2518
2519 int
2520 (is_End)(const ir_node *node) {
2521         return _is_End(node);
2522 }
2523
2524 int
2525 (is_Const)(const ir_node *node) {
2526         return _is_Const(node);
2527 }
2528
2529 int
2530 (is_Conv)(const ir_node *node) {
2531         return _is_Conv(node);
2532 }
2533
2534 int
2535 (is_no_Block)(const ir_node *node) {
2536         return _is_no_Block(node);
2537 }
2538
2539 int
2540 (is_Block)(const ir_node *node) {
2541         return _is_Block(node);
2542 }
2543
2544 /* returns true if node is an Unknown node. */
2545 int
2546 (is_Unknown)(const ir_node *node) {
2547         return _is_Unknown(node);
2548 }
2549
2550 /* returns true if node is a Return node. */
2551 int
2552 (is_Return)(const ir_node *node) {
2553         return _is_Return(node);
2554 }
2555
2556 /* returns true if node is a Call node. */
2557 int
2558 (is_Call)(const ir_node *node) {
2559         return _is_Call(node);
2560 }
2561
2562 /* returns true if node is a Sel node. */
2563 int
2564 (is_Sel)(const ir_node *node) {
2565         return _is_Sel(node);
2566 }
2567
2568 /* returns true if node is a Mux node or a Psi with only one condition. */
2569 int
2570 (is_Mux)(const ir_node *node) {
2571         return _is_Mux(node);
2572 }
2573
2574 /* returns true if node is a Load node. */
2575 int
2576 (is_Load)(const ir_node *node) {
2577         return _is_Load(node);
2578 }
2579
2580 /* returns true if node is a Load node. */
2581 int
2582 (is_Store)(const ir_node *node) {
2583         return _is_Store(node);
2584 }
2585
2586 /* returns true if node is a Sync node. */
2587 int
2588 (is_Sync)(const ir_node *node) {
2589         return _is_Sync(node);
2590 }
2591
2592 /* returns true if node is a Confirm node. */
2593 int
2594 (is_Confirm)(const ir_node *node) {
2595         return _is_Confirm(node);
2596 }
2597
2598 /* returns true if node is a Pin node. */
2599 int
2600 (is_Pin)(const ir_node *node) {
2601         return _is_Pin(node);
2602 }
2603
2604 /* returns true if node is a SymConst node. */
2605 int
2606 (is_SymConst)(const ir_node *node) {
2607         return _is_SymConst(node);
2608 }
2609
2610 /* returns true if node is a Cond node. */
2611 int
2612 (is_Cond)(const ir_node *node) {
2613         return _is_Cond(node);
2614 }
2615
2616 int
2617 (is_CopyB)(const ir_node *node) {
2618         return _is_CopyB(node);
2619 }
2620
2621 /* returns true if node is a Cmp node. */
2622 int
2623 (is_Cmp)(const ir_node *node) {
2624         return _is_Cmp(node);
2625 }
2626
2627 /* returns true if node is an Alloc node. */
2628 int
2629 (is_Alloc)(const ir_node *node) {
2630         return _is_Alloc(node);
2631 }
2632
2633 /* returns true if a node is a Jmp node. */
2634 int
2635 (is_Jmp)(const ir_node *node) {
2636         return _is_Jmp(node);
2637 }
2638
2639 /* returns true if a node is a Raise node. */
2640 int
2641 (is_Raise)(const ir_node *node) {
2642         return _is_Raise(node);
2643 }
2644
2645 int
2646 is_Proj(const ir_node *node) {
2647         assert(node);
2648         return node->op == op_Proj ||
2649                (!get_interprocedural_view() && node->op == op_Filter);
2650 }
2651
2652 /* Returns true if the operation manipulates control flow. */
2653 int
2654 is_cfop(const ir_node *node) {
2655         return is_cfopcode(get_irn_op(node));
2656 }
2657
2658 /* Returns true if the operation manipulates interprocedural control flow:
2659    CallBegin, EndReg, EndExcept */
2660 int is_ip_cfop(const ir_node *node) {
2661         return is_ip_cfopcode(get_irn_op(node));
2662 }
2663
2664 /* Returns true if the operation can change the control flow because
2665    of an exception. */
2666 int
2667 is_fragile_op(const ir_node *node) {
2668         return is_op_fragile(get_irn_op(node));
2669 }
2670
2671 /* Returns the memory operand of fragile operations. */
2672 ir_node *get_fragile_op_mem(ir_node *node) {
2673         assert(node && is_fragile_op(node));
2674
2675         switch (get_irn_opcode (node)) {
2676         case iro_Call  :
2677         case iro_Quot  :
2678         case iro_DivMod:
2679         case iro_Div   :
2680         case iro_Mod   :
2681         case iro_Load  :
2682         case iro_Store :
2683         case iro_Alloc :
2684         case iro_Bound :
2685                 return get_irn_n(node, 0);
2686         case iro_Bad   :
2687         case iro_Unknown:
2688                 return node;
2689         default: ;
2690                 assert(0 && "should not be reached");
2691                 return NULL;
2692         }
2693 }
2694
2695 /* Returns true if the operation is a forking control flow operation. */
2696 int (is_irn_forking)(const ir_node *node) {
2697         return _is_irn_forking(node);
2698 }
2699
2700 /* Return the type associated with the value produced by n
2701  * if the node remarks this type as it is the case for
2702  * Cast, Const, SymConst and some Proj nodes. */
2703 ir_type *(get_irn_type)(ir_node *node) {
2704         return _get_irn_type(node);
2705 }
2706
2707 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
2708    Cast) or NULL.*/
2709 ir_type *(get_irn_type_attr)(ir_node *node) {
2710         return _get_irn_type_attr(node);
2711 }
2712
2713 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
2714 ir_entity *(get_irn_entity_attr)(ir_node *node) {
2715         return _get_irn_entity_attr(node);
2716 }
2717
2718 /* Returns non-zero for constant-like nodes. */
2719 int (is_irn_constlike)(const ir_node *node) {
2720         return _is_irn_constlike(node);
2721 }
2722
2723 /*
2724  * Returns non-zero for nodes that are allowed to have keep-alives and
2725  * are neither Block nor PhiM.
2726  */
2727 int (is_irn_keep)(const ir_node *node) {
2728         return _is_irn_keep(node);
2729 }
2730
2731 /*
2732  * Returns non-zero for nodes that are always placed in the start block.
2733  */
2734 int (is_irn_start_block_placed)(const ir_node *node) {
2735         return _is_irn_start_block_placed(node);
2736 }
2737
2738 /* Returns non-zero for nodes that are machine operations. */
2739 int (is_irn_machine_op)(const ir_node *node) {
2740         return _is_irn_machine_op(node);
2741 }
2742
2743 /* Returns non-zero for nodes that are machine operands. */
2744 int (is_irn_machine_operand)(const ir_node *node) {
2745         return _is_irn_machine_operand(node);
2746 }
2747
2748 /* Returns non-zero for nodes that have the n'th user machine flag set. */
2749 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
2750         return _is_irn_machine_user(node, n);
2751 }
2752
2753
2754 /* Gets the string representation of the jump prediction .*/
2755 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
2756         switch (pred) {
2757         default:
2758         case COND_JMP_PRED_NONE:  return "no prediction";
2759         case COND_JMP_PRED_TRUE:  return "true taken";
2760         case COND_JMP_PRED_FALSE: return "false taken";
2761         }
2762 }
2763
2764 /* Returns the conditional jump prediction of a Cond node. */
2765 cond_jmp_predicate (get_Cond_jmp_pred)(ir_node *cond) {
2766         return _get_Cond_jmp_pred(cond);
2767 }
2768
2769 /* Sets a new conditional jump prediction. */
2770 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
2771         _set_Cond_jmp_pred(cond, pred);
2772 }
2773
2774 /** the get_type operation must be always implemented and return a firm type */
2775 static ir_type *get_Default_type(ir_node *n) {
2776         return get_unknown_type();
2777 }
2778
2779 /* Sets the get_type operation for an ir_op_ops. */
2780 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
2781         switch (code) {
2782         case iro_Const:    ops->get_type = get_Const_type; break;
2783         case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
2784         case iro_Cast:     ops->get_type = get_Cast_type; break;
2785         case iro_Proj:     ops->get_type = get_Proj_type; break;
2786         default:
2787                 /* not allowed to be NULL */
2788                 if (! ops->get_type)
2789                         ops->get_type = get_Default_type;
2790                 break;
2791         }
2792         return ops;
2793 }
2794
2795 /** Return the attribute type of a SymConst node if exists */
2796 static ir_type *get_SymConst_attr_type(ir_node *self) {
2797         symconst_kind kind = get_SymConst_kind(self);
2798         if (SYMCONST_HAS_TYPE(kind))
2799                 return get_SymConst_type(self);
2800         return NULL;
2801 }
2802
2803 /** Return the attribute entity of a SymConst node if exists */
2804 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
2805         symconst_kind kind = get_SymConst_kind(self);
2806         if (SYMCONST_HAS_ENT(kind))
2807                 return get_SymConst_entity(self);
2808         return NULL;
2809 }
2810
2811 /** the get_type_attr operation must be always implemented */
2812 static ir_type *get_Null_type(ir_node *n) {
2813         return firm_unknown_type;
2814 }
2815
2816 /* Sets the get_type operation for an ir_op_ops. */
2817 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
2818         switch (code) {
2819         case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
2820         case iro_Call:     ops->get_type_attr = get_Call_type; break;
2821         case iro_Alloc:    ops->get_type_attr = get_Alloc_type; break;
2822         case iro_Free:     ops->get_type_attr = get_Free_type; break;
2823         case iro_Cast:     ops->get_type_attr = get_Cast_type; break;
2824         default:
2825                 /* not allowed to be NULL */
2826                 if (! ops->get_type_attr)
2827                         ops->get_type_attr = get_Null_type;
2828                 break;
2829         }
2830         return ops;
2831 }
2832
2833 /** the get_entity_attr operation must be always implemented */
2834 static ir_entity *get_Null_ent(ir_node *n) {
2835         return NULL;
2836 }
2837
2838 /* Sets the get_type operation for an ir_op_ops. */
2839 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
2840         switch (code) {
2841         case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
2842         case iro_Sel:      ops->get_entity_attr = get_Sel_entity; break;
2843         default:
2844                 /* not allowed to be NULL */
2845                 if (! ops->get_entity_attr)
2846                         ops->get_entity_attr = get_Null_ent;
2847                 break;
2848         }
2849         return ops;
2850 }
2851
2852 #ifdef DEBUG_libfirm
2853 void dump_irn(ir_node *n) {
2854         int i, arity = get_irn_arity(n);
2855         printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
2856         if (!is_Block(n)) {
2857                 ir_node *pred = get_irn_n(n, -1);
2858                 printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2859                         get_irn_node_nr(pred), (void *)pred);
2860         }
2861         printf("  preds: \n");
2862         for (i = 0; i < arity; ++i) {
2863                 ir_node *pred = get_irn_n(n, i);
2864                 printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2865                         get_irn_node_nr(pred), (void *)pred);
2866         }
2867 }
2868
2869 #else  /* DEBUG_libfirm */
2870 void dump_irn(ir_node *n) {}
2871 #endif /* DEBUG_libfirm */