X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=97e0392b7f5e22e6e69935c81e2590ec7b8760b9;hb=70835fa5f038a3532642f5ea2b0038a1af6038e2;hp=cfeb23bd650968623d4e929791faba65b5eebe39;hpb=897fa7894e7573096bbf04746b422f3ee5ec511b;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index cfeb23bd6..97e0392b7 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -20,10 +20,8 @@
 #include "irgraph_t.h"
 #include "irmode_t.h"
 #include "typegmod.h"
-#include "array.h"
 #include "irbackedge_t.h"
 #include "irdump.h"
-#include "irflag_t.h"
 #include "irop_t.h"
 #include "irprog_t.h"
 
@@ -31,21 +29,11 @@
 
 /* some constants fixing the positions of nodes predecessors
    in the in array */
-#define CALL_PARAM_OFFSET 2
-#define SEL_INDEX_OFFSET 2
-#define RETURN_RESULT_OFFSET 1  /* mem is not a result */
-#define END_KEEPALIVE_OFFSET 0
-
-/* Declarations for inlineing */
-INLINE ir_node ** get_irn_in (const ir_node *node);
-INLINE ir_mode *get_irn_mode (const ir_node *node);
-INLINE ir_op *get_irn_op (const ir_node *node);
-INLINE opcode get_irn_opcode (const ir_node *node);
-INLINE ident *get_irn_opident (const ir_node *node);
-INLINE type *get_SymConst_type (ir_node *node);
-INLINE ir_node *skip_nop (ir_node *node);
-INLINE int is_Proj (const ir_node *node);
-
+#define CALL_PARAM_OFFSET     2
+#define FUNCCALL_PARAM_OFFSET 1
+#define SEL_INDEX_OFFSET      2
+#define RETURN_RESULT_OFFSET  1  /* mem is not a result */
+#define END_KEEPALIVE_OFFSET  0
 
 static const char *pnc_name_arr [] = {
   "False", "Eq", "Lt", "Le",
@@ -57,7 +45,7 @@ static const char *pnc_name_arr [] = {
 /**
  * returns the pnc name from an pnc constant
  */
-INLINE const char *get_pnc_string(int pnc) {
+const char *get_pnc_string(int pnc) {
   return pnc_name_arr[pnc];
 }
 
@@ -93,7 +81,7 @@ const char *pns_name_arr [] = {
 };
 
 const char *symconst_name_arr [] = {
-  "type_tag", "size", "linkage_ptr_info"
+  "type_tag", "size", "addr_name", "addr_ent"
 };
 
 void
@@ -107,15 +95,16 @@ init_irnode (void)
  * some incoming irnodes.
  * If arity is negative, a node with a dynamic array is created.
  */
-INLINE ir_node *
+ir_node *
 new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
-	     int arity, ir_node **in)
+         int arity, ir_node **in)
 {
   ir_node *res;
   int node_size = offsetof (ir_node, attr) +  op->attr_size;
 
   assert(irg && op && mode);
   res = (ir_node *) obstack_alloc (irg->obst, node_size);
+  memset((void *)res, 0, node_size);
 
   res->kind = k_ir_node;
   res->op = op;
@@ -149,42 +138,26 @@ copy_attrs (const ir_node *old_node, ir_node *new_node) {
   memcpy(&new_node->attr, &old_node->attr, get_op_attr_size(get_irn_op(old_node)));
 }
 
-/** getting some parameters from ir_nodes **/
+/*-- getting some parameters from ir_nodes --*/
 
 int
-is_ir_node (const void *thing) {
-  if (get_kind(thing) == k_ir_node)
-    return 1;
-  else
-    return 0;
+(is_ir_node)(const void *thing) {
+  return __is_ir_node(thing);
 }
 
-/* returns the number of predecessors without the block predecessor. */
-INLINE int
-get_irn_intra_arity (const ir_node *node) {
-  assert(node);
-  return ARR_LEN(node->in) - 1;
+int
+(get_irn_intra_arity)(const ir_node *node) {
+  return __get_irn_intra_arity(node);
 }
 
-/* returns the number of predecessors without the block predecessor. */
-INLINE int
-get_irn_inter_arity (const ir_node *node) {
-  assert(node);
-  if (get_irn_opcode(node) == iro_Filter) {
-    assert(node->attr.filter.in_cg);
-    return ARR_LEN(node->attr.filter.in_cg) - 1;
-  } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
-    return ARR_LEN(node->attr.block.in_cg) - 1;
-  }
-  return get_irn_intra_arity(node);
+int
+(get_irn_inter_arity)(const ir_node *node) {
+  return __get_irn_inter_arity(node);
 }
 
-/* returns the number of predecessors without the block predecessor. */
-INLINE int
-get_irn_arity (const ir_node *node) {
-  assert(node);
-  if (interprocedural_view) return get_irn_inter_arity(node);
-  return get_irn_intra_arity(node);
+int
+(get_irn_arity)(const ir_node *node) {
+  return __get_irn_arity(node);
 }
 
 /* Returns the array with ins. This array is shifted with respect to the
@@ -193,7 +166,7 @@ get_irn_arity (const ir_node *node) {
    The order of the predecessors in this array is not guaranteed, except that
    lists of operands as predecessors of Block or arguments of a Call are
    consecutive. */
-INLINE ir_node **
+ir_node **
 get_irn_in (const ir_node *node) {
   assert(node);
   if (interprocedural_view) { /* handle Filter and Block specially */
@@ -208,7 +181,7 @@ get_irn_in (const ir_node *node) {
   return node->in;
 }
 
-INLINE void
+void
 set_irn_in (ir_node *node, int arity, ir_node **in) {
   ir_node *** arr;
   assert(node);
@@ -233,40 +206,25 @@ set_irn_in (ir_node *node, int arity, ir_node **in) {
   memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
 }
 
-INLINE ir_node *
-get_irn_intra_n (ir_node *node, int n) {
-  return (node->in[n + 1] = skip_nop(node->in[n + 1]));
+ir_node *
+(get_irn_intra_n)(ir_node *node, int n) {
+  return __get_irn_intra_n (node, n);
 }
 
-INLINE ir_node*
-get_irn_inter_n (ir_node *node, int n) {
-  /* handle Filter and Block specially */
-  if (get_irn_opcode(node) == iro_Filter) {
-    assert(node->attr.filter.in_cg);
-    return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1]));
-  } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
-    return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1]));
-  }
-
-  return get_irn_intra_n (node, n);
+ir_node *
+(get_irn_inter_n)(ir_node *node, int n) {
+  return __get_irn_inter_n (node, n);
 }
 
-/* to iterate through the predecessors without touching the array */
-/* To iterate over the operands iterate from 0 to i < get_irn_arity(),
-   to iterate including the Block predecessor iterate from i = -1 to
-   i < get_irn_arity.
-   If it is a block, the entry -1 is NULL. */
-INLINE ir_node *
-get_irn_n (ir_node *node, int n) {
-  assert(node); assert(-1 <= n && n < get_irn_arity(node));
-  if (interprocedural_view)  return get_irn_inter_n (node, n);
-  return get_irn_intra_n (node, n);
+ir_node *
+(get_irn_n)(ir_node *node, int n) {
+  return __get_irn_n (node, n);
 }
 
-
-INLINE void
+void
 set_irn_n (ir_node *node, int n, ir_node *in) {
   assert(node && -1 <= n && n < get_irn_arity(node));
+	assert(in && in->kind == k_ir_node);
   if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
     /* Change block pred in both views! */
     node->in[n + 1] = in;
@@ -288,22 +246,18 @@ set_irn_n (ir_node *node, int n, ir_node *in) {
   node->in[n + 1] = in;
 }
 
-INLINE ir_mode *
-get_irn_mode (const ir_node *node)
-{
-  assert (node);
-  return node->mode;
+ir_mode *
+(get_irn_mode)(const ir_node *node) {
+  return __get_irn_mode(node);
 }
 
-INLINE void
-set_irn_mode (ir_node *node, ir_mode *mode)
+void
+(set_irn_mode)(ir_node *node, ir_mode *mode)
 {
-  assert (node);
-  node->mode=mode;
-  return;
+  __set_irn_mode(node, mode);
 }
 
-INLINE modecode
+modecode
 get_irn_modecode (const ir_node *node)
 {
   assert (node);
@@ -311,107 +265,116 @@ get_irn_modecode (const ir_node *node)
 }
 
 /** Gets the string representation of the mode .*/
-INLINE const char *
+const char *
 get_irn_modename (const ir_node *node)
 {
   assert(node);
   return get_mode_name(node->mode);
 }
 
-INLINE ident *
+ident *
 get_irn_modeident (const ir_node *node)
 {
   assert(node);
   return get_mode_ident(node->mode);
 }
 
-INLINE ir_op *
-get_irn_op (const ir_node *node)
+ir_op *
+(get_irn_op)(const ir_node *node)
 {
-  assert (node);
-  return node->op;
+  return __get_irn_op(node);
 }
 
 /* should be private to the library: */
-INLINE void
+void
 set_irn_op (ir_node *node, ir_op *op)
 {
   assert (node);
   node->op = op;
 }
 
-INLINE opcode
-get_irn_opcode (const ir_node *node)
+opcode
+(get_irn_opcode)(const ir_node *node)
 {
-  assert (k_ir_node == get_kind(node));
-  assert (node -> op);
-  return node->op->code;
+  return __get_irn_opcode(node);
 }
 
-INLINE const char *
+const char *
 get_irn_opname (const ir_node *node)
 {
   assert(node);
+  if ((get_irn_op((ir_node *)node) == op_Phi) &&
+      (get_irg_phase_state(get_irn_irg((ir_node *)node)) == phase_building) &&
+      (get_irn_arity((ir_node *)node) == 0)) return "Phi0";
   return get_id_str(node->op->name);
 }
 
-INLINE ident *
+ident *
 get_irn_opident (const ir_node *node)
 {
   assert(node);
   return node->op->name;
 }
 
-INLINE unsigned long
-get_irn_visited (const ir_node *node)
+unsigned long
+(get_irn_visited)(const ir_node *node)
 {
-  assert (node);
-  return node->visited;
+  return __get_irn_visited(node);
 }
 
-INLINE void
-set_irn_visited (ir_node *node, unsigned long visited)
+void
+(set_irn_visited)(ir_node *node, unsigned long visited)
 {
-  assert (node);
-  node->visited = visited;
+  __set_irn_visited(node, visited);
 }
 
-INLINE void
-mark_irn_visited (ir_node *node) {
-  assert (node);
-  node->visited = current_ir_graph->visited;
+void
+(mark_irn_visited)(ir_node *node) {
+  __mark_irn_visited(node);
 }
 
-INLINE int
-irn_not_visited  (const ir_node *node) {
-  assert (node);
-  return (node->visited < current_ir_graph->visited);
+int
+(irn_not_visited)(const ir_node *node) {
+  return __irn_not_visited(node);
 }
 
-INLINE int
-irn_visited  (const ir_node *node) {
-  assert (node);
-  return (node->visited >= current_ir_graph->visited);
+int
+(irn_visited)(const ir_node *node) {
+  return __irn_visited(node);
 }
 
-INLINE void
-set_irn_link (ir_node *node, void *link) {
-  assert (node);
-  /* Link field is used for Phi construction and various optimizations
-     in iropt. */
-  assert(get_irg_phase_state(current_ir_graph) != phase_building);
+void
+(set_irn_link)(ir_node *node, void *link) {
+  __set_irn_link(node, link);
+}
 
-  node->link = link;
+void *
+(get_irn_link)(const ir_node *node) {
+  return __get_irn_link(node);
 }
 
-INLINE void *
-get_irn_link (const ir_node *node) {
-  assert (node);
-  return node->link;
+
+#ifdef DO_HEAPANALYSIS
+/* Access the abstract interpretation information of a node.
+   Returns NULL if no such information is available. */
+struct abstval *get_irn_abst_value(ir_node *n) {
+  return n->av;
+}
+/* Set the abstract interpretation information of a node. */
+void set_irn_abst_value(ir_node *n, struct abstval *os) {
+  n->av = os;
 }
+struct section *firm_get_irn_section(ir_node *n) {
+  return n->sec;
+}
+void firm_set_irn_section(ir_node *n, struct section *s) {
+  n->sec = s;
+}
+#endif /* DO_HEAPANALYSIS */
+
 
 /* Outputs a unique number for this node */
-INLINE long
+long
 get_irn_node_nr(const ir_node *node) {
   assert(node);
 #ifdef DEBUG_libfirm
@@ -421,70 +384,70 @@ get_irn_node_nr(const ir_node *node) {
 #endif
 }
 
-INLINE const_attr
+const_attr
 get_irn_const_attr (ir_node *node)
 {
   assert (node->op == op_Const);
   return node->attr.con;
 }
 
-INLINE long
+long
 get_irn_proj_attr (ir_node *node)
 {
   assert (node->op == op_Proj);
   return node->attr.proj;
 }
 
-INLINE alloc_attr
+alloc_attr
 get_irn_alloc_attr (ir_node *node)
 {
   assert (node->op == op_Alloc);
   return node->attr.a;
 }
 
-INLINE type *
+type *
 get_irn_free_attr     (ir_node *node)
 {
   assert (node->op == op_Free);
   return node->attr.f = skip_tid(node->attr.f);
 }
 
-INLINE symconst_attr
+symconst_attr
 get_irn_symconst_attr (ir_node *node)
 {
   assert (node->op == op_SymConst);
   return node->attr.i;
 }
 
-INLINE type *
+type *
 get_irn_call_attr (ir_node *node)
 {
   assert (node->op == op_Call);
   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 }
 
-INLINE type *
+type *
 get_irn_funccall_attr (ir_node *node)
 {
   assert (node->op == op_FuncCall);
   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 }
 
-INLINE sel_attr
+sel_attr
 get_irn_sel_attr (ir_node *node)
 {
   assert (node->op == op_Sel);
   return node->attr.s;
 }
 
-INLINE int
+int
 get_irn_phi_attr (ir_node *node)
 {
   assert (node->op == op_Phi);
   return node->attr.phi0_pos;
 }
 
-INLINE block_attr
+block_attr
 get_irn_block_attr (ir_node *node)
 {
   assert (node->op == op_Block);
@@ -495,13 +458,13 @@ get_irn_block_attr (ir_node *node)
 
 /* this works for all except Block */
 ir_node *
-get_nodes_Block (ir_node *node) {
+get_nodes_block (ir_node *node) {
   assert (!(node->op == op_Block));
   return get_irn_n(node, -1);
 }
 
-INLINE void
-set_nodes_Block (ir_node *node, ir_node *block) {
+void
+set_nodes_block (ir_node *node, ir_node *block) {
   assert (!(node->op == op_Block));
   set_irn_n(node, -1, block);
 }
@@ -546,7 +509,7 @@ int is_value_arg_pointer(ir_node *n) {
    the implementation of the graph data structure this can be a copy of
    the internal representation of predecessors as well as the internal
    array itself. Therefore writing to this array might obstruct the ir. */
-INLINE ir_node **
+ir_node **
 get_Block_cfgpred_arr (ir_node *node)
 {
   assert ((node->op == op_Block));
@@ -554,74 +517,69 @@ get_Block_cfgpred_arr (ir_node *node)
 }
 
 
-INLINE int
+int
 get_Block_n_cfgpreds (ir_node *node) {
   assert ((node->op == op_Block));
-  return (get_irn_arity(node));
+  return get_irn_arity(node);
 }
 
-INLINE ir_node *
+ir_node *
 get_Block_cfgpred (ir_node *node, int pos) {
+  assert(node);
   assert (node->op == op_Block);
-  /* debug @@@
-  if (-1 > pos || get_irn_arity(node) <= pos) {
-    dump_ir_block_graph(current_ir_graph);
-    printf("pos: %d, arity: %d ", pos, get_irn_arity(node));
-    DDMN(node);
-    } */
-  assert(node); assert(-1 <= pos && pos < get_irn_arity(node));
+  assert(-1 <= pos && pos < get_irn_arity(node));
   return get_irn_n(node, pos);
 }
 
-INLINE void
+void
 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
   assert (node->op == op_Block);
   set_irn_n(node, pos, pred);
 }
 
-INLINE bool
+bool
 get_Block_matured (ir_node *node) {
   assert (node->op == op_Block);
   return node->attr.block.matured;
 }
 
-INLINE void
+void
 set_Block_matured (ir_node *node, bool matured) {
   assert (node->op == op_Block);
   node->attr.block.matured = matured;
 }
-INLINE unsigned long
+unsigned long
 get_Block_block_visited (ir_node *node) {
   assert (node->op == op_Block);
   return node->attr.block.block_visited;
 }
 
-INLINE void
+void
 set_Block_block_visited (ir_node *node, unsigned long visit) {
   assert (node->op == op_Block);
   node->attr.block.block_visited = visit;
 }
 
 /* For this current_ir_graph must be set. */
-INLINE void
+void
 mark_Block_block_visited (ir_node *node) {
   assert (node->op == op_Block);
   node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
 }
 
-INLINE int
+int
 Block_not_block_visited(ir_node *node) {
   assert (node->op == op_Block);
   return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
 }
 
-INLINE ir_node *
+ir_node *
 get_Block_graph_arr (ir_node *node, int pos) {
   assert (node->op == op_Block);
   return node->attr.block.graph_arr[pos+1];
 }
 
-INLINE void
+void
 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
   assert (node->op == op_Block);
   node->attr.block.graph_arr[pos+1] = value;
@@ -644,12 +602,12 @@ get_Block_handler (ir_node *block) {
 / * handler handling for Nodes * /
 void
 set_Node_handler (ir_node *node, ir_node *handler) {
-  set_Block_handler (get_nodes_Block (node), handler);
+  set_Block_handler (get_nodes_block (node), handler);
 }
 
 ir_node *
 get_Node_handler (ir_node *node) {
-  return (get_Block_handler (get_nodes_Block (node)));
+  return (get_Block_handler (get_nodes_block (node)));
 }
 
 / * exc_t handling for Blocks * /
@@ -665,11 +623,11 @@ exc_t get_Block_exc (ir_node *block) {
 
 / * exc_t handling for Nodes * /
 void set_Node_exc (ir_node *node, exc_t exc) {
-  set_Block_exc (get_nodes_Block (node), exc);
+  set_Block_exc (get_nodes_block (node), exc);
 }
 
 exc_t get_Node_exc (ir_node *node) {
-  return (get_Block_exc (get_nodes_Block (node)));
+  return (get_Block_exc (get_nodes_block (node)));
 }
 */
 
@@ -681,7 +639,7 @@ void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
     node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
     {
       /* Fix backedge array.  fix_backedges operates depending on
-	 interprocedural_view. */
+     interprocedural_view. */
       bool ipv = interprocedural_view;
       interprocedural_view = true;
       fix_backedges(current_ir_graph->obst, node);
@@ -693,8 +651,8 @@ void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
 
 void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) {
   assert(node->op == op_Block &&
-	 node->attr.block.in_cg &&
-	 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
+     node->attr.block.in_cg &&
+     0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1);
   node->attr.block.in_cg[pos + 1] = pred;
 }
 
@@ -718,60 +676,46 @@ void remove_Block_cg_cfgpred_arr(ir_node * node) {
   node->attr.block.in_cg = NULL;
 }
 
-/* Start references the irg it is in. */
-INLINE ir_graph *
-get_Start_irg(ir_node *node) {
-  return get_irn_irg(node);
-}
-
-INLINE void
+void
 set_Start_irg(ir_node *node, ir_graph *irg) {
   assert(node->op == op_Start);
   assert(is_ir_graph(irg));
-  assert(0 && " Why set irg? ");
-  //node->attr.start.irg = irg;
+  assert(0 && " Why set irg? -- use set_irn_irg");
 }
 
-INLINE int
+int
 get_End_n_keepalives(ir_node *end) {
   assert (end->op == op_End);
   return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
 }
 
-INLINE ir_node *
+ir_node *
 get_End_keepalive(ir_node *end, int pos) {
   assert (end->op == op_End);
   return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
 }
 
-INLINE void
+void
 add_End_keepalive (ir_node *end, ir_node *ka) {
   assert (end->op == op_End);
   ARR_APP1 (ir_node *, end->in, ka);
 }
 
-INLINE void
+void
 set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
   assert (end->op == op_End);
   set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 }
 
-INLINE void
+void
 free_End (ir_node *end) {
   assert (end->op == op_End);
   end->kind = k_BAD;
   DEL_ARR_F(end->in);  /* GL @@@ tut nicht ! */
   end->in = NULL;   /* @@@ make sure we get an error if we use the
-		       in array afterwards ... */
+               in array afterwards ... */
 }
 
-ir_graph *get_EndReg_irg (ir_node *end) {
-  return get_irn_irg(end);
-}
-
-ir_graph *get_EndExcept_irg  (ir_node *end) {
-  return get_irn_irg(end);
-}
 
 /*
 > Implementing the case construct (which is where the constant Proj node is
@@ -804,49 +748,55 @@ I don't want to choose 3) as 2a) seems to have advantages for
 dataflow analysis and 3) does not allow to convert the representation to
 2a).
 */
-INLINE ir_node *
+ir_node *
 get_Cond_selector (ir_node *node) {
   assert (node->op == op_Cond);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Cond_selector (ir_node *node, ir_node *selector) {
   assert (node->op == op_Cond);
   set_irn_n(node, 0, selector);
 }
 
-INLINE cond_kind
+cond_kind
 get_Cond_kind (ir_node *node) {
   assert (node->op == op_Cond);
   return node->attr.c.kind;
 }
 
-INLINE void
+void
 set_Cond_kind (ir_node *node, cond_kind kind) {
   assert (node->op == op_Cond);
   node->attr.c.kind = kind;
 }
 
-INLINE ir_node *
+long
+get_Cond_defaultProj (ir_node *node) {
+  assert (node->op == op_Cond);
+  return node->attr.c.default_proj;
+}
+
+ir_node *
 get_Return_mem (ir_node *node) {
   assert (node->op == op_Return);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Return_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Return);
   set_irn_n(node, 0, mem);
 }
 
-INLINE int
+int
 get_Return_n_ress (ir_node *node) {
   assert (node->op == op_Return);
   return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
 }
 
-INLINE ir_node **
+ir_node **
 get_Return_res_arr (ir_node *node)
 {
   assert ((node->op == op_Return));
@@ -857,55 +807,55 @@ get_Return_res_arr (ir_node *node)
 }
 
 /*
-INLINE void
+void
 set_Return_n_res (ir_node *node, int results) {
   assert (node->op == op_Return);
 }
 */
 
-INLINE ir_node *
+ir_node *
 get_Return_res (ir_node *node, int pos) {
   assert (node->op == op_Return);
   assert (get_Return_n_ress(node) > pos);
   return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
 }
 
-INLINE void
+void
 set_Return_res (ir_node *node, int pos, ir_node *res){
   assert (node->op == op_Return);
   set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
 }
 
-INLINE ir_node *
+ir_node *
 get_Raise_mem (ir_node *node) {
   assert (node->op == op_Raise);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Raise_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Raise);
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
+ir_node *
 get_Raise_exo_ptr (ir_node *node) {
   assert (node->op == op_Raise);
   return get_irn_n(node, 1);
 }
 
-INLINE void
+void
 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
   assert (node->op == op_Raise);
   set_irn_n(node, 1, exo_ptr);
 }
 
-INLINE tarval *get_Const_tarval (ir_node *node) {
+tarval *get_Const_tarval (ir_node *node) {
   assert (node->op == op_Const);
   return node->attr.con.tv;
 }
 
-INLINE void
+void
 set_Const_tarval (ir_node *node, tarval *con) {
   assert (node->op == op_Const);
   node->attr.con.tv = con;
@@ -915,113 +865,125 @@ set_Const_tarval (ir_node *node, tarval *con) {
 /* The source language type.  Must be an atomic type.  Mode of type must
    be mode of node. For tarvals from entities type must be pointer to
    entity type. */
-INLINE type *
+type *
 get_Const_type (ir_node *node) {
   assert (node->op == op_Const);
   return node->attr.con.tp;
 }
 
-INLINE void
+void
 set_Const_type (ir_node *node, type *tp) {
   assert (node->op == op_Const);
   if (tp != unknown_type) {
     assert (is_atomic_type(tp));
     assert (get_type_mode(tp) == get_irn_mode(node));
-    assert (!tarval_is_entity(get_Const_tarval(node)) ||
-	    (is_pointer_type(tp) &&
-	     (get_pointer_points_to_type(tp) ==
-	      get_entity_type(get_tarval_entity(get_Const_tarval(node))))));
   }
 
   node->attr.con.tp = tp;
 }
 
 
-INLINE symconst_kind
+symconst_kind
 get_SymConst_kind (const ir_node *node) {
   assert (node->op == op_SymConst);
   return node->attr.i.num;
 }
 
-INLINE void
+void
 set_SymConst_kind (ir_node *node, symconst_kind num) {
   assert (node->op == op_SymConst);
   node->attr.i.num = num;
 }
 
-INLINE type *
+type *
 get_SymConst_type (ir_node *node) {
   assert (   (node->op == op_SymConst)
-          && (   get_SymConst_kind(node) == type_tag
-              || get_SymConst_kind(node) == size));
-  return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
+          && (   get_SymConst_kind(node) == symconst_type_tag
+              || get_SymConst_kind(node) == symconst_size));
+  return node->attr.i.sym.type_p = skip_tid(node->attr.i.sym.type_p);
 }
 
-INLINE void
+void
 set_SymConst_type (ir_node *node, type *tp) {
   assert (   (node->op == op_SymConst)
-          && (   get_SymConst_kind(node) == type_tag
-              || get_SymConst_kind(node) == size));
-  node->attr.i.tori.typ = tp;
+          && (   get_SymConst_kind(node) == symconst_type_tag
+              || get_SymConst_kind(node) == symconst_size));
+  node->attr.i.sym.type_p = tp;
 }
 
-INLINE ident *
-get_SymConst_ptrinfo (ir_node *node) {
+ident *
+get_SymConst_name (ir_node *node) {
   assert (   (node->op == op_SymConst)
-          && (get_SymConst_kind(node) == linkage_ptr_info));
-  return node->attr.i.tori.ptrinfo;
+          && (get_SymConst_kind(node) == symconst_addr_name));
+  return node->attr.i.sym.ident_p;
 }
 
-INLINE void
-set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
+void
+set_SymConst_name (ir_node *node, ident *name) {
   assert (   (node->op == op_SymConst)
-          && (get_SymConst_kind(node) == linkage_ptr_info));
-  node->attr.i.tori.ptrinfo = ptrinfo;
+          && (get_SymConst_kind(node) == symconst_addr_name));
+  node->attr.i.sym.ident_p = name;
 }
 
-INLINE type_or_id_p
-get_SymConst_type_or_id (ir_node *node) {
+
+/* Only to access SymConst of kind symconst_addr_ent.  Else assertion: */
+entity   *get_SymConst_entity (ir_node *node) {
+  assert (   (node->op == op_SymConst)
+          && (get_SymConst_kind (node) == symconst_addr_ent));
+  return node->attr.i.sym.entity_p;
+}
+
+void     set_SymConst_entity (ir_node *node, entity *ent) {
+  assert (   (node->op == op_SymConst)
+          && (get_SymConst_kind(node) == symconst_addr_ent));
+  node->attr.i.sym.entity_p  = ent;
+}
+
+
+union symconst_symbol
+get_SymConst_symbol (ir_node *node) {
   assert (node->op == op_SymConst);
-  return &(node->attr.i.tori);
+  return node->attr.i.sym;
 }
 
-INLINE void
-set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
+void
+set_SymConst_symbol (ir_node *node, union symconst_symbol sym) {
   assert (node->op == op_SymConst);
-  memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
+  //memcpy (&(node->attr.i.sym), sym, sizeof(type_or_id));
+  node->attr.i.sym = sym;
 }
 
-INLINE ir_node *
+ir_node *
 get_Sel_mem (ir_node *node) {
   assert (node->op == op_Sel);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Sel_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Sel);
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
+ir_node *
 get_Sel_ptr (ir_node *node) {
   assert (node->op == op_Sel);
   return get_irn_n(node, 1);
 }
 
-INLINE void
+void
 set_Sel_ptr (ir_node *node, ir_node *ptr) {
   assert (node->op == op_Sel);
   set_irn_n(node, 1, ptr);
 }
 
-INLINE int
+int
 get_Sel_n_indexs (ir_node *node) {
   assert (node->op == op_Sel);
   return (get_irn_arity(node) - SEL_INDEX_OFFSET);
 }
 
-INLINE ir_node **
+ir_node **
 get_Sel_index_arr (ir_node *node)
 {
   assert ((node->op == op_Sel));
@@ -1031,25 +993,25 @@ get_Sel_index_arr (ir_node *node)
     return NULL;
 }
 
-INLINE ir_node *
+ir_node *
 get_Sel_index (ir_node *node, int pos) {
   assert (node->op == op_Sel);
   return get_irn_n(node, pos + SEL_INDEX_OFFSET);
 }
 
-INLINE void
+void
 set_Sel_index (ir_node *node, int pos, ir_node *index) {
   assert (node->op == op_Sel);
   set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
 }
 
-INLINE entity *
+entity *
 get_Sel_entity (ir_node *node) {
   assert (node->op == op_Sel);
   return node->attr.s.ent;
 }
 
-INLINE void
+void
 set_Sel_entity (ir_node *node, entity *ent) {
   assert (node->op == op_Sel);
   node->attr.s.ent = ent;
@@ -1100,73 +1062,73 @@ set_InstOf_obj (ir_node *node, ir_node *obj) {
    Shr, Shrs, Rotate, Cmp */
 
 
-INLINE ir_node *
+ir_node *
 get_Call_mem (ir_node *node) {
   assert (node->op == op_Call);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Call_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Call);
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
+ir_node *
 get_Call_ptr (ir_node *node) {
   assert (node->op == op_Call);
   return get_irn_n(node, 1);
 }
 
-INLINE void
+void
 set_Call_ptr (ir_node *node, ir_node *ptr) {
   assert (node->op == op_Call);
   set_irn_n(node, 1, ptr);
 }
 
-INLINE ir_node **
+ir_node **
 get_Call_param_arr (ir_node *node) {
   assert (node->op == op_Call);
   return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
 }
 
-INLINE int
+int
 get_Call_n_params (ir_node *node)  {
   assert (node->op == op_Call);
   return (get_irn_arity(node) - CALL_PARAM_OFFSET);
 }
 
-INLINE int
+int
 get_Call_arity (ir_node *node) {
   assert (node->op == op_Call);
   return get_Call_n_params(node);
 }
 
-/* INLINE void
+/* void
 set_Call_arity (ir_node *node, ir_node *arity) {
   assert (node->op == op_Call);
 }
 */
 
-INLINE ir_node *
+ir_node *
 get_Call_param (ir_node *node, int pos) {
   assert (node->op == op_Call);
   return get_irn_n(node, pos + CALL_PARAM_OFFSET);
 }
 
-INLINE void
+void
 set_Call_param (ir_node *node, int pos, ir_node *param) {
   assert (node->op == op_Call);
   set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
 }
 
-INLINE type *
+type *
 get_Call_type (ir_node *node) {
   assert (node->op == op_Call);
   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 }
 
-INLINE void
+void
 set_Call_type (ir_node *node, type *tp) {
   assert (node->op == op_Call);
   assert (is_method_type(tp));
@@ -1208,9 +1170,6 @@ void set_CallBegin_ptr (ir_node *node, ir_node *ptr) {
   assert(node->op == op_CallBegin);
   set_irn_n(node, 0, ptr);
 }
-ir_graph * get_CallBegin_irg (ir_node *node) {
-  return get_irn_irg(node);
-}
 ir_node * get_CallBegin_call (ir_node *node) {
   assert(node->op == op_CallBegin);
   return node->attr.callbegin.call;
@@ -1220,61 +1179,61 @@ void  set_CallBegin_call (ir_node *node, ir_node *call) {
   node->attr.callbegin.call = call;
 }
 
-INLINE ir_node *
+ir_node *
 get_FuncCall_ptr (ir_node *node) {
   assert (node->op == op_FuncCall);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_FuncCall_ptr (ir_node *node, ir_node *ptr) {
   assert (node->op == op_FuncCall);
   set_irn_n(node, 0, ptr);
 }
 
-INLINE ir_node **
+ir_node **
 get_FuncCall_param_arr (ir_node *node) {
   assert (node->op == op_FuncCall);
-  return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET];
+  return (ir_node **)&get_irn_in(node)[FUNCCALL_PARAM_OFFSET];
 }
 
-INLINE int
+int
 get_FuncCall_n_params (ir_node *node)  {
   assert (node->op == op_FuncCall);
-  return (get_irn_arity(node) - CALL_PARAM_OFFSET);
+  return (get_irn_arity(node) - FUNCCALL_PARAM_OFFSET);
 }
 
-INLINE int
+int
 get_FuncCall_arity (ir_node *node) {
   assert (node->op == op_FuncCall);
   return get_FuncCall_n_params(node);
 }
 
-/* INLINE void
+/* void
 set_FuncCall_arity (ir_node *node, ir_node *arity) {
   assert (node->op == op_FuncCall);
 }
 */
 
-INLINE ir_node *
+ir_node *
 get_FuncCall_param (ir_node *node, int pos) {
   assert (node->op == op_FuncCall);
-  return get_irn_n(node, pos + CALL_PARAM_OFFSET);
+  return get_irn_n(node, pos + FUNCCALL_PARAM_OFFSET);
 }
 
-INLINE void
+void
 set_FuncCall_param (ir_node *node, int pos, ir_node *param) {
   assert (node->op == op_FuncCall);
-  set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
+  set_irn_n(node, pos + FUNCCALL_PARAM_OFFSET, param);
 }
 
-INLINE type *
+type *
 get_FuncCall_type (ir_node *node) {
   assert (node->op == op_FuncCall);
   return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
 }
 
-INLINE void
+void
 set_FuncCall_type (ir_node *node, type *tp) {
   assert (node->op == op_FuncCall);
   assert (is_method_type(tp));
@@ -1309,32 +1268,32 @@ void remove_FuncCall_callee_arr(ir_node * node) {
 }
 
 
-#define BINOP(OP)					\
-ir_node * get_##OP##_left(ir_node *node) {		\
-  assert(node->op == op_##OP);				\
-  return get_irn_n(node, node->op->op_index);		\
-}							\
-void set_##OP##_left(ir_node *node, ir_node *left) {	\
-  assert(node->op == op_##OP);				\
-  set_irn_n(node, node->op->op_index, left);		\
-}							\
-ir_node *get_##OP##_right(ir_node *node) {		\
-  assert(node->op == op_##OP);				\
-  return get_irn_n(node, node->op->op_index + 1);	\
-}							\
-void set_##OP##_right(ir_node *node, ir_node *right) {	\
-  assert(node->op == op_##OP);				\
-  set_irn_n(node, node->op->op_index + 1, right);	\
+#define BINOP(OP)                   \
+ir_node * get_##OP##_left(ir_node *node) {      \
+  assert(node->op == op_##OP);              \
+  return get_irn_n(node, node->op->op_index);       \
+}                           \
+void set_##OP##_left(ir_node *node, ir_node *left) {    \
+  assert(node->op == op_##OP);              \
+  set_irn_n(node, node->op->op_index, left);        \
+}                           \
+ir_node *get_##OP##_right(ir_node *node) {      \
+  assert(node->op == op_##OP);              \
+  return get_irn_n(node, node->op->op_index + 1);   \
+}                           \
+void set_##OP##_right(ir_node *node, ir_node *right) {  \
+  assert(node->op == op_##OP);              \
+  set_irn_n(node, node->op->op_index + 1, right);   \
 }
 
-#define UNOP(OP)					\
-ir_node *get_##OP##_op(ir_node *node) {			\
-  assert(node->op == op_##OP);				\
-  return get_irn_n(node, node->op->op_index);		\
-}							\
-void set_##OP##_op (ir_node *node, ir_node *op) {	\
-  assert(node->op == op_##OP);				\
-  set_irn_n(node, node->op->op_index, op);		\
+#define UNOP(OP)                    \
+ir_node *get_##OP##_op(ir_node *node) {         \
+  assert(node->op == op_##OP);              \
+  return get_irn_n(node, node->op->op_index);       \
+}                           \
+void set_##OP##_op (ir_node *node, ir_node *op) {   \
+  assert(node->op == op_##OP);              \
+  set_irn_n(node, node->op->op_index, op);      \
 }
 
 BINOP(Add)
@@ -1343,13 +1302,13 @@ UNOP(Minus)
 BINOP(Mul)
 BINOP(Quot)
 
-INLINE ir_node *
+ir_node *
 get_Quot_mem (ir_node *node) {
   assert (node->op == op_Quot);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Quot_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Quot);
   set_irn_n(node, 0, mem);
@@ -1357,13 +1316,13 @@ set_Quot_mem (ir_node *node, ir_node *mem) {
 
 BINOP(DivMod)
 
-INLINE ir_node *
+ir_node *
 get_DivMod_mem (ir_node *node) {
   assert (node->op == op_DivMod);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_DivMod_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_DivMod);
   set_irn_n(node, 0, mem);
@@ -1371,13 +1330,13 @@ set_DivMod_mem (ir_node *node, ir_node *mem) {
 
 BINOP(Div)
 
-INLINE ir_node *
+ir_node *
 get_Div_mem (ir_node *node) {
   assert (node->op == op_Div);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Div_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Div);
   set_irn_n(node, 0, mem);
@@ -1385,13 +1344,13 @@ set_Div_mem (ir_node *node, ir_node *mem) {
 
 BINOP(Mod)
 
-INLINE ir_node *
+ir_node *
 get_Mod_mem (ir_node *node) {
   assert (node->op == op_Mod);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Mod_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Mod);
   set_irn_n(node, 0, mem);
@@ -1410,24 +1369,24 @@ BINOP(Cmp)
 UNOP(Conv)
 UNOP(Cast)
 
-INLINE type *
+type *
 get_Cast_type (ir_node *node) {
   assert (node->op == op_Cast);
   return node->attr.cast.totype;
 }
 
-INLINE void
+void
 set_Cast_type (ir_node *node, type *to_tp) {
   assert (node->op == op_Cast);
   node->attr.cast.totype = to_tp;
 }
 
-INLINE int
+int
 is_unop (ir_node *node) {
   return (node->op->opar == oparity_unary);
 }
 
-INLINE ir_node *
+ir_node *
 get_unop_op (ir_node *node) {
   if (node->op->opar == oparity_unary)
     return get_irn_n(node, node->op->op_index);
@@ -1436,7 +1395,7 @@ get_unop_op (ir_node *node) {
   return NULL;
 }
 
-INLINE void
+void
 set_unop_op (ir_node *node, ir_node *op) {
   if (node->op->opar == oparity_unary)
     set_irn_n(node, node->op->op_index, op);
@@ -1449,7 +1408,7 @@ is_binop (ir_node *node) {
   return (node->op->opar == oparity_binary);
 }
 
-INLINE ir_node *
+ir_node *
 get_binop_left (ir_node *node) {
   if (node->op->opar == oparity_binary)
     return get_irn_n(node, node->op->op_index);
@@ -1458,7 +1417,7 @@ get_binop_left (ir_node *node) {
   return NULL;
 }
 
-INLINE void
+void
 set_binop_left (ir_node *node, ir_node *left) {
   if (node->op->opar == oparity_binary)
     set_irn_n(node, node->op->op_index, left);
@@ -1466,7 +1425,7 @@ set_binop_left (ir_node *node, ir_node *left) {
   assert (node->op->opar == oparity_binary);
 }
 
-INLINE ir_node *
+ir_node *
 get_binop_right (ir_node *node) {
   if (node->op->opar == oparity_binary)
     return get_irn_n(node, node->op->op_index + 1);
@@ -1475,7 +1434,7 @@ get_binop_right (ir_node *node) {
   return NULL;
 }
 
-INLINE void
+void
 set_binop_right (ir_node *node, ir_node *right) {
   if (node->op->opar == oparity_binary)
     set_irn_n(node, node->op->op_index + 1, right);
@@ -1483,246 +1442,261 @@ set_binop_right (ir_node *node, ir_node *right) {
   assert (node->op->opar == oparity_binary);
 }
 
-INLINE int is_Phi (ir_node *n) {
+int is_Phi (ir_node *n) {
   ir_op *op;
 
   assert(n);
   op = get_irn_op(n);
-  return (op == op_Phi) || (op == op_Filter && interprocedural_view);
+
+  if (op == op_Filter) return interprocedural_view;
+
+  if (op == op_Phi)
+    return  ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
+         (get_irn_arity(n) > 0));
+
+  return 0;
 }
 
-INLINE ir_node **
+int is_Phi0 (ir_node *n) {
+  assert(n);
+
+  return ((get_irn_op(n) == op_Phi) &&
+      (get_irn_arity(n) == 0) &&
+      (get_irg_phase_state(get_irn_irg(n)) ==  phase_building));
+}
+
+ir_node **
 get_Phi_preds_arr (ir_node *node) {
   assert (node->op == op_Phi);
   return (ir_node **)&(get_irn_in(node)[1]);
 }
 
-INLINE int
+int
 get_Phi_n_preds (ir_node *node) {
-  assert (is_Phi(node));
+  assert (is_Phi(node) || is_Phi0(node));
   return (get_irn_arity(node));
 }
 
 /*
-INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
+void set_Phi_n_preds (ir_node *node, int n_preds) {
   assert (node->op == op_Phi);
 }
 */
 
-INLINE ir_node *
+ir_node *
 get_Phi_pred (ir_node *node, int pos) {
-  assert (is_Phi(node));
+  assert (is_Phi(node) || is_Phi0(node));
   return get_irn_n(node, pos);
 }
 
-INLINE void
+void
 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
-  assert (is_Phi(node));
+  assert (is_Phi(node) || is_Phi0(node));
   set_irn_n(node, pos, pred);
 }
 
-INLINE ir_node *
+ir_node *
 get_Load_mem (ir_node *node) {
   assert (node->op == op_Load);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Load_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Load);
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
+ir_node *
 get_Load_ptr (ir_node *node) {
   assert (node->op == op_Load);
   return get_irn_n(node, 1);
 }
 
-INLINE void
+void
 set_Load_ptr (ir_node *node, ir_node *ptr) {
   assert (node->op == op_Load);
   set_irn_n(node, 1, ptr);
 }
 
-INLINE
+
 ir_node *
 get_Store_mem (ir_node *node) {
   assert (node->op == op_Store);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Store_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Store);
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
+ir_node *
 get_Store_ptr (ir_node *node) {
   assert (node->op == op_Store);
   return get_irn_n(node, 1);
 }
 
-INLINE void
+void
 set_Store_ptr (ir_node *node, ir_node *ptr) {
   assert (node->op == op_Store);
   set_irn_n(node, 1, ptr);
 }
 
-INLINE ir_node *
+ir_node *
 get_Store_value (ir_node *node) {
   assert (node->op == op_Store);
   return get_irn_n(node, 2);
 }
 
-INLINE void
+void
 set_Store_value (ir_node *node, ir_node *value) {
   assert (node->op == op_Store);
   set_irn_n(node, 2, value);
 }
 
-INLINE ir_node *
+ir_node *
 get_Alloc_mem (ir_node *node) {
   assert (node->op == op_Alloc);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Alloc_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Alloc);
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
+ir_node *
 get_Alloc_size (ir_node *node) {
   assert (node->op == op_Alloc);
   return get_irn_n(node, 1);
 }
 
-INLINE void
+void
 set_Alloc_size (ir_node *node, ir_node *size) {
   assert (node->op == op_Alloc);
   set_irn_n(node, 1, size);
 }
 
-INLINE type  *
+type  *
 get_Alloc_type (ir_node *node) {
   assert (node->op == op_Alloc);
   return node->attr.a.type = skip_tid(node->attr.a.type);
 }
 
-INLINE void
+void
 set_Alloc_type (ir_node *node, type *tp) {
   assert (node->op == op_Alloc);
   node->attr.a.type = tp;
 }
 
-INLINE where_alloc
+where_alloc
 get_Alloc_where (ir_node *node) {
   assert (node->op == op_Alloc);
   return node->attr.a.where;
 }
 
-INLINE void
+void
 set_Alloc_where (ir_node *node, where_alloc where) {
   assert (node->op == op_Alloc);
   node->attr.a.where = where;
 }
 
 
-INLINE ir_node *
+ir_node *
 get_Free_mem (ir_node *node) {
   assert (node->op == op_Free);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Free_mem (ir_node *node, ir_node *mem) {
   assert (node->op == op_Free);
   set_irn_n(node, 0, mem);
 }
 
-INLINE ir_node *
+ir_node *
 get_Free_ptr (ir_node *node) {
   assert (node->op == op_Free);
   return get_irn_n(node, 1);
 }
 
-INLINE void
+void
 set_Free_ptr (ir_node *node, ir_node *ptr) {
   assert (node->op == op_Free);
   set_irn_n(node, 1, ptr);
 }
 
-INLINE ir_node *
+ir_node *
 get_Free_size (ir_node *node) {
   assert (node->op == op_Free);
   return get_irn_n(node, 2);
 }
 
-INLINE void
+void
 set_Free_size (ir_node *node, ir_node *size) {
   assert (node->op == op_Free);
   set_irn_n(node, 2, size);
 }
 
-INLINE type  *
+type  *
 get_Free_type (ir_node *node) {
   assert (node->op == op_Free);
   return node->attr.f = skip_tid(node->attr.f);
 }
 
-INLINE void
+void
 set_Free_type (ir_node *node, type *tp) {
   assert (node->op == op_Free);
   node->attr.f = tp;
 }
 
-INLINE ir_node **
+ir_node **
 get_Sync_preds_arr (ir_node *node) {
   assert (node->op == op_Sync);
   return (ir_node **)&(get_irn_in(node)[1]);
 }
 
-INLINE int
+int
 get_Sync_n_preds (ir_node *node) {
   assert (node->op == op_Sync);
   return (get_irn_arity(node));
 }
 
 /*
-INLINE void
+void
 set_Sync_n_preds (ir_node *node, int n_preds) {
   assert (node->op == op_Sync);
 }
 */
 
-INLINE ir_node *
+ir_node *
 get_Sync_pred (ir_node *node, int pos) {
   assert (node->op == op_Sync);
   return get_irn_n(node, pos);
 }
 
-INLINE void
+void
 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
   assert (node->op == op_Sync);
   set_irn_n(node, pos, pred);
 }
 
-INLINE ir_node *
+ir_node *
 get_Proj_pred (ir_node *node) {
   assert (is_Proj(node));
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Proj_pred (ir_node *node, ir_node *pred) {
   assert (is_Proj(node));
   set_irn_n(node, 0, pred);
 }
 
-INLINE long
+long
 get_Proj_proj (ir_node *node) {
   assert (is_Proj(node));
   if (get_irn_opcode(node) == iro_Proj) {
@@ -1733,97 +1707,97 @@ get_Proj_proj (ir_node *node) {
   }
 }
 
-INLINE void
+void
 set_Proj_proj (ir_node *node, long proj) {
   assert (node->op == op_Proj);
   node->attr.proj = proj;
 }
 
-INLINE ir_node **
+ir_node **
 get_Tuple_preds_arr (ir_node *node) {
   assert (node->op == op_Tuple);
   return (ir_node **)&(get_irn_in(node)[1]);
 }
 
-INLINE int
+int
 get_Tuple_n_preds (ir_node *node) {
   assert (node->op == op_Tuple);
   return (get_irn_arity(node));
 }
 
 /*
-INLINE void
+void
 set_Tuple_n_preds (ir_node *node, int n_preds) {
   assert (node->op == op_Tuple);
 }
 */
 
-INLINE ir_node *
+ir_node *
 get_Tuple_pred (ir_node *node, int pos) {
   assert (node->op == op_Tuple);
   return get_irn_n(node, pos);
 }
 
-INLINE void
+void
 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
   assert (node->op == op_Tuple);
   set_irn_n(node, pos, pred);
 }
 
-INLINE ir_node *
+ir_node *
 get_Id_pred (ir_node *node) {
   assert (node->op == op_Id);
   return get_irn_n(node, 0);
 }
 
-INLINE void
+void
 set_Id_pred (ir_node *node, ir_node *pred) {
   assert (node->op == op_Id);
   set_irn_n(node, 0, pred);
 }
 
-INLINE ir_node *get_Confirm_value (ir_node *node) {
+ir_node *get_Confirm_value (ir_node *node) {
   assert (node->op == op_Confirm);
   return get_irn_n(node, 0);
 }
-INLINE void     set_Confirm_value (ir_node *node, ir_node *value) {
+void     set_Confirm_value (ir_node *node, ir_node *value) {
   assert (node->op == op_Confirm);
   set_irn_n(node, 0, value);
 }
-INLINE ir_node *get_Confirm_bound (ir_node *node) {
+ir_node *get_Confirm_bound (ir_node *node) {
   assert (node->op == op_Confirm);
   return get_irn_n(node, 1);
 }
-INLINE void     set_Confirm_bound (ir_node *node, ir_node *bound) {
+void     set_Confirm_bound (ir_node *node, ir_node *bound) {
   assert (node->op == op_Confirm);
   set_irn_n(node, 0, bound);
 }
-INLINE pn_Cmp   get_Confirm_cmp   (ir_node *node) {
+pn_Cmp   get_Confirm_cmp   (ir_node *node) {
   assert (node->op == op_Confirm);
   return node->attr.confirm_cmp;
 }
-INLINE void     set_Confirm_cmp   (ir_node *node, pn_Cmp cmp) {
+void     set_Confirm_cmp   (ir_node *node, pn_Cmp cmp) {
   assert (node->op == op_Confirm);
   node->attr.confirm_cmp = cmp;
 }
 
 
-INLINE ir_node *
+ir_node *
 get_Filter_pred (ir_node *node) {
   assert(node->op == op_Filter);
   return node->in[1];
 }
-INLINE void
+void
 set_Filter_pred (ir_node *node, ir_node *pred) {
   assert(node->op == op_Filter);
   node->in[1] = pred;
 }
-INLINE long
+long
 get_Filter_proj(ir_node *node) {
   assert(node->op == op_Filter);
   return node->attr.filter.proj;
 }
-INLINE void
+void
 set_Filter_proj (ir_node *node, long proj) {
   assert(node->op == op_Filter);
   node->attr.filter.proj = proj;
@@ -1844,7 +1818,7 @@ void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
 
 void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) {
   assert(node->op == op_Filter && node->attr.filter.in_cg &&
-	 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
+     0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1);
   node->attr.filter.in_cg[pos + 1] = pred;
 }
 int get_Filter_n_cg_preds(ir_node *node) {
@@ -1854,17 +1828,19 @@ int get_Filter_n_cg_preds(ir_node *node) {
 ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
   int arity;
   assert(node->op == op_Filter && node->attr.filter.in_cg &&
-	 0 <= pos);
+     0 <= pos);
   arity = ARR_LEN(node->attr.filter.in_cg);
   assert(pos <  arity - 1);
   return node->attr.filter.in_cg[pos + 1];
 }
 
 
-INLINE ir_graph *
+ir_graph *
 get_irn_irg(ir_node *node) {
   if (get_irn_op(node) != op_Block)
     node = get_nodes_block(node);
+  if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
+    node = get_nodes_block(node);
   assert(get_irn_op(node) == op_Block);
   return node->attr.block.irg;
 }
@@ -1874,7 +1850,7 @@ get_irn_irg(ir_node *node) {
 /*  Auxiliary routines                                            */
 /*----------------------------------------------------------------*/
 
-INLINE ir_node *
+ir_node *
 skip_Proj (ir_node *node) {
   /* don't assert node !!! */
   if (node && is_Proj(node)) {
@@ -1884,29 +1860,38 @@ skip_Proj (ir_node *node) {
   }
 }
 
-INLINE ir_node *
+ir_node *
 skip_Tuple (ir_node *node) {
   ir_node *pred;
 
   if (!get_opt_normalize()) return node;
 
-  node = skip_nop(node);
+  node = skip_Id(node);
   if (get_irn_op(node) == op_Proj) {
-    pred = skip_nop(get_Proj_pred(node));
+    pred = skip_Id(get_Proj_pred(node));
     if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
-      pred = skip_nop(skip_Tuple(pred));
+      pred = skip_Id(skip_Tuple(pred));
     if (get_irn_op(pred) == op_Tuple)
       return get_Tuple_pred(pred, get_Proj_proj(node));
   }
   return node;
 }
 
+/** returns operand of node if node is a Cast */
+ir_node *skip_Cast  (ir_node *node) {
+  if (node && get_irn_op(node) == op_Cast) {
+    return skip_Id(get_irn_n(node, 0));
+  } else {
+    return node;
+  }
+}
+
 #if 0
 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
    than any other approach, as Id chains are resolved and all point to the real node, or
    all id's are self loops. */
-INLINE ir_node *
-skip_nop (ir_node *node) {
+ir_node *
+skip_Id (ir_node *node) {
   /* don't assert node !!! */
 
   if (!get_opt_normalize()) return node;
@@ -1920,7 +1905,7 @@ skip_nop (ir_node *node) {
     assert (get_irn_arity (node) > 0);
 
     node->in[0+1] = node;
-    res = skip_nop(rem_pred);
+    res = skip_Id(rem_pred);
     if (res->op == op_Id) /* self-loop */ return node;
 
     node->in[0+1] = res;
@@ -1933,17 +1918,22 @@ skip_nop (ir_node *node) {
 /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
    than any other approach, as Id chains are resolved and all point to the real node, or
    all id's are self loops. */
-extern int opt_normalize;
-INLINE ir_node *
-skip_nop (ir_node *node) {
+ir_node *
+skip_Id (ir_node *node) {
   ir_node *pred;
   /* don't assert node !!! */
 
+  if (!node || (node->op != op_Id)) return node;
+
   if (!get_opt_normalize()) return node;
 
   /* Don't use get_Id_pred:  We get into an endless loop for
      self-referencing Ids. */
-  if (node && (node->op == op_Id) && (node != (pred = node->in[0+1]))) {
+  pred = node->in[0+1];
+
+  if (pred->op != op_Id) return pred;
+
+  if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
     ir_node *rem_pred, *res;
 
     if (pred->op != op_Id) return pred; /* shortcut */
@@ -1951,11 +1941,11 @@ skip_nop (ir_node *node) {
 
     assert (get_irn_arity (node) > 0);
 
-    node->in[0+1] = node;
-    res = skip_nop(rem_pred);
+    node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
+    res = skip_Id(rem_pred);
     if (res->op == op_Id) /* self-loop */ return node;
 
-    node->in[0+1] = res;
+    node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
     return res;
   } else {
     return node;
@@ -1963,14 +1953,7 @@ skip_nop (ir_node *node) {
 }
 #endif
 
-
-
-INLINE ir_node *
-skip_Id (ir_node *node) {
-  return skip_nop(node);
-}
-
-INLINE int
+int
 is_Bad (ir_node *node) {
   assert(node);
   if ((node) && get_irn_opcode(node) == iro_Bad)
@@ -1978,26 +1961,26 @@ is_Bad (ir_node *node) {
   return 0;
 }
 
-INLINE int
+int
 is_no_Block (ir_node *node) {
   assert(node);
   return (get_irn_opcode(node) != iro_Block);
 }
 
-INLINE int
+int
 is_Block (ir_node *node) {
   assert(node);
   return (get_irn_opcode(node) == iro_Block);
 }
 
 /* returns true if node is a Unknown node. */
-INLINE int
+int
 is_Unknown (ir_node *node) {
   assert(node);
   return (get_irn_opcode(node) == iro_Unknown);
 }
 
-INLINE int
+int
 is_Proj (const ir_node *node) {
   assert(node);
   return node->op == op_Proj
@@ -2012,14 +1995,10 @@ is_cfop(ir_node *node) {
 
 /* Returns true if the operation manipulates interprocedural control flow:
    CallBegin, EndReg, EndExcept */
-INLINE int is_ip_cfop(ir_node *node) {
+int is_ip_cfop(ir_node *node) {
   return is_ip_cfopcode(get_irn_op(node));
 }
 
-ir_graph *get_ip_cfop_irg(ir_node *n) {
-  return get_irn_irg(n);
-}
-
 /* Returns true if the operation can change the control flow because
    of an exception. */
 int
@@ -2049,3 +2028,24 @@ ir_node *get_fragile_op_mem(ir_node *node) {
     return NULL;
   }
 }
+
+#ifdef DEBUG_libfirm
+void dump_irn (ir_node *n) {
+  int i, arity = get_irn_arity(n);
+  printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
+  if (!is_Block(n)) {
+    ir_node *pred = get_irn_n(n, -1);
+    printf("  block: %s%s: %ld (%p)\n", get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
+       get_irn_node_nr(pred), (void *)pred);
+  }
+  printf("  preds: \n");
+  for (i = 0; i < arity; ++i) {
+    ir_node *pred = get_irn_n(n, i);
+    printf("    %d: %s%s: %ld (%p)\n", i, get_irn_opname(pred), get_mode_name(get_irn_mode(pred)),
+       get_irn_node_nr(pred), (void *)pred);
+  }
+}
+
+#else  /* DEBUG_libfirm */
+void dump_irn (ir_node *n) {}
+#endif /* DEBUG_libfirm */