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