CVS:

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 5381030..a9fccc2 100644 (file)
--- 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",
@@ -84,6 +97,13 @@ new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
   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
@@ -97,7 +117,7 @@ ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
     return printed;
   }
 
-  XPF1 ("%I", get_irn_opname(np));
+  XPF1 ("%I", get_irn_opident(np));
 
   switch (get_irn_opcode (np)) {       /* node label */
   case iro_Const:
@@ -168,12 +188,10 @@ 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);
-  /* GL commented the assert in, 12.7.00, let's see whether it works */
   assert (get_irn_arity (node) > n);
   return skip_nop(node->in[n+1]);
 }
@@ -202,7 +220,7 @@ get_irn_modecode (ir_node *node)
 
 
 inline ident *
-get_irn_modename (ir_node *node)
+get_irn_modeident (ir_node *node)
 {
   assert(node);
   return node->mode->name;
@@ -230,8 +248,15 @@ get_irn_opcode (ir_node *node)
   return node->op->code;
 }
 
-inline ident *
+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;
@@ -357,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]);
 }
 
 
@@ -450,7 +475,7 @@ get_Return_res_arr (ir_node *node)
 {
   assert ((node->op == op_Return));
   if (get_Return_n_res(node) > 0)
-    return ((ir_node **)get_Return_res(node, 0));
+    return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
   else
     return NULL;
 }
@@ -458,7 +483,7 @@ get_Return_res_arr (ir_node *node)
 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);
 }
 
 /*
@@ -472,13 +497,13 @@ inline ir_node *
 get_Return_res (ir_node *node, int pos) {
   assert (node->op == op_Return);
   assert (get_Return_n_res(node) > pos);
-  return get_irn_n(node, pos+1);
+  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 *
@@ -549,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
@@ -560,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);
@@ -589,7 +624,7 @@ get_Sel_index_arr (ir_node *node)
 {
   assert ((node->op == op_Sel));
   if (get_Sel_n_index(node) > 0)
-    return (ir_node **)get_Sel_index(node, 0);
+    return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
   else
     return NULL;
 }
@@ -597,7 +632,7 @@ get_Sel_index_arr (ir_node *node)
 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);
 }
 
 /*
@@ -610,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 *
@@ -670,16 +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);
-  if (get_Call_arity(node) > 0)
-    return ((ir_node **)get_Call_param (node, 0));
-  else
-    return NULL;
+  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
@@ -691,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 *
@@ -1392,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
@@ -1499,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);
 }
@@ -1580,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
@@ -1635,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
@@ -1694,7 +1731,10 @@ skip_nop (ir_node *node) {
   /* don't assert node !!! */
 
   if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
-    return 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;
   }