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

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