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
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 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 #include <string.h>
  17
  18 #include "ident.h"
  19 #include "irnode_t.h"
  20 #include "irgraph_t.h"
  21 #include "irmode_t.h"
  22 #include "typegmod.h"
  23 #include "irbackedge_t.h"
  24 #include "irdump.h"
  25 #include "irop_t.h"
  26 #include "irprog_t.h"
  27
  28 #include "firmstat.h"
  29
  30 /* some constants fixing the positions of nodes predecessors
  31    in the in array */
  32 #define CALL_PARAM_OFFSET     2
  33 #define FUNCCALL_PARAM_OFFSET 1
  34 #define SEL_INDEX_OFFSET      2
  35 #define RETURN_RESULT_OFFSET  1  /* mem is not a result */
  36 #define END_KEEPALIVE_OFFSET  0
  37
  38 static const char *pnc_name_arr [] = {
  39   "False", "Eq", "Lt", "Le",
  40   "Gt", "Ge", "Lg", "Leg", "Uo",
  41   "Ue", "Ul", "Ule", "Ug", "Uge",
  42   "Ne", "True"
  43 };
  44
  45 /**
  46  * returns the pnc name from an pnc constant
  47  */
  48 const char *get_pnc_string(int pnc) {
  49   return pnc_name_arr[pnc];
  50 }
  51
  52 /**
  53  * Calculates the negated pnc condition.
  54  */
  55 int
  56 get_negated_pnc(int pnc) {
  57   switch (pnc) {
  58   case False: return True;  break;
  59   case Eq:    return Ne;    break;
  60   case Lt:    return Uge;   break;
  61   case Le:    return Ug;    break;
  62   case Gt:    return Ule;   break;
  63   case Ge:    return Ul;    break;
  64   case Lg:    return Ue;    break;
  65   case Leg:   return Uo;    break;
  66   case Uo:    return Leg;   break;
  67   case Ue:    return Lg;    break;
  68   case Ul:    return Ge;    break;
  69   case Ule:   return Gt;    break;
  70   case Ug:    return Le;    break;
  71   case Uge:   return Lt;    break;
  72   case Ne:    return Eq;    break;
  73   case True:  return False; break;
  74   }
  75   return 99; /* to shut up gcc */
  76 }
  77
  78 const char *pns_name_arr [] = {
  79   "initial_exec", "global_store",
  80   "frame_base", "globals", "args"
  81 };
  82
  83 const char *symconst_name_arr [] = {
  84   "type_tag", "size", "addr_name", "addr_ent"
  85 };
  86
  87 void
  88 init_irnode (void)
  89 {
  90 }
  91
  92 /*
  93  * irnode constructor.
  94  * Create a new irnode in irg, with an op, mode, arity and
  95  * some incoming irnodes.
  96  * If arity is negative, a node with a dynamic array is created.
  97  */
  98 ir_node *
  99 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
 100          int arity, ir_node **in)
 101 {
 102   ir_node *res;
 103   int node_size = offsetof (ir_node, attr) +  op->attr_size;
 104
 105   assert(irg && op && mode);
 106   res = (ir_node *) obstack_alloc (irg->obst, node_size);
 107   memset((void *)res, 0, node_size);
 108
 109   res->kind = k_ir_node;
 110   res->op = op;
 111   res->mode = mode;
 112   res->visited = 0;
 113   res->link = NULL;
 114   if (arity < 0) {
 115     res->in = NEW_ARR_F (ir_node *, 1);  /* 1: space for block */
 116   } else {
 117     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
 118     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
 119   }
 120   res->in[0] = block;
 121   set_irn_dbg_info(res, db);
 122   res->out = NULL;
 123
 124 #ifdef DEBUG_libfirm
 125   res->node_nr = get_irp_new_node_nr();
 126 #endif
 127
 128   stat_new_node(res);
 129
 130   return res;
 131 }
 132
 133 /* Copies all attributes stored in the old node to the new node.
 134    Assumes both have the same opcode and sufficient size. */
 135 void
 136 copy_attrs (const ir_node *old_node, ir_node *new_node) {
 137   assert(get_irn_op(old_node) == get_irn_op(new_node));
 138   memcpy(&new_node->attr, &old_node->attr, get_op_attr_size(get_irn_op(old_node)));
 139 }
 140
 141 /*-- getting some parameters from ir_nodes --*/
 142
 143 int
 144 (is_ir_node)(const void *thing) {
 145   return __is_ir_node(thing);
 146 }
 147
 148 int
 149 (get_irn_intra_arity)(const ir_node *node) {
 150   return __get_irn_intra_arity(node);
 151 }
 152
 153 int
 154 (get_irn_inter_arity)(const ir_node *node) {
 155   return __get_irn_inter_arity(node);
 156 }
 157
 158 int
 159 (get_irn_arity)(const ir_node *node) {
 160   return __get_irn_arity(node);
 161 }
 162
 163 /* Returns the array with ins. This array is shifted with respect to the
 164    array accessed by get_irn_n: The block operand is at position 0 not -1.
 165    (@@@ This should be changed.)
 166    The order of the predecessors in this array is not guaranteed, except that
 167    lists of operands as predecessors of Block or arguments of a Call are
 168    consecutive. */
 169 ir_node **
 170 get_irn_in (const ir_node *node) {
 171   assert(node);
 172   if (interprocedural_view) { /* handle Filter and Block specially */
 173     if (get_irn_opcode(node) == iro_Filter) {
 174       assert(node->attr.filter.in_cg);
 175       return node->attr.filter.in_cg;
 176     } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
 177       return node->attr.block.in_cg;
 178     }
 179     /* else fall through */
 180   }
 181   return node->in;
 182 }
 183
 184 void
 185 set_irn_in (ir_node *node, int arity, ir_node **in) {
 186   ir_node *** arr;
 187   assert(node);
 188   if (interprocedural_view) { /* handle Filter and Block specially */
 189     if (get_irn_opcode(node) == iro_Filter) {
 190       assert(node->attr.filter.in_cg);
 191       arr = &node->attr.filter.in_cg;
 192     } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
 193       arr = &node->attr.block.in_cg;
 194     } else {
 195       arr = &node->in;
 196     }
 197   } else {
 198     arr = &node->in;
 199   }
 200   if (arity != ARR_LEN(*arr) - 1) {
 201     ir_node * block = (*arr)[0];
 202     *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
 203     (*arr)[0] = block;
 204   }
 205   fix_backedges(current_ir_graph->obst, node);
 206   memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
 207 }
 208
 209 ir_node *
 210 (get_irn_intra_n)(ir_node *node, int n) {
 211   return __get_irn_intra_n (node, n);
 212 }
 213
 214 ir_node *
 215 (get_irn_inter_n)(ir_node *node, int n) {
 216   return __get_irn_inter_n (node, n);
 217 }
 218
 219 ir_node *
 220 (get_irn_n)(ir_node *node, int n) {
 221   return __get_irn_n (node, n);
 222 }
 223
 224 void
 225 set_irn_n (ir_node *node, int n, ir_node *in) {
 226   assert(node && node->kind == k_ir_node && -1 <= n && n < get_irn_arity(node));
 227   assert(in && in->kind == k_ir_node);
 228   if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
 229     /* Change block pred in both views! */
 230     node->in[n + 1] = in;
 231     assert(node->attr.filter.in_cg);
 232     node->attr.filter.in_cg[n + 1] = in;
 233     return;
 234   }
 235   if (interprocedural_view) { /* handle Filter and Block specially */
 236     if (get_irn_opcode(node) == iro_Filter) {
 237       assert(node->attr.filter.in_cg);
 238       node->attr.filter.in_cg[n + 1] = in;
 239       return;
 240     } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
 241       node->attr.block.in_cg[n + 1] = in;
 242       return;
 243     }
 244     /* else fall through */
 245   }
 246   node->in[n + 1] = in;
 247 }
 248
 249 ir_mode *
 250 (get_irn_mode)(const ir_node *node) {
 251   return __get_irn_mode(node);
 252 }
 253
 254 void
 255 (set_irn_mode)(ir_node *node, ir_mode *mode)
 256 {
 257   __set_irn_mode(node, mode);
 258 }
 259
 260 modecode
 261 get_irn_modecode (const ir_node *node)
 262 {
 263   assert (node);
 264   return node->mode->code;
 265 }
 266
 267 /** Gets the string representation of the mode .*/
 268 const char *
 269 get_irn_modename (const ir_node *node)
 270 {
 271   assert(node);
 272   return get_mode_name(node->mode);
 273 }
 274
 275 ident *
 276 get_irn_modeident (const ir_node *node)
 277 {
 278   assert(node);
 279   return get_mode_ident(node->mode);
 280 }
 281
 282 ir_op *
 283 (get_irn_op)(const ir_node *node)
 284 {
 285   return __get_irn_op(node);
 286 }
 287
 288 /* should be private to the library: */
 289 void
 290 set_irn_op (ir_node *node, ir_op *op)
 291 {
 292   assert (node);
 293   node->op = op;
 294 }
 295
 296 opcode
 297 (get_irn_opcode)(const ir_node *node)
 298 {
 299   return __get_irn_opcode(node);
 300 }
 301
 302 const char *
 303 get_irn_opname (const ir_node *node)
 304 {
 305   assert(node);
 306   if ((get_irn_op((ir_node *)node) == op_Phi) &&
 307       (get_irg_phase_state(get_irn_irg((ir_node *)node)) == phase_building) &&
 308       (get_irn_arity((ir_node *)node) == 0)) return "Phi0";
 309   return get_id_str(node->op->name);
 310 }
 311
 312 ident *
 313 get_irn_opident (const ir_node *node)
 314 {
 315   assert(node);
 316   return node->op->name;
 317 }
 318
 319 unsigned long
 320 (get_irn_visited)(const ir_node *node)
 321 {
 322   return __get_irn_visited(node);
 323 }
 324
 325 void
 326 (set_irn_visited)(ir_node *node, unsigned long visited)
 327 {
 328   __set_irn_visited(node, visited);
 329 }
 330
 331 void
 332 (mark_irn_visited)(ir_node *node) {
 333   __mark_irn_visited(node);
 334 }
 335
 336 int
 337 (irn_not_visited)(const ir_node *node) {
 338   return __irn_not_visited(node);
 339 }
 340
 341 int
 342 (irn_visited)(const ir_node *node) {
 343   return __irn_visited(node);
 344 }
 345
 346 void
 347 (set_irn_link)(ir_node *node, void *link) {
 348   __set_irn_link(node, link);
 349 }
 350
 351 void *
 352 (get_irn_link)(const ir_node *node) {
 353   return __get_irn_link(node);
 354 }
 355
 356 op_pin_state
 357 (get_irn_pinned)(const ir_node *node) {
 358   return __get_irn_pinned(node);
 359 }
 360
 361 void set_irn_pinned(ir_node *node, op_pin_state state) {
 362   /* due to optimization an opt may be turned into a Tuple */
 363   if (get_irn_op(node) == op_Tuple)
 364     return;
 365
 366   assert(node && get_op_pinned(get_irn_op(node)) == op_pin_state_exc_pinned);
 367   assert(state == op_pin_state_pinned || state == op_pin_state_floats);
 368
 369   node->attr.except.pin_state = state;
 370 }
 371
 372 #ifdef DO_HEAPANALYSIS
 373 /* Access the abstract interpretation information of a node.
 374    Returns NULL if no such information is available. */
 375 struct abstval *get_irn_abst_value(ir_node *n) {
 376   return n->av;
 377 }
 378 /* Set the abstract interpretation information of a node. */
 379 void set_irn_abst_value(ir_node *n, struct abstval *os) {
 380   n->av = os;
 381 }
 382 struct section *firm_get_irn_section(ir_node *n) {
 383   return n->sec;
 384 }
 385 void firm_set_irn_section(ir_node *n, struct section *s) {
 386   n->sec = s;
 387 }
 388 #endif /* DO_HEAPANALYSIS */
 389
 390
 391 /* Outputs a unique number for this node */
 392 long
 393 get_irn_node_nr(const ir_node *node) {
 394   assert(node);
 395 #ifdef DEBUG_libfirm
 396   return node->node_nr;
 397 #else
 398   return (long)node;
 399 #endif
 400 }
 401
 402 const_attr
 403 get_irn_const_attr (ir_node *node)
 404 {
 405   assert (node->op == op_Const);
 406   return node->attr.con;
 407 }
 408
 409 long
 410 get_irn_proj_attr (ir_node *node)
 411 {
 412   assert (node->op == op_Proj);
 413   return node->attr.proj;
 414 }
 415
 416 alloc_attr
 417 get_irn_alloc_attr (ir_node *node)
 418 {
 419   assert (node->op == op_Alloc);
 420   return node->attr.a;
 421 }
 422
 423 type *
 424 get_irn_free_attr     (ir_node *node)
 425 {
 426   assert (node->op == op_Free);
 427   return node->attr.f = skip_tid(node->attr.f);
 428 }
 429
 430 symconst_attr
 431 get_irn_symconst_attr (ir_node *node)
 432 {
 433   assert (node->op == op_SymConst);
 434   return node->attr.i;
 435 }
 436
 437 type *
 438 get_irn_call_attr (ir_node *node)
 439 {
 440   assert (node->op == op_Call);
 441   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 442 }
 443
 444 type *
 445 get_irn_funccall_attr (ir_node *node)
 446 {
 447   assert (node->op == op_FuncCall);
 448   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 449 }
 450
 451 sel_attr
 452 get_irn_sel_attr (ir_node *node)
 453 {
 454   assert (node->op == op_Sel);
 455   return node->attr.s;
 456 }
 457
 458 int
 459 get_irn_phi_attr (ir_node *node)
 460 {
 461   assert (node->op == op_Phi);
 462   return node->attr.phi0_pos;
 463 }
 464
 465 block_attr
 466 get_irn_block_attr (ir_node *node)
 467 {
 468   assert (node->op == op_Block);
 469   return node->attr.block;
 470 }
 471
 472 load_attr
 473 get_irn_load_attr (ir_node *node)
 474 {
 475   assert (node->op == op_Load);
 476   return node->attr.load;
 477 }
 478
 479 store_attr
 480 get_irn_store_attr (ir_node *node)
 481 {
 482   assert (node->op == op_Store);
 483   return node->attr.store;
 484 }
 485
 486 except_attr
 487 get_irn_except_attr (ir_node *node)
 488 {
 489   assert (node->op == op_Div || node->op == op_Quot ||
 490           node->op == op_DivMod || node->op == op_Mod);
 491   return node->attr.except;
 492 }
 493
 494 /** manipulate fields of individual nodes **/
 495
 496 /* this works for all except Block */
 497 ir_node *
 498 get_nodes_block (ir_node *node) {
 499   assert (!(node->op == op_Block));
 500   return get_irn_n(node, -1);
 501 }
 502
 503 void
 504 set_nodes_block (ir_node *node, ir_node *block) {
 505   assert (!(node->op == op_Block));
 506   set_irn_n(node, -1, block);
 507 }
 508
 509 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
 510  * from Start.  If so returns frame type, else Null. */
 511 type *is_frame_pointer(ir_node *n) {
 512   if ((get_irn_op(n) == op_Proj) &&
 513       (get_Proj_proj(n) == pn_Start_P_frame_base)) {
 514     ir_node *start = get_Proj_pred(n);
 515     if (get_irn_op(start) == op_Start) {
 516       return get_irg_frame_type(get_irn_irg(start));
 517     }
 518   }
 519   return NULL;
 520 }
 521
 522 /* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
 523  * from Start.  If so returns global type, else Null. */
 524 type *is_globals_pointer(ir_node *n) {
 525   if ((get_irn_op(n) == op_Proj) &&
 526       (get_Proj_proj(n) == pn_Start_P_globals)) {
 527     ir_node *start = get_Proj_pred(n);
 528     if (get_irn_op(start) == op_Start) {
 529       return get_glob_type();
 530     }
 531   }
 532   return NULL;
 533 }
 534
 535 /* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
 536  * from Start.  If so returns 1, else 0. */
 537 int is_value_arg_pointer(ir_node *n) {
 538   if ((get_irn_op(n) == op_Proj) &&
 539       (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
 540       (get_irn_op(get_Proj_pred(n)) == op_Start))
 541     return 1;
 542   return 0;
 543 }
 544
 545 /* Returns an array with the predecessors of the Block. Depending on
 546    the implementation of the graph data structure this can be a copy of
 547    the internal representation of predecessors as well as the internal
 548    array itself. Therefore writing to this array might obstruct the ir. */
 549 ir_node **
 550 get_Block_cfgpred_arr (ir_node *node)
 551 {
 552   assert ((node->op == op_Block));
 553   return (ir_node **)&(get_irn_in(node)[1]);
 554 }
 555
 556
 557 int
 558 get_Block_n_cfgpreds (ir_node *node) {
 559   assert ((node->op == op_Block));
 560   return get_irn_arity(node);
 561 }
 562
 563 ir_node *
 564 get_Block_cfgpred (ir_node *node, int pos) {
 565   assert(node);
 566   assert (node->op == op_Block);
 567   assert(-1 <= pos && pos < get_irn_arity(node));
 568   return get_irn_n(node, pos);
 569 }
 570
 571 void
 572 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
 573   assert (node->op == op_Block);
 574   set_irn_n(node, pos, pred);
 575 }
 576
 577 bool
 578 get_Block_matured (ir_node *node) {
 579   assert (node->op == op_Block);
 580   return node->attr.block.matured;
 581 }
 582
 583 void
 584 set_Block_matured (ir_node *node, bool matured) {
 585   assert (node->op == op_Block);
 586   node->attr.block.matured = matured;
 587 }
 588 unsigned long
 589 get_Block_block_visited (ir_node *node) {
 590   assert (node->op == op_Block);
 591   return node->attr.block.block_visited;
 592 }
 593
 594 void
 595 set_Block_block_visited (ir_node *node, unsigned long visit) {
 596   assert (node->op == op_Block);
 597   node->attr.block.block_visited = visit;
 598 }
 599
 600 /* For this current_ir_graph must be set. */
 601 void
 602 mark_Block_block_visited (ir_node *node) {
 603   assert (node->op == op_Block);
 604   node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
 605 }
 606
 607 int
 608 Block_not_block_visited(ir_node *node) {
 609   assert (node->op == op_Block);
 610   return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
 611 }
 612
 613 ir_node *
 614 get_Block_graph_arr (ir_node *node, int pos) {
 615   assert (node->op == op_Block);
 616   return node->attr.block.graph_arr[pos+1];
 617 }
 618
 619 void
 620 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
 621   assert (node->op == op_Block);
 622   node->attr.block.graph_arr[pos+1] = value;
 623 }
 624
 625 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
 626   assert(node->op == op_Block);
 627   if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
 628     node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
 629     node->attr.block.in_cg[0] = NULL;
 630     node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
 631     {
 632       /* Fix backedge array.  fix_backedges operates depending on
 633      interprocedural_view. */
 634       bool ipv = interprocedural_view;
 635       interprocedural_view = true;
 636       fix_backedges(current_ir_graph->obst, node);
 637       interprocedural_view = ipv;
 638     }
 639   }
 640   memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
 641 }
 642
 643 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
 644   assert(node->op == op_Block &&
 645      node->attr.block.in_cg &&
 646      0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
 647   node->attr.block.in_cg[pos + 1] = pred;
 648 }
 649
 650 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
 651   assert(node->op == op_Block);
 652   return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg  + 1;
 653 }
 654
 655 int get_Block_cg_n_cfgpreds(ir_node * node) {
 656   assert(node->op == op_Block);
 657   return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
 658 }
 659
 660 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
 661   assert(node->op == op_Block && node->attr.block.in_cg);
 662   return node->attr.block.in_cg[pos + 1];
 663 }
 664
 665 void remove_Block_cg_cfgpred_arr(ir_node * node) {
 666   assert(node->op == op_Block);
 667   node->attr.block.in_cg = NULL;
 668 }
 669
 670 void
 671 set_Start_irg(ir_node *node, ir_graph *irg) {
 672   assert(node->op == op_Start);
 673   assert(is_ir_graph(irg));
 674   assert(0 && " Why set irg? -- use set_irn_irg");
 675 }
 676
 677 int
 678 get_End_n_keepalives(ir_node *end) {
 679   assert (end->op == op_End);
 680   return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
 681 }
 682
 683 ir_node *
 684 get_End_keepalive(ir_node *end, int pos) {
 685   assert (end->op == op_End);
 686   return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
 687 }
 688
 689 void
 690 add_End_keepalive (ir_node *end, ir_node *ka) {
 691   assert (end->op == op_End);
 692   ARR_APP1 (ir_node *, end->in, ka);
 693 }
 694
 695 void
 696 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
 697   assert (end->op == op_End);
 698   set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 699 }
 700
 701 void
 702 free_End (ir_node *end) {
 703   assert (end->op == op_End);
 704   end->kind = k_BAD;
 705   DEL_ARR_F(end->in);  /* GL @@@ tut nicht ! */
 706   end->in = NULL;   /* @@@ make sure we get an error if we use the
 707                in array afterwards ... */
 708 }
 709
 710
 711 /*
 712 > Implementing the case construct (which is where the constant Proj node is
 713 > important) involves far more than simply determining the constant values.
 714 > We could argue that this is more properly a function of the translator from
 715 > Firm to the target machine.  That could be done if there was some way of
 716 > projecting "default" out of the Cond node.
 717 I know it's complicated.
 718 Basically there are two proglems:
 719  - determining the gaps between the projs
 720  - determining the biggest case constant to know the proj number for
 721    the default node.
 722 I see several solutions:
 723 1. Introduce a ProjDefault node.  Solves both problems.
 724    This means to extend all optimizations executed during construction.
 725 2. Give the Cond node for switch two flavors:
 726    a) there are no gaps in the projs  (existing flavor)
 727    b) gaps may exist, default proj is still the Proj with the largest
 728       projection number.  This covers also the gaps.
 729 3. Fix the semantic of the Cond to that of 2b)
 730
 731 Solution 2 seems to be the best:
 732 Computing the gaps in the Firm representation is not too hard, i.e.,
 733 libFIRM can implement a routine that transforms between the two
 734 flavours.  This is also possible for 1) but 2) does not require to
 735 change any existing optimization.
 736 Further it should be far simpler to determine the biggest constant than
 737 to compute all gaps.
 738 I don't want to choose 3) as 2a) seems to have advantages for
 739 dataflow analysis and 3) does not allow to convert the representation to
 740 2a).
 741 */
 742 ir_node *
 743 get_Cond_selector (ir_node *node) {
 744   assert (node->op == op_Cond);
 745   return get_irn_n(node, 0);
 746 }
 747
 748 void
 749 set_Cond_selector (ir_node *node, ir_node *selector) {
 750   assert (node->op == op_Cond);
 751   set_irn_n(node, 0, selector);
 752 }
 753
 754 cond_kind
 755 get_Cond_kind (ir_node *node) {
 756   assert (node->op == op_Cond);
 757   return node->attr.c.kind;
 758 }
 759
 760 void
 761 set_Cond_kind (ir_node *node, cond_kind kind) {
 762   assert (node->op == op_Cond);
 763   node->attr.c.kind = kind;
 764 }
 765
 766 long
 767 get_Cond_defaultProj (ir_node *node) {
 768   assert (node->op == op_Cond);
 769   return node->attr.c.default_proj;
 770 }
 771
 772 ir_node *
 773 get_Return_mem (ir_node *node) {
 774   assert (node->op == op_Return);
 775   return get_irn_n(node, 0);
 776 }
 777
 778 void
 779 set_Return_mem (ir_node *node, ir_node *mem) {
 780   assert (node->op == op_Return);
 781   set_irn_n(node, 0, mem);
 782 }
 783
 784 int
 785 get_Return_n_ress (ir_node *node) {
 786   assert (node->op == op_Return);
 787   return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
 788 }
 789
 790 ir_node **
 791 get_Return_res_arr (ir_node *node)
 792 {
 793   assert ((node->op == op_Return));
 794   if (get_Return_n_ress(node) > 0)
 795     return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
 796   else
 797     return NULL;
 798 }
 799
 800 /*
 801 void
 802 set_Return_n_res (ir_node *node, int results) {
 803   assert (node->op == op_Return);
 804 }
 805 */
 806
 807 ir_node *
 808 get_Return_res (ir_node *node, int pos) {
 809   assert (node->op == op_Return);
 810   assert (get_Return_n_ress(node) > pos);
 811   return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
 812 }
 813
 814 void
 815 set_Return_res (ir_node *node, int pos, ir_node *res){
 816   assert (node->op == op_Return);
 817   set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
 818 }
 819
 820 ir_node *
 821 get_Raise_mem (ir_node *node) {
 822   assert (node->op == op_Raise);
 823   return get_irn_n(node, 0);
 824 }
 825
 826 void
 827 set_Raise_mem (ir_node *node, ir_node *mem) {
 828   assert (node->op == op_Raise);
 829   set_irn_n(node, 0, mem);
 830 }
 831
 832 ir_node *
 833 get_Raise_exo_ptr (ir_node *node) {
 834   assert (node->op == op_Raise);
 835   return get_irn_n(node, 1);
 836 }
 837
 838 void
 839 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
 840   assert (node->op == op_Raise);
 841   set_irn_n(node, 1, exo_ptr);
 842 }
 843
 844 tarval *get_Const_tarval (ir_node *node) {
 845   assert (node->op == op_Const);
 846   return node->attr.con.tv;
 847 }
 848
 849 void
 850 set_Const_tarval (ir_node *node, tarval *con) {
 851   assert (node->op == op_Const);
 852   node->attr.con.tv = con;
 853 }
 854
 855
 856 /* The source language type.  Must be an atomic type.  Mode of type must
 857    be mode of node. For tarvals from entities type must be pointer to
 858    entity type. */
 859 type *
 860 get_Const_type (ir_node *node) {
 861   assert (node->op == op_Const);
 862   return node->attr.con.tp;
 863 }
 864
 865 void
 866 set_Const_type (ir_node *node, type *tp) {
 867   assert (node->op == op_Const);
 868   if (tp != unknown_type) {
 869     assert (is_atomic_type(tp));
 870     assert (get_type_mode(tp) == get_irn_mode(node));
 871   }
 872
 873   if ((get_irn_node_nr(node) == 259216) && (tp == unknown_type))
 874     assert(0);
 875
 876
 877   node->attr.con.tp = tp;
 878 }
 879
 880
 881 symconst_kind
 882 get_SymConst_kind (const ir_node *node) {
 883   assert (node->op == op_SymConst);
 884   return node->attr.i.num;
 885 }
 886
 887 void
 888 set_SymConst_kind (ir_node *node, symconst_kind num) {
 889   assert (node->op == op_SymConst);
 890   node->attr.i.num = num;
 891 }
 892
 893 type *
 894 get_SymConst_type (ir_node *node) {
 895   assert (   (node->op == op_SymConst)
 896           && (   get_SymConst_kind(node) == symconst_type_tag
 897               || get_SymConst_kind(node) == symconst_size));
 898   return node->attr.i.sym.type_p = skip_tid(node->attr.i.sym.type_p);
 899 }
 900
 901 void
 902 set_SymConst_type (ir_node *node, type *tp) {
 903   assert (   (node->op == op_SymConst)
 904           && (   get_SymConst_kind(node) == symconst_type_tag
 905               || get_SymConst_kind(node) == symconst_size));
 906   node->attr.i.sym.type_p = tp;
 907 }
 908
 909 ident *
 910 get_SymConst_name (ir_node *node) {
 911   assert (   (node->op == op_SymConst)
 912           && (get_SymConst_kind(node) == symconst_addr_name));
 913   return node->attr.i.sym.ident_p;
 914 }
 915
 916 void
 917 set_SymConst_name (ir_node *node, ident *name) {
 918   assert (   (node->op == op_SymConst)
 919           && (get_SymConst_kind(node) == symconst_addr_name));
 920   node->attr.i.sym.ident_p = name;
 921 }
 922
 923
 924 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
 925 entity   *get_SymConst_entity (ir_node *node) {
 926   assert (   (node->op == op_SymConst)
 927           && (get_SymConst_kind (node) == symconst_addr_ent));
 928   return node->attr.i.sym.entity_p;
 929 }
 930
 931 void     set_SymConst_entity (ir_node *node, entity *ent) {
 932   assert (   (node->op == op_SymConst)
 933           && (get_SymConst_kind(node) == symconst_addr_ent));
 934   node->attr.i.sym.entity_p  = ent;
 935 }
 936
 937 union symconst_symbol
 938 get_SymConst_symbol (ir_node *node) {
 939   assert (node->op == op_SymConst);
 940   return node->attr.i.sym;
 941 }
 942
 943 void
 944 set_SymConst_symbol (ir_node *node, union symconst_symbol sym) {
 945   assert (node->op == op_SymConst);
 946   //memcpy (&(node->attr.i.sym), sym, sizeof(type_or_id));
 947   node->attr.i.sym = sym;
 948 }
 949
 950 type *
 951 get_SymConst_value_type (ir_node *node) {
 952   assert (node->op == op_SymConst);
 953   return node->attr.i.tp = skip_tid(node->attr.i.tp);
 954 }
 955
 956 void
 957 set_SymConst_value_type (ir_node *node, type *tp) {
 958   assert (node->op == op_SymConst);
 959   node->attr.i.tp = tp;
 960 }
 961
 962 ir_node *
 963 get_Sel_mem (ir_node *node) {
 964   assert (node->op == op_Sel);
 965   return get_irn_n(node, 0);
 966 }
 967
 968 void
 969 set_Sel_mem (ir_node *node, ir_node *mem) {
 970   assert (node->op == op_Sel);
 971   set_irn_n(node, 0, mem);
 972 }
 973
 974 ir_node *
 975 get_Sel_ptr (ir_node *node) {
 976   assert (node->op == op_Sel);
 977   return get_irn_n(node, 1);
 978 }
 979
 980 void
 981 set_Sel_ptr (ir_node *node, ir_node *ptr) {
 982   assert (node->op == op_Sel);
 983   set_irn_n(node, 1, ptr);
 984 }
 985
 986 int
 987 get_Sel_n_indexs (ir_node *node) {
 988   assert (node->op == op_Sel);
 989   return (get_irn_arity(node) - SEL_INDEX_OFFSET);
 990 }
 991
 992 ir_node **
 993 get_Sel_index_arr (ir_node *node)
 994 {
 995   assert ((node->op == op_Sel));
 996   if (get_Sel_n_indexs(node) > 0)
 997     return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
 998   else
 999     return NULL;
1000 }
1001
1002 ir_node *
1003 get_Sel_index (ir_node *node, int pos) {
1004   assert (node->op == op_Sel);
1005   return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1006 }
1007
1008 void
1009 set_Sel_index (ir_node *node, int pos, ir_node *index) {
1010   assert (node->op == op_Sel);
1011   set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1012 }
1013
1014 entity *
1015 get_Sel_entity (ir_node *node) {
1016   assert (node->op == op_Sel);
1017   return node->attr.s.ent;
1018 }
1019
1020 void
1021 set_Sel_entity (ir_node *node, entity *ent) {
1022   assert (node->op == op_Sel);
1023   node->attr.s.ent = ent;
1024 }
1025
1026 type *
1027 get_InstOf_ent (ir_node *node) {
1028   assert (node->op = op_InstOf);
1029   return (node->attr.io.ent);
1030 }
1031
1032 void
1033 set_InstOf_ent (ir_node *node, type *ent) {
1034   assert (node->op = op_InstOf);
1035   node->attr.io.ent = ent;
1036 }
1037
1038 ir_node *
1039 get_InstOf_store (ir_node *node) {
1040   assert (node->op = op_InstOf);
1041   return (get_irn_n (node, 0));
1042 }
1043
1044 void
1045 set_InstOf_store (ir_node *node, ir_node *obj) {
1046   assert (node->op = op_InstOf);
1047   set_irn_n (node, 0, obj);
1048 }
1049
1050 ir_node *
1051 get_InstOf_obj (ir_node *node) {
1052   assert (node->op = op_InstOf);
1053   return (get_irn_n (node, 1));
1054 }
1055
1056 void
1057 set_InstOf_obj (ir_node *node, ir_node *obj) {
1058   assert (node->op = op_InstOf);
1059   set_irn_n (node, 1, obj);
1060 }
1061
1062
1063 /* For unary and binary arithmetic operations the access to the
1064    operands can be factored out.  Left is the first, right the
1065    second arithmetic value  as listed in tech report 0999-33.
1066    unops are: Minus, Abs, Not, Conv, Cast
1067    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1068    Shr, Shrs, Rotate, Cmp */
1069
1070
1071 ir_node *
1072 get_Call_mem (ir_node *node) {
1073   assert (node->op == op_Call);
1074   return get_irn_n(node, 0);
1075 }
1076
1077 void
1078 set_Call_mem (ir_node *node, ir_node *mem) {
1079   assert (node->op == op_Call);
1080   set_irn_n(node, 0, mem);
1081 }
1082
1083 ir_node *
1084 get_Call_ptr (ir_node *node) {
1085   assert (node->op == op_Call);
1086   return get_irn_n(node, 1);
1087 }
1088
1089 void
1090 set_Call_ptr (ir_node *node, ir_node *ptr) {
1091   assert (node->op == op_Call);
1092   set_irn_n(node, 1, ptr);
1093 }
1094
1095 ir_node **
1096 get_Call_param_arr (ir_node *node) {
1097   assert (node->op == op_Call);
1098   return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1099 }
1100
1101 int
1102 get_Call_n_params (ir_node *node)  {
1103   assert (node->op == op_Call);
1104   return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1105 }
1106
1107 int
1108 get_Call_arity (ir_node *node) {
1109   assert (node->op == op_Call);
1110   return get_Call_n_params(node);
1111 }
1112
1113 /* void
1114 set_Call_arity (ir_node *node, ir_node *arity) {
1115   assert (node->op == op_Call);
1116 }
1117 */
1118
1119 ir_node *
1120 get_Call_param (ir_node *node, int pos) {
1121   assert (node->op == op_Call);
1122   return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1123 }
1124
1125 void
1126 set_Call_param (ir_node *node, int pos, ir_node *param) {
1127   assert (node->op == op_Call);
1128   set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1129 }
1130
1131 type *
1132 get_Call_type (ir_node *node) {
1133   assert (node->op == op_Call);
1134   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1135 }
1136
1137 void
1138 set_Call_type (ir_node *node, type *tp) {
1139   assert (node->op == op_Call);
1140   assert ((get_unknown_type() == tp) || is_method_type(tp));
1141   node->attr.call.cld_tp = tp;
1142 }
1143
1144 int Call_has_callees(ir_node *node) {
1145   assert(node && node->op == op_Call);
1146   return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1147       (node->attr.call.callee_arr != NULL));
1148 }
1149
1150 int get_Call_n_callees(ir_node * node) {
1151   assert(node && node->op == op_Call && node->attr.call.callee_arr);
1152   return ARR_LEN(node->attr.call.callee_arr);
1153 }
1154
1155 entity * get_Call_callee(ir_node * node, int pos) {
1156   assert(pos >= 0 && pos < get_Call_n_callees(node));
1157   return node->attr.call.callee_arr[pos];
1158 }
1159
1160 void set_Call_callee_arr(ir_node * node, const int n, entity ** arr) {
1161   assert(node->op == op_Call);
1162   if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1163     node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1164   }
1165   memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1166 }
1167
1168 void remove_Call_callee_arr(ir_node * node) {
1169   assert(node->op == op_Call);
1170   node->attr.call.callee_arr = NULL;
1171 }
1172
1173 ir_node * get_CallBegin_ptr (ir_node *node) {
1174   assert(node->op == op_CallBegin);
1175   return get_irn_n(node, 0);
1176 }
1177 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1178   assert(node->op == op_CallBegin);
1179   set_irn_n(node, 0, ptr);
1180 }
1181 ir_node * get_CallBegin_call (ir_node *node) {
1182   assert(node->op == op_CallBegin);
1183   return node->attr.callbegin.call;
1184 }
1185 void  set_CallBegin_call (ir_node *node, ir_node *call) {
1186   assert(node->op == op_CallBegin);
1187   node->attr.callbegin.call = call;
1188 }
1189
1190 ir_node *
1191 get_FuncCall_ptr (ir_node *node) {
1192   assert (node->op == op_FuncCall);
1193   return get_irn_n(node, 0);
1194 }
1195
1196 void
1197 set_FuncCall_ptr (ir_node *node, ir_node *ptr) {
1198   assert (node->op == op_FuncCall);
1199   set_irn_n(node, 0, ptr);
1200 }
1201
1202 ir_node **
1203 get_FuncCall_param_arr (ir_node *node) {
1204   assert (node->op == op_FuncCall);
1205   return (ir_node **)&get_irn_in(node)[FUNCCALL_PARAM_OFFSET];
1206 }
1207
1208 int
1209 get_FuncCall_n_params (ir_node *node)  {
1210   assert (node->op == op_FuncCall);
1211   return (get_irn_arity(node) - FUNCCALL_PARAM_OFFSET);
1212 }
1213
1214 int
1215 get_FuncCall_arity (ir_node *node) {
1216   assert (node->op == op_FuncCall);
1217   return get_FuncCall_n_params(node);
1218 }
1219
1220 /* void
1221 set_FuncCall_arity (ir_node *node, ir_node *arity) {
1222   assert (node->op == op_FuncCall);
1223 }
1224 */
1225
1226 ir_node *
1227 get_FuncCall_param (ir_node *node, int pos) {
1228   assert (node->op == op_FuncCall);
1229   return get_irn_n(node, pos + FUNCCALL_PARAM_OFFSET);
1230 }
1231
1232 void
1233 set_FuncCall_param (ir_node *node, int pos, ir_node *param) {
1234   assert (node->op == op_FuncCall);
1235   set_irn_n(node, pos + FUNCCALL_PARAM_OFFSET, param);
1236 }
1237
1238 type *
1239 get_FuncCall_type (ir_node *node) {
1240   assert (node->op == op_FuncCall);
1241   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1242 }
1243
1244 void
1245 set_FuncCall_type (ir_node *node, type *tp) {
1246   assert (node->op == op_FuncCall);
1247   assert (is_method_type(tp));
1248   node->attr.call.cld_tp = tp;
1249 }
1250
1251 int FuncCall_has_callees(ir_node *node) {
1252   return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1253       (node->attr.call.callee_arr != NULL));
1254 }
1255
1256 int get_FuncCall_n_callees(ir_node * node) {
1257   assert(node->op == op_FuncCall && node->attr.call.callee_arr);
1258   return ARR_LEN(node->attr.call.callee_arr);
1259 }
1260
1261 entity * get_FuncCall_callee(ir_node * node, int pos) {
1262   assert(node->op == op_FuncCall && node->attr.call.callee_arr);
1263   return node->attr.call.callee_arr[pos];
1264 }
1265
1266 void set_FuncCall_callee_arr(ir_node * node, int n, entity ** arr) {
1267   assert(node->op == op_FuncCall);
1268   if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1269     node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1270   }
1271   memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1272 }
1273
1274 void remove_FuncCall_callee_arr(ir_node * node) {
1275   assert(node->op == op_FuncCall);
1276   node->attr.call.callee_arr = NULL;
1277 }
1278
1279
1280 #define BINOP(OP)                   \
1281 ir_node * get_##OP##_left(ir_node *node) {      \
1282   assert(node->op == op_##OP);              \
1283   return get_irn_n(node, node->op->op_index);       \
1284 }                           \
1285 void set_##OP##_left(ir_node *node, ir_node *left) {    \
1286   assert(node->op == op_##OP);              \
1287   set_irn_n(node, node->op->op_index, left);        \
1288 }                           \
1289 ir_node *get_##OP##_right(ir_node *node) {      \
1290   assert(node->op == op_##OP);              \
1291   return get_irn_n(node, node->op->op_index + 1);   \
1292 }                           \
1293 void set_##OP##_right(ir_node *node, ir_node *right) {  \
1294   assert(node->op == op_##OP);              \
1295   set_irn_n(node, node->op->op_index + 1, right);   \
1296 }
1297
1298 #define UNOP(OP)                    \
1299 ir_node *get_##OP##_op(ir_node *node) {         \
1300   assert(node->op == op_##OP);              \
1301   return get_irn_n(node, node->op->op_index);       \
1302 }                           \
1303 void set_##OP##_op (ir_node *node, ir_node *op) {   \
1304   assert(node->op == op_##OP);              \
1305   set_irn_n(node, node->op->op_index, op);      \
1306 }
1307
1308 BINOP(Add)
1309 BINOP(Sub)
1310 UNOP(Minus)
1311 BINOP(Mul)
1312 BINOP(Quot)
1313
1314 ir_node *
1315 get_Quot_mem (ir_node *node) {
1316   assert (node->op == op_Quot);
1317   return get_irn_n(node, 0);
1318 }
1319
1320 void
1321 set_Quot_mem (ir_node *node, ir_node *mem) {
1322   assert (node->op == op_Quot);
1323   set_irn_n(node, 0, mem);
1324 }
1325
1326 BINOP(DivMod)
1327
1328 ir_node *
1329 get_DivMod_mem (ir_node *node) {
1330   assert (node->op == op_DivMod);
1331   return get_irn_n(node, 0);
1332 }
1333
1334 void
1335 set_DivMod_mem (ir_node *node, ir_node *mem) {
1336   assert (node->op == op_DivMod);
1337   set_irn_n(node, 0, mem);
1338 }
1339
1340 BINOP(Div)
1341
1342 ir_node *
1343 get_Div_mem (ir_node *node) {
1344   assert (node->op == op_Div);
1345   return get_irn_n(node, 0);
1346 }
1347
1348 void
1349 set_Div_mem (ir_node *node, ir_node *mem) {
1350   assert (node->op == op_Div);
1351   set_irn_n(node, 0, mem);
1352 }
1353
1354 BINOP(Mod)
1355
1356 ir_node *
1357 get_Mod_mem (ir_node *node) {
1358   assert (node->op == op_Mod);
1359   return get_irn_n(node, 0);
1360 }
1361
1362 void
1363 set_Mod_mem (ir_node *node, ir_node *mem) {
1364   assert (node->op == op_Mod);
1365   set_irn_n(node, 0, mem);
1366 }
1367
1368 UNOP(Abs)
1369 BINOP(And)
1370 BINOP(Or)
1371 BINOP(Eor)
1372 UNOP(Not)
1373 BINOP(Shl)
1374 BINOP(Shr)
1375 BINOP(Shrs)
1376 BINOP(Rot)
1377 BINOP(Cmp)
1378 UNOP(Conv)
1379 UNOP(Cast)
1380
1381 type *
1382 get_Cast_type (ir_node *node) {
1383   assert (node->op == op_Cast);
1384   return node->attr.cast.totype;
1385 }
1386
1387 void
1388 set_Cast_type (ir_node *node, type *to_tp) {
1389   assert (node->op == op_Cast);
1390   node->attr.cast.totype = to_tp;
1391 }
1392
1393 int
1394 is_unop (ir_node *node) {
1395   return (node->op->opar == oparity_unary);
1396 }
1397
1398 ir_node *
1399 get_unop_op (ir_node *node) {
1400   if (node->op->opar == oparity_unary)
1401     return get_irn_n(node, node->op->op_index);
1402
1403   assert(node->op->opar == oparity_unary);
1404   return NULL;
1405 }
1406
1407 void
1408 set_unop_op (ir_node *node, ir_node *op) {
1409   if (node->op->opar == oparity_unary)
1410     set_irn_n(node, node->op->op_index, op);
1411
1412   assert(node->op->opar == oparity_unary);
1413 }
1414
1415 int
1416 is_binop (ir_node *node) {
1417   return (node->op->opar == oparity_binary);
1418 }
1419
1420 ir_node *
1421 get_binop_left (ir_node *node) {
1422   if (node->op->opar == oparity_binary)
1423     return get_irn_n(node, node->op->op_index);
1424
1425   assert(node->op->opar == oparity_binary);
1426   return NULL;
1427 }
1428
1429 void
1430 set_binop_left (ir_node *node, ir_node *left) {
1431   if (node->op->opar == oparity_binary)
1432     set_irn_n(node, node->op->op_index, left);
1433
1434   assert (node->op->opar == oparity_binary);
1435 }
1436
1437 ir_node *
1438 get_binop_right (ir_node *node) {
1439   if (node->op->opar == oparity_binary)
1440     return get_irn_n(node, node->op->op_index + 1);
1441
1442   assert(node->op->opar == oparity_binary);
1443   return NULL;
1444 }
1445
1446 void
1447 set_binop_right (ir_node *node, ir_node *right) {
1448   if (node->op->opar == oparity_binary)
1449     set_irn_n(node, node->op->op_index + 1, right);
1450
1451   assert (node->op->opar == oparity_binary);
1452 }
1453
1454 int is_Phi (ir_node *n) {
1455   ir_op *op;
1456
1457   assert(n);
1458   op = get_irn_op(n);
1459
1460   if (op == op_Filter) return interprocedural_view;
1461
1462   if (op == op_Phi)
1463     return  ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
1464          (get_irn_arity(n) > 0));
1465
1466   return 0;
1467 }
1468
1469 int is_Phi0 (ir_node *n) {
1470   assert(n);
1471
1472   return ((get_irn_op(n) == op_Phi) &&
1473       (get_irn_arity(n) == 0) &&
1474       (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1475 }
1476
1477 ir_node **
1478 get_Phi_preds_arr (ir_node *node) {
1479   assert (node->op == op_Phi);
1480   return (ir_node **)&(get_irn_in(node)[1]);
1481 }
1482
1483 int
1484 get_Phi_n_preds (ir_node *node) {
1485   assert (is_Phi(node) || is_Phi0(node));
1486   return (get_irn_arity(node));
1487 }
1488
1489 /*
1490 void set_Phi_n_preds (ir_node *node, int n_preds) {
1491   assert (node->op == op_Phi);
1492 }
1493 */
1494
1495 ir_node *
1496 get_Phi_pred (ir_node *node, int pos) {
1497   assert (is_Phi(node) || is_Phi0(node));
1498   return get_irn_n(node, pos);
1499 }
1500
1501 void
1502 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1503   assert (is_Phi(node) || is_Phi0(node));
1504   set_irn_n(node, pos, pred);
1505 }
1506
1507
1508 int is_memop(ir_node *node) {
1509   return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
1510 }
1511
1512 ir_node *get_memop_mem (ir_node *node) {
1513   assert(is_memop(node));
1514   return get_irn_n(node, 0);
1515 }
1516
1517 void     set_memop_mem (ir_node *node, ir_node *mem) {
1518   assert(is_memop(node));
1519   set_irn_n(node, 0, mem);
1520 }
1521
1522 ir_node *get_memop_ptr (ir_node *node) {
1523   assert(is_memop(node));
1524   return get_irn_n(node, 1);
1525 }
1526
1527 void     set_memop_ptr (ir_node *node, ir_node *ptr) {
1528   assert(is_memop(node));
1529   set_irn_n(node, 1, ptr);
1530 }
1531
1532 ir_node *
1533 get_Load_mem (ir_node *node) {
1534   assert (node->op == op_Load);
1535   return get_irn_n(node, 0);
1536 }
1537
1538 void
1539 set_Load_mem (ir_node *node, ir_node *mem) {
1540   assert (node->op == op_Load);
1541   set_irn_n(node, 0, mem);
1542 }
1543
1544 ir_node *
1545 get_Load_ptr (ir_node *node) {
1546   assert (node->op == op_Load);
1547   return get_irn_n(node, 1);
1548 }
1549
1550 void
1551 set_Load_ptr (ir_node *node, ir_node *ptr) {
1552   assert (node->op == op_Load);
1553   set_irn_n(node, 1, ptr);
1554 }
1555
1556 ir_mode *
1557 get_Load_mode (ir_node *node) {
1558   assert (node->op == op_Load);
1559   return node->attr.load.load_mode;
1560 }
1561
1562 void
1563 set_Load_mode (ir_node *node, ir_mode *mode) {
1564   assert (node->op == op_Load);
1565   node->attr.load.load_mode = mode;
1566 }
1567
1568 ent_volatility
1569 get_Load_volatility (ir_node *node) {
1570   assert (node->op == op_Load);
1571   return node->attr.load.volatility;
1572 }
1573
1574 void
1575 set_Load_volatility (ir_node *node, ent_volatility volatility) {
1576   assert (node->op == op_Load);
1577   node->attr.load.volatility = volatility;
1578 }
1579
1580
1581 ir_node *
1582 get_Store_mem (ir_node *node) {
1583   assert (node->op == op_Store);
1584   return get_irn_n(node, 0);
1585 }
1586
1587 void
1588 set_Store_mem (ir_node *node, ir_node *mem) {
1589   assert (node->op == op_Store);
1590   set_irn_n(node, 0, mem);
1591 }
1592
1593 ir_node *
1594 get_Store_ptr (ir_node *node) {
1595   assert (node->op == op_Store);
1596   return get_irn_n(node, 1);
1597 }
1598
1599 void
1600 set_Store_ptr (ir_node *node, ir_node *ptr) {
1601   assert (node->op == op_Store);
1602   set_irn_n(node, 1, ptr);
1603 }
1604
1605 ir_node *
1606 get_Store_value (ir_node *node) {
1607   assert (node->op == op_Store);
1608   return get_irn_n(node, 2);
1609 }
1610
1611 void
1612 set_Store_value (ir_node *node, ir_node *value) {
1613   assert (node->op == op_Store);
1614   set_irn_n(node, 2, value);
1615 }
1616
1617 ent_volatility
1618 get_Store_volatility (ir_node *node) {
1619   assert (node->op == op_Store);
1620   return node->attr.store.volatility;
1621 }
1622
1623 void
1624 set_Store_volatility (ir_node *node, ent_volatility volatility) {
1625   assert (node->op == op_Store);
1626   node->attr.store.volatility = volatility;
1627 }
1628
1629
1630 ir_node *
1631 get_Alloc_mem (ir_node *node) {
1632   assert (node->op == op_Alloc);
1633   return get_irn_n(node, 0);
1634 }
1635
1636 void
1637 set_Alloc_mem (ir_node *node, ir_node *mem) {
1638   assert (node->op == op_Alloc);
1639   set_irn_n(node, 0, mem);
1640 }
1641
1642 ir_node *
1643 get_Alloc_size (ir_node *node) {
1644   assert (node->op == op_Alloc);
1645   return get_irn_n(node, 1);
1646 }
1647
1648 void
1649 set_Alloc_size (ir_node *node, ir_node *size) {
1650   assert (node->op == op_Alloc);
1651   set_irn_n(node, 1, size);
1652 }
1653
1654 type  *
1655 get_Alloc_type (ir_node *node) {
1656   assert (node->op == op_Alloc);
1657   return node->attr.a.type = skip_tid(node->attr.a.type);
1658 }
1659
1660 void
1661 set_Alloc_type (ir_node *node, type *tp) {
1662   assert (node->op == op_Alloc);
1663   node->attr.a.type = tp;
1664 }
1665
1666 where_alloc
1667 get_Alloc_where (ir_node *node) {
1668   assert (node->op == op_Alloc);
1669   return node->attr.a.where;
1670 }
1671
1672 void
1673 set_Alloc_where (ir_node *node, where_alloc where) {
1674   assert (node->op == op_Alloc);
1675   node->attr.a.where = where;
1676 }
1677
1678
1679 ir_node *
1680 get_Free_mem (ir_node *node) {
1681   assert (node->op == op_Free);
1682   return get_irn_n(node, 0);
1683 }
1684
1685 void
1686 set_Free_mem (ir_node *node, ir_node *mem) {
1687   assert (node->op == op_Free);
1688   set_irn_n(node, 0, mem);
1689 }
1690
1691 ir_node *
1692 get_Free_ptr (ir_node *node) {
1693   assert (node->op == op_Free);
1694   return get_irn_n(node, 1);
1695 }
1696
1697 void
1698 set_Free_ptr (ir_node *node, ir_node *ptr) {
1699   assert (node->op == op_Free);
1700   set_irn_n(node, 1, ptr);
1701 }
1702
1703 ir_node *
1704 get_Free_size (ir_node *node) {
1705   assert (node->op == op_Free);
1706   return get_irn_n(node, 2);
1707 }
1708
1709 void
1710 set_Free_size (ir_node *node, ir_node *size) {
1711   assert (node->op == op_Free);
1712   set_irn_n(node, 2, size);
1713 }
1714
1715 type  *
1716 get_Free_type (ir_node *node) {
1717   assert (node->op == op_Free);
1718   return node->attr.f = skip_tid(node->attr.f);
1719 }
1720
1721 void
1722 set_Free_type (ir_node *node, type *tp) {
1723   assert (node->op == op_Free);
1724   node->attr.f = tp;
1725 }
1726
1727 ir_node **
1728 get_Sync_preds_arr (ir_node *node) {
1729   assert (node->op == op_Sync);
1730   return (ir_node **)&(get_irn_in(node)[1]);
1731 }
1732
1733 int
1734 get_Sync_n_preds (ir_node *node) {
1735   assert (node->op == op_Sync);
1736   return (get_irn_arity(node));
1737 }
1738
1739 /*
1740 void
1741 set_Sync_n_preds (ir_node *node, int n_preds) {
1742   assert (node->op == op_Sync);
1743 }
1744 */
1745
1746 ir_node *
1747 get_Sync_pred (ir_node *node, int pos) {
1748   assert (node->op == op_Sync);
1749   return get_irn_n(node, pos);
1750 }
1751
1752 void
1753 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1754   assert (node->op == op_Sync);
1755   set_irn_n(node, pos, pred);
1756 }
1757
1758 ir_node *
1759 get_Proj_pred (ir_node *node) {
1760   assert (is_Proj(node));
1761   return get_irn_n(node, 0);
1762 }
1763
1764 void
1765 set_Proj_pred (ir_node *node, ir_node *pred) {
1766   assert (is_Proj(node));
1767   set_irn_n(node, 0, pred);
1768 }
1769
1770 long
1771 get_Proj_proj (ir_node *node) {
1772   assert (is_Proj(node));
1773   if (get_irn_opcode(node) == iro_Proj) {
1774     return node->attr.proj;
1775   } else {
1776     assert(get_irn_opcode(node) == iro_Filter);
1777     return node->attr.filter.proj;
1778   }
1779 }
1780
1781 void
1782 set_Proj_proj (ir_node *node, long proj) {
1783   assert (node->op == op_Proj);
1784   node->attr.proj = proj;
1785 }
1786
1787 ir_node **
1788 get_Tuple_preds_arr (ir_node *node) {
1789   assert (node->op == op_Tuple);
1790   return (ir_node **)&(get_irn_in(node)[1]);
1791 }
1792
1793 int
1794 get_Tuple_n_preds (ir_node *node) {
1795   assert (node->op == op_Tuple);
1796   return (get_irn_arity(node));
1797 }
1798
1799 /*
1800 void
1801 set_Tuple_n_preds (ir_node *node, int n_preds) {
1802   assert (node->op == op_Tuple);
1803 }
1804 */
1805
1806 ir_node *
1807 get_Tuple_pred (ir_node *node, int pos) {
1808   assert (node->op == op_Tuple);
1809   return get_irn_n(node, pos);
1810 }
1811
1812 void
1813 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1814   assert (node->op == op_Tuple);
1815   set_irn_n(node, pos, pred);
1816 }
1817
1818 ir_node *
1819 get_Id_pred (ir_node *node) {
1820   assert (node->op == op_Id);
1821   return get_irn_n(node, 0);
1822 }
1823
1824 void
1825 set_Id_pred (ir_node *node, ir_node *pred) {
1826   assert (node->op == op_Id);
1827   set_irn_n(node, 0, pred);
1828 }
1829
1830 ir_node *get_Confirm_value (ir_node *node) {
1831   assert (node->op == op_Confirm);
1832   return get_irn_n(node, 0);
1833 }
1834 void     set_Confirm_value (ir_node *node, ir_node *value) {
1835   assert (node->op == op_Confirm);
1836   set_irn_n(node, 0, value);
1837 }
1838 ir_node *get_Confirm_bound (ir_node *node) {
1839   assert (node->op == op_Confirm);
1840   return get_irn_n(node, 1);
1841 }
1842 void     set_Confirm_bound (ir_node *node, ir_node *bound) {
1843   assert (node->op == op_Confirm);
1844   set_irn_n(node, 0, bound);
1845 }
1846 pn_Cmp   get_Confirm_cmp   (ir_node *node) {
1847   assert (node->op == op_Confirm);
1848   return node->attr.confirm_cmp;
1849 }
1850 void     set_Confirm_cmp   (ir_node *node, pn_Cmp cmp) {
1851   assert (node->op == op_Confirm);
1852   node->attr.confirm_cmp = cmp;
1853 }
1854
1855
1856 ir_node *
1857 get_Filter_pred (ir_node *node) {
1858   assert(node->op == op_Filter);
1859   return node->in[1];
1860 }
1861 void
1862 set_Filter_pred (ir_node *node, ir_node *pred) {
1863   assert(node->op == op_Filter);
1864   node->in[1] = pred;
1865 }
1866 long
1867 get_Filter_proj(ir_node *node) {
1868   assert(node->op == op_Filter);
1869   return node->attr.filter.proj;
1870 }
1871 void
1872 set_Filter_proj (ir_node *node, long proj) {
1873   assert(node->op == op_Filter);
1874   node->attr.filter.proj = proj;
1875 }
1876
1877 /* Don't use get_irn_arity, get_irn_n in implementation as access
1878    shall work independent of view!!! */
1879 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
1880   assert(node->op == op_Filter);
1881   if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
1882     node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
1883     node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
1884     memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
1885     node->attr.filter.in_cg[0] = node->in[0];
1886   }
1887   memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
1888 }
1889
1890 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
1891   assert(node->op == op_Filter && node->attr.filter.in_cg &&
1892      0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
1893   node->attr.filter.in_cg[pos + 1] = pred;
1894 }
1895 int get_Filter_n_cg_preds(ir_node *node) {
1896   assert(node->op == op_Filter && node->attr.filter.in_cg);
1897   return (ARR_LEN(node->attr.filter.in_cg) - 1);
1898 }
1899 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
1900   int arity;
1901   assert(node->op == op_Filter && node->attr.filter.in_cg &&
1902      0 <= pos);
1903   arity = ARR_LEN(node->attr.filter.in_cg);
1904   assert(pos <  arity - 1);
1905   return node->attr.filter.in_cg[pos + 1];
1906 }
1907
1908
1909 ir_graph *
1910 get_irn_irg(ir_node *node) {
1911   if (get_irn_op(node) != op_Block)
1912     node = get_nodes_block(node);
1913   if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
1914     node = get_nodes_block(node);
1915   assert(get_irn_op(node) == op_Block);
1916   return node->attr.block.irg;
1917 }
1918
1919
1920 /*----------------------------------------------------------------*/
1921 /*  Auxiliary routines                                            */
1922 /*----------------------------------------------------------------*/
1923
1924 ir_node *
1925 skip_Proj (ir_node *node) {
1926   /* don't assert node !!! */
1927   if (node && is_Proj(node)) {
1928     return get_Proj_pred(node);
1929   } else {
1930     return node;
1931   }
1932 }
1933
1934 ir_node *
1935 skip_Tuple (ir_node *node) {
1936   ir_node *pred;
1937
1938   if (!get_opt_normalize()) return node;
1939
1940   node = skip_Id(node);
1941   if (get_irn_op(node) == op_Proj) {
1942     pred = skip_Id(get_Proj_pred(node));
1943     if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
1944       pred = skip_Id(skip_Tuple(pred));
1945     if (get_irn_op(pred) == op_Tuple)
1946       return get_Tuple_pred(pred, get_Proj_proj(node));
1947   }
1948   return node;
1949 }
1950
1951 /** returns operand of node if node is a Cast */
1952 ir_node *skip_Cast  (ir_node *node) {
1953   if (node && get_irn_op(node) == op_Cast) {
1954     return skip_Id(get_irn_n(node, 0));
1955   } else {
1956     return node;
1957   }
1958 }
1959
1960 #if 0
1961 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
1962    than any other approach, as Id chains are resolved and all point to the real node, or
1963    all id's are self loops. */
1964 ir_node *
1965 skip_Id (ir_node *node) {
1966   /* don't assert node !!! */
1967
1968   if (!get_opt_normalize()) return node;
1969
1970   /* Don't use get_Id_pred:  We get into an endless loop for
1971      self-referencing Ids. */
1972   if (node && (node->op == op_Id) && (node != node->in[0+1])) {
1973     ir_node *rem_pred = node->in[0+1];
1974     ir_node *res;
1975
1976     assert (get_irn_arity (node) > 0);
1977
1978     node->in[0+1] = node;
1979     res = skip_Id(rem_pred);
1980     if (res->op == op_Id) /* self-loop */ return node;
1981
1982     node->in[0+1] = res;
1983     return res;
1984   } else {
1985     return node;
1986   }
1987 }
1988 #else
1989 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
1990    than any other approach, as Id chains are resolved and all point to the real node, or
1991    all id's are self loops. */
1992 ir_node *
1993 skip_Id (ir_node *node) {
1994   ir_node *pred;
1995   /* don't assert node !!! */
1996
1997   if (!node || (node->op != op_Id)) return node;
1998
1999   if (!get_opt_normalize()) return node;
2000
2001   /* Don't use get_Id_pred:  We get into an endless loop for
2002      self-referencing Ids. */
2003   pred = node->in[0+1];
2004
2005   if (pred->op != op_Id) return pred;
2006
2007   if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
2008     ir_node *rem_pred, *res;
2009
2010     if (pred->op != op_Id) return pred; /* shortcut */
2011     rem_pred = pred;
2012
2013     assert (get_irn_arity (node) > 0);
2014
2015     node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
2016     res = skip_Id(rem_pred);
2017     if (res->op == op_Id) /* self-loop */ return node;
2018
2019     node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
2020     return res;
2021   } else {
2022     return node;
2023   }
2024 }
2025 #endif
2026
2027 int
2028 is_Bad (ir_node *node) {
2029   assert(node);
2030   if ((node) && get_irn_opcode(node) == iro_Bad)
2031     return 1;
2032   return 0;
2033 }
2034
2035 int
2036 is_no_Block (ir_node *node) {
2037   assert(node);
2038   return (get_irn_opcode(node) != iro_Block);
2039 }
2040
2041 int
2042 is_Block (ir_node *node) {
2043   assert(node);
2044   return (get_irn_opcode(node) == iro_Block);
2045 }
2046
2047 /* returns true if node is a Unknown node. */
2048 int
2049 is_Unknown (ir_node *node) {
2050   assert(node);
2051   return (get_irn_opcode(node) == iro_Unknown);
2052 }
2053
2054 int
2055 is_Proj (const ir_node *node) {
2056   assert(node);
2057   return node->op == op_Proj
2058     || (!interprocedural_view && node->op == op_Filter);
2059 }
2060
2061 /* Returns true if the operation manipulates control flow. */
2062 int
2063 is_cfop(ir_node *node) {
2064   return is_cfopcode(get_irn_op(node));
2065 }
2066
2067 /* Returns true if the operation manipulates interprocedural control flow:
2068    CallBegin, EndReg, EndExcept */
2069 int is_ip_cfop(ir_node *node) {
2070   return is_ip_cfopcode(get_irn_op(node));
2071 }
2072
2073 /* Returns true if the operation can change the control flow because
2074    of an exception. */
2075 int
2076 is_fragile_op(ir_node *node) {
2077   return is_op_fragile(get_irn_op(node));
2078 }
2079
2080 /* Returns the memory operand of fragile operations. */
2081 ir_node *get_fragile_op_mem(ir_node *node) {
2082   assert(node && is_fragile_op(node));
2083
2084   switch (get_irn_opcode (node)) {
2085   case iro_Call  :
2086   case iro_Quot  :
2087   case iro_DivMod:
2088   case iro_Div   :
2089   case iro_Mod   :
2090   case iro_Load  :
2091   case iro_Store :
2092   case iro_Alloc :
2093     return get_irn_n(node, 0);
2094   case iro_Bad   :
2095   case iro_Unknown:
2096     return node;
2097   default: ;
2098     assert(0 && "should not be reached");
2099     return NULL;
2100   }
2101 }
2102
2103 /* Returns true if the operation is a forking control flow operation. */
2104 int
2105 is_forking_op(ir_node *node) {
2106   return is_op_forking(get_irn_op(node));
2107 }
2108
2109 #ifdef DEBUG_libfirm
2110 void dump_irn (ir_node *n) {
2111   int i, arity = get_irn_arity(n);
2112   printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
2113   if (!is_Block(n)) {
2114     ir_node *pred = get_irn_n(n, -1);
2115     printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2116        get_irn_node_nr(pred), (void *)pred);
2117   }
2118   printf("  preds: \n");
2119   for (i = 0; i < arity; ++i) {
2120     ir_node *pred = get_irn_n(n, i);
2121     printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2122        get_irn_node_nr(pred), (void *)pred);
2123   }
2124 }
2125
2126 #else  /* DEBUG_libfirm */
2127 void dump_irn (ir_node *n) {}
2128 #endif /* DEBUG_libfirm */