renamed all type * to ir_type *

[libfirm] / ir / ir / irnode.c

diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c
index 7828fca..5a8a7b2 100644 (file)
--- a/ir/ir/irnode.c
+++ b/ir/ir/irnode.c
@@ -223,6 +223,7 @@ get_irn_in (const ir_node *node) {
 
 void
 set_irn_in (ir_node *node, int arity, ir_node **in) {
+  int i;
   ir_node *** arr;
   assert(node);
   if (get_interprocedural_view()) { /* handle Filter and Block specially */
@@ -237,12 +238,24 @@ set_irn_in (ir_node *node, int arity, ir_node **in) {
   } else {
     arr = &node->in;
   }
-  if (arity != ARR_LEN(*arr) - 1) {
+
+       for (i = 0; i < arity; i++) {
+               if (i < ARR_LEN(*arr)-1)
+       edges_notify_edge(node, i, in[i], (*arr)[i+1], current_ir_graph);
+               else
+           edges_notify_edge(node, i, in[i], NULL,        current_ir_graph);
+  }
+       for(;i < ARR_LEN(*arr)-1; i++) {
+               edges_notify_edge(node, i, NULL, (*arr)[i+1], current_ir_graph);
+       }
+
+       if (arity != ARR_LEN(*arr) - 1) {
     ir_node * block = (*arr)[0];
     *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
     (*arr)[0] = block;
   }
   fix_backedges(current_ir_graph->obst, node);
+
   memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
 }
 
@@ -636,14 +649,14 @@ ir_node  *
   return _get_Block_cfgpred_block(node, pos);
 }
 
-bool
+int
 get_Block_matured (ir_node *node) {
   assert (node->op == op_Block);
-  return node->attr.block.matured;
+  return (int)node->attr.block.matured;
 }
 
 void
-set_Block_matured (ir_node *node, bool matured) {
+set_Block_matured (ir_node *node, int matured) {
   assert (node->op == op_Block);
   node->attr.block.matured = matured;
 }
@@ -688,10 +701,10 @@ void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) {
     node->attr.block.in_cg[0] = NULL;
     node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity);
     {
-      /* Fix backedge array.  fix_backedges operates depending on
+      /* Fix backedge array.  fix_backedges() operates depending on
      interprocedural_view. */
       int ipv = get_interprocedural_view();
-      set_interprocedural_view(true);
+      set_interprocedural_view(1);
       fix_backedges(current_ir_graph->obst, node);
       set_interprocedural_view(ipv);
     }
@@ -1409,8 +1422,8 @@ int is_Cast_upcast(ir_node *node) {
 
   assert(fromtype);
 
-  if (!is_Class_type(totype)) return false;
-  return is_subclass_of(fromtype, totype);
+  if (!is_Class_type(totype)) return 0;
+  return is_SubClass_of(fromtype, totype);
 }
 
 /* Checks for downcast.
@@ -1431,8 +1444,8 @@ int is_Cast_downcast(ir_node *node) {
 
   assert(fromtype);
 
-  if (!is_Class_type(totype)) return false;
-  return is_subclass_of(totype, fromtype);
+  if (!is_Class_type(totype)) return 0;
+  return is_SubClass_of(totype, fromtype);
 }
 
 int
@@ -2022,6 +2035,48 @@ void     set_Mux_true  (ir_node *node, ir_node *ir_true) {
   node->in[3] = ir_true;
 }
 
+/* CopyB support */
+ir_node *get_CopyB_mem (ir_node *node) {
+  assert (node->op == op_CopyB);
+  return get_irn_n(node, 0);
+}
+
+void     set_CopyB_mem (ir_node *node, ir_node *mem) {
+  assert (node->op == op_CopyB);
+  set_irn_n(node, 0, mem);
+}
+
+ir_node *get_CopyB_dst (ir_node *node) {
+  assert (node->op == op_CopyB);
+  return get_irn_n(node, 1);
+}
+
+void     set_CopyB_dst (ir_node *node, ir_node *dst) {
+  assert (node->op == op_CopyB);
+  set_irn_n(node, 1, dst);
+}
+
+ir_node *get_CopyB_src (ir_node *node) {
+  assert (node->op == op_CopyB);
+  return get_irn_n(node, 2);
+}
+
+void     set_CopyB_src (ir_node *node, ir_node *src) {
+  assert (node->op == op_CopyB);
+  set_irn_n(node, 2, src);
+}
+
+type    *get_CopyB_type(ir_node *node) {
+  assert (node->op == op_CopyB);
+  return node->attr.copyb.data_type;
+}
+
+void     set_CopyB_type(ir_node *node, type *data_type) {
+  assert (node->op == op_CopyB && data_type);
+  node->attr.copyb.data_type = data_type;
+}
+
+
 ir_graph *
 get_irn_irg(const ir_node *node) {
        /*
@@ -2290,17 +2345,21 @@ static type *get_Null_type(ir_node *n) {
   return NULL;
 }
 
-/* set the get_type operation */
-ir_op *firm_set_default_get_type(ir_op *op)
+/* Sets the get_type operation for an ir_op_ops. */
+ir_op_ops *firm_set_default_get_type(opcode code, ir_op_ops *ops)
 {
-  switch (op->code) {
-  case iro_Const:    op->get_type = get_Const_type; break;
-  case iro_SymConst: op->get_type = get_SymConst_value_type; break;
-  case iro_Cast:     op->get_type = get_Cast_type; break;
-  case iro_Proj:     op->get_type = get_Proj_type; break;
-  default:           op->get_type = get_Null_type; break;
+  switch (code) {
+  case iro_Const:    ops->get_type = get_Const_type; break;
+  case iro_SymConst: ops->get_type = get_SymConst_value_type; break;
+  case iro_Cast:     ops->get_type = get_Cast_type; break;
+  case iro_Proj:     ops->get_type = get_Proj_type; break;
+  default:
+    /* not allowed to be NULL */
+    if (! ops->get_type)
+      ops->get_type = get_Null_type;
+    break;
   }
-  return op;
+  return ops;
 }
 
 #ifdef DEBUG_libfirm