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