X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firmemory.c;h=c0b3e5e78ef83c5e128d9170a466090a54e7cb35;hb=fe6c9130a81330693ec34a0e2a261ccf47b48599;hp=d9b7a58c24708f91ad4fc482aa4df04f794e22f8;hpb=ce6161a7e42a48f7422b7babcc64d8ace18e2687;p=libfirm

diff --git a/ir/ana/irmemory.c b/ir/ana/irmemory.c
index d9b7a58c2..c0b3e5e78 100644
--- a/ir/ana/irmemory.c
+++ b/ir/ana/irmemory.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -91,6 +91,12 @@ void set_irp_memory_disambiguator_options(unsigned options)
 	global_mem_disamgig_opt = options;
 }  /* set_irp_memory_disambiguator_options */
 
+/* Get the base storage class (ignore modifier) */
+ir_storage_class_class_t get_base_sc(ir_storage_class_class_t x)
+{
+	return x & ~ir_sc_modifiers;
+}  /* get_base_sc */
+
 /**
  * Find the base address and entity of an Sel node.
  *
@@ -127,7 +133,7 @@ static ir_alias_relation check_const(const ir_node *cns, int size)
 	if (size == 0)
 		return tarval_is_null(tv) ? ir_may_alias : ir_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) ? ir_no_alias : ir_may_alias;
+	return tarval_cmp(tv_size, tv) & (ir_relation_less_equal) ? ir_no_alias : ir_may_alias;
 }  /* check_const */
 
 /**
@@ -195,7 +201,7 @@ static ir_alias_relation different_index(const ir_node *idx1, const ir_node *idx
 				} else {
 					tv_size = new_tarval_from_long(size, m2);
 
-					if (tarval_cmp(tv2, tv_size) & (pn_Cmp_Eq|pn_Cmp_Gt)) {
+					if (tarval_cmp(tv2, tv_size) & (ir_relation_greater_equal)) {
 						/* tv1 is negative and tv2 >= tv_size, so the difference is bigger than size */
 						return ir_no_alias;
 					}
@@ -209,11 +215,11 @@ static ir_alias_relation different_index(const ir_node *idx1, const ir_node *idx
 					tv1 = tarval_convert_to(tv1, m2);
 
 					/* now we can compare without overflow */
-					return tarval_cmp(tv1, tv2) & (pn_Cmp_Eq|pn_Cmp_Gt) ? ir_no_alias : ir_may_alias;
+					return tarval_cmp(tv1, tv2) & (ir_relation_greater_equal) ? ir_no_alias : ir_may_alias;
 				}
 			}
 		}
-		if (tarval_cmp(tv1, tv2) == pn_Cmp_Gt) {
+		if (tarval_cmp(tv1, tv2) == ir_relation_greater) {
 			ir_tarval *t = tv1;
 			tv1 = tv2;
 			tv2 = t;
@@ -221,7 +227,7 @@ static ir_alias_relation different_index(const ir_node *idx1, const ir_node *idx
 		/* tv1 is now the "smaller" one */
 		tv      = tarval_sub(tv2, tv1, NULL);
 		tv_size = new_tarval_from_long(size, get_tarval_mode(tv));
-		return tarval_cmp(tv_size, tv) & (pn_Cmp_Eq|pn_Cmp_Lt) ? ir_no_alias : ir_may_alias;
+		return tarval_cmp(tv_size, tv) & (ir_relation_less_equal) ? ir_no_alias : ir_may_alias;
 	}
 
 	/* Note: we rely here on the fact that normalization puts constants on the RIGHT side */
@@ -431,17 +437,14 @@ ir_storage_class_class_t classify_pointer(const ir_node *irn,
 	ir_storage_class_class_t res = ir_sc_pointer;
 	if (is_Global(irn)) {
 		ir_entity *entity = get_Global_entity(irn);
-		res = ir_sc_globalvar;
+		ir_type   *owner  = get_entity_owner(entity);
+		res = owner == get_tls_type() ? ir_sc_tls : ir_sc_globalvar;
 		if (! (get_entity_usage(entity) & ir_usage_address_taken))
 			res |= ir_sc_modifier_nottaken;
 	} else if (irn == get_irg_frame(irg)) {
 		res = ir_sc_localvar;
 		if (ent != NULL && !(get_entity_usage(ent) & ir_usage_address_taken))
 			res |= ir_sc_modifier_nottaken;
-	} else if (irn == get_irg_tls(irg)) {
-		res = ir_sc_tls;
-		if (ent != NULL && !(get_entity_usage(ent) & ir_usage_address_taken))
-			res |= ir_sc_modifier_nottaken;
 	} else if (is_Proj(irn) && is_malloc_Result(irn)) {
 		return ir_sc_malloced;
 	} else if (is_Const(irn)) {
@@ -561,7 +564,7 @@ static ir_alias_relation _get_alias_relation(
 	/*
 	 * Bitfields can be constructed as Sels from its base address.
 	 * As they have different entities, the disambiguator would find that they are
-	 * alias free. While this is true for it's values, it is false for the addresses
+	 * alias free. While this is true for its values, it is false for the addresses
 	 * (strictly speaking, the Sel's are NOT the addresses of the bitfields).
 	 * So, skip those bitfield selecting Sel's.
 	 */
@@ -594,6 +597,16 @@ static ir_alias_relation _get_alias_relation(
 	class1 = get_base_sc(mod1);
 	class2 = get_base_sc(mod2);
 
+	/* struct-access cannot alias with variables */
+	if (ent1 == NULL && ent2 != NULL && is_compound_type(get_entity_owner(ent2))
+		&& (class1 == ir_sc_globalvar || class1 == ir_sc_localvar || class1 == ir_sc_tls || class1 == ir_sc_globaladdr)) {
+		return ir_no_alias;
+	}
+	if (ent2 == NULL && ent1 != NULL && is_compound_type(get_entity_owner(ent1))
+		&& (class2 == ir_sc_globalvar || class2 == ir_sc_localvar || class2 == ir_sc_tls || class2 == ir_sc_globaladdr)) {
+		return ir_no_alias;
+	}
+
 	if (class1 == ir_sc_pointer || class2 == ir_sc_pointer) {
 		/* swap pointer class to class1 */
 		if (class2 == ir_sc_pointer) {
@@ -883,14 +896,14 @@ static ir_entity_usage determine_entity_usage(const ir_node *irn, ir_entity *ent
 			res |= determine_entity_usage(succ, entity);
 			break;
 		case iro_Sel: {
-			ir_entity *entity = get_Sel_entity(succ);
+			ir_entity *sel_entity = get_Sel_entity(succ);
 			/* this analysis can't handle unions correctly */
-			if (is_Union_type(get_entity_owner(entity))) {
+			if (is_Union_type(get_entity_owner(sel_entity))) {
 				res |= ir_usage_unknown;
 				break;
 			}
 			/* Check the successor of irn. */
-			res |= determine_entity_usage(succ, entity);
+			res |= determine_entity_usage(succ, sel_entity);
 			break;
 		}
 
@@ -952,10 +965,11 @@ static void analyse_irg_entity_usage(ir_graph *irg)
 {
 	ir_type *ft = get_irg_frame_type(irg);
 	ir_node *irg_frame;
-	int i, j, k, static_link_arg;
+	size_t i, n;
+	int j, k, static_link_arg;
 
 	/* set initial state to not_taken, as this is the "smallest" state */
-	for (i = get_class_n_members(ft) - 1; i >= 0; --i) {
+	for (i = 0, n = get_class_n_members(ft); i < n; ++i) {
 		ir_entity *ent = get_class_member(ft, i);
 
 		/* methods can only be analyzed globally */
@@ -971,8 +985,8 @@ static void analyse_irg_entity_usage(ir_graph *irg)
 
 	irg_frame = get_irg_frame(irg);
 
-	for (i = get_irn_n_outs(irg_frame) - 1; i >= 0; --i) {
-		ir_node        *succ = get_irn_out(irg_frame, i);
+	for (j = get_irn_n_outs(irg_frame) - 1; j >= 0; --j) {
+		ir_node        *succ = get_irn_out(irg_frame, j);
 		ir_entity      *entity;
 		unsigned        flags;
 
@@ -987,7 +1001,7 @@ static void analyse_irg_entity_usage(ir_graph *irg)
 
 	/* check inner functions accessing outer frame */
 	static_link_arg = 0;
-	for (i = get_class_n_members(ft) - 1; i >= 0; --i) {
+	for (i = 0, n = get_class_n_members(ft); i < n; ++i) {
 		ir_entity *ent = get_class_member(ft, i);
 		ir_graph  *inner_irg;
 		ir_node   *args;
@@ -1054,10 +1068,10 @@ void assure_irg_entity_usage_computed(ir_graph *irg)
  */
 static void init_entity_usage(ir_type *tp)
 {
-	int i;
+	size_t i, n;
 
 	/* We have to be conservative: All external visible entities are unknown */
-	for (i = get_compound_n_members(tp) - 1; i >= 0; --i) {
+	for (i = 0, n = get_compound_n_members(tp); i < n; ++i) {
 		ir_entity       *ent   = get_compound_member(tp, i);
 		unsigned         flags = ir_usage_none;
 
@@ -1075,8 +1089,8 @@ static void init_entity_usage(ir_type *tp)
  */
 static void check_initializer_nodes(ir_initializer_t *initializer)
 {
-	unsigned i;
-	ir_node  *n;
+	size_t  i;
+	ir_node *n;
 
 	switch (initializer->kind) {
 	case IR_INITIALIZER_CONST:
@@ -1109,9 +1123,6 @@ static void check_initializer_nodes(ir_initializer_t *initializer)
  */
 static void check_initializer(ir_entity *ent)
 {
-	ir_node *n;
-	int i;
-
 	/* Beware: Methods are always initialized with "themself". This does not
 	 * count as a taken address.
 	 * TODO: this initialisation with "themself" is wrong and should be removed
@@ -1122,13 +1133,15 @@ static void check_initializer(ir_entity *ent)
 	if (ent->initializer != NULL) {
 		check_initializer_nodes(ent->initializer);
 	} else if (entity_has_compound_ent_values(ent)) {
-		for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) {
-			n = get_compound_ent_value(ent, i);
+		size_t i, n;
+
+		for (i = 0, n = get_compound_ent_n_values(ent); i < n; ++i) {
+			ir_node *irn = get_compound_ent_value(ent, i);
 
 			/* let's check if it's an address */
-			if (is_Global(n)) {
-				ir_entity *ent = get_Global_entity(n);
-				set_entity_usage(ent, ir_usage_unknown);
+			if (is_Global(irn)) {
+				ir_entity *symconst_ent = get_Global_entity(irn);
+				set_entity_usage(symconst_ent, ir_usage_unknown);
 			}
 		}
 	}
@@ -1142,9 +1155,9 @@ static void check_initializer(ir_entity *ent)
  */
 static void check_initializers(ir_type *tp)
 {
-	int i;
+	size_t i, n;
 
-	for (i = get_compound_n_members(tp) - 1; i >= 0; --i) {
+	for (i = 0, n = get_compound_n_members(tp); i < n; ++i) {
 		ir_entity *ent = get_compound_member(tp, i);
 
 		check_initializer(ent);
@@ -1157,10 +1170,10 @@ static void check_initializers(ir_type *tp)
  *
  * @param tp  a compound type
  */
-static void print_entity_usage_flags(ir_type *tp)
+static void print_entity_usage_flags(const ir_type *tp)
 {
-	int i;
-	for (i = get_compound_n_members(tp) - 1; i >= 0; --i) {
+	size_t i, n;
+	for (i = 0, n = get_compound_n_members(tp); i < n; ++i) {
 		ir_entity *ent = get_compound_member(tp, i);
 		ir_entity_usage flags = get_entity_usage(ent);
 
@@ -1183,18 +1196,15 @@ static void print_entity_usage_flags(ir_type *tp)
 /**
  * Post-walker: check for global entity address
  */
-static void check_global_address(ir_node *irn, void *env)
+static void check_global_address(ir_node *irn, void *data)
 {
-	ir_node *tls = (ir_node*) env;
 	ir_entity *ent;
 	unsigned flags;
+	(void) data;
 
 	if (is_Global(irn)) {
 		/* A global. */
 		ent = get_Global_entity(irn);
-	} else if (is_Sel(irn) && get_Sel_ptr(irn) == tls) {
-		/* A TLS variable. */
-		ent = get_Sel_entity(irn);
 	} else
 		return;
 
@@ -1208,7 +1218,7 @@ static void check_global_address(ir_node *irn, void *env)
  */
 static void analyse_irp_globals_entity_usage(void)
 {
-	int i;
+	size_t i, n;
 	ir_segment_t s;
 
 	for (s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
@@ -1221,11 +1231,11 @@ static void analyse_irp_globals_entity_usage(void)
 		check_initializers(type);
 	}
 
-	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+	for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
 		ir_graph *irg = get_irp_irg(i);
 
 		assure_irg_outs(irg);
-		irg_walk_graph(irg, NULL, check_global_address, get_irg_tls(irg));
+		irg_walk_graph(irg, NULL, check_global_address, NULL);
 	}
 
 #ifdef DEBUG_libfirm
@@ -1319,7 +1329,7 @@ static void update_calls_to_private(ir_node *call, void *env)
 /* Mark all private methods, i.e. those of which all call sites are known. */
 void mark_private_methods(void)
 {
-	int i;
+	size_t i, n;
 	int changed = 0;
 
 	assure_irp_globals_entity_usage_computed();
@@ -1327,13 +1337,12 @@ void mark_private_methods(void)
 	mtp_map = pmap_create();
 
 	/* first step: change the calling conventions of the local non-escaped entities */
-	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+	for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
 		ir_graph        *irg   = get_irp_irg(i);
 		ir_entity       *ent   = get_irg_entity(irg);
 		ir_entity_usage  flags = get_entity_usage(ent);
 
-		if (!entity_is_externally_visible(ent) &&
-		    !(flags & ir_usage_address_taken)) {
+		if (!(flags & ir_usage_address_taken) && !entity_is_externally_visible(ent)) {
 			ir_type *mtp = get_entity_type(ent);
 
 			add_entity_additional_properties(ent, mtp_property_private);