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
 357 #ifdef DO_HEAPANALYSIS
 358 /* Access the abstract interpretation information of a node.
 359    Returns NULL if no such information is available. */
 360 struct abstval *get_irn_abst_value(ir_node *n) {
 361   return n->av;
 362 }
 363 /* Set the abstract interpretation information of a node. */
 364 void set_irn_abst_value(ir_node *n, struct abstval *os) {
 365   n->av = os;
 366 }
 367 struct section *firm_get_irn_section(ir_node *n) {
 368   return n->sec;
 369 }
 370 void firm_set_irn_section(ir_node *n, struct section *s) {
 371   n->sec = s;
 372 }
 373 #endif /* DO_HEAPANALYSIS */
 374
 375
 376 /* Outputs a unique number for this node */
 377 long
 378 get_irn_node_nr(const ir_node *node) {
 379   assert(node);
 380 #ifdef DEBUG_libfirm
 381   return node->node_nr;
 382 #else
 383   return (long)&node;
 384 #endif
 385 }
 386
 387 const_attr
 388 get_irn_const_attr (ir_node *node)
 389 {
 390   assert (node->op == op_Const);
 391   return node->attr.con;
 392 }
 393
 394 long
 395 get_irn_proj_attr (ir_node *node)
 396 {
 397   assert (node->op == op_Proj);
 398   return node->attr.proj;
 399 }
 400
 401 alloc_attr
 402 get_irn_alloc_attr (ir_node *node)
 403 {
 404   assert (node->op == op_Alloc);
 405   return node->attr.a;
 406 }
 407
 408 type *
 409 get_irn_free_attr     (ir_node *node)
 410 {
 411   assert (node->op == op_Free);
 412   return node->attr.f = skip_tid(node->attr.f);
 413 }
 414
 415 symconst_attr
 416 get_irn_symconst_attr (ir_node *node)
 417 {
 418   assert (node->op == op_SymConst);
 419   return node->attr.i;
 420 }
 421
 422 type *
 423 get_irn_call_attr (ir_node *node)
 424 {
 425   assert (node->op == op_Call);
 426   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 427 }
 428
 429 type *
 430 get_irn_funccall_attr (ir_node *node)
 431 {
 432   assert (node->op == op_FuncCall);
 433   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 434 }
 435
 436 sel_attr
 437 get_irn_sel_attr (ir_node *node)
 438 {
 439   assert (node->op == op_Sel);
 440   return node->attr.s;
 441 }
 442
 443 int
 444 get_irn_phi_attr (ir_node *node)
 445 {
 446   assert (node->op == op_Phi);
 447   return node->attr.phi0_pos;
 448 }
 449
 450 block_attr
 451 get_irn_block_attr (ir_node *node)
 452 {
 453   assert (node->op == op_Block);
 454   return node->attr.block;
 455 }
 456
 457 /** manipulate fields of individual nodes **/
 458
 459 /* this works for all except Block */
 460 ir_node *
 461 get_nodes_block (ir_node *node) {
 462   assert (!(node->op == op_Block));
 463   return get_irn_n(node, -1);
 464 }
 465
 466 void
 467 set_nodes_block (ir_node *node, ir_node *block) {
 468   assert (!(node->op == op_Block));
 469   set_irn_n(node, -1, block);
 470 }
 471
 472 /* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
 473  * from Start.  If so returns frame type, else Null. */
 474 type *is_frame_pointer(ir_node *n) {
 475   if ((get_irn_op(n) == op_Proj) &&
 476       (get_Proj_proj(n) == pn_Start_P_frame_base)) {
 477     ir_node *start = get_Proj_pred(n);
 478     if (get_irn_op(start) == op_Start) {
 479       return get_irg_frame_type(get_irn_irg(start));
 480     }
 481   }
 482   return NULL;
 483 }
 484
 485 /* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
 486  * from Start.  If so returns global type, else Null. */
 487 type *is_globals_pointer(ir_node *n) {
 488   if ((get_irn_op(n) == op_Proj) &&
 489       (get_Proj_proj(n) == pn_Start_P_globals)) {
 490     ir_node *start = get_Proj_pred(n);
 491     if (get_irn_op(start) == op_Start) {
 492       return get_glob_type();
 493     }
 494   }
 495   return NULL;
 496 }
 497
 498 /* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
 499  * from Start.  If so returns 1, else 0. */
 500 int is_value_arg_pointer(ir_node *n) {
 501   if ((get_irn_op(n) == op_Proj) &&
 502       (get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
 503       (get_irn_op(get_Proj_pred(n)) == op_Start))
 504     return 1;
 505   return 0;
 506 }
 507
 508 /* Returns an array with the predecessors of the Block. Depending on
 509    the implementation of the graph data structure this can be a copy of
 510    the internal representation of predecessors as well as the internal
 511    array itself. Therefore writing to this array might obstruct the ir. */
 512 ir_node **
 513 get_Block_cfgpred_arr (ir_node *node)
 514 {
 515   assert ((node->op == op_Block));
 516   return (ir_node **)&(get_irn_in(node)[1]);
 517 }
 518
 519
 520 int
 521 get_Block_n_cfgpreds (ir_node *node) {
 522   assert ((node->op == op_Block));
 523   return get_irn_arity(node);
 524 }
 525
 526 ir_node *
 527 get_Block_cfgpred (ir_node *node, int pos) {
 528   assert(node);
 529   assert (node->op == op_Block);
 530   assert(-1 <= pos && pos < get_irn_arity(node));
 531   return get_irn_n(node, pos);
 532 }
 533
 534 void
 535 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
 536   assert (node->op == op_Block);
 537   set_irn_n(node, pos, pred);
 538 }
 539
 540 bool
 541 get_Block_matured (ir_node *node) {
 542   assert (node->op == op_Block);
 543   return node->attr.block.matured;
 544 }
 545
 546 void
 547 set_Block_matured (ir_node *node, bool matured) {
 548   assert (node->op == op_Block);
 549   node->attr.block.matured = matured;
 550 }
 551 unsigned long
 552 get_Block_block_visited (ir_node *node) {
 553   assert (node->op == op_Block);
 554   return node->attr.block.block_visited;
 555 }
 556
 557 void
 558 set_Block_block_visited (ir_node *node, unsigned long visit) {
 559   assert (node->op == op_Block);
 560   node->attr.block.block_visited = visit;
 561 }
 562
 563 /* For this current_ir_graph must be set. */
 564 void
 565 mark_Block_block_visited (ir_node *node) {
 566   assert (node->op == op_Block);
 567   node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
 568 }
 569
 570 int
 571 Block_not_block_visited(ir_node *node) {
 572   assert (node->op == op_Block);
 573   return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
 574 }
 575
 576 ir_node *
 577 get_Block_graph_arr (ir_node *node, int pos) {
 578   assert (node->op == op_Block);
 579   return node->attr.block.graph_arr[pos+1];
 580 }
 581
 582 void
 583 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
 584   assert (node->op == op_Block);
 585   node->attr.block.graph_arr[pos+1] = value;
 586 }
 587
 588 /* handler handling for Blocks * /
 589 void
 590 set_Block_handler (ir_node *block, ir_node *handler)  {
 591   assert ((block->op == op_Block));
 592   assert ((handler->op == op_Block));
 593   block->attr.block.handler_entry = handler;
 594 }
 595
 596 ir_node *
 597 get_Block_handler (ir_node *block) {
 598   assert ((block->op == op_Block));
 599   return (block->attr.block.handler_entry);
 600 }
 601
 602 / * handler handling for Nodes * /
 603 void
 604 set_Node_handler (ir_node *node, ir_node *handler) {
 605   set_Block_handler (get_nodes_block (node), handler);
 606 }
 607
 608 ir_node *
 609 get_Node_handler (ir_node *node) {
 610   return (get_Block_handler (get_nodes_block (node)));
 611 }
 612
 613 / * exc_t handling for Blocks * /
 614 void set_Block_exc (ir_node *block, exc_t exc) {
 615   assert ((block->op == op_Block));
 616   block->attr.block.exc = exc;
 617 }
 618
 619 exc_t get_Block_exc (ir_node *block) {
 620   assert ((block->op == op_Block));
 621   return (block->attr.block.exc);
 622 }
 623
 624 / * exc_t handling for Nodes * /
 625 void set_Node_exc (ir_node *node, exc_t exc) {
 626   set_Block_exc (get_nodes_block (node), exc);
 627 }
 628
 629 exc_t get_Node_exc (ir_node *node) {
 630   return (get_Block_exc (get_nodes_block (node)));
 631 }
 632 */
 633
 634 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
 635   assert(node->op == op_Block);
 636   if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
 637     node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
 638     node->attr.block.in_cg[0] = NULL;
 639     node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
 640     {
 641       /* Fix backedge array.  fix_backedges operates depending on
 642      interprocedural_view. */
 643       bool ipv = interprocedural_view;
 644       interprocedural_view = true;
 645       fix_backedges(current_ir_graph->obst, node);
 646       interprocedural_view = ipv;
 647     }
 648   }
 649   memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
 650 }
 651
 652 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
 653   assert(node->op == op_Block &&
 654      node->attr.block.in_cg &&
 655      0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
 656   node->attr.block.in_cg[pos + 1] = pred;
 657 }
 658
 659 ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) {
 660   assert(node->op == op_Block);
 661   return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg  + 1;
 662 }
 663
 664 int get_Block_cg_n_cfgpreds(ir_node * node) {
 665   assert(node->op == op_Block);
 666   return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
 667 }
 668
 669 ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) {
 670   assert(node->op == op_Block && node->attr.block.in_cg);
 671   return node->attr.block.in_cg[pos + 1];
 672 }
 673
 674 void remove_Block_cg_cfgpred_arr(ir_node * node) {
 675   assert(node->op == op_Block);
 676   node->attr.block.in_cg = NULL;
 677 }
 678
 679 void
 680 set_Start_irg(ir_node *node, ir_graph *irg) {
 681   assert(node->op == op_Start);
 682   assert(is_ir_graph(irg));
 683   assert(0 && " Why set irg? -- use set_irn_irg");
 684 }
 685
 686 int
 687 get_End_n_keepalives(ir_node *end) {
 688   assert (end->op == op_End);
 689   return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
 690 }
 691
 692 ir_node *
 693 get_End_keepalive(ir_node *end, int pos) {
 694   assert (end->op == op_End);
 695   return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
 696 }
 697
 698 void
 699 add_End_keepalive (ir_node *end, ir_node *ka) {
 700   assert (end->op == op_End);
 701   ARR_APP1 (ir_node *, end->in, ka);
 702 }
 703
 704 void
 705 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
 706   assert (end->op == op_End);
 707   set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 708 }
 709
 710 void
 711 free_End (ir_node *end) {
 712   assert (end->op == op_End);
 713   end->kind = k_BAD;
 714   DEL_ARR_F(end->in);  /* GL @@@ tut nicht ! */
 715   end->in = NULL;   /* @@@ make sure we get an error if we use the
 716                in array afterwards ... */
 717 }
 718
 719
 720 /*
 721 > Implementing the case construct (which is where the constant Proj node is
 722 > important) involves far more than simply determining the constant values.
 723 > We could argue that this is more properly a function of the translator from
 724 > Firm to the target machine.  That could be done if there was some way of
 725 > projecting "default" out of the Cond node.
 726 I know it's complicated.
 727 Basically there are two proglems:
 728  - determining the gaps between the projs
 729  - determining the biggest case constant to know the proj number for
 730    the default node.
 731 I see several solutions:
 732 1. Introduce a ProjDefault node.  Solves both problems.
 733    This means to extend all optimizations executed during construction.
 734 2. Give the Cond node for switch two flavors:
 735    a) there are no gaps in the projs  (existing flavor)
 736    b) gaps may exist, default proj is still the Proj with the largest
 737       projection number.  This covers also the gaps.
 738 3. Fix the semantic of the Cond to that of 2b)
 739
 740 Solution 2 seems to be the best:
 741 Computing the gaps in the Firm representation is not too hard, i.e.,
 742 libFIRM can implement a routine that transforms between the two
 743 flavours.  This is also possible for 1) but 2) does not require to
 744 change any existing optimization.
 745 Further it should be far simpler to determine the biggest constant than
 746 to compute all gaps.
 747 I don't want to choose 3) as 2a) seems to have advantages for
 748 dataflow analysis and 3) does not allow to convert the representation to
 749 2a).
 750 */
 751 ir_node *
 752 get_Cond_selector (ir_node *node) {
 753   assert (node->op == op_Cond);
 754   return get_irn_n(node, 0);
 755 }
 756
 757 void
 758 set_Cond_selector (ir_node *node, ir_node *selector) {
 759   assert (node->op == op_Cond);
 760   set_irn_n(node, 0, selector);
 761 }
 762
 763 cond_kind
 764 get_Cond_kind (ir_node *node) {
 765   assert (node->op == op_Cond);
 766   return node->attr.c.kind;
 767 }
 768
 769 void
 770 set_Cond_kind (ir_node *node, cond_kind kind) {
 771   assert (node->op == op_Cond);
 772   node->attr.c.kind = kind;
 773 }
 774
 775 long
 776 get_Cond_defaultProj (ir_node *node) {
 777   assert (node->op == op_Cond);
 778   return node->attr.c.default_proj;
 779 }
 780
 781 ir_node *
 782 get_Return_mem (ir_node *node) {
 783   assert (node->op == op_Return);
 784   return get_irn_n(node, 0);
 785 }
 786
 787 void
 788 set_Return_mem (ir_node *node, ir_node *mem) {
 789   assert (node->op == op_Return);
 790   set_irn_n(node, 0, mem);
 791 }
 792
 793 int
 794 get_Return_n_ress (ir_node *node) {
 795   assert (node->op == op_Return);
 796   return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
 797 }
 798
 799 ir_node **
 800 get_Return_res_arr (ir_node *node)
 801 {
 802   assert ((node->op == op_Return));
 803   if (get_Return_n_ress(node) > 0)
 804     return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
 805   else
 806     return NULL;
 807 }
 808
 809 /*
 810 void
 811 set_Return_n_res (ir_node *node, int results) {
 812   assert (node->op == op_Return);
 813 }
 814 */
 815
 816 ir_node *
 817 get_Return_res (ir_node *node, int pos) {
 818   assert (node->op == op_Return);
 819   assert (get_Return_n_ress(node) > pos);
 820   return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
 821 }
 822
 823 void
 824 set_Return_res (ir_node *node, int pos, ir_node *res){
 825   assert (node->op == op_Return);
 826   set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
 827 }
 828
 829 ir_node *
 830 get_Raise_mem (ir_node *node) {
 831   assert (node->op == op_Raise);
 832   return get_irn_n(node, 0);
 833 }
 834
 835 void
 836 set_Raise_mem (ir_node *node, ir_node *mem) {
 837   assert (node->op == op_Raise);
 838   set_irn_n(node, 0, mem);
 839 }
 840
 841 ir_node *
 842 get_Raise_exo_ptr (ir_node *node) {
 843   assert (node->op == op_Raise);
 844   return get_irn_n(node, 1);
 845 }
 846
 847 void
 848 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
 849   assert (node->op == op_Raise);
 850   set_irn_n(node, 1, exo_ptr);
 851 }
 852
 853 tarval *get_Const_tarval (ir_node *node) {
 854   assert (node->op == op_Const);
 855   return node->attr.con.tv;
 856 }
 857
 858 void
 859 set_Const_tarval (ir_node *node, tarval *con) {
 860   assert (node->op == op_Const);
 861   node->attr.con.tv = con;
 862 }
 863
 864
 865 /* The source language type.  Must be an atomic type.  Mode of type must
 866    be mode of node. For tarvals from entities type must be pointer to
 867    entity type. */
 868 type *
 869 get_Const_type (ir_node *node) {
 870   assert (node->op == op_Const);
 871   return node->attr.con.tp;
 872 }
 873
 874 void
 875 set_Const_type (ir_node *node, type *tp) {
 876   assert (node->op == op_Const);
 877   if (tp != unknown_type) {
 878     assert (is_atomic_type(tp));
 879     assert (get_type_mode(tp) == get_irn_mode(node));
 880   }
 881
 882   node->attr.con.tp = tp;
 883 }
 884
 885
 886 symconst_kind
 887 get_SymConst_kind (const ir_node *node) {
 888   assert (node->op == op_SymConst);
 889   return node->attr.i.num;
 890 }
 891
 892 void
 893 set_SymConst_kind (ir_node *node, symconst_kind num) {
 894   assert (node->op == op_SymConst);
 895   node->attr.i.num = num;
 896 }
 897
 898 type *
 899 get_SymConst_type (ir_node *node) {
 900   assert (   (node->op == op_SymConst)
 901           && (   get_SymConst_kind(node) == symconst_type_tag
 902               || get_SymConst_kind(node) == symconst_size));
 903   return node->attr.i.sym.type_p = skip_tid(node->attr.i.sym.type_p);
 904 }
 905
 906 void
 907 set_SymConst_type (ir_node *node, type *tp) {
 908   assert (   (node->op == op_SymConst)
 909           && (   get_SymConst_kind(node) == symconst_type_tag
 910               || get_SymConst_kind(node) == symconst_size));
 911   node->attr.i.sym.type_p = tp;
 912 }
 913
 914 ident *
 915 get_SymConst_name (ir_node *node) {
 916   assert (   (node->op == op_SymConst)
 917           && (get_SymConst_kind(node) == symconst_addr_name));
 918   return node->attr.i.sym.ident_p;
 919 }
 920
 921 void
 922 set_SymConst_name (ir_node *node, ident *name) {
 923   assert (   (node->op == op_SymConst)
 924           && (get_SymConst_kind(node) == symconst_addr_name));
 925   node->attr.i.sym.ident_p = name;
 926 }
 927
 928
 929 /* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
 930 entity   *get_SymConst_entity (ir_node *node) {
 931   assert (   (node->op == op_SymConst)
 932           && (get_SymConst_kind (node) == symconst_addr_ent));
 933   return node->attr.i.sym.entity_p;
 934 }
 935
 936 void     set_SymConst_entity (ir_node *node, entity *ent) {
 937   assert (   (node->op == op_SymConst)
 938           && (get_SymConst_kind(node) == symconst_addr_ent));
 939   node->attr.i.sym.entity_p  = ent;
 940 }
 941
 942
 943 union symconst_symbol
 944 get_SymConst_symbol (ir_node *node) {
 945   assert (node->op == op_SymConst);
 946   return node->attr.i.sym;
 947 }
 948
 949 void
 950 set_SymConst_symbol (ir_node *node, union symconst_symbol sym) {
 951   assert (node->op == op_SymConst);
 952   //memcpy (&(node->attr.i.sym), sym, sizeof(type_or_id));
 953   node->attr.i.sym = sym;
 954 }
 955
 956 ir_node *
 957 get_Sel_mem (ir_node *node) {
 958   assert (node->op == op_Sel);
 959   return get_irn_n(node, 0);
 960 }
 961
 962 void
 963 set_Sel_mem (ir_node *node, ir_node *mem) {
 964   assert (node->op == op_Sel);
 965   set_irn_n(node, 0, mem);
 966 }
 967
 968 ir_node *
 969 get_Sel_ptr (ir_node *node) {
 970   assert (node->op == op_Sel);
 971   return get_irn_n(node, 1);
 972 }
 973
 974 void
 975 set_Sel_ptr (ir_node *node, ir_node *ptr) {
 976   assert (node->op == op_Sel);
 977   set_irn_n(node, 1, ptr);
 978 }
 979
 980 int
 981 get_Sel_n_indexs (ir_node *node) {
 982   assert (node->op == op_Sel);
 983   return (get_irn_arity(node) - SEL_INDEX_OFFSET);
 984 }
 985
 986 ir_node **
 987 get_Sel_index_arr (ir_node *node)
 988 {
 989   assert ((node->op == op_Sel));
 990   if (get_Sel_n_indexs(node) > 0)
 991     return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
 992   else
 993     return NULL;
 994 }
 995
 996 ir_node *
 997 get_Sel_index (ir_node *node, int pos) {
 998   assert (node->op == op_Sel);
 999   return get_irn_n(node, pos + SEL_INDEX_OFFSET);
1000 }
1001
1002 void
1003 set_Sel_index (ir_node *node, int pos, ir_node *index) {
1004   assert (node->op == op_Sel);
1005   set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
1006 }
1007
1008 entity *
1009 get_Sel_entity (ir_node *node) {
1010   assert (node->op == op_Sel);
1011   return node->attr.s.ent;
1012 }
1013
1014 void
1015 set_Sel_entity (ir_node *node, entity *ent) {
1016   assert (node->op == op_Sel);
1017   node->attr.s.ent = ent;
1018 }
1019
1020 type *
1021 get_InstOf_ent (ir_node *node) {
1022   assert (node->op = op_InstOf);
1023   return (node->attr.io.ent);
1024 }
1025
1026 void
1027 set_InstOf_ent (ir_node *node, type *ent) {
1028   assert (node->op = op_InstOf);
1029   node->attr.io.ent = ent;
1030 }
1031
1032 ir_node *
1033 get_InstOf_store (ir_node *node) {
1034   assert (node->op = op_InstOf);
1035   return (get_irn_n (node, 0));
1036 }
1037
1038 void
1039 set_InstOf_store (ir_node *node, ir_node *obj) {
1040   assert (node->op = op_InstOf);
1041   set_irn_n (node, 0, obj);
1042 }
1043
1044 ir_node *
1045 get_InstOf_obj (ir_node *node) {
1046   assert (node->op = op_InstOf);
1047   return (get_irn_n (node, 1));
1048 }
1049
1050 void
1051 set_InstOf_obj (ir_node *node, ir_node *obj) {
1052   assert (node->op = op_InstOf);
1053   set_irn_n (node, 1, obj);
1054 }
1055
1056
1057 /* For unary and binary arithmetic operations the access to the
1058    operands can be factored out.  Left is the first, right the
1059    second arithmetic value  as listed in tech report 0999-33.
1060    unops are: Minus, Abs, Not, Conv, Cast
1061    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
1062    Shr, Shrs, Rotate, Cmp */
1063
1064
1065 ir_node *
1066 get_Call_mem (ir_node *node) {
1067   assert (node->op == op_Call);
1068   return get_irn_n(node, 0);
1069 }
1070
1071 void
1072 set_Call_mem (ir_node *node, ir_node *mem) {
1073   assert (node->op == op_Call);
1074   set_irn_n(node, 0, mem);
1075 }
1076
1077 ir_node *
1078 get_Call_ptr (ir_node *node) {
1079   assert (node->op == op_Call);
1080   return get_irn_n(node, 1);
1081 }
1082
1083 void
1084 set_Call_ptr (ir_node *node, ir_node *ptr) {
1085   assert (node->op == op_Call);
1086   set_irn_n(node, 1, ptr);
1087 }
1088
1089 ir_node **
1090 get_Call_param_arr (ir_node *node) {
1091   assert (node->op == op_Call);
1092   return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
1093 }
1094
1095 int
1096 get_Call_n_params (ir_node *node)  {
1097   assert (node->op == op_Call);
1098   return (get_irn_arity(node) - CALL_PARAM_OFFSET);
1099 }
1100
1101 int
1102 get_Call_arity (ir_node *node) {
1103   assert (node->op == op_Call);
1104   return get_Call_n_params(node);
1105 }
1106
1107 /* void
1108 set_Call_arity (ir_node *node, ir_node *arity) {
1109   assert (node->op == op_Call);
1110 }
1111 */
1112
1113 ir_node *
1114 get_Call_param (ir_node *node, int pos) {
1115   assert (node->op == op_Call);
1116   return get_irn_n(node, pos + CALL_PARAM_OFFSET);
1117 }
1118
1119 void
1120 set_Call_param (ir_node *node, int pos, ir_node *param) {
1121   assert (node->op == op_Call);
1122   set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
1123 }
1124
1125 type *
1126 get_Call_type (ir_node *node) {
1127   assert (node->op == op_Call);
1128   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1129 }
1130
1131 void
1132 set_Call_type (ir_node *node, type *tp) {
1133   assert (node->op == op_Call);
1134   assert (is_method_type(tp));
1135   node->attr.call.cld_tp = tp;
1136 }
1137
1138 int Call_has_callees(ir_node *node) {
1139
1140   return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1141           (node->attr.call.callee_arr != NULL));
1142 }
1143
1144 int get_Call_n_callees(ir_node * node) {
1145   assert(node->op == op_Call && node->attr.call.callee_arr);
1146   return ARR_LEN(node->attr.call.callee_arr);
1147 }
1148
1149 entity * get_Call_callee(ir_node * node, int pos) {
1150   assert(node->op == op_Call && node->attr.call.callee_arr);
1151   return node->attr.call.callee_arr[pos];
1152 }
1153
1154 void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
1155   assert(node->op == op_Call);
1156   if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1157     node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1158   }
1159   memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1160 }
1161
1162 void remove_Call_callee_arr(ir_node * node) {
1163   assert(node->op == op_Call);
1164   node->attr.call.callee_arr = NULL;
1165 }
1166
1167 ir_node * get_CallBegin_ptr (ir_node *node) {
1168   assert(node->op == op_CallBegin);
1169   return get_irn_n(node, 0);
1170 }
1171 void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
1172   assert(node->op == op_CallBegin);
1173   set_irn_n(node, 0, ptr);
1174 }
1175 ir_node * get_CallBegin_call (ir_node *node) {
1176   assert(node->op == op_CallBegin);
1177   return node->attr.callbegin.call;
1178 }
1179 void  set_CallBegin_call (ir_node *node, ir_node *call) {
1180   assert(node->op == op_CallBegin);
1181   node->attr.callbegin.call = call;
1182 }
1183
1184 ir_node *
1185 get_FuncCall_ptr (ir_node *node) {
1186   assert (node->op == op_FuncCall);
1187   return get_irn_n(node, 0);
1188 }
1189
1190 void
1191 set_FuncCall_ptr (ir_node *node, ir_node *ptr) {
1192   assert (node->op == op_FuncCall);
1193   set_irn_n(node, 0, ptr);
1194 }
1195
1196 ir_node **
1197 get_FuncCall_param_arr (ir_node *node) {
1198   assert (node->op == op_FuncCall);
1199   return (ir_node **)&get_irn_in(node)[FUNCCALL_PARAM_OFFSET];
1200 }
1201
1202 int
1203 get_FuncCall_n_params (ir_node *node)  {
1204   assert (node->op == op_FuncCall);
1205   return (get_irn_arity(node) - FUNCCALL_PARAM_OFFSET);
1206 }
1207
1208 int
1209 get_FuncCall_arity (ir_node *node) {
1210   assert (node->op == op_FuncCall);
1211   return get_FuncCall_n_params(node);
1212 }
1213
1214 /* void
1215 set_FuncCall_arity (ir_node *node, ir_node *arity) {
1216   assert (node->op == op_FuncCall);
1217 }
1218 */
1219
1220 ir_node *
1221 get_FuncCall_param (ir_node *node, int pos) {
1222   assert (node->op == op_FuncCall);
1223   return get_irn_n(node, pos + FUNCCALL_PARAM_OFFSET);
1224 }
1225
1226 void
1227 set_FuncCall_param (ir_node *node, int pos, ir_node *param) {
1228   assert (node->op == op_FuncCall);
1229   set_irn_n(node, pos + FUNCCALL_PARAM_OFFSET, param);
1230 }
1231
1232 type *
1233 get_FuncCall_type (ir_node *node) {
1234   assert (node->op == op_FuncCall);
1235   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
1236 }
1237
1238 void
1239 set_FuncCall_type (ir_node *node, type *tp) {
1240   assert (node->op == op_FuncCall);
1241   assert (is_method_type(tp));
1242   node->attr.call.cld_tp = tp;
1243 }
1244
1245 int FuncCall_has_callees(ir_node *node) {
1246   return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
1247           (node->attr.call.callee_arr != NULL));
1248 }
1249
1250 int get_FuncCall_n_callees(ir_node * node) {
1251   assert(node->op == op_FuncCall && node->attr.call.callee_arr);
1252   return ARR_LEN(node->attr.call.callee_arr);
1253 }
1254
1255 entity * get_FuncCall_callee(ir_node * node, int pos) {
1256   assert(node->op == op_FuncCall && node->attr.call.callee_arr);
1257   return node->attr.call.callee_arr[pos];
1258 }
1259
1260 void set_FuncCall_callee_arr(ir_node * node, int n, entity ** arr) {
1261   assert(node->op == op_FuncCall);
1262   if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
1263     node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
1264   }
1265   memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *));
1266 }
1267
1268 void remove_FuncCall_callee_arr(ir_node * node) {
1269   assert(node->op == op_FuncCall);
1270   node->attr.call.callee_arr = NULL;
1271 }
1272
1273
1274 #define BINOP(OP)                   \
1275 ir_node * get_##OP##_left(ir_node *node) {      \
1276   assert(node->op == op_##OP);              \
1277   return get_irn_n(node, node->op->op_index);       \
1278 }                           \
1279 void set_##OP##_left(ir_node *node, ir_node *left) {    \
1280   assert(node->op == op_##OP);              \
1281   set_irn_n(node, node->op->op_index, left);        \
1282 }                           \
1283 ir_node *get_##OP##_right(ir_node *node) {      \
1284   assert(node->op == op_##OP);              \
1285   return get_irn_n(node, node->op->op_index + 1);   \
1286 }                           \
1287 void set_##OP##_right(ir_node *node, ir_node *right) {  \
1288   assert(node->op == op_##OP);              \
1289   set_irn_n(node, node->op->op_index + 1, right);   \
1290 }
1291
1292 #define UNOP(OP)                    \
1293 ir_node *get_##OP##_op(ir_node *node) {         \
1294   assert(node->op == op_##OP);              \
1295   return get_irn_n(node, node->op->op_index);       \
1296 }                           \
1297 void set_##OP##_op (ir_node *node, ir_node *op) {   \
1298   assert(node->op == op_##OP);              \
1299   set_irn_n(node, node->op->op_index, op);      \
1300 }
1301
1302 BINOP(Add)
1303 BINOP(Sub)
1304 UNOP(Minus)
1305 BINOP(Mul)
1306 BINOP(Quot)
1307
1308 ir_node *
1309 get_Quot_mem (ir_node *node) {
1310   assert (node->op == op_Quot);
1311   return get_irn_n(node, 0);
1312 }
1313
1314 void
1315 set_Quot_mem (ir_node *node, ir_node *mem) {
1316   assert (node->op == op_Quot);
1317   set_irn_n(node, 0, mem);
1318 }
1319
1320 BINOP(DivMod)
1321
1322 ir_node *
1323 get_DivMod_mem (ir_node *node) {
1324   assert (node->op == op_DivMod);
1325   return get_irn_n(node, 0);
1326 }
1327
1328 void
1329 set_DivMod_mem (ir_node *node, ir_node *mem) {
1330   assert (node->op == op_DivMod);
1331   set_irn_n(node, 0, mem);
1332 }
1333
1334 BINOP(Div)
1335
1336 ir_node *
1337 get_Div_mem (ir_node *node) {
1338   assert (node->op == op_Div);
1339   return get_irn_n(node, 0);
1340 }
1341
1342 void
1343 set_Div_mem (ir_node *node, ir_node *mem) {
1344   assert (node->op == op_Div);
1345   set_irn_n(node, 0, mem);
1346 }
1347
1348 BINOP(Mod)
1349
1350 ir_node *
1351 get_Mod_mem (ir_node *node) {
1352   assert (node->op == op_Mod);
1353   return get_irn_n(node, 0);
1354 }
1355
1356 void
1357 set_Mod_mem (ir_node *node, ir_node *mem) {
1358   assert (node->op == op_Mod);
1359   set_irn_n(node, 0, mem);
1360 }
1361
1362 UNOP(Abs)
1363 BINOP(And)
1364 BINOP(Or)
1365 BINOP(Eor)
1366 UNOP(Not)
1367 BINOP(Shl)
1368 BINOP(Shr)
1369 BINOP(Shrs)
1370 BINOP(Rot)
1371 BINOP(Cmp)
1372 UNOP(Conv)
1373 UNOP(Cast)
1374
1375 type *
1376 get_Cast_type (ir_node *node) {
1377   assert (node->op == op_Cast);
1378   return node->attr.cast.totype;
1379 }
1380
1381 void
1382 set_Cast_type (ir_node *node, type *to_tp) {
1383   assert (node->op == op_Cast);
1384   node->attr.cast.totype = to_tp;
1385 }
1386
1387 int
1388 is_unop (ir_node *node) {
1389   return (node->op->opar == oparity_unary);
1390 }
1391
1392 ir_node *
1393 get_unop_op (ir_node *node) {
1394   if (node->op->opar == oparity_unary)
1395     return get_irn_n(node, node->op->op_index);
1396
1397   assert(node->op->opar == oparity_unary);
1398   return NULL;
1399 }
1400
1401 void
1402 set_unop_op (ir_node *node, ir_node *op) {
1403   if (node->op->opar == oparity_unary)
1404     set_irn_n(node, node->op->op_index, op);
1405
1406   assert(node->op->opar == oparity_unary);
1407 }
1408
1409 int
1410 is_binop (ir_node *node) {
1411   return (node->op->opar == oparity_binary);
1412 }
1413
1414 ir_node *
1415 get_binop_left (ir_node *node) {
1416   if (node->op->opar == oparity_binary)
1417     return get_irn_n(node, node->op->op_index);
1418
1419   assert(node->op->opar == oparity_binary);
1420   return NULL;
1421 }
1422
1423 void
1424 set_binop_left (ir_node *node, ir_node *left) {
1425   if (node->op->opar == oparity_binary)
1426     set_irn_n(node, node->op->op_index, left);
1427
1428   assert (node->op->opar == oparity_binary);
1429 }
1430
1431 ir_node *
1432 get_binop_right (ir_node *node) {
1433   if (node->op->opar == oparity_binary)
1434     return get_irn_n(node, node->op->op_index + 1);
1435
1436   assert(node->op->opar == oparity_binary);
1437   return NULL;
1438 }
1439
1440 void
1441 set_binop_right (ir_node *node, ir_node *right) {
1442   if (node->op->opar == oparity_binary)
1443     set_irn_n(node, node->op->op_index + 1, right);
1444
1445   assert (node->op->opar == oparity_binary);
1446 }
1447
1448 int is_Phi (ir_node *n) {
1449   ir_op *op;
1450
1451   assert(n);
1452   op = get_irn_op(n);
1453
1454   if (op == op_Filter) return interprocedural_view;
1455
1456   if (op == op_Phi)
1457     return  ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
1458          (get_irn_arity(n) > 0));
1459
1460   return 0;
1461 }
1462
1463 int is_Phi0 (ir_node *n) {
1464   assert(n);
1465
1466   return ((get_irn_op(n) == op_Phi) &&
1467       (get_irn_arity(n) == 0) &&
1468       (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
1469 }
1470
1471 ir_node **
1472 get_Phi_preds_arr (ir_node *node) {
1473   assert (node->op == op_Phi);
1474   return (ir_node **)&(get_irn_in(node)[1]);
1475 }
1476
1477 int
1478 get_Phi_n_preds (ir_node *node) {
1479   assert (is_Phi(node) || is_Phi0(node));
1480   return (get_irn_arity(node));
1481 }
1482
1483 /*
1484 void set_Phi_n_preds (ir_node *node, int n_preds) {
1485   assert (node->op == op_Phi);
1486 }
1487 */
1488
1489 ir_node *
1490 get_Phi_pred (ir_node *node, int pos) {
1491   assert (is_Phi(node) || is_Phi0(node));
1492   return get_irn_n(node, pos);
1493 }
1494
1495 void
1496 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1497   assert (is_Phi(node) || is_Phi0(node));
1498   set_irn_n(node, pos, pred);
1499 }
1500
1501 ir_node *
1502 get_Load_mem (ir_node *node) {
1503   assert (node->op == op_Load);
1504   return get_irn_n(node, 0);
1505 }
1506
1507 void
1508 set_Load_mem (ir_node *node, ir_node *mem) {
1509   assert (node->op == op_Load);
1510   set_irn_n(node, 0, mem);
1511 }
1512
1513 ir_node *
1514 get_Load_ptr (ir_node *node) {
1515   assert (node->op == op_Load);
1516   return get_irn_n(node, 1);
1517 }
1518
1519 void
1520 set_Load_ptr (ir_node *node, ir_node *ptr) {
1521   assert (node->op == op_Load);
1522   set_irn_n(node, 1, ptr);
1523 }
1524
1525
1526 ir_node *
1527 get_Store_mem (ir_node *node) {
1528   assert (node->op == op_Store);
1529   return get_irn_n(node, 0);
1530 }
1531
1532 void
1533 set_Store_mem (ir_node *node, ir_node *mem) {
1534   assert (node->op == op_Store);
1535   set_irn_n(node, 0, mem);
1536 }
1537
1538 ir_node *
1539 get_Store_ptr (ir_node *node) {
1540   assert (node->op == op_Store);
1541   return get_irn_n(node, 1);
1542 }
1543
1544 void
1545 set_Store_ptr (ir_node *node, ir_node *ptr) {
1546   assert (node->op == op_Store);
1547   set_irn_n(node, 1, ptr);
1548 }
1549
1550 ir_node *
1551 get_Store_value (ir_node *node) {
1552   assert (node->op == op_Store);
1553   return get_irn_n(node, 2);
1554 }
1555
1556 void
1557 set_Store_value (ir_node *node, ir_node *value) {
1558   assert (node->op == op_Store);
1559   set_irn_n(node, 2, value);
1560 }
1561
1562 ir_node *
1563 get_Alloc_mem (ir_node *node) {
1564   assert (node->op == op_Alloc);
1565   return get_irn_n(node, 0);
1566 }
1567
1568 void
1569 set_Alloc_mem (ir_node *node, ir_node *mem) {
1570   assert (node->op == op_Alloc);
1571   set_irn_n(node, 0, mem);
1572 }
1573
1574 ir_node *
1575 get_Alloc_size (ir_node *node) {
1576   assert (node->op == op_Alloc);
1577   return get_irn_n(node, 1);
1578 }
1579
1580 void
1581 set_Alloc_size (ir_node *node, ir_node *size) {
1582   assert (node->op == op_Alloc);
1583   set_irn_n(node, 1, size);
1584 }
1585
1586 type  *
1587 get_Alloc_type (ir_node *node) {
1588   assert (node->op == op_Alloc);
1589   return node->attr.a.type = skip_tid(node->attr.a.type);
1590 }
1591
1592 void
1593 set_Alloc_type (ir_node *node, type *tp) {
1594   assert (node->op == op_Alloc);
1595   node->attr.a.type = tp;
1596 }
1597
1598 where_alloc
1599 get_Alloc_where (ir_node *node) {
1600   assert (node->op == op_Alloc);
1601   return node->attr.a.where;
1602 }
1603
1604 void
1605 set_Alloc_where (ir_node *node, where_alloc where) {
1606   assert (node->op == op_Alloc);
1607   node->attr.a.where = where;
1608 }
1609
1610
1611 ir_node *
1612 get_Free_mem (ir_node *node) {
1613   assert (node->op == op_Free);
1614   return get_irn_n(node, 0);
1615 }
1616
1617 void
1618 set_Free_mem (ir_node *node, ir_node *mem) {
1619   assert (node->op == op_Free);
1620   set_irn_n(node, 0, mem);
1621 }
1622
1623 ir_node *
1624 get_Free_ptr (ir_node *node) {
1625   assert (node->op == op_Free);
1626   return get_irn_n(node, 1);
1627 }
1628
1629 void
1630 set_Free_ptr (ir_node *node, ir_node *ptr) {
1631   assert (node->op == op_Free);
1632   set_irn_n(node, 1, ptr);
1633 }
1634
1635 ir_node *
1636 get_Free_size (ir_node *node) {
1637   assert (node->op == op_Free);
1638   return get_irn_n(node, 2);
1639 }
1640
1641 void
1642 set_Free_size (ir_node *node, ir_node *size) {
1643   assert (node->op == op_Free);
1644   set_irn_n(node, 2, size);
1645 }
1646
1647 type  *
1648 get_Free_type (ir_node *node) {
1649   assert (node->op == op_Free);
1650   return node->attr.f = skip_tid(node->attr.f);
1651 }
1652
1653 void
1654 set_Free_type (ir_node *node, type *tp) {
1655   assert (node->op == op_Free);
1656   node->attr.f = tp;
1657 }
1658
1659 ir_node **
1660 get_Sync_preds_arr (ir_node *node) {
1661   assert (node->op == op_Sync);
1662   return (ir_node **)&(get_irn_in(node)[1]);
1663 }
1664
1665 int
1666 get_Sync_n_preds (ir_node *node) {
1667   assert (node->op == op_Sync);
1668   return (get_irn_arity(node));
1669 }
1670
1671 /*
1672 void
1673 set_Sync_n_preds (ir_node *node, int n_preds) {
1674   assert (node->op == op_Sync);
1675 }
1676 */
1677
1678 ir_node *
1679 get_Sync_pred (ir_node *node, int pos) {
1680   assert (node->op == op_Sync);
1681   return get_irn_n(node, pos);
1682 }
1683
1684 void
1685 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1686   assert (node->op == op_Sync);
1687   set_irn_n(node, pos, pred);
1688 }
1689
1690 ir_node *
1691 get_Proj_pred (ir_node *node) {
1692   assert (is_Proj(node));
1693   return get_irn_n(node, 0);
1694 }
1695
1696 void
1697 set_Proj_pred (ir_node *node, ir_node *pred) {
1698   assert (is_Proj(node));
1699   set_irn_n(node, 0, pred);
1700 }
1701
1702 long
1703 get_Proj_proj (ir_node *node) {
1704   assert (is_Proj(node));
1705   if (get_irn_opcode(node) == iro_Proj) {
1706     return node->attr.proj;
1707   } else {
1708     assert(get_irn_opcode(node) == iro_Filter);
1709     return node->attr.filter.proj;
1710   }
1711 }
1712
1713 void
1714 set_Proj_proj (ir_node *node, long proj) {
1715   assert (node->op == op_Proj);
1716   node->attr.proj = proj;
1717 }
1718
1719 ir_node **
1720 get_Tuple_preds_arr (ir_node *node) {
1721   assert (node->op == op_Tuple);
1722   return (ir_node **)&(get_irn_in(node)[1]);
1723 }
1724
1725 int
1726 get_Tuple_n_preds (ir_node *node) {
1727   assert (node->op == op_Tuple);
1728   return (get_irn_arity(node));
1729 }
1730
1731 /*
1732 void
1733 set_Tuple_n_preds (ir_node *node, int n_preds) {
1734   assert (node->op == op_Tuple);
1735 }
1736 */
1737
1738 ir_node *
1739 get_Tuple_pred (ir_node *node, int pos) {
1740   assert (node->op == op_Tuple);
1741   return get_irn_n(node, pos);
1742 }
1743
1744 void
1745 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1746   assert (node->op == op_Tuple);
1747   set_irn_n(node, pos, pred);
1748 }
1749
1750 ir_node *
1751 get_Id_pred (ir_node *node) {
1752   assert (node->op == op_Id);
1753   return get_irn_n(node, 0);
1754 }
1755
1756 void
1757 set_Id_pred (ir_node *node, ir_node *pred) {
1758   assert (node->op == op_Id);
1759   set_irn_n(node, 0, pred);
1760 }
1761
1762 ir_node *get_Confirm_value (ir_node *node) {
1763   assert (node->op == op_Confirm);
1764   return get_irn_n(node, 0);
1765 }
1766 void     set_Confirm_value (ir_node *node, ir_node *value) {
1767   assert (node->op == op_Confirm);
1768   set_irn_n(node, 0, value);
1769 }
1770 ir_node *get_Confirm_bound (ir_node *node) {
1771   assert (node->op == op_Confirm);
1772   return get_irn_n(node, 1);
1773 }
1774 void     set_Confirm_bound (ir_node *node, ir_node *bound) {
1775   assert (node->op == op_Confirm);
1776   set_irn_n(node, 0, bound);
1777 }
1778 pn_Cmp   get_Confirm_cmp   (ir_node *node) {
1779   assert (node->op == op_Confirm);
1780   return node->attr.confirm_cmp;
1781 }
1782 void     set_Confirm_cmp   (ir_node *node, pn_Cmp cmp) {
1783   assert (node->op == op_Confirm);
1784   node->attr.confirm_cmp = cmp;
1785 }
1786
1787
1788 ir_node *
1789 get_Filter_pred (ir_node *node) {
1790   assert(node->op == op_Filter);
1791   return node->in[1];
1792 }
1793 void
1794 set_Filter_pred (ir_node *node, ir_node *pred) {
1795   assert(node->op == op_Filter);
1796   node->in[1] = pred;
1797 }
1798 long
1799 get_Filter_proj(ir_node *node) {
1800   assert(node->op == op_Filter);
1801   return node->attr.filter.proj;
1802 }
1803 void
1804 set_Filter_proj (ir_node *node, long proj) {
1805   assert(node->op == op_Filter);
1806   node->attr.filter.proj = proj;
1807 }
1808
1809 /* Don't use get_irn_arity, get_irn_n in implementation as access
1810    shall work independent of view!!! */
1811 void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
1812   assert(node->op == op_Filter);
1813   if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
1814     node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
1815     node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
1816     memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
1817     node->attr.filter.in_cg[0] = node->in[0];
1818   }
1819   memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
1820 }
1821
1822 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
1823   assert(node->op == op_Filter && node->attr.filter.in_cg &&
1824      0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
1825   node->attr.filter.in_cg[pos + 1] = pred;
1826 }
1827 int get_Filter_n_cg_preds(ir_node *node) {
1828   assert(node->op == op_Filter && node->attr.filter.in_cg);
1829   return (ARR_LEN(node->attr.filter.in_cg) - 1);
1830 }
1831 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
1832   int arity;
1833   assert(node->op == op_Filter && node->attr.filter.in_cg &&
1834      0 <= pos);
1835   arity = ARR_LEN(node->attr.filter.in_cg);
1836   assert(pos <  arity - 1);
1837   return node->attr.filter.in_cg[pos + 1];
1838 }
1839
1840
1841 ir_graph *
1842 get_irn_irg(ir_node *node) {
1843   if (get_irn_op(node) != op_Block)
1844     node = get_nodes_block(node);
1845   if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
1846     node = get_nodes_block(node);
1847   assert(get_irn_op(node) == op_Block);
1848   return node->attr.block.irg;
1849 }
1850
1851
1852 /*----------------------------------------------------------------*/
1853 /*  Auxiliary routines                                            */
1854 /*----------------------------------------------------------------*/
1855
1856 ir_node *
1857 skip_Proj (ir_node *node) {
1858   /* don't assert node !!! */
1859   if (node && is_Proj(node)) {
1860     return get_Proj_pred(node);
1861   } else {
1862     return node;
1863   }
1864 }
1865
1866 ir_node *
1867 skip_Tuple (ir_node *node) {
1868   ir_node *pred;
1869
1870   if (!get_opt_normalize()) return node;
1871
1872   node = skip_Id(node);
1873   if (get_irn_op(node) == op_Proj) {
1874     pred = skip_Id(get_Proj_pred(node));
1875     if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
1876       pred = skip_Id(skip_Tuple(pred));
1877     if (get_irn_op(pred) == op_Tuple)
1878       return get_Tuple_pred(pred, get_Proj_proj(node));
1879   }
1880   return node;
1881 }
1882
1883 /** returns operand of node if node is a Cast */
1884 ir_node *skip_Cast  (ir_node *node) {
1885   if (node && get_irn_op(node) == op_Cast) {
1886     return skip_Id(get_irn_n(node, 0));
1887   } else {
1888     return node;
1889   }
1890 }
1891
1892 #if 0
1893 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
1894    than any other approach, as Id chains are resolved and all point to the real node, or
1895    all id's are self loops. */
1896 ir_node *
1897 skip_Id (ir_node *node) {
1898   /* don't assert node !!! */
1899
1900   if (!get_opt_normalize()) return node;
1901
1902   /* Don't use get_Id_pred:  We get into an endless loop for
1903      self-referencing Ids. */
1904   if (node && (node->op == op_Id) && (node != node->in[0+1])) {
1905     ir_node *rem_pred = node->in[0+1];
1906     ir_node *res;
1907
1908     assert (get_irn_arity (node) > 0);
1909
1910     node->in[0+1] = node;
1911     res = skip_Id(rem_pred);
1912     if (res->op == op_Id) /* self-loop */ return node;
1913
1914     node->in[0+1] = res;
1915     return res;
1916   } else {
1917     return node;
1918   }
1919 }
1920 #else
1921 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
1922    than any other approach, as Id chains are resolved and all point to the real node, or
1923    all id's are self loops. */
1924 ir_node *
1925 skip_Id (ir_node *node) {
1926   ir_node *pred;
1927   /* don't assert node !!! */
1928
1929   if (!node || (node->op != op_Id)) return node;
1930
1931   if (!get_opt_normalize()) return node;
1932
1933   /* Don't use get_Id_pred:  We get into an endless loop for
1934      self-referencing Ids. */
1935   pred = node->in[0+1];
1936
1937   if (pred->op != op_Id) return pred;
1938
1939   if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
1940     ir_node *rem_pred, *res;
1941
1942     if (pred->op != op_Id) return pred; /* shortcut */
1943     rem_pred = pred;
1944
1945     assert (get_irn_arity (node) > 0);
1946
1947     node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
1948     res = skip_Id(rem_pred);
1949     if (res->op == op_Id) /* self-loop */ return node;
1950
1951     node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
1952     return res;
1953   } else {
1954     return node;
1955   }
1956 }
1957 #endif
1958
1959 int
1960 is_Bad (ir_node *node) {
1961   assert(node);
1962   if ((node) && get_irn_opcode(node) == iro_Bad)
1963     return 1;
1964   return 0;
1965 }
1966
1967 int
1968 is_no_Block (ir_node *node) {
1969   assert(node);
1970   return (get_irn_opcode(node) != iro_Block);
1971 }
1972
1973 int
1974 is_Block (ir_node *node) {
1975   assert(node);
1976   return (get_irn_opcode(node) == iro_Block);
1977 }
1978
1979 /* returns true if node is a Unknown node. */
1980 int
1981 is_Unknown (ir_node *node) {
1982   assert(node);
1983   return (get_irn_opcode(node) == iro_Unknown);
1984 }
1985
1986 int
1987 is_Proj (const ir_node *node) {
1988   assert(node);
1989   return node->op == op_Proj
1990     || (!interprocedural_view && node->op == op_Filter);
1991 }
1992
1993 /* Returns true if the operation manipulates control flow. */
1994 int
1995 is_cfop(ir_node *node) {
1996   return is_cfopcode(get_irn_op(node));
1997 }
1998
1999 /* Returns true if the operation manipulates interprocedural control flow:
2000    CallBegin, EndReg, EndExcept */
2001 int is_ip_cfop(ir_node *node) {
2002   return is_ip_cfopcode(get_irn_op(node));
2003 }
2004
2005 /* Returns true if the operation can change the control flow because
2006    of an exception. */
2007 int
2008 is_fragile_op(ir_node *node) {
2009   return is_op_fragile(get_irn_op(node));
2010 }
2011
2012 /* Returns the memory operand of fragile operations. */
2013 ir_node *get_fragile_op_mem(ir_node *node) {
2014   assert(node && is_fragile_op(node));
2015
2016   switch (get_irn_opcode (node)) {
2017   case iro_Call  :
2018   case iro_Quot  :
2019   case iro_DivMod:
2020   case iro_Div   :
2021   case iro_Mod   :
2022   case iro_Load  :
2023   case iro_Store :
2024   case iro_Alloc :
2025     return get_irn_n(node, 0);
2026   case iro_Bad   :
2027   case iro_Unknown:
2028     return node;
2029   default: ;
2030     assert(0 && "should not be reached");
2031     return NULL;
2032   }
2033 }
2034
2035 #ifdef DEBUG_libfirm
2036 void dump_irn (ir_node *n) {
2037   int i, arity = get_irn_arity(n);
2038   printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
2039   if (!is_Block(n)) {
2040     ir_node *pred = get_irn_n(n, -1);
2041     printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2042        get_irn_node_nr(pred), (void *)pred);
2043   }
2044   printf("  preds: \n");
2045   for (i = 0; i < arity; ++i) {
2046     ir_node *pred = get_irn_n(n, i);
2047     printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
2048        get_irn_node_nr(pred), (void *)pred);
2049   }
2050 }
2051
2052 #else  /* DEBUG_libfirm */
2053 void dump_irn (ir_node *n) {}
2054 #endif /* DEBUG_libfirm */