Removed last change, did not work with fltcalc

[libfirm] / ir / tr / entity.c

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index 7c337b5..e16c5ef 100644 (file)
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -221,12 +221,12 @@ get_entity_nr(entity *ent) {
 }
 
 const char *
-(get_entity_name)(entity *ent) {
+(get_entity_name)(const entity *ent) {
   return __get_entity_name(ent);
 }
 
 ident *
-(get_entity_ident)(entity *ent) {
+(get_entity_ident)(const entity *ent) {
   return get_entity_ident(ent);
 }
 
@@ -282,7 +282,7 @@ void
 }
 
 ent_allocation
-(get_entity_allocation)(entity *ent) {
+(get_entity_allocation)(const entity *ent) {
   return __get_entity_allocation(ent);
 }
 
@@ -307,7 +307,7 @@ const char *get_allocation_name(ent_allocation all)
 
 
 ent_visibility
-(get_entity_visibility)(entity *ent) {
+(get_entity_visibility)(const entity *ent) {
   return __get_entity_visibility(ent);
 }
 
@@ -336,7 +336,7 @@ const char *get_visibility_name(ent_visibility vis)
 }
 
 ent_variability
-(get_entity_variability)(entity *ent) {
+(get_entity_variability)(const entity *ent) {
   return __get_entity_variability(ent);
 }
 
@@ -383,7 +383,7 @@ const char *get_variability_name(ent_variability var)
 }
 
 ent_volatility
-(get_entity_volatility)(entity *ent) {
+(get_entity_volatility)(const entity *ent) {
   return __get_entity_volatility(ent);
 }
 
@@ -405,7 +405,7 @@ const char *get_volatility_name(ent_volatility var)
 }
 
 peculiarity
-(get_entity_peculiarity)(entity *ent) {
+(get_entity_peculiarity)(const entity *ent) {
   return __get_entity_peculiarity(ent);
 }
 
@@ -429,7 +429,7 @@ const char *get_peculiarity_name(peculiarity var)
 
 /* Get the entity's stickyness */
 ent_stickyness
-(get_entity_stickyness)(entity *ent) {
+(get_entity_stickyness)(const entity *ent) {
   return __get_entity_stickyness(ent);
 }
 
@@ -461,20 +461,18 @@ set_atomic_ent_value(entity *ent, ir_node *val) {
 int is_irn_const_expression(ir_node *n) {
   ir_mode *m;
 
+  /* we are in dange iff an exception will arise. TODO: be more precisely,
+   * for instance Div. will NOT rise if divisor != 0
+   */
+  if (is_binop(n) && !is_fragile_op(n))
+    return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
+
   m = get_irn_mode(n);
   switch(get_irn_opcode(n)) {
   case iro_Const:
   case iro_SymConst:
   case iro_Unknown:
     return true; break;
-  case iro_Add:
-  case iro_Sub:
-  case iro_Mul:
-  case iro_And:
-  case iro_Or:
-  case iro_Eor:
-    if (is_irn_const_expression(get_binop_left(n)))
-      return is_irn_const_expression(get_binop_right(n));
   case iro_Conv:
   case iro_Cast:
     return is_irn_const_expression(get_irn_n(n, 0));
@@ -490,32 +488,38 @@ ir_node *copy_const_value(ir_node *n) {
   ir_node *nn;
   ir_mode *m;
 
+  /* @@@ GL I think  we should implement this using the routines from irgopt for
+     dead node elimination/inlineing. */
+
   m = get_irn_mode(n);
   switch(get_irn_opcode(n)) {
   case iro_Const:
-    nn = new_Const(m, get_Const_tarval(n)); break;
+    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));
+    break;
   case iro_SymConst:
-
-    nn = new_SymConst(get_SymConst_symbol(n), get_SymConst_kind(n));
+    nn = new_d_SymConst_type(NULL, 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;
+                copy_const_value(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;
+                copy_const_value(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;
+                copy_const_value(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;
+                copy_const_value(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;
+               copy_const_value(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;
+                copy_const_value(get_Eor_right(n)), m); break;
   case iro_Cast:
     nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
   case iro_Conv:
@@ -524,7 +528,7 @@ ir_node *copy_const_value(ir_node *n) {
     nn = new_Unknown(m); break;
   default:
     DDMN(n);
-    assert(0 && "opdope invalid or not implemented");
+    assert(0 && "opcode invalid or not implemented");
     nn = NULL;
     break;
   }
@@ -732,6 +736,7 @@ set_array_entity_values(entity *ent, tarval **values, int num_vals) {
   ir_graph *rem = current_ir_graph;
   type *arrtp = get_entity_type(ent);
   ir_node *val;
+  type *elttp = get_array_element_type(arrtp);
 
   assert(is_array_type(arrtp));
   assert(get_array_n_dimensions(arrtp) == 1);
@@ -742,7 +747,7 @@ set_array_entity_values(entity *ent, tarval **values, int num_vals) {
   current_ir_graph = get_const_code_irg();
 
   for (i = 0; i < num_vals; i++) {
-    val = new_Const(get_tarval_mode (values[i]), values[i]);
+    val = new_Const_type(values[i], elttp);
     add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
     set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
   }
@@ -761,13 +766,13 @@ int  get_compound_ent_value_offset_bits(entity *ent, int pos) {
     type *node_tp = get_entity_type(node);
     type *owner_tp = get_entity_owner(node);
     if (is_array_type(owner_tp)) {
-      int size  = get_mode_size_bits (get_type_mode(node_tp));
-      int align = get_mode_align_bits(get_type_mode(node_tp));
+      int size  = get_type_size_bits(node_tp);
+      int align = get_type_alignment_bits(node_tp);
       if (size < align)
-    size = align;
+        size = align;
       else {
-    assert(size % align == 0);
-    /* ansonsten aufrunden */
+        assert(size % align == 0);
+        /* ansonsten aufrunden */
       }
       offset += size * get_compound_graph_path_array_index(path, i);
     } else {
@@ -963,12 +968,12 @@ void sort_compound_ent_values(entity *ent) {
 }
 
 int
-(get_entity_offset_bytes)(entity *ent) {
+(get_entity_offset_bytes)(const entity *ent) {
   return __get_entity_offset_bytes(ent);
 }
 
 int
-(get_entity_offset_bits)(entity *ent) {
+(get_entity_offset_bits)(const entity *ent) {
   return __get_entity_offset_bits(ent);
 }
 
@@ -1082,7 +1087,7 @@ void    remove_entity_overwrittenby(entity *ent, entity *overwrites) {
 
 /* A link to store intermediate information */
 void *
-(get_entity_link)(entity *ent) {
+(get_entity_link)(const entity *ent) {
   return __get_entity_link(ent);
 }
 
@@ -1092,7 +1097,7 @@ void
 }
 
 ir_graph *
-(get_entity_irg)(entity *ent) {
+(get_entity_irg)(const entity *ent) {
   return __get_entity_irg(ent);
 }
 
@@ -1110,7 +1115,7 @@ set_entity_irg(entity *ent, ir_graph *irg) {
 }
 
 int
-(is_entity)(void *thing) {
+(is_entity)(const void *thing) {
   return __is_entity(thing);
 }