fehler66 (more unsigned int -> double magic)

[libfirm] / ir / ana / irmemory.c

diff --git a/ir/ana/irmemory.c b/ir/ana/irmemory.c
index 32d6341..596ba8e 100644 (file)
--- a/ir/ana/irmemory.c
+++ b/ir/ana/irmemory.c
@@ -118,10 +118,69 @@ static ir_alias_relation different_index(ir_node *idx1, ir_node *idx2, int size)
                tarval *tv1 = get_Const_tarval(idx1);
                tarval *tv2 = get_Const_tarval(idx2);
                tarval *tv, *tv_size;
+               ir_mode *m1, *m2;
 
                if (size == 0)
                        return tv1 == tv2 ? sure_alias : no_alias;
 
+               /* arg, modes may be different */
+               m1 = get_tarval_mode(tv1);
+               m2 = get_tarval_mode(tv2);
+               if (m1 != m2) {
+                       int size = get_mode_size_bits(m1) - get_mode_size_bits(m2);
+
+                       if (size < 0) {
+                               /* m1 is a small mode, cast up */
+                               m1 = mode_is_signed(m1) ? find_signed_mode(m2) : find_unsigned_mode(m2);
+                               if (m1 == NULL) {
+                                       /* should NOT happen, but if it does we give up here */
+                                       return may_alias;
+                               }
+                               tv1 = tarval_convert_to(tv1, m1);
+                       } else if (size > 0) {
+                               /* m2 is a small mode, cast up */
+                               m2 = mode_is_signed(m2) ? find_signed_mode(m1) : find_unsigned_mode(m1);
+                               if (m2 == NULL) {
+                                       /* should NOT happen, but if it does we give up here */
+                                       return may_alias;
+                               }
+                               tv2 = tarval_convert_to(tv2, m2);
+                       }
+                       /* here the size should be identical, check for signed */
+                       if (get_mode_sign(m1) != get_mode_sign(m2)) {
+                               /* find the signed */
+                               if (mode_is_signed(m2)) {
+                                       tarval *t = tv1;
+                                       ir_mode *tm = m1;
+                                       tv1 = tv2; m1 = m2;
+                                       tv2 = t;   m2 = tm;
+                               }
+
+                               /* m1 is now the signed one */
+                               if (tarval_cmp(tv1, get_tarval_null(m1)) & (pn_Cmp_Eq|pn_Cmp_Gt)) {
+                                       /* tv1 is signed, but >= 0, simply cast into unsigned */
+                                       tv1 = tarval_convert_to(tv1, m2);
+                               } else {
+                                       tv_size = new_tarval_from_long(size, m2);
+
+                                       if (tarval_cmp(tv2, tv_size) & (pn_Cmp_Eq|pn_Cmp_Gt)) {
+                                               /* tv1 is negative and tv2 >= tv_size, so the difference is bigger than size */
+                                               return no_alias;
+                                       }
+                                       /* tv_size > tv2, so we can subtract without overflow */
+                                       tv2 = tarval_sub(tv_size, tv2);
+
+                                       /* tv1 is < 0, so we can negate it */
+                                       tv1 = tarval_neg(tv1);
+
+                                       /* cast it into unsigned. for two-complement it does the right thing for MIN_INT */
+                                       tv1 = tarval_convert_to(tv1, m2);
+
+                                       /* now we can compare without overflow */
+                                       return tarval_cmp(tv1, tv2) & (pn_Cmp_Eq|pn_Cmp_Gt) ? no_alias : may_alias;
+                               }
+                       }
+               }
                if (tarval_cmp(tv1, tv2) == pn_Cmp_Gt) {
                        tarval *t = tv1;
                        tv1 = tv2;
@@ -845,6 +904,7 @@ void assure_irg_address_taken_computed(ir_graph *irg) {
                analyse_irg_address_taken(irg);
 }  /* assure_irg_address_taken_computed */
 
+
 /**
  * Initialize the address_taken flag for a global type like type.
  */
@@ -863,6 +923,51 @@ static void init_taken_flag(ir_type * tp) {
        }
 }  /* init_taken_flag */
 
+/**
+ * Mark all entities used in the initializer for the given entity as address taken
+ */
+static void check_initializer(ir_entity *ent) {
+       ir_node *n;
+       int i;
+
+       /* do not check uninitialized values */
+       if (get_entity_variability(ent) == variability_uninitialized)
+               return;
+
+       if (is_atomic_entity(ent)) {
+               /* let's check if it's an address */
+               n = get_atomic_ent_value(ent);
+               if (is_SymConst(n) && get_SymConst_kind(n) == symconst_addr_ent) {
+                       ir_entity *ent = get_SymConst_entity(n);
+                       set_entity_address_taken(ent, ir_address_taken);
+               }
+       } else {
+               for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) {
+                       n = get_compound_ent_value(ent, i);
+
+                       /* let's check if it's an address */
+                       if (is_SymConst(n) && get_SymConst_kind(n) == symconst_addr_ent) {
+                               ir_entity *ent = get_SymConst_entity(n);
+                               set_entity_address_taken(ent, ir_address_taken);
+                       }
+               }
+       }
+}  /* check_initializer */
+
+
+/**
+ * Mark all entities used in initializers as address taken
+ */
+static void check_initializers(ir_type *tp) {
+       int i;
+
+       for (i = get_compound_n_members(tp) - 1; i >= 0; --i) {
+               ir_entity *ent = get_compound_member(tp, i);
+
+               check_initializer(ent);
+       }
+}  /* check_initializers */
+
 #ifdef DEBUG_libfirm
 /**
  * Print the address taken state of all entities of a given type for debugging.
@@ -918,6 +1023,9 @@ static void analyse_irp_globals_address_taken(void) {
        init_taken_flag(get_glob_type());
        init_taken_flag(get_tls_type());
 
+       check_initializers(get_glob_type());
+       check_initializers(get_tls_type());
+
        for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
                ir_graph *irg = get_irp_irg(i);