nsz Git - libfirm/blob - ir/ir/irnode.c

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