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