return ptr;
} /* find_base_adr */
-/**
- * Check if the address can be decomposed into base PLUS offset.
- */
-static int has_offset(ir_node *adr, int *offset) {
- if (is_SymConst(adr)) {
- *offset = 0;
- return 1;
- }
- if (is_Sel(adr)) {
- ir_entity *ent = get_Sel_entity(adr);
- ir_type *owner = get_entity_owner(ent);
-
- if (get_type_state(owner) != layout_fixed) {
- /* The layout is NOT fixed yet, symbolic evaluation needed */
- }
- }
- return 0;
-} /* has_offset */
-
-/**
- * Two address expressions have the same base address,
- * check if there offsets are different.
- *
- * @param adr1 The first address.
- * @param adr2 The second address.
- */
-static ir_alias_relation different_offsets(ir_node *adr1, ir_node *adr2) {
- int offset1, offset2;
- if (has_offset(adr1, &offset1) && has_offset(adr2, &offset2)) {
- /* */
- }
- return may_alias;
-} /* different_offsets */
-
/**
* Check if a given Const node is greater or equal a given size.
*
tarval *tv_size;
if (size == 0)
- return classify_tarval(tv) != TV_CLASSIFY_NULL ? no_alias : may_alias;
+ return tarval_is_null(tv) ? may_alias : no_alias;
tv_size = new_tarval_from_long(size, get_tarval_mode(tv));
return tarval_cmp(tv_size, tv) & (pn_Cmp_Eq|pn_Cmp_Lt) ? no_alias : may_alias;
} /* check_const */
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;
return check_const(r1, size);
}
if (is_Add(idx2)) {
- /* both are Adds, check if they are of x + c kind */
+ /* both are Adds, check if they are of x + a == x + b kind */
ir_node *l2 = get_Add_left(idx2);
ir_node *r2 = get_Add_right(idx2);
}
if (is_Sub(idx2)) {
- /* both are Subs, check if they are of x - c kind */
+ /* both are Subs, check if they are of x - a == x - b kind */
ir_node *l2 = get_Sub_left(idx2);
if (l1 == l2) {
/* base2 address is a global var (R1 a) */
if (adr1 != base2)
return no_alias;
- else
- return different_offsets(adr1, adr2);
} else if (base2 == get_irg_frame(irg)) {
/* the second one is a local variable so they are always
different (R1 b) */
analyse_irg_address_taken(irg);
} /* assure_irg_address_taken_computed */
+
/**
* Initialize the address_taken flag for a global type like type.
*/
}
} /* 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;
+
+ /* Beware: Methods initialized with "themself". This does not count as a taken
+ address. */
+ if (is_Method_type(get_entity_type(ent)))
+ 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.
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);
if (is_SymConst(ptr)) {
ir_entity *ent = get_SymConst_entity(ptr);
+ ir_type *mtp = get_entity_type(ent);
ir_type *ctp = get_Call_type(call);
- if ((get_method_additional_properties(ctp) & mtp_property_private) == 0) {
+ if (mtp != ctp && get_method_additional_properties(mtp) & mtp_property_private) {
set_method_additional_property(ctp, mtp_property_private);
DB((dbgcall, LEVEL_1, "changed call to private method %+F\n", ent));
}
projects / libfirm / blobdiff