X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=a9fccc2d44f26732899d9161cfe3bf6128742553;hb=5f8ddee6b08c8040c0a304a347d65045c1141d52;hp=56c50c219ea0fc79e86fb906f70d663215fcdc94;hpb=c0c2062d35691e2346f83fc1ad9309fdb9aad2a5;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 56c50c219..a9fccc2d4 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -5,9 +5,22 @@
 **
 */
 
-#include "irnode.h"
+#include "irnode_t.h"
+#include "irgraph_t.h"
+#include "ident_t.h"
+#include "irmode_t.h"
 #include "array.h"
 
+#ifdef DEBUG_libfirm
+#include "irprog.h"
+#endif
+
+/* 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 */
+
 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
 				"Gt", "Ge", "Lg", "Leg", "Uo",
 				"Ue", "Ul", "Ule", "Ug", "Uge",
@@ -76,9 +89,21 @@ new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
   }
   res->in[0] = block;
+
+#ifdef DEBUG_libfirm
+  res->node_nr = get_irp_new_node_nr();
+#endif
+
   return res;
 }
 
+/* Copies all attributes stored in the old node to the new node.
+   Assumes both have the same opcode and sufficient size. */
+void
+copy_attrs (ir_node *old, ir_node *new) {
+  assert (get_irn_opcode(old) == get_irn_opcode(new));
+  memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
+}
 
 /* IR-Nodes with attributes */
 int
@@ -92,7 +117,7 @@ ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
     return printed;
   }
 
-  XPF1 ("%I", get_irn_op(np)->name);
+  XPF1 ("%I", get_irn_opident(np));
 
   switch (get_irn_opcode (np)) {	/* node label */
   case iro_Const:
@@ -163,12 +188,11 @@ get_irn_in (ir_node *node)
    to iterate includind 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 (get_irn_arity (node) > n);
+  assert (get_irn_arity (node) > n);
   return skip_nop(node->in[n+1]);
 }
 
@@ -194,6 +218,14 @@ get_irn_modecode (ir_node *node)
   return node->mode->code;
 }
 
+
+inline ident *
+get_irn_modeident (ir_node *node)
+{
+  assert(node);
+  return node->mode->name;
+}
+
 inline ir_op *
 get_irn_op (ir_node *node)
 {
@@ -209,11 +241,25 @@ set_irn_op (ir_node *node, ir_op *op)
   node->op = op;
 }
 
-inline void
-set_irn_visited (ir_node *node, unsigned long visited)
+inline opcode
+get_irn_opcode (ir_node *node)
 {
   assert (node);
-  node->visited = visited;
+  return node->op->code;
+}
+
+inline const char *
+get_irn_opname (ir_node *node)
+{
+  assert(node);
+  return id_to_str(node->op->name);
+}
+
+inline ident *
+get_irn_opident (ir_node *node)
+{
+  assert(node);
+  return node->op->name;
 }
 
 inline unsigned long
@@ -223,13 +269,12 @@ get_irn_visited (ir_node *node)
   return node->visited;
 }
 
-inline opcode
-get_irn_opcode (ir_node *node)
+inline void
+set_irn_visited (ir_node *node, unsigned long visited)
 {
   assert (node);
-  return node->op->code;
+  node->visited = visited;
 }
-
 inline void
 set_irn_link (ir_node *node, ir_node *link) {
   assert (node);
@@ -242,6 +287,15 @@ get_irn_link (ir_node *node) {
   return node->link;
 }
 
+#ifdef DEBUG_libfirm
+/* Outputs a unique number for this node */
+inline long
+get_irn_node_nr(ir_node *node) {
+  assert(node);
+  return node->node_nr;
+}
+#endif
+
 inline tarval *
 get_irn_const_attr (ir_node *node)
 {
@@ -328,7 +382,7 @@ inline ir_node **
 get_Block_cfgpred_arr (ir_node *node)
 {
   assert ((node->op == op_Block));
-  return (ir_node **)get_Block_cfgpred(node, 0);
+  return (ir_node **)&(get_irn_in(node)[1]);
 }
 
 
@@ -420,13 +474,16 @@ inline ir_node **
 get_Return_res_arr (ir_node *node)
 {
   assert ((node->op == op_Return));
-  return ((ir_node **)get_Return_res(node, 0));
+  if (get_Return_n_res(node) > 0)
+    return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
+  else
+    return NULL;
 }
 
 inline int
 get_Return_n_res (ir_node *node) {
   assert (node->op == op_Return);
-  return (get_irn_arity(node) - 1);
+  return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
 }
 
 /*
@@ -439,13 +496,14 @@ set_Return_n_res (ir_node *node, int results) {
 inline ir_node *
 get_Return_res (ir_node *node, int pos) {
   assert (node->op == op_Return);
-  return get_irn_n(node, pos+1);
+  assert (get_Return_n_res(node) > pos);
+  return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
 }
 
 inline void
 set_Return_res (ir_node *node, int pos, ir_node *res){
   assert (node->op == op_Return);
-  set_irn_n(node, pos+1, res);
+  set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
 }
 
 inline ir_node *
@@ -516,8 +574,6 @@ get_SymConst_ptrinfo (ir_node *node) {
   assert (   (node->op == op_SymConst)
           && (get_SymConst_kind(node) == linkage_ptr_info));
   return node->attr.i.tori.ptrinfo;
-
-
 }
 
 inline void
@@ -527,6 +583,18 @@ set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
   node->attr.i.tori.ptrinfo = ptrinfo;
 }
 
+inline type_or_id_p
+get_SymConst_type_or_id (ir_node *node) {
+  assert (node->op == op_SymConst);
+  return &(node->attr.i.tori);
+}
+
+inline void
+set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
+  assert (node->op == op_SymConst);
+  memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
+}
+
 inline ir_node *
 get_Sel_mem (ir_node *node) {
   assert (node->op == op_Sel);
@@ -555,13 +623,16 @@ inline ir_node **
 get_Sel_index_arr (ir_node *node)
 {
   assert ((node->op == op_Sel));
-  return (ir_node **)get_Sel_index(node, 0);
+  if (get_Sel_n_index(node) > 0)
+    return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
+  else
+    return NULL;
 }
 
 inline int
 get_Sel_n_index (ir_node *node) {
   assert (node->op == op_Sel);
-  return (get_irn_arity(node) - 2);
+  return (get_irn_arity(node) - SEL_INDEX_OFFSET);
 }
 
 /*
@@ -574,13 +645,13 @@ set_Sel_n_index (ir_node *node, int n_index) {
 inline ir_node *
 get_Sel_index (ir_node *node, int pos) {
   assert (node->op == op_Sel);
-  return get_irn_n(node, pos+2);
+  return get_irn_n(node, pos + SEL_INDEX_OFFSET);
 }
 
 inline void
 set_Sel_index (ir_node *node, int pos, ir_node *index) {
   assert (node->op == op_Sel);
-  set_irn_n(node, pos+2, index);
+  set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
 }
 
 inline entity *
@@ -634,13 +705,18 @@ set_Call_ptr (ir_node *node, ir_node *ptr) {
 inline ir_node **
 get_Call_param_arr (ir_node *node) {
   assert (node->op == op_Call);
-  return ((ir_node **)get_Call_param (node, 0));
+  return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
 }
 
 inline int
-get_Call_arity (ir_node *node) {
+get_Call_n_params (ir_node *node)  {
   assert (node->op == op_Call);
-  return (get_irn_arity(node) - 2);
+  return (get_irn_arity(node) - CALL_PARAM_OFFSET);
+}
+
+inline int
+get_Call_arity (ir_node *node) {
+  return get_Call_n_params(node);
 }
 
 /* inline void
@@ -652,13 +728,13 @@ set_Call_arity (ir_node *node, ir_node *arity) {
 inline ir_node *
 get_Call_param (ir_node *node, int pos) {
   assert (node->op == op_Call);
-  return get_irn_n(node, pos+1);
+  return get_irn_n(node, pos + CALL_PARAM_OFFSET);
 }
 
 inline void
 set_Call_param (ir_node *node, int pos, ir_node *param) {
   assert (node->op == op_Call);
-  set_irn_n(node, pos+1, param);
+  set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
 }
 
 inline type_method *
@@ -1353,7 +1429,7 @@ set_Conv_op (ir_node *node, ir_node *op) {
 inline ir_node **
 get_Phi_preds_arr (ir_node *node) {
   assert (node->op == op_Phi);
-  return ((ir_node **)get_Phi_pred(node, 0));
+  return (ir_node **)&(get_irn_in(node)[1]);
 }
 
 inline int
@@ -1460,7 +1536,7 @@ get_Alloc_size (ir_node *node) {
 }
 
 inline void
-set_Allco_size (ir_node *node, ir_node *size) {
+set_Alloc_size (ir_node *node, ir_node *size) {
   assert (node->op == op_Alloc);
   set_irn_n(node, 1, size);
 }
@@ -1541,7 +1617,7 @@ set_Free_type (ir_node *node, type *type) {
 inline ir_node **
 get_Sync_preds_arr (ir_node *node) {
   assert (node->op == op_Sync);
-  return ((ir_node **)get_Sync_pred(node, 0));
+  return (ir_node **)&(get_irn_in(node)[1]);
 }
 
 inline int
@@ -1596,7 +1672,7 @@ set_Proj_proj (ir_node *node, long proj) {
 inline ir_node **
 get_Tuple_preds_arr (ir_node *node) {
   assert (node->op == op_Tuple);
-  return ((ir_node **)get_Tuple_pred(node, 0));
+  return (ir_node **)&(get_irn_in(node)[1]);
 }
 
 inline int
@@ -1653,8 +1729,12 @@ skip_Proj (ir_node *node) {
 inline ir_node *
 skip_nop (ir_node *node) {
   /* don't assert node !!! */
-  if (node && (node->op == op_Id)) {
-    return get_Id_pred(node);
+
+  if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
+    /* Don't use get_Id_pred:  We get into an endless loop for
+       self-referencing Ids. */
+    assert (get_irn_arity (node) > 0);
+    return node->in[0+1];
   } else {
     return node;
   }