Added support for out edges.

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index e432cbb..d4e9c68 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -27,6 +27,7 @@
 #include "irdump.h"
 #include "irop_t.h"
 #include "irprog_t.h"
+#include "iredges_t.h"
 
 #include "irhooks.h"
 
@@ -147,6 +148,7 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo
     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
   }
+
   res->in[0] = block;
   set_irn_dbg_info(res, db);
   res->out = NULL;
@@ -155,7 +157,19 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo
   res->node_nr = get_irp_new_node_nr();
 #endif
 
-  hook_new_node(res);
+#ifdef FIRM_EDGES_INPLACE
+       {
+               int i, n;
+               int not_a_block = !is_Block(res);
+
+               INIT_LIST_HEAD(&res->edge_info.outs_head);
+
+               for(i = 0, n = arity + not_a_block; i < n; ++i)
+                       edges_notify_edge(res, i - not_a_block, res->in[i], NULL, irg);
+       }
+#endif
+
+  hook_new_node(irg, res);
 
   return res;
 }
@@ -164,24 +178,24 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo
 
 int
 (is_ir_node)(const void *thing) {
-  return __is_ir_node(thing);
+  return _is_ir_node(thing);
 }
 
 int
 (get_irn_intra_arity)(const ir_node *node) {
-  return __get_irn_intra_arity(node);
+  return _get_irn_intra_arity(node);
 }
 
 int
 (get_irn_inter_arity)(const ir_node *node) {
-  return __get_irn_inter_arity(node);
+  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) = _get_irn_intra_arity;
 
 int
 (get_irn_arity)(const ir_node *node) {
-  return __get_irn_arity(node);
+  return _get_irn_arity(node);
 }
 
 /* Returns the array with ins. This array is shifted with respect to the
@@ -232,24 +246,26 @@ set_irn_in (ir_node *node, int arity, ir_node **in) {
 
 ir_node *
 (get_irn_intra_n)(const ir_node *node, int n) {
-  return __get_irn_intra_n (node, n);
+  return _get_irn_intra_n (node, n);
 }
 
 ir_node *
 (get_irn_inter_n)(const ir_node *node, int n) {
-  return __get_irn_inter_n (node, n);
+  return _get_irn_inter_n (node, n);
 }
 
-ir_node *(*__get_irn_n)(const ir_node *node, int n) = __get_irn_intra_n;
+ir_node *(*_get_irn_n)(const ir_node *node, int n) = _get_irn_intra_n;
 
 ir_node *
 (get_irn_n)(const ir_node *node, int n) {
-  return __get_irn_n(node, n);
+  return _get_irn_n(node, n);
 }
 
 void
 set_irn_n (ir_node *node, int n, ir_node *in) {
-  assert(node && node->kind == k_ir_node && -1 <= n && n < get_irn_arity(node));
+  assert(node && node->kind == k_ir_node);
+  assert(-1 <= n);
+  assert(n < get_irn_arity(node));
   assert(in && in->kind == k_ir_node);
 
   if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
@@ -270,18 +286,27 @@ set_irn_n (ir_node *node, int n, ir_node *in) {
     }
     /* else fall through */
   }
+
+       /* Call the hook */
+       hook_set_irn_n(node, n, in, node->in[n + 1]);
+
+#ifdef FIRM_EDGES_INPLACE
+       /* Here, we rely on src and tgt being in the current ir graph */
+       edges_notify_edge(node, n, in, node->in[n + 1], current_ir_graph);
+#endif
+
   node->in[n + 1] = in;
 }
 
 ir_mode *
 (get_irn_mode)(const ir_node *node) {
-  return __get_irn_mode(node);
+  return _get_irn_mode(node);
 }
 
 void
 (set_irn_mode)(ir_node *node, ir_mode *mode)
 {
-  __set_irn_mode(node, mode);
+  _set_irn_mode(node, mode);
 }
 
 modecode
@@ -309,7 +334,7 @@ get_irn_modeident (const ir_node *node)
 ir_op *
 (get_irn_op)(const ir_node *node)
 {
-  return __get_irn_op(node);
+  return _get_irn_op(node);
 }
 
 /* should be private to the library: */
@@ -323,7 +348,7 @@ set_irn_op (ir_node *node, ir_op *op)
 opcode
 (get_irn_opcode)(const ir_node *node)
 {
-  return __get_irn_opcode(node);
+  return _get_irn_opcode(node);
 }
 
 const char *
@@ -346,43 +371,43 @@ get_irn_opident (const ir_node *node)
 unsigned long
 (get_irn_visited)(const ir_node *node)
 {
-  return __get_irn_visited(node);
+  return _get_irn_visited(node);
 }
 
 void
 (set_irn_visited)(ir_node *node, unsigned long visited)
 {
-  __set_irn_visited(node, visited);
+  _set_irn_visited(node, visited);
 }
 
 void
 (mark_irn_visited)(ir_node *node) {
-  __mark_irn_visited(node);
+  _mark_irn_visited(node);
 }
 
 int
 (irn_not_visited)(const ir_node *node) {
-  return __irn_not_visited(node);
+  return _irn_not_visited(node);
 }
 
 int
 (irn_visited)(const ir_node *node) {
-  return __irn_visited(node);
+  return _irn_visited(node);
 }
 
 void
 (set_irn_link)(ir_node *node, void *link) {
-  __set_irn_link(node, link);
+  _set_irn_link(node, link);
 }
 
 void *
 (get_irn_link)(const ir_node *node) {
-  return __get_irn_link(node);
+  return _get_irn_link(node);
 }
 
 op_pin_state
 (get_irn_pinned)(const ir_node *node) {
-  return __get_irn_pinned(node);
+  return _get_irn_pinned(node);
 }
 
 void set_irn_pinned(ir_node *node, op_pin_state state) {
@@ -453,11 +478,11 @@ get_irn_alloc_attr (ir_node *node)
   return node->attr.a;
 }
 
-type *
+free_attr
 get_irn_free_attr     (ir_node *node)
 {
   assert (node->op == op_Free);
-  return node->attr.f = skip_tid(node->attr.f);
+  return node->attr.f;
 }
 
 symconst_attr
@@ -693,11 +718,11 @@ void remove_Block_cg_cfgpred_arr(ir_node * node) {
 }
 
 ir_node *(set_Block_dead)(ir_node *block) {
-  return __set_Block_dead(block);
+  return _set_Block_dead(block);
 }
 
 int (is_Block_dead)(const ir_node *block) {
-  return __is_Block_dead(block);
+  return _is_Block_dead(block);
 }
 
 void
@@ -874,9 +899,8 @@ set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
   set_irn_n(node, 1, exo_ptr);
 }
 
-tarval *get_Const_tarval (ir_node *node) {
-  assert (node->op == op_Const);
-  return node->attr.con.tv;
+tarval *(get_Const_tarval)(ir_node *node) {
+       return _get_Const_tarval(node);
 }
 
 void
@@ -885,6 +909,11 @@ set_Const_tarval (ir_node *node, tarval *con) {
   node->attr.con.tv = con;
 }
 
+cnst_classify_t (classify_Const)(ir_node *node)
+{
+       return _classify_Const(node);
+}
+
 
 /* The source language type.  Must be an atomic type.  Mode of type must
    be mode of node. For tarvals from entities type must be pointer to
@@ -1332,7 +1361,7 @@ set_Cast_type (ir_node *node, type *to_tp) {
 
 int
 (is_unop)(const ir_node *node) {
-  return __is_unop(node);
+  return _is_unop(node);
 }
 
 ir_node *
@@ -1354,7 +1383,7 @@ set_unop_op (ir_node *node, ir_node *op) {
 
 int
 (is_binop)(const ir_node *node) {
-  return __is_binop(node);
+  return _is_binop(node);
 }
 
 ir_node *
@@ -1655,13 +1684,25 @@ set_Free_size (ir_node *node, ir_node *size) {
 type  *
 get_Free_type (ir_node *node) {
   assert (node->op == op_Free);
-  return node->attr.f = skip_tid(node->attr.f);
+  return node->attr.f.type = skip_tid(node->attr.f.type);
 }
 
 void
 set_Free_type (ir_node *node, type *tp) {
   assert (node->op == op_Free);
-  node->attr.f = tp;
+  node->attr.f.type = tp;
+}
+
+where_alloc
+get_Free_where (ir_node *node) {
+  assert (node->op == op_Free);
+  return node->attr.f.where;
+}
+
+void
+set_Free_where (ir_node *node, where_alloc where) {
+  assert (node->op == op_Free);
+  node->attr.f.where = where;
 }
 
 ir_node **
@@ -1994,17 +2035,17 @@ skip_Id (ir_node *node) {
 
 int
 (is_Bad)(const ir_node *node) {
-  return __is_Bad(node);
+  return _is_Bad(node);
 }
 
 int
 (is_no_Block)(const ir_node *node) {
-  return  __is_no_Block(node);
+  return _is_no_Block(node);
 }
 
 int
 (is_Block)(const ir_node *node) {
-  return __is_Block(node);
+  return _is_Block(node);
 }
 
 /* returns true if node is a Unknown node. */