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

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