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

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