replaced all recursive computed_value calls ba value_of()

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index a446381..901bd90 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -155,6 +155,8 @@ int
   return __get_irn_inter_arity(node);
 }
 
+int (*__get_irn_arity)(const ir_node *node) = __get_irn_intra_arity;
+
 int
 (get_irn_arity)(const ir_node *node) {
   return __get_irn_arity(node);
@@ -169,7 +171,7 @@ int
 ir_node **
 get_irn_in (const ir_node *node) {
   assert(node);
-  if (interprocedural_view) { /* handle Filter and Block specially */
+  if (get_interprocedural_view()) { /* handle Filter and Block specially */
     if (get_irn_opcode(node) == iro_Filter) {
       assert(node->attr.filter.in_cg);
       return node->attr.filter.in_cg;
@@ -185,7 +187,7 @@ void
 set_irn_in (ir_node *node, int arity, ir_node **in) {
   ir_node *** arr;
   assert(node);
-  if (interprocedural_view) { /* handle Filter and Block specially */
+  if (get_interprocedural_view()) { /* handle Filter and Block specially */
     if (get_irn_opcode(node) == iro_Filter) {
       assert(node->attr.filter.in_cg);
       arr = &node->attr.filter.in_cg;
@@ -216,9 +218,11 @@ ir_node *
   return __get_irn_inter_n (node, n);
 }
 
+ir_node *(*__get_irn_n)(ir_node *node, int n) = __get_irn_intra_n;
+
 ir_node *
 (get_irn_n)(ir_node *node, int n) {
-  return __get_irn_n (node, n);
+  return __get_irn_n(node, n);
 }
 
 void
@@ -232,7 +236,7 @@ set_irn_n (ir_node *node, int n, ir_node *in) {
     node->attr.filter.in_cg[n + 1] = in;
     return;
   }
-  if (interprocedural_view) { /* handle Filter and Block specially */
+  if (get_interprocedural_view()) { /* handle Filter and Block specially */
     if (get_irn_opcode(node) == iro_Filter) {
       assert(node->attr.filter.in_cg);
       node->attr.filter.in_cg[n + 1] = in;
@@ -353,6 +357,21 @@ void *
   return __get_irn_link(node);
 }
 
+op_pin_state
+(get_irn_pinned)(const ir_node *node) {
+  return __get_irn_pinned(node);
+}
+
+void set_irn_pinned(ir_node *node, op_pin_state state) {
+  /* due to optimization an opt may be turned into a Tuple */
+  if (get_irn_op(node) == op_Tuple)
+    return;
+
+  assert(node && get_op_pinned(get_irn_op(node)) == op_pin_state_exc_pinned);
+  assert(state == op_pin_state_pinned || state == op_pin_state_floats);
+
+  node->attr.except.pin_state = state;
+}
 
 #ifdef DO_HEAPANALYSIS
 /* Access the abstract interpretation information of a node.
@@ -607,52 +626,6 @@ set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
   node->attr.block.graph_arr[pos+1] = value;
 }
 
-/* handler handling for Blocks * /
-void
-set_Block_handler (ir_node *block, ir_node *handler)  {
-  assert ((block->op == op_Block));
-  assert ((handler->op == op_Block));
-  block->attr.block.handler_entry = handler;
-}
-
-ir_node *
-get_Block_handler (ir_node *block) {
-  assert ((block->op == op_Block));
-  return (block->attr.block.handler_entry);
-}
-
-/ * handler handling for Nodes * /
-void
-set_Node_handler (ir_node *node, ir_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)));
-}
-
-/ * exc_t handling for Blocks * /
-void set_Block_exc (ir_node *block, exc_t exc) {
-  assert ((block->op == op_Block));
-  block->attr.block.exc = exc;
-}
-
-exc_t get_Block_exc (ir_node *block) {
-  assert ((block->op == op_Block));
-  return (block->attr.block.exc);
-}
-
-/ * exc_t handling for Nodes * /
-void set_Node_exc (ir_node *node, exc_t 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)));
-}
-*/
-
 void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
   assert(node->op == op_Block);
   if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
@@ -662,10 +635,10 @@ void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
     {
       /* Fix backedge array.  fix_backedges operates depending on
      interprocedural_view. */
-      bool ipv = interprocedural_view;
-      interprocedural_view = true;
+      int ipv = get_interprocedural_view();
+      set_interprocedural_view(true);
       fix_backedges(current_ir_graph->obst, node);
-      interprocedural_view = ipv;
+      set_interprocedural_view(ipv);
     }
   }
   memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity);
@@ -901,6 +874,10 @@ set_Const_type (ir_node *node, type *tp) {
     assert (get_type_mode(tp) == get_irn_mode(node));
   }
 
+  if ((get_irn_node_nr(node) == 259216) && (tp == unknown_type))
+    assert(0);
+
+
   node->attr.con.tp = tp;
 }
 
@@ -961,7 +938,6 @@ void     set_SymConst_entity (ir_node *node, entity *ent) {
   node->attr.i.sym.entity_p  = ent;
 }
 
-
 union symconst_symbol
 get_SymConst_symbol (ir_node *node) {
   assert (node->op == op_SymConst);
@@ -975,6 +951,18 @@ set_SymConst_symbol (ir_node *node, union symconst_symbol sym) {
   node->attr.i.sym = sym;
 }
 
+type *
+get_SymConst_value_type (ir_node *node) {
+  assert (node->op == op_SymConst);
+  return node->attr.i.tp = skip_tid(node->attr.i.tp);
+}
+
+void
+set_SymConst_value_type (ir_node *node, type *tp) {
+  assert (node->op == op_SymConst);
+  node->attr.i.tp = tp;
+}
+
 ir_node *
 get_Sel_mem (ir_node *node) {
   assert (node->op == op_Sel);
@@ -1153,14 +1141,14 @@ get_Call_type (ir_node *node) {
 void
 set_Call_type (ir_node *node, type *tp) {
   assert (node->op == op_Call);
-  assert (is_method_type(tp));
+  assert ((get_unknown_type() == tp) || is_method_type(tp));
   node->attr.call.cld_tp = tp;
 }
 
 int Call_has_callees(ir_node *node) {
   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));
+      (node->attr.call.callee_arr != NULL));
 }
 
 int get_Call_n_callees(ir_node * node) {
@@ -1266,7 +1254,7 @@ set_FuncCall_type (ir_node *node, type *tp) {
 
 int FuncCall_has_callees(ir_node *node) {
   return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
-         (node->attr.call.callee_arr != NULL));
+      (node->attr.call.callee_arr != NULL));
 }
 
 int get_FuncCall_n_callees(ir_node * node) {
@@ -1473,7 +1461,7 @@ int is_Phi (ir_node *n) {
   assert(n);
   op = get_irn_op(n);
 
-  if (op == op_Filter) return interprocedural_view;
+  if (op == op_Filter) return get_interprocedural_view();
 
   if (op == op_Phi)
     return  ((get_irg_phase_state(get_irn_irg(n)) !=  phase_building) ||
@@ -2071,7 +2059,7 @@ int
 is_Proj (const ir_node *node) {
   assert(node);
   return node->op == op_Proj
-    || (!interprocedural_view && node->op == op_Filter);
+    || (!get_interprocedural_view() && node->op == op_Filter);
 }
 
 /* Returns true if the operation manipulates control flow. */
@@ -2116,6 +2104,12 @@ ir_node *get_fragile_op_mem(ir_node *node) {
   }
 }
 
+/* Returns true if the operation is a forking control flow operation. */
+int
+is_forking_op(ir_node *node) {
+  return is_op_forking(get_irn_op(node));
+}
+
 #ifdef DEBUG_libfirm
 void dump_irn (ir_node *n) {
   int i, arity = get_irn_arity(n);