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

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