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