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