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