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 #ifdef INTERPROCEDURAL_VIEW
 802 void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]) {
 803         assert(node->op == op_Block);
 804         if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
 805                 node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
 806                 node->attr.block.in_cg[0] = NULL;
 807                 node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
 808                 {
 809                         /* Fix backedge array.  fix_backedges() operates depending on
 810                            interprocedural_view. */
 811                         int ipv = get_interprocedural_view();
 812                         set_interprocedural_view(1);
 813                         fix_backedges(current_ir_graph->obst, node);
 814                         set_interprocedural_view(ipv);
 815                 }
 816         }
 817         memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
 818 }
 819
 820 void set_Block_cg_cfgpred(ir_node *node, int pos, ir_node *pred) {
 821         assert(node->op == op_Block &&
 822                node->attr.block.in_cg &&
 823                0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
 824         node->attr.block.in_cg[pos + 1] = pred;
 825 }
 826
 827 ir_node **get_Block_cg_cfgpred_arr(ir_node *node) {
 828         assert(node->op == op_Block);
 829         return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg  + 1;
 830 }
 831
 832 int get_Block_cg_n_cfgpreds(ir_node *node) {
 833         assert(node->op == op_Block);
 834         return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
 835 }
 836
 837 ir_node *get_Block_cg_cfgpred(ir_node *node, int pos) {
 838         assert(node->op == op_Block && node->attr.block.in_cg);
 839         return node->attr.block.in_cg[pos + 1];
 840 }
 841
 842 void remove_Block_cg_cfgpred_arr(ir_node *node) {
 843         assert(node->op == op_Block);
 844         node->attr.block.in_cg = NULL;
 845 }
 846 #endif
 847
 848 ir_node *(set_Block_dead)(ir_node *block) {
 849         return _set_Block_dead(block);
 850 }
 851
 852 int (is_Block_dead)(const ir_node *block) {
 853         return _is_Block_dead(block);
 854 }
 855
 856 ir_extblk *get_Block_extbb(const ir_node *block) {
 857         ir_extblk *res;
 858         assert(is_Block(block));
 859         res = block->attr.block.extblk;
 860         assert(res == NULL || is_ir_extbb(res));
 861         return res;
 862 }
 863
 864 void set_Block_extbb(ir_node *block, ir_extblk *extblk) {
 865         assert(is_Block(block));
 866         assert(extblk == NULL || is_ir_extbb(extblk));
 867         block->attr.block.extblk = extblk;
 868 }
 869
 870 /* returns the macro block header of a block. */
 871 ir_node *get_Block_MacroBlock(const ir_node *block) {
 872         ir_node *mbh;
 873         assert(is_Block(block));
 874         mbh = get_irn_n(block, -1);
 875         /* once macro block header is respected by all optimizations,
 876            this assert can be removed */
 877         assert(mbh != NULL);
 878         return mbh;
 879 }
 880
 881 /* returns the graph of a Block. */
 882 ir_graph *get_Block_irg(const ir_node *block) {
 883         assert(is_Block(block));
 884         return block->attr.block.irg;
 885 }
 886
 887 int has_Block_label(const ir_node *block) {
 888         assert(is_Block(block));
 889         return block->attr.block.has_label;
 890 }
 891
 892 ir_label_t get_Block_label(const ir_node *block) {
 893         assert(is_Block(block));
 894         return block->attr.block.label;
 895 }
 896
 897 void set_Block_label(ir_node *block, ir_label_t label) {
 898         assert(is_Block(block));
 899         block->attr.block.has_label = 1;
 900         block->attr.block.label = label;
 901 }
 902
 903 int
 904 get_End_n_keepalives(ir_node *end) {
 905         assert(end->op == op_End);
 906         return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
 907 }
 908
 909 ir_node *
 910 get_End_keepalive(ir_node *end, int pos) {
 911         assert(end->op == op_End);
 912         return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
 913 }
 914
 915 void
 916 add_End_keepalive(ir_node *end, ir_node *ka) {
 917         assert(end->op == op_End);
 918         assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!");
 919         add_irn_n(end, ka);
 920 }
 921
 922 void
 923 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
 924         assert(end->op == op_End);
 925         set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 926 }
 927
 928 /* Set new keep-alives */
 929 void set_End_keepalives(ir_node *end, int n, ir_node *in[]) {
 930         int i;
 931         ir_graph *irg = get_irn_irg(end);
 932
 933         /* notify that edges are deleted */
 934         for (i = END_KEEPALIVE_OFFSET; i < ARR_LEN(end->in) - 1; ++i) {
 935                 edges_notify_edge(end, i, NULL, end->in[i + 1], irg);
 936         }
 937         ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET);
 938
 939         for (i = 0; i < n; ++i) {
 940                 end->in[1 + END_KEEPALIVE_OFFSET + i] = in[i];
 941                 edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, end->in[1 + END_KEEPALIVE_OFFSET + i], NULL, irg);
 942         }
 943 }
 944
 945 /* Set new keep-alives from old keep-alives, skipping irn */
 946 void remove_End_keepalive(ir_node *end, ir_node *irn) {
 947         int     n = get_End_n_keepalives(end);
 948         ir_node **in;
 949         int     i, idx;
 950
 951         NEW_ARR_A(ir_node *, in, n);
 952
 953         for (idx = i = 0; i < n; ++i) {
 954                 ir_node *old_ka = get_End_keepalive(end, i);
 955
 956                 /* skip irn */
 957                 if (old_ka != irn)
 958                         in[idx++] = old_ka;
 959         }
 960
 961         /* set new keep-alives */
 962         set_End_keepalives(end, idx, in);
 963 }
 964
 965 void
 966 free_End (ir_node *end) {
 967         assert(end->op == op_End);
 968         end->kind = k_BAD;
 969         DEL_ARR_F(end->in);
 970         end->in = NULL;   /* @@@ make sure we get an error if we use the
 971                              in array afterwards ... */
 972 }
 973
 974 /* Return the target address of an IJmp */
 975 ir_node *get_IJmp_target(ir_node *ijmp) {
 976         assert(ijmp->op == op_IJmp);
 977         return get_irn_n(ijmp, 0);
 978 }
 979
 980 /** Sets the target address of an IJmp */
 981 void set_IJmp_target(ir_node *ijmp, ir_node *tgt) {
 982         assert(ijmp->op == op_IJmp);
 983         set_irn_n(ijmp, 0, tgt);
 984 }
 985
 986 /*
 987 > Implementing the case construct (which is where the constant Proj node is
 988 > important) involves far more than simply determining the constant values.
 989 > We could argue that this is more properly a function of the translator from
 990 > Firm to the target machine.  That could be done if there was some way of
 991 > projecting "default" out of the Cond node.
 992 I know it's complicated.
 993 Basically there are two proglems:
 994  - determining the gaps between the projs
 995  - determining the biggest case constant to know the proj number for
 996    the default node.
 997 I see several solutions:
 998 1. Introduce a ProjDefault node.  Solves both problems.
 999    This means to extend all optimizations executed during construction.
1000 2. Give the Cond node for switch two flavors:
1001    a) there are no gaps in the projs  (existing flavor)
1002    b) gaps may exist, default proj is still the Proj with the largest
1003       projection number.  This covers also the gaps.
1004 3. Fix the semantic of the Cond to that of 2b)
1005
1006 Solution 2 seems to be the best:
1007 Computing the gaps in the Firm representation is not too hard, i.e.,
1008 libFIRM can implement a routine that transforms between the two
1009 flavours.  This is also possible for 1) but 2) does not require to
1010 change any existing optimization.
1011 Further it should be far simpler to determine the biggest constant than
1012 to compute all gaps.
1013 I don't want to choose 3) as 2a) seems to have advantages for
1014 dataflow analysis and 3) does not allow to convert the representation to
1015 2a).
1016 */
1017 ir_node *
1018 get_Cond_selector(ir_node *node) {
1019         assert(node->op == op_Cond);
1020         return get_irn_n(node, 0);
1021 }
1022
1023 void
1024 set_Cond_selector(ir_node *node, ir_node *selector) {
1025         assert(node->op == op_Cond);
1026         set_irn_n(node, 0, selector);
1027 }
1028
1029 cond_kind
1030 get_Cond_kind(ir_node *node) {
1031         assert(node->op == op_Cond);
1032         return node->attr.cond.kind;
1033 }
1034
1035 void
1036 set_Cond_kind(ir_node *node, cond_kind kind) {
1037         assert(node->op == op_Cond);
1038         node->attr.cond.kind = kind;
1039 }
1040
1041 long
1042 get_Cond_defaultProj(ir_node *node) {
1043         assert(node->op == op_Cond);
1044         return node->attr.cond.default_proj;
1045 }
1046
1047 ir_node *
1048 get_Return_mem(ir_node *node) {
1049         assert(node->op == op_Return);
1050         return get_irn_n(node, 0);
1051 }
1052
1053 void
1054 set_Return_mem(ir_node *node, ir_node *mem) {
1055         assert(node->op == op_Return);
1056         set_irn_n(node, 0, mem);
1057 }
1058
1059 int
1060 get_Return_n_ress(ir_node *node) {
1061         assert(node->op == op_Return);
1062         return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
1063 }
1064
1065 ir_node **
1066 get_Return_res_arr (ir_node *node) {
1067         assert((node->op == op_Return));
1068         if (get_Return_n_ress(node) > 0)
1069                 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
1070         else
1071                 return NULL;
1072 }
1073
1074 /*
1075 void
1076 set_Return_n_res(ir_node *node, int results) {
1077         assert(node->op == op_Return);
1078 }
1079 */
1080
1081 ir_node *
1082 get_Return_res(ir_node *node, int pos) {
1083         assert(node->op == op_Return);
1084         assert(get_Return_n_ress(node) > pos);
1085         return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
1086 }
1087
1088 void
1089 set_Return_res(ir_node *node, int pos, ir_node *res){
1090         assert(node->op == op_Return);
1091         set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
1092 }
1093
1094 tarval *(get_Const_tarval)(const ir_node *node) {
1095         return _get_Const_tarval(node);
1096 }
1097
1098 void
1099 set_Const_tarval(ir_node *node, tarval *con) {
1100         assert(node->op == op_Const);
1101         node->attr.con.tv = con;
1102 }
1103
1104 int (is_Const_null)(const ir_node *node) {
1105         return _is_Const_null(node);
1106 }
1107
1108 int (is_Const_one)(const ir_node *node) {
1109         return _is_Const_one(node);
1110 }
1111
1112 int (is_Const_all_one)(const ir_node *node) {
1113         return _is_Const_all_one(node);
1114 }
1115
1116
1117 /* The source language type.  Must be an atomic type.  Mode of type must
1118    be mode of node. For tarvals from entities type must be pointer to
1119    entity type. */
1120 ir_type *
1121 get_Const_type(ir_node *node) {
1122         assert(node->op == op_Const);
1123         return node->attr.con.tp;
1124 }
1125
1126 void
1127 set_Const_type(ir_node *node, ir_type *tp) {
1128         assert(node->op == op_Const);
1129         if (tp != firm_unknown_type) {
1130                 assert(is_atomic_type(tp));
1131                 assert(get_type_mode(tp) == get_irn_mode(node));
1132         }
1133         node->attr.con.tp = tp;
1134 }
1135
1136
1137 symconst_kind
1138 get_SymConst_kind(const ir_node *node) {
1139         assert(node->op == op_SymConst);
1140         return node->attr.symc.num;
1141 }
1142
1143 void
1144 set_SymConst_kind(ir_node *node, symconst_kind num) {
1145         assert(node->op == op_SymConst);
1146         node->attr.symc.num = num;
1147 }
1148
1149 ir_type *
1150 get_SymConst_type(ir_node *node) {
1151         assert((node->op == op_SymConst) &&
1152                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1153         return node->attr.symc.sym.type_p = skip_tid(node->attr.symc.sym.type_p);
1154 }
1155
1156 void
1157 set_SymConst_type(ir_node *node, ir_type *tp) {
1158         assert((node->op == op_SymConst) &&
1159                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
1160         node->attr.symc.sym.type_p = tp;
1161 }
1162
1163 ident *
1164 get_SymConst_name(const ir_node *node) {
1165         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1166         return node->attr.symc.sym.ident_p;
1167 }
1168
1169 void
1170 set_SymConst_name(ir_node *node, ident *name) {
1171         assert(node->op == op_SymConst && SYMCONST_HAS_ID(get_SymConst_kind(node)));
1172         node->attr.symc.sym.ident_p = name;
1173 }
1174
1175
1176 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
1177 ir_entity *get_SymConst_entity(const ir_node *node) {
1178         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1179         return node->attr.symc.sym.entity_p;
1180 }
1181
1182 void set_SymConst_entity(ir_node *node, ir_entity *ent) {
1183         assert(node->op == op_SymConst && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
1184         node->attr.symc.sym.entity_p  = ent;
1185 }
1186
1187 ir_enum_const *get_SymConst_enum(const ir_node *node) {
1188         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1189         return node->attr.symc.sym.enum_p;
1190 }
1191
1192 void set_SymConst_enum(ir_node *node, ir_enum_const *ec) {
1193         assert(node->op == op_SymConst && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
1194         node->attr.symc.sym.enum_p  = ec;
1195 }
1196
1197 union symconst_symbol
1198 get_SymConst_symbol(const ir_node *node) {
1199         assert(node->op == op_SymConst);
1200         return node->attr.symc.sym;
1201 }
1202
1203 void
1204 set_SymConst_symbol(ir_node *node, union symconst_symbol sym) {
1205         assert(node->op == op_SymConst);
1206         node->attr.symc.sym = sym;
1207 }
1208
1209 ir_label_t get_SymConst_label(const ir_node *node) {
1210         assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
1211         return node->attr.symc.sym.label;
1212 }
1213
1214 void set_SymConst_label(ir_node *node, ir_label_t label) {
1215         assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
1216         node->attr.symc.sym.label = label;
1217 }
1218
1219 ir_type *
1220 get_SymConst_value_type(ir_node *node) {
1221         assert(node->op == op_SymConst);
1222         if (node->attr.symc.tp) node->attr.symc.tp = skip_tid(node->attr.symc.tp);
1223         return node->attr.symc.tp;
1224 }
1225
1226 void
1227 set_SymConst_value_type(ir_node *node, ir_type *tp) {
1228         assert(node->op == op_SymConst);
1229         node->attr.symc.tp = tp;
1230 }
1231
1232 ir_node *
1233 get_Sel_mem(ir_node *node) {
1234         assert(node->op == op_Sel);
1235         return get_irn_n(node, 0);
1236 }
1237
1238 void
1239 set_Sel_mem(ir_node *node, ir_node *mem) {
1240         assert(node->op == op_Sel);
1241         set_irn_n(node, 0, mem);
1242 }
1243
1244 ir_node *
1245 get_Sel_ptr(ir_node *node) {
1246         assert(node->op == op_Sel);
1247         return get_irn_n(node, 1);
1248 }
1249
1250 void
1251 set_Sel_ptr(ir_node *node, ir_node *ptr) {
1252         assert(node->op == op_Sel);
1253         set_irn_n(node, 1, ptr);
1254 }
1255
1256 int
1257 get_Sel_n_indexs(ir_node *node) {
1258         assert(node->op == op_Sel);
1259         return (get_irn_arity(node) - SEL_INDEX_OFFSET);
1260 }
1261
1262 ir_node **
1263 get_Sel_index_arr(ir_node *node) {
1264         assert((node->op == op_Sel));
1265         if (get_Sel_n_indexs(node) > 0)
1266                 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
1267         else
1268                 return NULL;
1269 }
1270
1271 ir_node *
1272 get_Sel_index(ir_node *node, int pos) {
1273         assert(node->op == op_Sel);
1274         return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1275 }
1276
1277 void
1278 set_Sel_index(ir_node *node, int pos, ir_node *index) {
1279         assert(node->op == op_Sel);
1280         set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1281 }
1282
1283 ir_entity *
1284 get_Sel_entity(ir_node *node) {
1285         assert(node->op == op_Sel);
1286         return node->attr.sel.ent;
1287 }
1288
1289 void
1290 set_Sel_entity(ir_node *node, ir_entity *ent) {
1291         assert(node->op == op_Sel);
1292         node->attr.sel.ent = ent;
1293 }
1294
1295
1296 /* For unary and binary arithmetic operations the access to the
1297    operands can be factored out.  Left is the first, right the
1298    second arithmetic value  as listed in tech report 0999-33.
1299    unops are: Minus, Abs, Not, Conv, Cast
1300    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1301    Shr, Shrs, Rotate, Cmp */
1302
1303
1304 ir_node *
1305 get_Call_mem(ir_node *node) {
1306         assert(node->op == op_Call);
1307         return get_irn_n(node, 0);
1308 }
1309
1310 void
1311 set_Call_mem(ir_node *node, ir_node *mem) {
1312         assert(node->op == op_Call);
1313         set_irn_n(node, 0, mem);
1314 }
1315
1316 ir_node *
1317 get_Call_ptr(ir_node *node) {
1318         assert(node->op == op_Call);
1319         return get_irn_n(node, 1);
1320 }
1321
1322 void
1323 set_Call_ptr(ir_node *node, ir_node *ptr) {
1324         assert(node->op == op_Call);
1325         set_irn_n(node, 1, ptr);
1326 }
1327
1328 ir_node **
1329 get_Call_param_arr(ir_node *node) {
1330         assert(node->op == op_Call);
1331         return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1332 }
1333
1334 int
1335 get_Call_n_params(ir_node *node)  {
1336         assert(node->op == op_Call);
1337         return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1338 }
1339
1340 int
1341 get_Call_arity(ir_node *node) {
1342         assert(node->op == op_Call);
1343         return get_Call_n_params(node);
1344 }
1345
1346 /* void
1347 set_Call_arity(ir_node *node, ir_node *arity) {
1348         assert(node->op == op_Call);
1349 }
1350 */
1351
1352 ir_node *
1353 get_Call_param(ir_node *node, int pos) {
1354         assert(node->op == op_Call);
1355         return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1356 }
1357
1358 void
1359 set_Call_param(ir_node *node, int pos, ir_node *param) {
1360         assert(node->op == op_Call);
1361         set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1362 }
1363
1364 ir_type *
1365 get_Call_type(ir_node *node) {
1366         assert(node->op == op_Call);
1367         return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1368 }
1369
1370 void
1371 set_Call_type(ir_node *node, ir_type *tp) {
1372         assert(node->op == op_Call);
1373         assert((get_unknown_type() == tp) || is_Method_type(tp));
1374         node->attr.call.cld_tp = tp;
1375 }
1376
1377 int Call_has_callees(ir_node *node) {
1378         assert(node && node->op == op_Call);
1379         return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1380                 (node->attr.call.callee_arr != NULL));
1381 }
1382
1383 int get_Call_n_callees(ir_node * node) {
1384   assert(node && node->op == op_Call && node->attr.call.callee_arr);
1385   return ARR_LEN(node->attr.call.callee_arr);
1386 }
1387
1388 ir_entity * get_Call_callee(ir_node * node, int pos) {
1389         assert(pos >= 0 && pos < get_Call_n_callees(node));
1390         return node->attr.call.callee_arr[pos];
1391 }
1392
1393 void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
1394         assert(node->op == op_Call);
1395         if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1396                 node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
1397         }
1398         memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
1399 }
1400
1401 void remove_Call_callee_arr(ir_node * node) {
1402         assert(node->op == op_Call);
1403         node->attr.call.callee_arr = NULL;
1404 }
1405
1406 ir_node * get_CallBegin_ptr(ir_node *node) {
1407         assert(node->op == op_CallBegin);
1408         return get_irn_n(node, 0);
1409 }
1410
1411 void set_CallBegin_ptr(ir_node *node, ir_node *ptr) {
1412         assert(node->op == op_CallBegin);
1413         set_irn_n(node, 0, ptr);
1414 }
1415
1416 ir_node * get_CallBegin_call(ir_node *node) {
1417         assert(node->op == op_CallBegin);
1418         return node->attr.callbegin.call;
1419 }
1420
1421 void  set_CallBegin_call(ir_node *node, ir_node *call) {
1422         assert(node->op == op_CallBegin);
1423         node->attr.callbegin.call = call;
1424 }
1425
1426
1427 #define BINOP(OP)                                      \
1428 ir_node * get_##OP##_left(const ir_node *node) {       \
1429   assert(node->op == op_##OP);                         \
1430   return get_irn_n(node, node->op->op_index);          \
1431 }                                                      \
1432 void set_##OP##_left(ir_node *node, ir_node *left) {   \
1433   assert(node->op == op_##OP);                         \
1434   set_irn_n(node, node->op->op_index, left);           \
1435 }                                                      \
1436 ir_node *get_##OP##_right(const ir_node *node) {       \
1437   assert(node->op == op_##OP);                         \
1438   return get_irn_n(node, node->op->op_index + 1);      \
1439 }                                                      \
1440 void set_##OP##_right(ir_node *node, ir_node *right) { \
1441   assert(node->op == op_##OP);                         \
1442   set_irn_n(node, node->op->op_index + 1, right);      \
1443 }
1444
1445 #define UNOP(OP)                                  \
1446 ir_node *get_##OP##_op(const ir_node *node) {     \
1447   assert(node->op == op_##OP);                    \
1448   return get_irn_n(node, node->op->op_index);     \
1449 }                                                 \
1450 void set_##OP##_op (ir_node *node, ir_node *op) { \
1451   assert(node->op == op_##OP);                    \
1452   set_irn_n(node, node->op->op_index, op);        \
1453 }
1454
1455 #define BINOP_MEM(OP)                         \
1456 BINOP(OP)                                     \
1457                                               \
1458 ir_node *                                     \
1459 get_##OP##_mem(ir_node *node) {               \
1460   assert(node->op == op_##OP);                \
1461   return get_irn_n(node, 0);                  \
1462 }                                             \
1463                                               \
1464 void                                          \
1465 set_##OP##_mem(ir_node *node, ir_node *mem) { \
1466   assert(node->op == op_##OP);                \
1467   set_irn_n(node, 0, mem);                    \
1468 }
1469
1470 #define DIVOP(OP)                                       \
1471 BINOP_MEM(OP)                                           \
1472                                                         \
1473 ir_mode *get_##OP##_resmode(const ir_node *node) {      \
1474   assert(node->op == op_##OP);                          \
1475   return node->attr.divmod.res_mode;                    \
1476 }                                                       \
1477                                                         \
1478 void set_##OP##_resmode(ir_node *node, ir_mode *mode) { \
1479   assert(node->op == op_##OP);                          \
1480   node->attr.divmod.res_mode = mode;                    \
1481 }
1482
1483
1484 BINOP(Add)
1485 BINOP(Sub)
1486 UNOP(Minus)
1487 BINOP(Mul)
1488 BINOP(Mulh)
1489 DIVOP(Quot)
1490 DIVOP(DivMod)
1491 DIVOP(Div)
1492 DIVOP(Mod)
1493 UNOP(Abs)
1494 BINOP(And)
1495 BINOP(Or)
1496 BINOP(Eor)
1497 UNOP(Not)
1498 BINOP(Shl)
1499 BINOP(Shr)
1500 BINOP(Shrs)
1501 BINOP(Rot)
1502 BINOP(Cmp)
1503 UNOP(Conv)
1504 UNOP(Cast)
1505
1506 int get_Conv_strict(ir_node *node) {
1507         assert(node->op == op_Conv);
1508         return node->attr.conv.strict;
1509 }
1510
1511 void set_Conv_strict(ir_node *node, int strict_flag) {
1512         assert(node->op == op_Conv);
1513         node->attr.conv.strict = (char)strict_flag;
1514 }
1515
1516 ir_type *
1517 get_Cast_type(ir_node *node) {
1518         assert(node->op == op_Cast);
1519         return node->attr.cast.totype;
1520 }
1521
1522 void
1523 set_Cast_type(ir_node *node, ir_type *to_tp) {
1524         assert(node->op == op_Cast);
1525         node->attr.cast.totype = to_tp;
1526 }
1527
1528
1529 /* Checks for upcast.
1530  *
1531  * Returns true if the Cast node casts a class type to a super type.
1532  */
1533 int is_Cast_upcast(ir_node *node) {
1534         ir_type *totype   = get_Cast_type(node);
1535         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1536         ir_graph *myirg = get_irn_irg(node);
1537
1538         assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
1539         assert(fromtype);
1540
1541         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1542                 totype   = get_pointer_points_to_type(totype);
1543                 fromtype = get_pointer_points_to_type(fromtype);
1544         }
1545
1546         assert(fromtype);
1547
1548         if (!is_Class_type(totype)) return 0;
1549         return is_SubClass_of(fromtype, totype);
1550 }
1551
1552 /* Checks for downcast.
1553  *
1554  * Returns true if the Cast node casts a class type to a sub type.
1555  */
1556 int is_Cast_downcast(ir_node *node) {
1557         ir_type *totype   = get_Cast_type(node);
1558         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
1559
1560         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
1561         assert(fromtype);
1562
1563         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
1564                 totype   = get_pointer_points_to_type(totype);
1565                 fromtype = get_pointer_points_to_type(fromtype);
1566         }
1567
1568         assert(fromtype);
1569
1570         if (!is_Class_type(totype)) return 0;
1571         return is_SubClass_of(totype, fromtype);
1572 }
1573
1574 int
1575 (is_unop)(const ir_node *node) {
1576         return _is_unop(node);
1577 }
1578
1579 ir_node *
1580 get_unop_op(const ir_node *node) {
1581         if (node->op->opar == oparity_unary)
1582                 return get_irn_n(node, node->op->op_index);
1583
1584         assert(node->op->opar == oparity_unary);
1585         return NULL;
1586 }
1587
1588 void
1589 set_unop_op(ir_node *node, ir_node *op) {
1590         if (node->op->opar == oparity_unary)
1591                 set_irn_n(node, node->op->op_index, op);
1592
1593         assert(node->op->opar == oparity_unary);
1594 }
1595
1596 int
1597 (is_binop)(const ir_node *node) {
1598         return _is_binop(node);
1599 }
1600
1601 ir_node *
1602 get_binop_left(const ir_node *node) {
1603         assert(node->op->opar == oparity_binary);
1604         return get_irn_n(node, node->op->op_index);
1605 }
1606
1607 void
1608 set_binop_left(ir_node *node, ir_node *left) {
1609         assert(node->op->opar == oparity_binary);
1610         set_irn_n(node, node->op->op_index, left);
1611 }
1612
1613 ir_node *
1614 get_binop_right(const ir_node *node) {
1615         assert(node->op->opar == oparity_binary);
1616         return get_irn_n(node, node->op->op_index + 1);
1617 }
1618
1619 void
1620 set_binop_right(ir_node *node, ir_node *right) {
1621         assert(node->op->opar == oparity_binary);
1622         set_irn_n(node, node->op->op_index + 1, right);
1623 }
1624
1625 int
1626 (is_Phi)(const ir_node *n) {
1627         ir_op *op;
1628
1629         assert(n);
1630         op = get_irn_op(n);
1631
1632         if (op == op_Filter) return get_interprocedural_view();
1633
1634         if (op == op_Phi)
1635                 return ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
1636                         (get_irn_arity(n) > 0));
1637
1638         return 0;
1639 }
1640
1641 int is_Phi0(const ir_node *n) {
1642         assert(n);
1643
1644         return ((get_irn_op(n) == op_Phi) &&
1645                 (get_irn_arity(n) == 0) &&
1646                 (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1647 }
1648
1649 ir_node **
1650 get_Phi_preds_arr(ir_node *node) {
1651   assert(node->op == op_Phi);
1652   return (ir_node **)&(get_irn_in(node)[1]);
1653 }
1654
1655 int
1656 get_Phi_n_preds(const ir_node *node) {
1657         assert(is_Phi(node) || is_Phi0(node));
1658         return (get_irn_arity(node));
1659 }
1660
1661 /*
1662 void set_Phi_n_preds(ir_node *node, int n_preds) {
1663         assert(node->op == op_Phi);
1664 }
1665 */
1666
1667 ir_node *
1668 get_Phi_pred(const ir_node *node, int pos) {
1669         assert(is_Phi(node) || is_Phi0(node));
1670         return get_irn_n(node, pos);
1671 }
1672
1673 void
1674 set_Phi_pred(ir_node *node, int pos, ir_node *pred) {
1675         assert(is_Phi(node) || is_Phi0(node));
1676         set_irn_n(node, pos, pred);
1677 }
1678
1679
1680 int is_memop(ir_node *node) {
1681         return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
1682 }
1683
1684 ir_node *get_memop_mem(ir_node *node) {
1685         assert(is_memop(node));
1686         return get_irn_n(node, 0);
1687 }
1688
1689 void set_memop_mem(ir_node *node, ir_node *mem) {
1690         assert(is_memop(node));
1691         set_irn_n(node, 0, mem);
1692 }
1693
1694 ir_node *get_memop_ptr(ir_node *node) {
1695         assert(is_memop(node));
1696         return get_irn_n(node, 1);
1697 }
1698
1699 void set_memop_ptr(ir_node *node, ir_node *ptr) {
1700         assert(is_memop(node));
1701         set_irn_n(node, 1, ptr);
1702 }
1703
1704 ir_node *
1705 get_Load_mem(ir_node *node) {
1706         assert(node->op == op_Load);
1707         return get_irn_n(node, 0);
1708 }
1709
1710 void
1711 set_Load_mem(ir_node *node, ir_node *mem) {
1712         assert(node->op == op_Load);
1713         set_irn_n(node, 0, mem);
1714 }
1715
1716 ir_node *
1717 get_Load_ptr(ir_node *node) {
1718         assert(node->op == op_Load);
1719         return get_irn_n(node, 1);
1720 }
1721
1722 void
1723 set_Load_ptr(ir_node *node, ir_node *ptr) {
1724         assert(node->op == op_Load);
1725         set_irn_n(node, 1, ptr);
1726 }
1727
1728 ir_mode *
1729 get_Load_mode(ir_node *node) {
1730         assert(node->op == op_Load);
1731         return node->attr.load.load_mode;
1732 }
1733
1734 void
1735 set_Load_mode(ir_node *node, ir_mode *mode) {
1736         assert(node->op == op_Load);
1737         node->attr.load.load_mode = mode;
1738 }
1739
1740 ir_volatility
1741 get_Load_volatility(ir_node *node) {
1742         assert(node->op == op_Load);
1743         return node->attr.load.volatility;
1744 }
1745
1746 void
1747 set_Load_volatility(ir_node *node, ir_volatility volatility) {
1748         assert(node->op == op_Load);
1749         node->attr.load.volatility = volatility;
1750 }
1751
1752 ir_align
1753 get_Load_align(ir_node *node) {
1754         assert(node->op == op_Load);
1755         return node->attr.load.aligned;
1756 }
1757
1758 void
1759 set_Load_align(ir_node *node, ir_align align) {
1760         assert(node->op == op_Load);
1761         node->attr.load.aligned = align;
1762 }
1763
1764
1765 ir_node *
1766 get_Store_mem(ir_node *node) {
1767         assert(node->op == op_Store);
1768         return get_irn_n(node, 0);
1769 }
1770
1771 void
1772 set_Store_mem(ir_node *node, ir_node *mem) {
1773         assert(node->op == op_Store);
1774         set_irn_n(node, 0, mem);
1775 }
1776
1777 ir_node *
1778 get_Store_ptr(ir_node *node) {
1779         assert(node->op == op_Store);
1780         return get_irn_n(node, 1);
1781 }
1782
1783 void
1784 set_Store_ptr(ir_node *node, ir_node *ptr) {
1785         assert(node->op == op_Store);
1786         set_irn_n(node, 1, ptr);
1787 }
1788
1789 ir_node *
1790 get_Store_value(ir_node *node) {
1791         assert(node->op == op_Store);
1792         return get_irn_n(node, 2);
1793 }
1794
1795 void
1796 set_Store_value(ir_node *node, ir_node *value) {
1797         assert(node->op == op_Store);
1798         set_irn_n(node, 2, value);
1799 }
1800
1801 ir_volatility
1802 get_Store_volatility(ir_node *node) {
1803         assert(node->op == op_Store);
1804         return node->attr.store.volatility;
1805 }
1806
1807 void
1808 set_Store_volatility(ir_node *node, ir_volatility volatility) {
1809         assert(node->op == op_Store);
1810         node->attr.store.volatility = volatility;
1811 }
1812
1813 ir_align
1814 get_Store_align(ir_node *node) {
1815         assert(node->op == op_Store);
1816         return node->attr.store.aligned;
1817 }
1818
1819 void
1820 set_Store_align(ir_node *node, ir_align align) {
1821         assert(node->op == op_Store);
1822         node->attr.store.aligned = align;
1823 }
1824
1825
1826 ir_node *
1827 get_Alloc_mem(ir_node *node) {
1828         assert(node->op == op_Alloc);
1829         return get_irn_n(node, 0);
1830 }
1831
1832 void
1833 set_Alloc_mem(ir_node *node, ir_node *mem) {
1834         assert(node->op == op_Alloc);
1835         set_irn_n(node, 0, mem);
1836 }
1837
1838 ir_node *
1839 get_Alloc_size(ir_node *node) {
1840         assert(node->op == op_Alloc);
1841         return get_irn_n(node, 1);
1842 }
1843
1844 void
1845 set_Alloc_size(ir_node *node, ir_node *size) {
1846         assert(node->op == op_Alloc);
1847         set_irn_n(node, 1, size);
1848 }
1849
1850 ir_type *
1851 get_Alloc_type(ir_node *node) {
1852         assert(node->op == op_Alloc);
1853         return node->attr.alloc.type = skip_tid(node->attr.alloc.type);
1854 }
1855
1856 void
1857 set_Alloc_type(ir_node *node, ir_type *tp) {
1858         assert(node->op == op_Alloc);
1859         node->attr.alloc.type = tp;
1860 }
1861
1862 where_alloc
1863 get_Alloc_where(ir_node *node) {
1864         assert(node->op == op_Alloc);
1865         return node->attr.alloc.where;
1866 }
1867
1868 void
1869 set_Alloc_where(ir_node *node, where_alloc where) {
1870         assert(node->op == op_Alloc);
1871         node->attr.alloc.where = where;
1872 }
1873
1874
1875 ir_node *
1876 get_Free_mem(ir_node *node) {
1877         assert(node->op == op_Free);
1878         return get_irn_n(node, 0);
1879 }
1880
1881 void
1882 set_Free_mem(ir_node *node, ir_node *mem) {
1883         assert(node->op == op_Free);
1884         set_irn_n(node, 0, mem);
1885 }
1886
1887 ir_node *
1888 get_Free_ptr(ir_node *node) {
1889         assert(node->op == op_Free);
1890         return get_irn_n(node, 1);
1891 }
1892
1893 void
1894 set_Free_ptr(ir_node *node, ir_node *ptr) {
1895         assert(node->op == op_Free);
1896         set_irn_n(node, 1, ptr);
1897 }
1898
1899 ir_node *
1900 get_Free_size(ir_node *node) {
1901         assert(node->op == op_Free);
1902         return get_irn_n(node, 2);
1903 }
1904
1905 void
1906 set_Free_size(ir_node *node, ir_node *size) {
1907         assert(node->op == op_Free);
1908         set_irn_n(node, 2, size);
1909 }
1910
1911 ir_type *
1912 get_Free_type(ir_node *node) {
1913         assert(node->op == op_Free);
1914         return node->attr.free.type = skip_tid(node->attr.free.type);
1915 }
1916
1917 void
1918 set_Free_type(ir_node *node, ir_type *tp) {
1919         assert(node->op == op_Free);
1920         node->attr.free.type = tp;
1921 }
1922
1923 where_alloc
1924 get_Free_where(ir_node *node) {
1925         assert(node->op == op_Free);
1926         return node->attr.free.where;
1927 }
1928
1929 void
1930 set_Free_where(ir_node *node, where_alloc where) {
1931         assert(node->op == op_Free);
1932         node->attr.free.where = where;
1933 }
1934
1935 ir_node **get_Sync_preds_arr(ir_node *node) {
1936         assert(node->op == op_Sync);
1937         return (ir_node **)&(get_irn_in(node)[1]);
1938 }
1939
1940 int get_Sync_n_preds(ir_node *node) {
1941         assert(node->op == op_Sync);
1942         return (get_irn_arity(node));
1943 }
1944
1945 /*
1946 void set_Sync_n_preds(ir_node *node, int n_preds) {
1947         assert(node->op == op_Sync);
1948 }
1949 */
1950
1951 ir_node *get_Sync_pred(ir_node *node, int pos) {
1952         assert(node->op == op_Sync);
1953         return get_irn_n(node, pos);
1954 }
1955
1956 void set_Sync_pred(ir_node *node, int pos, ir_node *pred) {
1957         assert(node->op == op_Sync);
1958         set_irn_n(node, pos, pred);
1959 }
1960
1961 /* Add a new Sync predecessor */
1962 void add_Sync_pred(ir_node *node, ir_node *pred) {
1963         assert(node->op == op_Sync);
1964         add_irn_n(node, pred);
1965 }
1966
1967 /* Returns the source language type of a Proj node. */
1968 ir_type *get_Proj_type(ir_node *n) {
1969         ir_type *tp   = firm_unknown_type;
1970         ir_node *pred = get_Proj_pred(n);
1971
1972         switch (get_irn_opcode(pred)) {
1973         case iro_Proj: {
1974                 ir_node *pred_pred;
1975                 /* Deal with Start / Call here: we need to know the Proj Nr. */
1976                 assert(get_irn_mode(pred) == mode_T);
1977                 pred_pred = get_Proj_pred(pred);
1978                 if (get_irn_op(pred_pred) == op_Start)  {
1979                         ir_type *mtp = get_entity_type(get_irg_entity(get_irn_irg(pred_pred)));
1980                         tp = get_method_param_type(mtp, get_Proj_proj(n));
1981                 } else if (get_irn_op(pred_pred) == op_Call) {
1982                         ir_type *mtp = get_Call_type(pred_pred);
1983                         tp = get_method_res_type(mtp, get_Proj_proj(n));
1984                 }
1985         } break;
1986         case iro_Start: break;
1987         case iro_Call: break;
1988         case iro_Load: {
1989                 ir_node *a = get_Load_ptr(pred);
1990                 if (is_Sel(a))
1991                         tp = get_entity_type(get_Sel_entity(a));
1992         } break;
1993         default:
1994                 break;
1995         }
1996         return tp;
1997 }
1998
1999 ir_node *
2000 get_Proj_pred(const ir_node *node) {
2001         assert(is_Proj(node));
2002         return get_irn_n(node, 0);
2003 }
2004
2005 void
2006 set_Proj_pred(ir_node *node, ir_node *pred) {
2007         assert(is_Proj(node));
2008         set_irn_n(node, 0, pred);
2009 }
2010
2011 long
2012 get_Proj_proj(const ir_node *node) {
2013         assert(is_Proj(node));
2014         if (get_irn_opcode(node) == iro_Proj) {
2015                 return node->attr.proj;
2016         } else {
2017                 assert(get_irn_opcode(node) == iro_Filter);
2018                 return node->attr.filter.proj;
2019         }
2020 }
2021
2022 void
2023 set_Proj_proj(ir_node *node, long proj) {
2024         assert(node->op == op_Proj);
2025         node->attr.proj = proj;
2026 }
2027
2028 ir_node **
2029 get_Tuple_preds_arr(ir_node *node) {
2030         assert(node->op == op_Tuple);
2031         return (ir_node **)&(get_irn_in(node)[1]);
2032 }
2033
2034 int
2035 get_Tuple_n_preds(ir_node *node) {
2036         assert(node->op == op_Tuple);
2037         return (get_irn_arity(node));
2038 }
2039
2040 /*
2041 void
2042 set_Tuple_n_preds(ir_node *node, int n_preds) {
2043         assert(node->op == op_Tuple);
2044 }
2045 */
2046
2047 ir_node *
2048 get_Tuple_pred (ir_node *node, int pos) {
2049   assert(node->op == op_Tuple);
2050   return get_irn_n(node, pos);
2051 }
2052
2053 void
2054 set_Tuple_pred(ir_node *node, int pos, ir_node *pred) {
2055         assert(node->op == op_Tuple);
2056         set_irn_n(node, pos, pred);
2057 }
2058
2059 ir_node *
2060 get_Id_pred(ir_node *node) {
2061         assert(node->op == op_Id);
2062         return get_irn_n(node, 0);
2063 }
2064
2065 void
2066 set_Id_pred(ir_node *node, ir_node *pred) {
2067         assert(node->op == op_Id);
2068         set_irn_n(node, 0, pred);
2069 }
2070
2071 ir_node *get_Confirm_value(ir_node *node) {
2072         assert(node->op == op_Confirm);
2073         return get_irn_n(node, 0);
2074 }
2075
2076 void set_Confirm_value(ir_node *node, ir_node *value) {
2077         assert(node->op == op_Confirm);
2078         set_irn_n(node, 0, value);
2079 }
2080
2081 ir_node *get_Confirm_bound(ir_node *node) {
2082         assert(node->op == op_Confirm);
2083         return get_irn_n(node, 1);
2084 }
2085
2086 void set_Confirm_bound(ir_node *node, ir_node *bound) {
2087         assert(node->op == op_Confirm);
2088         set_irn_n(node, 0, bound);
2089 }
2090
2091 pn_Cmp get_Confirm_cmp(const ir_node *node) {
2092         assert(node->op == op_Confirm);
2093         return node->attr.confirm.cmp;
2094 }
2095
2096 void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
2097         assert(node->op == op_Confirm);
2098         node->attr.confirm.cmp = cmp;
2099 }
2100
2101 ir_node *
2102 get_Filter_pred(ir_node *node) {
2103         assert(node->op == op_Filter);
2104         return node->in[1];
2105 }
2106
2107 void
2108 set_Filter_pred(ir_node *node, ir_node *pred) {
2109         assert(node->op == op_Filter);
2110         node->in[1] = pred;
2111 }
2112
2113 long
2114 get_Filter_proj(ir_node *node) {
2115         assert(node->op == op_Filter);
2116         return node->attr.filter.proj;
2117 }
2118
2119 void
2120 set_Filter_proj(ir_node *node, long proj) {
2121         assert(node->op == op_Filter);
2122         node->attr.filter.proj = proj;
2123 }
2124
2125 /* Don't use get_irn_arity, get_irn_n in implementation as access
2126    shall work independent of view!!! */
2127 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
2128         assert(node->op == op_Filter);
2129         if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
2130                 node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
2131                 node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
2132                 memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
2133                 node->attr.filter.in_cg[0] = node->in[0];
2134         }
2135         memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
2136 }
2137
2138 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
2139         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2140                0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
2141         node->attr.filter.in_cg[pos + 1] = pred;
2142 }
2143
2144 int get_Filter_n_cg_preds(ir_node *node) {
2145         assert(node->op == op_Filter && node->attr.filter.in_cg);
2146         return (ARR_LEN(node->attr.filter.in_cg) - 1);
2147 }
2148
2149 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
2150         int arity;
2151         assert(node->op == op_Filter && node->attr.filter.in_cg &&
2152                0 <= pos);
2153         arity = ARR_LEN(node->attr.filter.in_cg);
2154         assert(pos < arity - 1);
2155         return node->attr.filter.in_cg[pos + 1];
2156 }
2157
2158 /* Mux support */
2159 ir_node *get_Mux_sel(ir_node *node) {
2160         if (node->op == op_Psi) {
2161                 assert(get_irn_arity(node) == 3);
2162                 return get_Psi_cond(node, 0);
2163         }
2164         assert(node->op == op_Mux);
2165         return node->in[1];
2166 }
2167
2168 void set_Mux_sel(ir_node *node, ir_node *sel) {
2169         if (node->op == op_Psi) {
2170                 assert(get_irn_arity(node) == 3);
2171                 set_Psi_cond(node, 0, sel);
2172         } else {
2173                 assert(node->op == op_Mux);
2174                 node->in[1] = sel;
2175         }
2176 }
2177
2178 ir_node *get_Mux_false(ir_node *node) {
2179         if (node->op == op_Psi) {
2180                 assert(get_irn_arity(node) == 3);
2181                 return get_Psi_default(node);
2182         }
2183         assert(node->op == op_Mux);
2184         return node->in[2];
2185 }
2186
2187 void set_Mux_false(ir_node *node, ir_node *ir_false) {
2188         if (node->op == op_Psi) {
2189                 assert(get_irn_arity(node) == 3);
2190                 set_Psi_default(node, ir_false);
2191         } else {
2192                 assert(node->op == op_Mux);
2193                 node->in[2] = ir_false;
2194         }
2195 }
2196
2197 ir_node *get_Mux_true(ir_node *node) {
2198         if (node->op == op_Psi) {
2199                 assert(get_irn_arity(node) == 3);
2200                 return get_Psi_val(node, 0);
2201         }
2202         assert(node->op == op_Mux);
2203         return node->in[3];
2204 }
2205
2206 void set_Mux_true(ir_node *node, ir_node *ir_true) {
2207         if (node->op == op_Psi) {
2208                 assert(get_irn_arity(node) == 3);
2209                 set_Psi_val(node, 0, ir_true);
2210         } else {
2211                 assert(node->op == op_Mux);
2212                 node->in[3] = ir_true;
2213         }
2214 }
2215
2216 /* Psi support */
2217 ir_node *get_Psi_cond(ir_node *node, int pos) {
2218         int num_conds = get_Psi_n_conds(node);
2219         assert(node->op == op_Psi);
2220         assert(pos < num_conds);
2221         return get_irn_n(node, 2 * pos);
2222 }
2223
2224 void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
2225         int num_conds = get_Psi_n_conds(node);
2226         assert(node->op == op_Psi);
2227         assert(pos < num_conds);
2228         set_irn_n(node, 2 * pos, cond);
2229 }
2230
2231 ir_node *get_Psi_val(ir_node *node, int pos) {
2232         int num_vals = get_Psi_n_conds(node);
2233         assert(node->op == op_Psi);
2234         assert(pos < num_vals);
2235         return get_irn_n(node, 2 * pos + 1);
2236 }
2237
2238 void set_Psi_val(ir_node *node, int pos, ir_node *val) {
2239         int num_vals = get_Psi_n_conds(node);
2240         assert(node->op == op_Psi);
2241         assert(pos < num_vals);
2242         set_irn_n(node, 2 * pos + 1, val);
2243 }
2244
2245 ir_node *get_Psi_default(ir_node *node) {
2246         int def_pos = get_irn_arity(node) - 1;
2247         assert(node->op == op_Psi);
2248         return get_irn_n(node, def_pos);
2249 }
2250
2251 void set_Psi_default(ir_node *node, ir_node *val) {
2252         int def_pos = get_irn_arity(node);
2253         assert(node->op == op_Psi);
2254         set_irn_n(node, def_pos, val);
2255 }
2256
2257 int (get_Psi_n_conds)(ir_node *node) {
2258         return _get_Psi_n_conds(node);
2259 }
2260
2261 /* CopyB support */
2262 ir_node *get_CopyB_mem(ir_node *node) {
2263         assert(node->op == op_CopyB);
2264         return get_irn_n(node, 0);
2265 }
2266
2267 void set_CopyB_mem(ir_node *node, ir_node *mem) {
2268         assert(node->op == op_CopyB);
2269         set_irn_n(node, 0, mem);
2270 }
2271
2272 ir_node *get_CopyB_dst(ir_node *node) {
2273         assert(node->op == op_CopyB);
2274         return get_irn_n(node, 1);
2275 }
2276
2277 void set_CopyB_dst(ir_node *node, ir_node *dst) {
2278         assert(node->op == op_CopyB);
2279         set_irn_n(node, 1, dst);
2280 }
2281
2282 ir_node *get_CopyB_src (ir_node *node) {
2283   assert(node->op == op_CopyB);
2284   return get_irn_n(node, 2);
2285 }
2286
2287 void set_CopyB_src(ir_node *node, ir_node *src) {
2288         assert(node->op == op_CopyB);
2289         set_irn_n(node, 2, src);
2290 }
2291
2292 ir_type *get_CopyB_type(ir_node *node) {
2293         assert(node->op == op_CopyB);
2294         return node->attr.copyb.data_type;
2295 }
2296
2297 void set_CopyB_type(ir_node *node, ir_type *data_type) {
2298         assert(node->op == op_CopyB && data_type);
2299         node->attr.copyb.data_type = data_type;
2300 }
2301
2302
2303 ir_type *
2304 get_InstOf_type(ir_node *node) {
2305         assert(node->op = op_InstOf);
2306         return node->attr.instof.type;
2307 }
2308
2309 void
2310 set_InstOf_type(ir_node *node, ir_type *type) {
2311         assert(node->op = op_InstOf);
2312         node->attr.instof.type = type;
2313 }
2314
2315 ir_node *
2316 get_InstOf_store(ir_node *node) {
2317         assert(node->op = op_InstOf);
2318         return get_irn_n(node, 0);
2319 }
2320
2321 void
2322 set_InstOf_store(ir_node *node, ir_node *obj) {
2323         assert(node->op = op_InstOf);
2324         set_irn_n(node, 0, obj);
2325 }
2326
2327 ir_node *
2328 get_InstOf_obj(ir_node *node) {
2329         assert(node->op = op_InstOf);
2330         return get_irn_n(node, 1);
2331 }
2332
2333 void
2334 set_InstOf_obj(ir_node *node, ir_node *obj) {
2335         assert(node->op = op_InstOf);
2336         set_irn_n(node, 1, obj);
2337 }
2338
2339 /* Returns the memory input of a Raise operation. */
2340 ir_node *
2341 get_Raise_mem(ir_node *node) {
2342         assert(node->op == op_Raise);
2343         return get_irn_n(node, 0);
2344 }
2345
2346 void
2347 set_Raise_mem(ir_node *node, ir_node *mem) {
2348         assert(node->op == op_Raise);
2349         set_irn_n(node, 0, mem);
2350 }
2351
2352 ir_node *
2353 get_Raise_exo_ptr(ir_node *node) {
2354         assert(node->op == op_Raise);
2355         return get_irn_n(node, 1);
2356 }
2357
2358 void
2359 set_Raise_exo_ptr(ir_node *node, ir_node *exo_ptr) {
2360         assert(node->op == op_Raise);
2361         set_irn_n(node, 1, exo_ptr);
2362 }
2363
2364 /* Bound support */
2365
2366 /* Returns the memory input of a Bound operation. */
2367 ir_node *get_Bound_mem(ir_node *bound) {
2368         assert(bound->op == op_Bound);
2369         return get_irn_n(bound, 0);
2370 }
2371
2372 void set_Bound_mem(ir_node *bound, ir_node *mem) {
2373         assert(bound->op == op_Bound);
2374         set_irn_n(bound, 0, mem);
2375 }
2376
2377 /* Returns the index input of a Bound operation. */
2378 ir_node *get_Bound_index(ir_node *bound) {
2379         assert(bound->op == op_Bound);
2380         return get_irn_n(bound, 1);
2381 }
2382
2383 void set_Bound_index(ir_node *bound, ir_node *idx) {
2384         assert(bound->op == op_Bound);
2385         set_irn_n(bound, 1, idx);
2386 }
2387
2388 /* Returns the lower bound input of a Bound operation. */
2389 ir_node *get_Bound_lower(ir_node *bound) {
2390         assert(bound->op == op_Bound);
2391         return get_irn_n(bound, 2);
2392 }
2393
2394 void set_Bound_lower(ir_node *bound, ir_node *lower) {
2395         assert(bound->op == op_Bound);
2396         set_irn_n(bound, 2, lower);
2397 }
2398
2399 /* Returns the upper bound input of a Bound operation. */
2400 ir_node *get_Bound_upper(ir_node *bound) {
2401         assert(bound->op == op_Bound);
2402         return get_irn_n(bound, 3);
2403 }
2404
2405 void set_Bound_upper(ir_node *bound, ir_node *upper) {
2406         assert(bound->op == op_Bound);
2407         set_irn_n(bound, 3, upper);
2408 }
2409
2410 /* Return the operand of a Pin node. */
2411 ir_node *get_Pin_op(const ir_node *pin) {
2412         assert(pin->op == op_Pin);
2413         return get_irn_n(pin, 0);
2414 }
2415
2416 void set_Pin_op(ir_node *pin, ir_node *node) {
2417         assert(pin->op == op_Pin);
2418         set_irn_n(pin, 0, node);
2419 }
2420
2421 /* Return the assembler text of an ASM pseudo node. */
2422 ident *get_ASM_text(const ir_node *node) {
2423         assert(node->op == op_ASM);
2424         return node->attr.assem.asm_text;
2425 }
2426
2427 /* Return the number of input constraints for an ASM node. */
2428 int get_ASM_n_input_constraints(const ir_node *node) {
2429         assert(node->op == op_ASM);
2430         return ARR_LEN(node->attr.assem.inputs);
2431 }
2432
2433 /* Return the input constraints for an ASM node. This is a flexible array. */
2434 const ir_asm_constraint *get_ASM_input_constraints(const ir_node *node) {
2435         assert(node->op == op_ASM);
2436         return node->attr.assem.inputs;
2437 }
2438
2439 /* Return the number of output constraints for an ASM node.  */
2440 int get_ASM_n_output_constraints(const ir_node *node) {
2441         assert(node->op == op_ASM);
2442         return ARR_LEN(node->attr.assem.outputs);
2443 }
2444
2445 /* Return the output constraints for an ASM node. */
2446 const ir_asm_constraint *get_ASM_output_constraints(const ir_node *node) {
2447         assert(node->op == op_ASM);
2448         return node->attr.assem.outputs;
2449 }
2450
2451 /* Return the number of clobbered registers for an ASM node.  */
2452 int get_ASM_n_clobbers(const ir_node *node) {
2453         assert(node->op == op_ASM);
2454         return ARR_LEN(node->attr.assem.clobber);
2455 }
2456
2457 /* Return the list of clobbered registers for an ASM node. */
2458 ident **get_ASM_clobbers(const ir_node *node) {
2459         assert(node->op == op_ASM);
2460         return node->attr.assem.clobber;
2461 }
2462
2463 /* returns the graph of a node */
2464 ir_graph *
2465 get_irn_irg(const ir_node *node) {
2466         /*
2467          * Do not use get_nodes_Block() here, because this
2468          * will check the pinned state.
2469          * However even a 'wrong' block is always in the proper
2470          * irg.
2471          */
2472         if (! is_Block(node))
2473                 node = get_irn_n(node, -1);
2474         if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
2475                 node = get_irn_n(node, -1);
2476         assert(get_irn_op(node) == op_Block);
2477         return node->attr.block.irg;
2478 }
2479
2480
2481 /*----------------------------------------------------------------*/
2482 /*  Auxiliary routines                                            */
2483 /*----------------------------------------------------------------*/
2484
2485 ir_node *
2486 skip_Proj(ir_node *node) {
2487         /* don't assert node !!! */
2488         if (node == NULL)
2489                 return NULL;
2490
2491         if (is_Proj(node))
2492                 node = get_Proj_pred(node);
2493
2494         return node;
2495 }
2496
2497 const ir_node *
2498 skip_Proj_const(const ir_node *node) {
2499         /* don't assert node !!! */
2500         if (node == NULL)
2501                 return NULL;
2502
2503         if (is_Proj(node))
2504                 node = get_Proj_pred(node);
2505
2506         return node;
2507 }
2508
2509 ir_node *
2510 skip_Tuple(ir_node *node) {
2511   ir_node *pred;
2512   ir_op   *op;
2513
2514   if (!get_opt_normalize()) return node;
2515
2516 restart:
2517         if (get_irn_op(node) == op_Proj) {
2518             pred = get_Proj_pred(node);
2519             op   = get_irn_op(pred);
2520
2521                 /*
2522                  * Looks strange but calls get_irn_op() only once
2523                  * in most often cases.
2524                  */
2525                 if (op == op_Proj) { /* nested Tuple ? */
2526                     pred = skip_Tuple(pred);
2527                     op   = get_irn_op(pred);
2528
2529                         if (op == op_Tuple) {
2530                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
2531                                 goto restart;
2532                         }
2533                 } else if (op == op_Tuple) {
2534                         node = get_Tuple_pred(pred, get_Proj_proj(node));
2535                         goto restart;
2536                 }
2537         }
2538         return node;
2539 }
2540
2541 /* returns operand of node if node is a Cast */
2542 ir_node *skip_Cast(ir_node *node) {
2543         if (get_irn_op(node) == op_Cast)
2544                 return get_Cast_op(node);
2545         return node;
2546 }
2547
2548 /* returns operand of node if node is a Confirm */
2549 ir_node *skip_Confirm(ir_node *node) {
2550         if (get_irn_op(node) == op_Confirm)
2551                 return get_Confirm_value(node);
2552         return node;
2553 }
2554
2555 /* skip all high-level ops */
2556 ir_node *skip_HighLevel(ir_node *node) {
2557         if (is_op_highlevel(get_irn_op(node)))
2558                 return get_irn_n(node, 0);
2559         return node;
2560 }
2561
2562
2563 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
2564  * than any other approach, as Id chains are resolved and all point to the real node, or
2565  * all id's are self loops.
2566  *
2567  * Note: This function takes 10% of mostly ANY the compiler run, so it's
2568  * a little bit "hand optimized".
2569  *
2570  * Moreover, it CANNOT be switched off using get_opt_normalize() ...
2571  */
2572 ir_node *
2573 skip_Id(ir_node *node) {
2574         ir_node *pred;
2575         /* don't assert node !!! */
2576
2577         if (!node || (node->op != op_Id)) return node;
2578
2579         /* Don't use get_Id_pred():  We get into an endless loop for
2580            self-referencing Ids. */
2581         pred = node->in[0+1];
2582
2583         if (pred->op != op_Id) return pred;
2584
2585         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2586                 ir_node *rem_pred, *res;
2587
2588                 if (pred->op != op_Id) return pred; /* shortcut */
2589                 rem_pred = pred;
2590
2591                 assert(get_irn_arity (node) > 0);
2592
2593                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2594                 res = skip_Id(rem_pred);
2595                 if (res->op == op_Id) /* self-loop */ return node;
2596
2597                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2598                 return res;
2599         } else {
2600                 return node;
2601         }
2602 }
2603
2604 void skip_Id_and_store(ir_node **node) {
2605         ir_node *n = *node;
2606
2607         if (!n || (n->op != op_Id)) return;
2608
2609         /* Don't use get_Id_pred():  We get into an endless loop for
2610            self-referencing Ids. */
2611         *node = skip_Id(n);
2612 }
2613
2614 int
2615 (is_Bad)(const ir_node *node) {
2616         return _is_Bad(node);
2617 }
2618
2619 int
2620 (is_NoMem)(const ir_node *node) {
2621         return _is_NoMem(node);
2622 }
2623
2624 int
2625 (is_Minus)(const ir_node *node) {
2626         return _is_Minus(node);
2627 }
2628
2629 int
2630 (is_Mod)(const ir_node *node) {
2631         return _is_Mod(node);
2632 }
2633
2634 int
2635 (is_Div)(const ir_node *node) {
2636         return _is_Div(node);
2637 }
2638
2639 int
2640 (is_DivMod)(const ir_node *node) {
2641         return _is_DivMod(node);
2642 }
2643
2644 int
2645 (is_Quot)(const ir_node *node) {
2646         return _is_Quot(node);
2647 }
2648
2649 int
2650 (is_Add)(const ir_node *node) {
2651         return _is_Add(node);
2652 }
2653
2654 int
2655 (is_And)(const ir_node *node) {
2656         return _is_And(node);
2657 }
2658
2659 int
2660 (is_Or)(const ir_node *node) {
2661         return _is_Or(node);
2662 }
2663
2664 int
2665 (is_Eor)(const ir_node *node) {
2666         return _is_Eor(node);
2667 }
2668
2669 int
2670 (is_Sub)(const ir_node *node) {
2671         return _is_Sub(node);
2672 }
2673
2674 int
2675 (is_Shl)(const ir_node *node) {
2676         return _is_Shl(node);
2677 }
2678
2679 int
2680 (is_Shr)(const ir_node *node) {
2681         return _is_Shr(node);
2682 }
2683
2684 int
2685 (is_Shrs)(const ir_node *node) {
2686         return _is_Shrs(node);
2687 }
2688
2689 int
2690 (is_Rot)(const ir_node *node) {
2691         return _is_Rot(node);
2692 }
2693
2694 int
2695 (is_Not)(const ir_node *node) {
2696         return _is_Not(node);
2697 }
2698
2699 int
2700 (is_Psi)(const ir_node *node) {
2701         return _is_Psi(node);
2702 }
2703
2704 int
2705 (is_Tuple)(const ir_node *node) {
2706         return _is_Tuple(node);
2707 }
2708
2709 int
2710 (is_Start)(const ir_node *node) {
2711   return _is_Start(node);
2712 }
2713
2714 int
2715 (is_End)(const ir_node *node) {
2716         return _is_End(node);
2717 }
2718
2719 int
2720 (is_Const)(const ir_node *node) {
2721         return _is_Const(node);
2722 }
2723
2724 int
2725 (is_Conv)(const ir_node *node) {
2726         return _is_Conv(node);
2727 }
2728
2729 int
2730 (is_Cast)(const ir_node *node) {
2731         return _is_Cast(node);
2732 }
2733
2734 int
2735 (is_no_Block)(const ir_node *node) {
2736         return _is_no_Block(node);
2737 }
2738
2739 int
2740 (is_Block)(const ir_node *node) {
2741         return _is_Block(node);
2742 }
2743
2744 /* returns true if node is an Unknown node. */
2745 int
2746 (is_Unknown)(const ir_node *node) {
2747         return _is_Unknown(node);
2748 }
2749
2750 /* returns true if node is a Return node. */
2751 int
2752 (is_Return)(const ir_node *node) {
2753         return _is_Return(node);
2754 }
2755
2756 /* returns true if node is a Call node. */
2757 int
2758 (is_Call)(const ir_node *node) {
2759         return _is_Call(node);
2760 }
2761
2762 /* returns true if node is a Sel node. */
2763 int
2764 (is_Sel)(const ir_node *node) {
2765         return _is_Sel(node);
2766 }
2767
2768 /* returns true if node is a Mux node or a Psi with only one condition. */
2769 int
2770 (is_Mux)(const ir_node *node) {
2771         return _is_Mux(node);
2772 }
2773
2774 /* returns true if node is a Load node. */
2775 int
2776 (is_Load)(const ir_node *node) {
2777         return _is_Load(node);
2778 }
2779
2780 /* returns true if node is a Load node. */
2781 int
2782 (is_Store)(const ir_node *node) {
2783         return _is_Store(node);
2784 }
2785
2786 /* returns true if node is a Sync node. */
2787 int
2788 (is_Sync)(const ir_node *node) {
2789         return _is_Sync(node);
2790 }
2791
2792 /* returns true if node is a Confirm node. */
2793 int
2794 (is_Confirm)(const ir_node *node) {
2795         return _is_Confirm(node);
2796 }
2797
2798 /* returns true if node is a Pin node. */
2799 int
2800 (is_Pin)(const ir_node *node) {
2801         return _is_Pin(node);
2802 }
2803
2804 /* returns true if node is a SymConst node. */
2805 int
2806 (is_SymConst)(const ir_node *node) {
2807         return _is_SymConst(node);
2808 }
2809
2810 /* returns true if node is a Cond node. */
2811 int
2812 (is_Cond)(const ir_node *node) {
2813         return _is_Cond(node);
2814 }
2815
2816 int
2817 (is_CopyB)(const ir_node *node) {
2818         return _is_CopyB(node);
2819 }
2820
2821 /* returns true if node is a Cmp node. */
2822 int
2823 (is_Cmp)(const ir_node *node) {
2824         return _is_Cmp(node);
2825 }
2826
2827 /* returns true if node is an Alloc node. */
2828 int
2829 (is_Alloc)(const ir_node *node) {
2830         return _is_Alloc(node);
2831 }
2832
2833 /* returns true if a node is a Jmp node. */
2834 int
2835 (is_Jmp)(const ir_node *node) {
2836         return _is_Jmp(node);
2837 }
2838
2839 /* returns true if a node is a Raise node. */
2840 int
2841 (is_Raise)(const ir_node *node) {
2842         return _is_Raise(node);
2843 }
2844
2845 /* returns true if a node is an ASM node. */
2846 int
2847 (is_ASM)(const ir_node *node) {
2848         return _is_ASM(node);
2849 }
2850
2851 int
2852 (is_Proj)(const ir_node *node) {
2853         assert(node);
2854         return node->op == op_Proj ||
2855                (!get_interprocedural_view() && node->op == op_Filter);
2856 }
2857
2858 /* Returns true if the operation manipulates control flow. */
2859 int
2860 is_cfop(const ir_node *node) {
2861         return is_cfopcode(get_irn_op(node));
2862 }
2863
2864 /* Returns true if the operation manipulates interprocedural control flow:
2865    CallBegin, EndReg, EndExcept */
2866 int is_ip_cfop(const ir_node *node) {
2867         return is_ip_cfopcode(get_irn_op(node));
2868 }
2869
2870 /* Returns true if the operation can change the control flow because
2871    of an exception. */
2872 int
2873 is_fragile_op(const ir_node *node) {
2874         return is_op_fragile(get_irn_op(node));
2875 }
2876
2877 /* Returns the memory operand of fragile operations. */
2878 ir_node *get_fragile_op_mem(ir_node *node) {
2879         assert(node && is_fragile_op(node));
2880
2881         switch (get_irn_opcode(node)) {
2882         case iro_Call  :
2883         case iro_Quot  :
2884         case iro_DivMod:
2885         case iro_Div   :
2886         case iro_Mod   :
2887         case iro_Load  :
2888         case iro_Store :
2889         case iro_Alloc :
2890         case iro_Bound :
2891                 return get_irn_n(node, 0);
2892         case iro_Bad   :
2893         case iro_Unknown:
2894                 return node;
2895         default: ;
2896                 assert(0 && "should not be reached");
2897                 return NULL;
2898         }
2899 }
2900
2901 /* Returns the result mode of a Div operation. */
2902 ir_mode *get_divop_resmod(const ir_node *node) {
2903         switch (get_irn_opcode(node)) {
2904         case iro_Quot  : return get_Quot_resmode(node);
2905         case iro_DivMod: return get_DivMod_resmode(node);
2906         case iro_Div   : return get_Div_resmode(node);
2907         case iro_Mod   : return get_Mod_resmode(node);
2908         default: ;
2909                 assert(0 && "should not be reached");
2910                 return NULL;
2911         }
2912 }
2913
2914 /* Returns true if the operation is a forking control flow operation. */
2915 int (is_irn_forking)(const ir_node *node) {
2916         return _is_irn_forking(node);
2917 }
2918
2919 /* Return the type associated with the value produced by n
2920  * if the node remarks this type as it is the case for
2921  * Cast, Const, SymConst and some Proj nodes. */
2922 ir_type *(get_irn_type)(ir_node *node) {
2923         return _get_irn_type(node);
2924 }
2925
2926 /* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
2927    Cast) or NULL.*/
2928 ir_type *(get_irn_type_attr)(ir_node *node) {
2929         return _get_irn_type_attr(node);
2930 }
2931
2932 /* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
2933 ir_entity *(get_irn_entity_attr)(ir_node *node) {
2934         return _get_irn_entity_attr(node);
2935 }
2936
2937 /* Returns non-zero for constant-like nodes. */
2938 int (is_irn_constlike)(const ir_node *node) {
2939         return _is_irn_constlike(node);
2940 }
2941
2942 /*
2943  * Returns non-zero for nodes that are allowed to have keep-alives and
2944  * are neither Block nor PhiM.
2945  */
2946 int (is_irn_keep)(const ir_node *node) {
2947         return _is_irn_keep(node);
2948 }
2949
2950 /*
2951  * Returns non-zero for nodes that are always placed in the start block.
2952  */
2953 int (is_irn_start_block_placed)(const ir_node *node) {
2954         return _is_irn_start_block_placed(node);
2955 }
2956
2957 /* Returns non-zero for nodes that are machine operations. */
2958 int (is_irn_machine_op)(const ir_node *node) {
2959         return _is_irn_machine_op(node);
2960 }
2961
2962 /* Returns non-zero for nodes that are machine operands. */
2963 int (is_irn_machine_operand)(const ir_node *node) {
2964         return _is_irn_machine_operand(node);
2965 }
2966
2967 /* Returns non-zero for nodes that have the n'th user machine flag set. */
2968 int (is_irn_machine_user)(const ir_node *node, unsigned n) {
2969         return _is_irn_machine_user(node, n);
2970 }
2971
2972
2973 /* Gets the string representation of the jump prediction .*/
2974 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred) {
2975         switch (pred) {
2976         default:
2977         case COND_JMP_PRED_NONE:  return "no prediction";
2978         case COND_JMP_PRED_TRUE:  return "true taken";
2979         case COND_JMP_PRED_FALSE: return "false taken";
2980         }
2981 }
2982
2983 /* Returns the conditional jump prediction of a Cond node. */
2984 cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *cond) {
2985         return _get_Cond_jmp_pred(cond);
2986 }
2987
2988 /* Sets a new conditional jump prediction. */
2989 void (set_Cond_jmp_pred)(ir_node *cond, cond_jmp_predicate pred) {
2990         _set_Cond_jmp_pred(cond, pred);
2991 }
2992
2993 /** the get_type operation must be always implemented and return a firm type */
2994 static ir_type *get_Default_type(ir_node *n) {
2995         (void) n;
2996         return get_unknown_type();
2997 }
2998
2999 /* Sets the get_type operation for an ir_op_ops. */
3000 ir_op_ops *firm_set_default_get_type(ir_opcode code, ir_op_ops *ops) {
3001         switch (code) {
3002         case iro_Const:    ops->get_type = get_Const_type; break;
3003         case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
3004         case iro_Cast:     ops->get_type = get_Cast_type; break;
3005         case iro_Proj:     ops->get_type = get_Proj_type; break;
3006         default:
3007                 /* not allowed to be NULL */
3008                 if (! ops->get_type)
3009                         ops->get_type = get_Default_type;
3010                 break;
3011         }
3012         return ops;
3013 }
3014
3015 /** Return the attribute type of a SymConst node if exists */
3016 static ir_type *get_SymConst_attr_type(ir_node *self) {
3017         symconst_kind kind = get_SymConst_kind(self);
3018         if (SYMCONST_HAS_TYPE(kind))
3019                 return get_SymConst_type(self);
3020         return NULL;
3021 }
3022
3023 /** Return the attribute entity of a SymConst node if exists */
3024 static ir_entity *get_SymConst_attr_entity(ir_node *self) {
3025         symconst_kind kind = get_SymConst_kind(self);
3026         if (SYMCONST_HAS_ENT(kind))
3027                 return get_SymConst_entity(self);
3028         return NULL;
3029 }
3030
3031 /** the get_type_attr operation must be always implemented */
3032 static ir_type *get_Null_type(ir_node *n) {
3033         (void) n;
3034         return firm_unknown_type;
3035 }
3036
3037 /* Sets the get_type operation for an ir_op_ops. */
3038 ir_op_ops *firm_set_default_get_type_attr(ir_opcode code, ir_op_ops *ops) {
3039         switch (code) {
3040         case iro_SymConst: ops->get_type_attr = get_SymConst_attr_type; break;
3041         case iro_Call:     ops->get_type_attr = get_Call_type; break;
3042         case iro_Alloc:    ops->get_type_attr = get_Alloc_type; break;
3043         case iro_Free:     ops->get_type_attr = get_Free_type; break;
3044         case iro_Cast:     ops->get_type_attr = get_Cast_type; break;
3045         default:
3046                 /* not allowed to be NULL */
3047                 if (! ops->get_type_attr)
3048                         ops->get_type_attr = get_Null_type;
3049                 break;
3050         }
3051         return ops;
3052 }
3053
3054 /** the get_entity_attr operation must be always implemented */
3055 static ir_entity *get_Null_ent(ir_node *n) {
3056         (void) n;
3057         return NULL;
3058 }
3059
3060 /* Sets the get_type operation for an ir_op_ops. */
3061 ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
3062         switch (code) {
3063         case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
3064         case iro_Sel:      ops->get_entity_attr = get_Sel_entity; break;
3065         default:
3066                 /* not allowed to be NULL */
3067                 if (! ops->get_entity_attr)
3068                         ops->get_entity_attr = get_Null_ent;
3069                 break;
3070         }
3071         return ops;
3072 }
3073
3074 /* Sets the debug information of a node. */
3075 void (set_irn_dbg_info)(ir_node *n, dbg_info *db) {
3076         _set_irn_dbg_info(n, db);
3077 }
3078
3079 /**
3080  * Returns the debug information of an node.
3081  *
3082  * @param n   The node.
3083  */
3084 dbg_info *(get_irn_dbg_info)(const ir_node *n) {
3085         return _get_irn_dbg_info(n);
3086 }
3087
3088
3089
3090 #ifdef DEBUG_libfirm
3091 void dump_irn(ir_node *n) {
3092         int i, arity = get_irn_arity(n);
3093         printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
3094         if (!is_Block(n)) {
3095                 ir_node *pred = get_irn_n(n, -1);
3096                 printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
3097                         get_irn_node_nr(pred), (void *)pred);
3098         }
3099         printf("  preds: \n");
3100         for (i = 0; i < arity; ++i) {
3101                 ir_node *pred = get_irn_n(n, i);
3102                 printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
3103                         get_irn_node_nr(pred), (void *)pred);
3104         }
3105 }
3106
3107 #else  /* DEBUG_libfirm */
3108 void dump_irn(ir_node *n) {}
3109 #endif /* DEBUG_libfirm */