X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=a446381cf1115ea73949f76b238fea9517aab25b;hb=cb91bddc9cacdab7c28e4336847bd3dc248aa549;hp=ff0aff091d6125d304edba31bca12dc744c2a50d;hpb=631e02a373dab9a011eb660a9a78c92cbaa757af;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index ff0aff091..a446381cf 100644
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -223,7 +223,8 @@ ir_node *
 
 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;
@@ -352,6 +353,26 @@ void *
   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) {
@@ -359,7 +380,7 @@ get_irn_node_nr(const ir_node *node) {
 #ifdef DEBUG_libfirm
   return node->node_nr;
 #else
-  return (long)&node;
+  return (long)node;
 #endif
 }
 
@@ -433,17 +454,39 @@ get_irn_block_attr (ir_node *node)
   return node->attr.block;
 }
 
+load_attr
+get_irn_load_attr (ir_node *node)
+{
+  assert (node->op == op_Load);
+  return node->attr.load;
+}
+
+store_attr
+get_irn_store_attr (ir_node *node)
+{
+  assert (node->op == op_Store);
+  return node->attr.store;
+}
+
+except_attr
+get_irn_except_attr (ir_node *node)
+{
+  assert (node->op == op_Div || node->op == op_Quot ||
+          node->op == op_DivMod || node->op == op_Mod);
+  return node->attr.except;
+}
+
 /** manipulate fields of individual nodes **/
 
 /* 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);
 }
@@ -581,12 +624,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 * /
@@ -602,11 +645,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)));
 }
 */
 
@@ -655,12 +698,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);
@@ -701,13 +738,6 @@ free_End (ir_node *end) {
                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
@@ -869,10 +899,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;
@@ -1132,20 +1158,22 @@ set_Call_type (ir_node *node, type *tp) {
 }
 
 int Call_has_callees(ir_node *node) {
-  return (node->attr.call.callee_arr != NULL);
+  assert(node && node->op == op_Call);
+  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) {
-  assert(node->op == op_Call && node->attr.call.callee_arr);
+  assert(node && node->op == op_Call && node->attr.call.callee_arr);
   return ARR_LEN(node->attr.call.callee_arr);
 }
 
 entity * get_Call_callee(ir_node * node, int pos) {
-  assert(node->op == op_Call && node->attr.call.callee_arr);
+  assert(pos >= 0 && pos < get_Call_n_callees(node));
   return node->attr.call.callee_arr[pos];
 }
 
-void set_Call_callee_arr(ir_node * node, int n, entity ** arr) {
+void set_Call_callee_arr(ir_node * node, const int n, entity ** arr) {
   assert(node->op == op_Call);
   if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
     node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n);
@@ -1166,9 +1194,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;
@@ -1240,7 +1265,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) {
@@ -1494,6 +1520,31 @@ set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
   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);
@@ -1518,6 +1569,30 @@ set_Load_ptr (ir_node *node, ir_node *ptr) {
   set_irn_n(node, 1, ptr);
 }
 
+ir_mode *
+get_Load_mode (ir_node *node) {
+  assert (node->op == op_Load);
+  return node->attr.load.load_mode;
+}
+
+void
+set_Load_mode (ir_node *node, ir_mode *mode) {
+  assert (node->op == op_Load);
+  node->attr.load.load_mode = mode;
+}
+
+ent_volatility
+get_Load_volatility (ir_node *node) {
+  assert (node->op == op_Load);
+  return node->attr.load.volatility;
+}
+
+void
+set_Load_volatility (ir_node *node, ent_volatility volatility) {
+  assert (node->op == op_Load);
+  node->attr.load.volatility = volatility;
+}
+
 
 ir_node *
 get_Store_mem (ir_node *node) {
@@ -1555,6 +1630,19 @@ set_Store_value (ir_node *node, ir_node *value) {
   set_irn_n(node, 2, value);
 }
 
+ent_volatility
+get_Store_volatility (ir_node *node) {
+  assert (node->op == op_Store);
+  return node->attr.store.volatility;
+}
+
+void
+set_Store_volatility (ir_node *node, ent_volatility volatility) {
+  assert (node->op == op_Store);
+  node->attr.store.volatility = volatility;
+}
+
+
 ir_node *
 get_Alloc_mem (ir_node *node) {
   assert (node->op == op_Alloc);
@@ -1865,11 +1953,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));
   }
@@ -1879,7 +1967,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;
   }
@@ -1890,7 +1978,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;
@@ -1904,7 +1992,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;
@@ -1918,7 +2006,7 @@ 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 !!! */
 
@@ -1941,7 +2029,7 @@ skip_nop (ir_node *node) {
     assert (get_irn_arity (node) > 0);
 
     node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
-    res = skip_nop(rem_pred);
+    res = skip_Id(rem_pred);
     if (res->op == op_Id) /* self-loop */ return node;
 
     node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
@@ -1952,11 +2040,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);
@@ -2003,10 +2086,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