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