X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=8334e4fee9d8a20931363648e98eaff635753f9d;hb=8399216d8aebc713bbda04b6e3e250a1d52b20bf;hp=87bc6061a382dac68868d19a1927bf13629408bb;hpb=1577fb63998cc7d3a638950262ef82cb2eea9ce7;p=libfirm

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 87bc6061a..8334e4fee 100644
--- 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
@@ -238,19 +231,19 @@ set_irn_in (ir_node *node, int arity, ir_node **in) {
 }
 
 ir_node *
-(get_irn_intra_n)(ir_node *node, int n) {
+(get_irn_intra_n)(const ir_node *node, int n) {
   return __get_irn_intra_n (node, n);
 }
 
 ir_node *
-(get_irn_inter_n)(ir_node *node, int n) {
+(get_irn_inter_n)(const ir_node *node, int n) {
   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)(const ir_node *node, int n) = __get_irn_intra_n;
 
 ir_node *
-(get_irn_n)(ir_node *node, int n) {
+(get_irn_n)(const ir_node *node, int n) {
   return __get_irn_n(node, n);
 }
 
@@ -527,7 +520,7 @@ get_irn_except_attr (ir_node *node)
 
 /* this works for all except Block */
 ir_node *
-get_nodes_block (ir_node *node) {
+get_nodes_block (const ir_node *node) {
   assert (!(node->op == op_Block));
   return get_irn_n(node, -1);
 }
@@ -698,6 +691,14 @@ void remove_Block_cg_cfgpred_arr(ir_node * node) {
   node->attr.block.in_cg = NULL;
 }
 
+ir_node *(set_Block_dead)(ir_node *block) {
+  return __set_Block_dead(block);
+}
+
+int (is_Block_dead)(const ir_node *block) {
+  return __is_Block_dead(block);
+}
+
 void
 set_Start_irg(ir_node *node, ir_graph *irg) {
   assert(node->op == op_Start);
@@ -896,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));
   }
@@ -1389,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);
@@ -1404,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) &&
@@ -1843,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);