X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firmemory.c;h=99b5849f6685ecfbf56742b4f58a5226d509c5e5;hb=85d72a506c89cd19337601049c2911ad72644879;hp=21ab97886e889efa22237d9c77b686253701e078;hpb=3571b99127e71fef4e0e017b2b60ea5be6210468;p=libfirm

diff --git a/ir/ana/irmemory.c b/ir/ana/irmemory.c
index 21ab97886..99b5849f6 100644
--- a/ir/ana/irmemory.c
+++ b/ir/ana/irmemory.c
@@ -88,40 +88,6 @@ static ir_node *find_base_adr(ir_node *sel, ir_entity **pEnt) {
 	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.
  *
@@ -152,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;
@@ -178,7 +203,7 @@ static ir_alias_relation different_index(ir_node *idx1, ir_node *idx2, int size)
 				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);
 
@@ -214,7 +239,7 @@ static ir_alias_relation different_index(ir_node *idx1, ir_node *idx2, int size)
 		}
 
 		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) {
@@ -492,8 +517,6 @@ static ir_alias_relation _get_alias_relation(
 				/* 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) */
@@ -881,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.
  */
@@ -899,6 +923,56 @@ 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;
+
+	/* 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.
@@ -954,6 +1028,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);
 
@@ -987,3 +1064,56 @@ void assure_irp_globals_address_taken_computed(void) {
 	if (irp->globals_adr_taken_state == ir_address_taken_not_computed)
 		analyse_irp_globals_address_taken();
 }  /* assure_irp_globals_address_taken_computed */
+
+
+DEBUG_ONLY(static firm_dbg_module_t *dbgcall = NULL;)
+
+/**
+ * Copy the calling conventions from the entities to the call type.
+ */
+static void update_calls(ir_node *call, void *env) {
+	(void) env;
+	if (is_Call(call)) {
+		ir_node *ptr = get_Call_ptr(call);
+
+		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 (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));
+			}
+		}
+	}
+}
+
+/* Mark all private methods, i.e. those of which all call sites are known. */
+void mark_private_methods(void) {
+	int i;
+	int changed = 0;
+
+	FIRM_DBG_REGISTER(dbgcall, "firm.opt.cc");
+
+	assure_irp_globals_address_taken_computed();
+
+	/* first step: change the calling conventions of the local non-escaped entities */
+	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+		ir_graph               *irg = get_irp_irg(i);
+		ir_entity              *ent = get_irg_entity(irg);
+		ir_address_taken_state state = get_entity_address_taken(ent);
+
+		if (get_entity_visibility(ent) == visibility_local &&
+		    state == ir_address_not_taken) {
+			ir_type *mtp = get_entity_type(ent);
+
+			set_method_additional_property(mtp, mtp_property_private);
+			changed = 1;
+			DB((dbgcall, LEVEL_1, "found private method %+F\n", ent));
+		}
+	}
+
+	if (changed)
+		all_irg_walk(NULL, update_calls, NULL);
+}