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

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