removed INLIEN before global functions

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index d13d314..8334e4f 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -11,9 +11,12 @@
  */
 
 #ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
+#endif
+
+#ifdef HAVE_STRING_H
+# include <string.h>
 #endif
-#include <string.h>
 
 #include "ident.h"
 #include "irnode_t.h"
@@ -94,23 +97,22 @@ static int forbid_new_data = 0;
  * The amount of additional space for custom data to be allocated upon
  * creating a new node.
  */
-static size_t additional_node_data_size = 0;
+unsigned firm_add_node_size = 0;
 
 
-size_t register_additional_node_data(size_t size)
-{
-       assert(!forbid_new_data && "Too late to register additional node data");
+/* register new space for every node */
+unsigned register_additional_node_data(unsigned size) {
+  assert(!forbid_new_data && "Too late to register additional node data");
 
-       if(forbid_new_data)
-               return 0;
+  if (forbid_new_data)
+    return 0;
 
-       return additional_node_data_size += size;
+  return firm_add_node_size += size;
 }
 
 
 void
-init_irnode (void)
-{
+init_irnode(void) {
        /* Forbid the addition of new data to an ir node. */
        forbid_new_data = 1;
 }
@@ -126,13 +128,13 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo
          int arity, ir_node **in)
 {
   ir_node *res;
-  size_t node_size = offsetof(ir_node, attr) + op->attr_size + additional_node_data_size;
+  size_t node_size = offsetof(ir_node, attr) + op->attr_size + firm_add_node_size;
        char *p;
 
   assert(irg && op && mode);
   p = obstack_alloc (irg->obst, node_size);
   memset(p, 0, node_size);
-       res = (ir_node *) (p + additional_node_data_size);
+       res = (ir_node *) (p + firm_add_node_size);
 
   res->kind    = k_ir_node;
   res->op      = op;
@@ -158,15 +160,6 @@ new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mo
   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 (const ir_node *old_node, ir_node *new_node) {
-  assert(get_irn_op(old_node) == get_irn_op(new_node));
-  memcpy(&new_node->attr, &old_node->attr, get_op_attr_size(get_irn_op(old_node)));
-  if (get_irn_op(new_node) == op_Call) remove_Call_callee_arr(new_node);
-}
-
 /*-- getting some parameters from ir_nodes --*/
 
 int
@@ -904,7 +897,7 @@ get_Const_type (ir_node *node) {
 void
 set_Const_type (ir_node *node, type *tp) {
   assert (node->op == op_Const);
-  if (tp != unknown_type) {
+  if (tp != firm_unknown_type) {
     assert (is_atomic_type(tp));
     assert (get_type_mode(tp) == get_irn_mode(node));
   }
@@ -1397,7 +1390,7 @@ set_binop_right (ir_node *node, ir_node *right) {
   assert (node->op->opar == oparity_binary);
 }
 
-int is_Phi (ir_node *n) {
+int is_Phi (const ir_node *n) {
   ir_op *op;
 
   assert(n);
@@ -1412,7 +1405,7 @@ int is_Phi (ir_node *n) {
   return 0;
 }
 
-int is_Phi0 (ir_node *n) {
+int is_Phi0 (const ir_node *n) {
   assert(n);
 
   return ((get_irn_op(n) == op_Phi) &&
@@ -1851,10 +1844,38 @@ ir_node *get_Filter_cg_pred(ir_node *node, int pos) {
   return node->attr.filter.in_cg[pos + 1];
 }
 
+/* Mux support */
+ir_node *get_Mux_sel   (ir_node *node) {
+  assert(node->op == op_Mux);
+  return node->in[1];
+}
+void     set_Mux_sel   (ir_node *node, ir_node *sel) {
+  assert(node->op == op_Mux);
+  node->in[1] = sel;
+}
+
+ir_node *get_Mux_false (ir_node *node) {
+  assert(node->op == op_Mux);
+  return node->in[2];
+}
+void     set_Mux_false (ir_node *node, ir_node *ir_false) {
+  assert(node->op == op_Mux);
+  node->in[2] = ir_false;
+}
+
+ir_node *get_Mux_true  (ir_node *node) {
+  assert(node->op == op_Mux);
+  return node->in[3];
+}
+void     set_Mux_true  (ir_node *node, ir_node *ir_true) {
+  assert(node->op == op_Mux);
+  node->in[3] = ir_true;
+}
+
 
 ir_graph *
-get_irn_irg(ir_node *node) {
-  if (get_irn_op(node) != op_Block)
+get_irn_irg(const ir_node *node) {
+  if (! is_Block(node))
     node = get_nodes_block(node);
   if (is_Bad(node))  /* sometimes bad is predecessor of nodes instead of block: in case of optimization */
     node = get_nodes_block(node);