X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=224f1fdccd3702b4c71b6fd8f553883af13eba2e;hb=16d8de24b7945a58705aa754530955768ca35486;hp=6ee1682aa12008fbda9e2d6bfec5e4b46dafc95a;hpb=3ce6d7f83a9ad4478370bc4a773226246915d792;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 6ee1682aa..224f1fdcc 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -29,10 +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
+#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",
@@ -80,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
@@ -96,13 +97,14 @@ init_irnode (void)
  */
 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;
@@ -136,29 +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);
 }
 
 int
-get_irn_intra_arity (const ir_node *node) {
-  return intern_get_irn_intra_arity(node);
+(get_irn_intra_arity)(const ir_node *node) {
+  return __get_irn_intra_arity(node);
 }
 
 int
-get_irn_inter_arity (const ir_node *node) {
-  return intern_get_irn_inter_arity(node);
+(get_irn_inter_arity)(const ir_node *node) {
+  return __get_irn_inter_arity(node);
 }
 
 int
-get_irn_arity (const ir_node *node) {
-  return intern_get_irn_arity(node);
+(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
@@ -208,23 +207,24 @@ set_irn_in (ir_node *node, int arity, ir_node **in) {
 }
 
 ir_node *
-get_irn_intra_n (ir_node *node, int n) {
-  return intern_get_irn_intra_n (node, n);
+(get_irn_intra_n)(ir_node *node, int n) {
+  return __get_irn_intra_n (node, n);
 }
 
 ir_node *
-get_irn_inter_n (ir_node *node, int n) {
-  return intern_get_irn_inter_n (node, n);
+(get_irn_inter_n)(ir_node *node, int n) {
+  return __get_irn_inter_n (node, n);
 }
 
 ir_node *
-get_irn_n (ir_node *node, int n) {
-  return intern_get_irn_n (node, n);
+(get_irn_n)(ir_node *node, int n) {
+  return __get_irn_n (node, n);
 }
 
 void
 set_irn_n (ir_node *node, int n, ir_node *in) {
-  assert(node && -1 <= n && n < get_irn_arity(node));
+  assert(node && node->kind == k_ir_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;
@@ -247,16 +247,14 @@ set_irn_n (ir_node *node, int n, ir_node *in) {
 }
 
 ir_mode *
-get_irn_mode (const ir_node *node) {
-  return intern_get_irn_mode(node);
+(get_irn_mode)(const ir_node *node) {
+  return __get_irn_mode(node);
 }
 
 void
-set_irn_mode (ir_node *node, ir_mode *mode)
+(set_irn_mode)(ir_node *node, ir_mode *mode)
 {
-  assert (node);
-  node->mode=mode;
-  return;
+  __set_irn_mode(node, mode);
 }
 
 modecode
@@ -282,9 +280,9 @@ get_irn_modeident (const ir_node *node)
 }
 
 ir_op *
-get_irn_op (const ir_node *node)
+(get_irn_op)(const ir_node *node)
 {
-  return intern_get_irn_op(node);
+  return __get_irn_op(node);
 }
 
 /* should be private to the library: */
@@ -296,15 +294,18 @@ set_irn_op (ir_node *node, ir_op *op)
 }
 
 opcode
-get_irn_opcode (const ir_node *node)
+(get_irn_opcode)(const ir_node *node)
 {
-  return intern_get_irn_opcode(node);
+  return __get_irn_opcode(node);
 }
 
 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);
 }
 
@@ -316,53 +317,62 @@ get_irn_opident (const ir_node *node)
 }
 
 unsigned long
-get_irn_visited (const ir_node *node)
+(get_irn_visited)(const ir_node *node)
 {
-  assert (node);
-  return node->visited;
+  return __get_irn_visited(node);
 }
 
 void
-set_irn_visited (ir_node *node, unsigned long visited)
+(set_irn_visited)(ir_node *node, unsigned long visited)
 {
-  assert (node);
-  node->visited = visited;
+  __set_irn_visited(node, visited);
 }
 
 void
-mark_irn_visited (ir_node *node) {
-  assert (node);
-  node->visited = current_ir_graph->visited;
+(mark_irn_visited)(ir_node *node) {
+  __mark_irn_visited(node);
 }
 
 int
-irn_not_visited  (const ir_node *node) {
-  assert (node);
-  return (node->visited < current_ir_graph->visited);
+(irn_not_visited)(const ir_node *node) {
+  return __irn_not_visited(node);
 }
 
 int
-irn_visited  (const ir_node *node) {
-  assert (node);
-  return (node->visited >= current_ir_graph->visited);
+(irn_visited)(const ir_node *node) {
+  return __irn_visited(node);
 }
 
 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);
-
-  node->link = link;
+(set_irn_link)(ir_node *node, void *link) {
+  __set_irn_link(node, link);
 }
 
 void *
-get_irn_link (const ir_node *node) {
-  assert (node);
-  return node->link;
+(get_irn_link)(const ir_node *node) {
+  return __get_irn_link(node);
 }
 
+
+#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 */
 long
 get_irn_node_nr(const ir_node *node) {
@@ -448,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);
 }
 
 void
-set_nodes_Block (ir_node *node, ir_node *block) {
+set_nodes_block (ir_node *node, ir_node *block) {
   assert (!(node->op == op_Block));
   set_irn_n(node, -1, block);
 }
@@ -510,19 +520,14 @@ get_Block_cfgpred_arr (ir_node *node)
 int
 get_Block_n_cfgpreds (ir_node *node) {
   assert ((node->op == op_Block));
-  return (get_irn_arity(node));
+  return get_irn_arity(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);
 }
 
@@ -597,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 * /
@@ -618,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)));
 }
 */
 
@@ -634,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);
@@ -646,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;
 }
 
@@ -671,12 +676,6 @@ void remove_Block_cg_cfgpred_arr(ir_node * node) {
   node->attr.block.in_cg = NULL;
 }
 
-/* Start references the irg it is in. */
-ir_graph *
-get_Start_irg(ir_node *node) {
-  return get_irn_irg(node);
-}
-
 void
 set_Start_irg(ir_node *node, ir_graph *irg) {
   assert(node->op == op_Start);
@@ -714,16 +713,9 @@ free_End (ir_node *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 ... */
-}
-
-ir_graph *get_EndReg_irg (ir_node *end) {
-  return get_irn_irg(end);
+               in array afterwards ... */
 }
 
-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
@@ -780,6 +772,12 @@ set_Cond_kind (ir_node *node, cond_kind kind) {
   node->attr.c.kind = kind;
 }
 
+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);
@@ -879,10 +877,6 @@ set_Const_type (ir_node *node, type *tp) {
   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;
@@ -904,43 +898,59 @@ set_SymConst_kind (ir_node *node, symconst_kind num) {
 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);
 }
 
 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;
 }
 
 ident *
-get_SymConst_ptrinfo (ir_node *node) {
+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;
 }
 
 void
-set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
+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;
 }
 
-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;
 }
 
 void
-set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
+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;
 }
 
 ir_node *
@@ -1126,7 +1136,9 @@ set_Call_type (ir_node *node, type *tp) {
 }
 
 int Call_has_callees(ir_node *node) {
-  return (node->attr.call.callee_arr != NULL);
+
+  return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
+	  (node->attr.call.callee_arr != NULL));
 }
 
 int get_Call_n_callees(ir_node * node) {
@@ -1160,9 +1172,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;
@@ -1187,13 +1196,13 @@ set_FuncCall_ptr (ir_node *node, ir_node *ptr) {
 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];
 }
 
 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);
 }
 
 int
@@ -1211,13 +1220,13 @@ set_FuncCall_arity (ir_node *node, ir_node *arity) {
 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);
 }
 
 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);
 }
 
 type *
@@ -1234,7 +1243,8 @@ set_FuncCall_type (ir_node *node, type *tp) {
 }
 
 int FuncCall_has_callees(ir_node *node) {
-  return (node->attr.call.callee_arr != NULL);
+  return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
+	  (node->attr.call.callee_arr != NULL));
 }
 
 int get_FuncCall_n_callees(ir_node * node) {
@@ -1261,32 +1271,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)
@@ -1440,7 +1450,22 @@ int is_Phi (ir_node *n) {
 
   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;
+}
+
+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 **
@@ -1451,7 +1476,7 @@ get_Phi_preds_arr (ir_node *node) {
 
 int
 get_Phi_n_preds (ir_node *node) {
-  assert (is_Phi(node));
+  assert (is_Phi(node) || is_Phi0(node));
   return (get_irn_arity(node));
 }
 
@@ -1463,16 +1488,41 @@ void set_Phi_n_preds (ir_node *node, int n_preds) {
 
 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);
 }
 
 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);
 }
 
+
+int is_memop(ir_node *node) {
+  return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
+}
+
+ir_node *get_memop_mem (ir_node *node) {
+  assert(is_memop(node));
+  return get_irn_n(node, 0);
+}
+
+void     set_memop_mem (ir_node *node, ir_node *mem) {
+  assert(is_memop(node));
+  set_irn_n(node, 0, mem);
+}
+
+ir_node *get_memop_ptr (ir_node *node) {
+  assert(is_memop(node));
+  return get_irn_n(node, 1);
+}
+
+void     set_memop_ptr (ir_node *node, ir_node *ptr) {
+  assert(is_memop(node));
+  set_irn_n(node, 1, ptr);
+}
+
 ir_node *
 get_Load_mem (ir_node *node) {
   assert (node->op == op_Load);
@@ -1796,7 +1846,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) {
@@ -1806,7 +1856,7 @@ 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];
@@ -1844,11 +1894,11 @@ skip_Tuple (ir_node *node) {
 
   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));
   }
@@ -1858,7 +1908,7 @@ skip_Tuple (ir_node *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_nop(get_irn_n(node, 0));
+    return skip_Id(get_irn_n(node, 0));
   } else {
     return node;
   }
@@ -1869,7 +1919,7 @@ ir_node *skip_Cast  (ir_node *node) {
    than any other approach, as Id chains are resolved and all point to the real node, or
    all id's are self loops. */
 ir_node *
-skip_nop (ir_node *node) {
+skip_Id (ir_node *node) {
   /* don't assert node !!! */
 
   if (!get_opt_normalize()) return node;
@@ -1880,10 +1930,10 @@ skip_nop (ir_node *node) {
     ir_node *rem_pred = node->in[0+1];
     ir_node *res;
 
-    assert (intern_get_irn_arity (node) > 0);
+    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;
@@ -1897,27 +1947,33 @@ skip_nop (ir_node *node) {
    than any other approach, as Id chains are resolved and all point to the real node, or
    all id's are self loops. */
 ir_node *
-skip_nop (ir_node *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 */
     rem_pred = pred;
 
-    assert (intern_get_irn_arity (node) > 0);
+    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;
@@ -1925,11 +1981,6 @@ skip_nop (ir_node *node) {
 }
 #endif
 
-ir_node *
-skip_Id (ir_node *node) {
-  return skip_nop(node);
-}
-
 int
 is_Bad (ir_node *node) {
   assert(node);
@@ -1976,10 +2027,6 @@ 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
@@ -2009,3 +2056,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 */