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

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