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

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