do not check for the entity type, simpl check the the initialier entity

[libfirm] / ir / tr / entity.c

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index cdf5980..3cded46 100644 (file)
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -28,6 +28,8 @@
 # include "mangle.h"
 # include "typegmod.h"
 # include "array.h"
+# include "irtools.h"
+# include "irhooks.h"
 
 /* All this is needed to build the constant node for methods: */
 # include "irprog_t.h"
@@ -158,6 +160,7 @@ new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
   /* Remember entity in it's owner. */
   insert_entity_in_owner (res);
 
+  hook_new_entity(res);
   return res;
 }
 
@@ -520,8 +523,11 @@ int is_irn_const_expression(ir_node *n) {
   return false;
 }
 
-
-ir_node *copy_const_value(ir_node *n) {
+/*
+ * Copies a firm subgraph that complies to the restrictions for
+ * constant expressions to current_block in current_ir_graph.
+ */
+ir_node *copy_const_value(dbg_info *dbg, ir_node *n) {
   ir_node *nn;
   ir_mode *m;
 
@@ -529,40 +535,38 @@ ir_node *copy_const_value(ir_node *n) {
      dead node elimination/inlineing. */
 
   m = get_irn_mode(n);
-  switch(get_irn_opcode(n)) {
+  switch (get_irn_opcode(n)) {
   case iro_Const:
-    nn = new_Const(m, get_Const_tarval(n));     set_Const_type(nn, get_Const_type(n));
-    //nn = new_rd_Const_type(get_irn_dbg_info(n), current_ir_graph, get_cur_block(),
-    //            m,  get_Const_tarval(n), get_Const_type(n));
+    nn = new_d_Const_type(dbg, m, get_Const_tarval(n), get_Const_type(n));
     break;
   case iro_SymConst:
-    nn = new_d_SymConst_type(NULL, get_SymConst_symbol(n), get_SymConst_kind(n),
+    nn = new_d_SymConst_type(dbg, get_SymConst_symbol(n), get_SymConst_kind(n),
                             get_SymConst_value_type(n));
     break;
   case iro_Add:
-    nn = new_Add(copy_const_value(get_Add_left(n)),
-                copy_const_value(get_Add_right(n)), m); break;
+    nn = new_d_Add(dbg, copy_const_value(dbg, get_Add_left(n)),
+                copy_const_value(dbg, get_Add_right(n)), m); break;
   case iro_Sub:
-    nn = new_Sub(copy_const_value(get_Sub_left(n)),
-                copy_const_value(get_Sub_right(n)), m); break;
+    nn = new_d_Sub(dbg, copy_const_value(dbg, get_Sub_left(n)),
+                copy_const_value(dbg, get_Sub_right(n)), m); break;
   case iro_Mul:
-    nn = new_Mul(copy_const_value(get_Mul_left(n)),
-                copy_const_value(get_Mul_right(n)), m); break;
+    nn = new_d_Mul(dbg, copy_const_value(dbg, get_Mul_left(n)),
+                copy_const_value(dbg, get_Mul_right(n)), m); break;
   case iro_And:
-    nn = new_And(copy_const_value(get_And_left(n)),
-                copy_const_value(get_And_right(n)), m); break;
+    nn = new_d_And(dbg, copy_const_value(dbg, get_And_left(n)),
+                copy_const_value(dbg, get_And_right(n)), m); break;
   case iro_Or:
-    nn = new_Or(copy_const_value(get_Or_left(n)),
-               copy_const_value(get_Or_right(n)), m); break;
+    nn = new_d_Or(dbg, copy_const_value(dbg, get_Or_left(n)),
+               copy_const_value(dbg, get_Or_right(n)), m); break;
   case iro_Eor:
-    nn = new_Eor(copy_const_value(get_Eor_left(n)),
-                copy_const_value(get_Eor_right(n)), m); break;
+    nn = new_d_Eor(dbg, copy_const_value(dbg, get_Eor_left(n)),
+                copy_const_value(dbg, get_Eor_right(n)), m); break;
   case iro_Cast:
-    nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
+    nn = new_d_Cast(dbg, copy_const_value(dbg, get_Cast_op(n)), get_Cast_type(n)); break;
   case iro_Conv:
-    nn = new_Conv(copy_const_value(get_Conv_op(n)), m); break;
+    nn = new_d_Conv(dbg, copy_const_value(dbg, get_Conv_op(n)), m); break;
   case iro_Unknown:
-    nn = new_Unknown(m); break;
+    nn = new_d_Unknown(dbg, m); break;
   default:
     DDMN(n);
     assert(0 && "opcode invalid or not implemented");
@@ -920,7 +924,7 @@ static void init_index(type *arr) {
   else
     init = get_array_upper_bound_int(arr, 0) +1;
 
-  set_entity_link(get_array_element_entity(arr), (void *)init);
+  set_entity_link(get_array_element_entity(arr), INT_TO_PTR(init));
 }
 
 
@@ -932,20 +936,20 @@ static int get_next_index(entity *elem_ent) {
   assert(get_array_n_dimensions(arr) == 1);
 
   if (has_array_lower_bound(arr, dim)) {
-    next = (int)get_entity_link(elem_ent) +1;
+    next = PTR_TO_INT(get_entity_link(elem_ent)) + 1;
     if (has_array_upper_bound(arr, dim)) {
       int upper = get_array_upper_bound_int(arr, dim);
       if (next == upper) next = get_array_lower_bound_int(arr, dim);
     }
   } else {
-    next = (int)get_entity_link(elem_ent) -1;
+    next = PTR_TO_INT(get_entity_link(elem_ent)) - 1;
     if (has_array_lower_bound(arr, dim)) {
       int upper = get_array_upper_bound_int(arr, dim);
       if (next == upper) next = get_array_upper_bound_int(arr, dim);
     }
   }
 
-  set_entity_link(elem_ent, (void *)next);
+  set_entity_link(elem_ent, INT_TO_PTR(next));
   return next;
 }
 
@@ -1307,12 +1311,22 @@ void (set_entity_additional_property)(entity *ent, unsigned flag) {
   _set_entity_additional_property(ent, (irg_additional_property)flag);
 }
 
-void init_entity(void)
+/* Returns the calling convention of an entities graph. */
+unsigned (get_entity_calling_convention)(const entity *ent) {
+  return _get_entity_calling_convention(ent);
+}
+
+/* Sets the calling convention of an entities graph. */
+void (set_entity_calling_convention)(entity *ent, unsigned cc_mask) {
+  _set_entity_calling_convention(ent, cc_mask);
+}
+
+void firm_init_entity(void)
 {
   symconst_symbol sym;
 
-  assert(firm_unknown_type && "Call init_type before init_entity!");
-  assert(!unknown_entity && "Call init_entity only once!");
+  assert(firm_unknown_type && "Call init_type() before firm_init_entity()!");
+  assert(!unknown_entity && "Call firm_init_entity() only once!");
   unknown_entity = new_rd_entity(NULL, firm_unknown_type, new_id_from_str(UNKNOWN_ENTITY_NAME), firm_unknown_type);
   set_entity_visibility(unknown_entity, visibility_external_allocated);
   set_entity_ld_ident(unknown_entity, get_entity_ident(unknown_entity));