X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fana%2Firmemory.c;h=1c37358843a0552974b4a7fb5420f3bc50f16608;hb=54529d18bc9e81fe062cdce548d3b899750c6e0b;hp=db1f94cfcfe7b1afdd22697b154e1ba8dd925f5c;hpb=1e2aa7ad40a2e9d61eac5ad8d8c4d4a4c55b37a3;p=libfirm

diff --git a/ir/ana/irmemory.c b/ir/ana/irmemory.c
index db1f94cfc..1c3735884 100644
--- a/ir/ana/irmemory.c
+++ b/ir/ana/irmemory.c
@@ -68,7 +68,7 @@ const char *get_ir_alias_relation_name(ir_alias_relation rel) {
 }
 
 /* Get the memory disambiguator options for a graph. */
-unsigned get_irg_memory_disambiguator_options(ir_graph *irg) {
+unsigned get_irg_memory_disambiguator_options(const ir_graph *irg) {
 	unsigned opt = irg->mem_disambig_opt;
 	if (opt & aa_opt_inherited)
 		return global_mem_disamgig_opt;
@@ -93,7 +93,7 @@ void set_irp_memory_disambiguator_options(unsigned options) {
  *
  * @return the base address.
  */
-static ir_node *find_base_adr(ir_node *sel, ir_entity **pEnt) {
+static ir_node *find_base_adr(const ir_node *sel, ir_entity **pEnt) {
 	ir_node *ptr = get_Sel_ptr(sel);
 
 	while (is_Sel(ptr)) {
@@ -112,7 +112,7 @@ static ir_node *find_base_adr(ir_node *sel, ir_entity **pEnt) {
  *
  * @return ir_no_alias if the Const is greater, ir_may_alias else
  */
-static ir_alias_relation check_const(ir_node *cns, int size) {
+static ir_alias_relation check_const(const ir_node *cns, int size) {
 	tarval *tv = get_Const_tarval(cns);
 	tarval *tv_size;
 
@@ -133,7 +133,7 @@ static ir_alias_relation check_const(ir_node *cns, int size) {
  *         ir_no_alias iff they ALWAYS differ more than size
  *         ir_may_alias else
  */
-static ir_alias_relation different_index(ir_node *idx1, ir_node *idx2, int size) {
+static ir_alias_relation different_index(const ir_node *idx1, const ir_node *idx2, int size) {
 	if (idx1 == idx2)
 		return ir_sure_alias;
 	if (is_Const(idx1) && is_Const(idx2)) {
@@ -292,7 +292,7 @@ static ir_alias_relation different_index(ir_node *idx1, ir_node *idx2, int size)
  * @param adr1  The first address.
  * @param adr2  The second address.
  */
-static ir_alias_relation different_sel_offsets(ir_node *sel1, ir_node *sel2) {
+static ir_alias_relation different_sel_offsets(const ir_node *sel1, const ir_node *sel2) {
 	/* seems to be broken */
 	(void) sel1;
 	(void) sel2;
@@ -347,7 +347,7 @@ static ir_alias_relation different_sel_offsets(ir_node *sel1, ir_node *sel2) {
  * @param adr1    The first address.
  * @param adr2    The second address.
  */
-static ir_alias_relation different_types(ir_node *adr1, ir_node *adr2)
+static ir_alias_relation different_types(const ir_node *adr1, const ir_node *adr2)
 {
 	ir_entity *ent1 = NULL, *ent2 = NULL;
 
@@ -395,7 +395,7 @@ static ir_alias_relation different_types(ir_node *adr1, ir_node *adr2)
  *
  * @param node  the Proj node to test
  */
-static int is_malloc_Result(ir_node *node) {
+static int is_malloc_Result(const ir_node *node) {
 	node = get_Proj_pred(node);
 	if (! is_Proj(node))
 		return 0;
@@ -420,7 +420,7 @@ static int is_malloc_Result(ir_node *node) {
  * @param irn  the node representing the base address
  * @param ent  the base entity of the base address iff any
  */
-ir_storage_class_class_t classify_pointer(ir_graph *irg, ir_node *irn, ir_entity *ent)
+ir_storage_class_class_t classify_pointer(const ir_graph *irg, const ir_node *irn, const ir_entity *ent)
 {
 	ir_storage_class_class_t res = ir_sc_pointer;
 	if (is_Global(irn)) {
@@ -432,8 +432,6 @@ ir_storage_class_class_t classify_pointer(ir_graph *irg, ir_node *irn, ir_entity
 		res = ir_sc_localvar;
 		if (ent != NULL && !(get_entity_usage(ent) & ir_usage_address_taken))
 			res |= ir_sc_modifier_nottaken;
-	} else if (is_arg_Proj(irn)) {
-		return ir_sc_argument;
 	} else if (irn == get_irg_tls(irg)) {
 		res = ir_sc_tls;
 		if (ent != NULL && !(get_entity_usage(ent) & ir_usage_address_taken))
@@ -442,6 +440,8 @@ ir_storage_class_class_t classify_pointer(ir_graph *irg, ir_node *irn, ir_entity
 		return ir_sc_malloced;
 	} else if (is_Const(irn)) {
 		return ir_sc_globaladdr;
+	} else if (is_arg_Proj(irn)) {
+		res |= ir_sc_modifier_argument;
 	}
 
 	return res;
@@ -450,7 +450,7 @@ ir_storage_class_class_t classify_pointer(ir_graph *irg, ir_node *irn, ir_entity
 /**
  * If adr represents a Bitfield Sel, skip it
  */
-static ir_node *skip_Bitfield_Sels(ir_node *adr) {
+static const ir_node *skip_Bitfield_Sels(const ir_node *adr) {
 	if (is_Sel(adr)) {
 		ir_entity *ent     = get_Sel_entity(adr);
 		ir_type   *bf_type = get_entity_type(ent);
@@ -474,20 +474,20 @@ static ir_node *skip_Bitfield_Sels(ir_node *adr) {
  * @return found memory relation
  */
 static ir_alias_relation _get_alias_relation(
-	ir_graph *irg,
-	ir_node *adr1, ir_mode *mode1,
-	ir_node *adr2, ir_mode *mode2)
+	const ir_graph *irg,
+	const ir_node *adr1, const ir_mode *mode1,
+	const ir_node *adr2, const ir_mode *mode2)
 {
 	ir_entity             *ent1, *ent2;
 	unsigned              options;
 	long                  offset1 = 0;
 	long                  offset2 = 0;
-	ir_node               *base1;
-	ir_node               *base2;
-	ir_node               *orig_adr1 = adr1;
-	ir_node               *orig_adr2 = adr2;
+	const ir_node         *base1;
+	const ir_node         *base2;
+	const ir_node         *orig_adr1 = adr1;
+	const ir_node         *orig_adr2 = adr2;
 	unsigned              mode_size;
-	ir_storage_class_class_t class1, class2;
+	ir_storage_class_class_t class1, class2, mod1, mod2;
 	int                   have_const_offsets;
 
 	if (! get_opt_alias_analysis())
@@ -581,19 +581,35 @@ static ir_alias_relation _get_alias_relation(
 			return different_sel_offsets(adr1, adr2);
 	}
 
-	class1 = classify_pointer(irg, base1, ent1);
-	class2 = classify_pointer(irg, base2, ent2);
+	mod1 = classify_pointer(irg, base1, ent1);
+	mod2 = classify_pointer(irg, base2, ent2);
 
-	if (class1 == ir_sc_pointer) {
-		if (class2 & ir_sc_modifier_nottaken) {
-			/* a pointer and an object whose objects was never taken */
-			return ir_no_alias;
+	class1 = GET_BASE_SC(mod1);
+	class2 = GET_BASE_SC(mod2);
+
+	if (class1 == ir_sc_pointer || class2 == ir_sc_pointer) {
+		/* swap pointer class to class1 */
+		if (class2 == ir_sc_pointer) {
+			ir_storage_class_class_t temp = mod1;
+			mod1 = mod2;
+			mod2 = temp;
+			class1 = GET_BASE_SC(mod1);
+			class2 = GET_BASE_SC(mod2);
 		}
-	} else if (class2 == ir_sc_pointer) {
-		if (class1 & ir_sc_modifier_nottaken) {
-			/* a pointer and an object whose objects was never taken */
+		/* a pointer and an object whose address was never taken */
+		if (mod2 & ir_sc_modifier_nottaken) {
 			return ir_no_alias;
 		}
+		if (mod1 & ir_sc_modifier_argument) {
+			if ( (options & aa_opt_no_alias_args)
+					&& (mod2 & ir_sc_modifier_argument))
+				return ir_no_alias;
+			if ( (options & aa_opt_no_alias_args_global)
+					&& (class2 == ir_sc_globalvar
+						|| class2 == ir_sc_tls
+						|| class2 == ir_sc_globaladdr))
+				return ir_no_alias;
+		}
 	} else if (class1 != class2) {
 		/* two objects from different memory spaces */
 		return ir_no_alias;
@@ -651,8 +667,8 @@ leave_type_based_alias:;
 	}
 
 	/* do we have a language specific memory disambiguator? */
-	if (language_disambuigator) {
-		ir_alias_relation rel = (*language_disambuigator)(irg, orig_adr1, mode1, orig_adr2, mode2);
+	if (language_disambuigator != NULL) {
+		ir_alias_relation rel = language_disambuigator(irg, orig_adr1, mode1, orig_adr2, mode2);
 		if (rel != ir_may_alias)
 			return rel;
 	}
@@ -665,9 +681,9 @@ leave_type_based_alias:;
  * Determine the alias relation between two addresses.
  */
 ir_alias_relation get_alias_relation(
-	ir_graph *irg,
-	ir_node *adr1, ir_mode *mode1,
-	ir_node *adr2, ir_mode *mode2)
+	const ir_graph *irg,
+	const ir_node *adr1, const ir_mode *mode1,
+	const ir_node *adr2, const ir_mode *mode2)
 {
 	ir_alias_relation rel = _get_alias_relation(irg, adr1, mode1, adr2, mode2);
 	DB((dbg, LEVEL_1, "alias(%+F, %+F) = %s\n", adr1, adr2, get_ir_alias_relation_name(rel)));
@@ -684,8 +700,10 @@ static set *result_cache = NULL;
 
 /** An entry in the relation cache. */
 typedef struct mem_disambig_entry {
-	ir_node	          *adr1;    /**< The first address. */
-	ir_node	          *adr2;    /**< The second address. */
+	const ir_node	  *adr1;    /**< The first address. */
+	const ir_mode	  *mode1;   /**< The first address mode. */
+	const ir_node	  *adr2;    /**< The second address. */
+	const ir_mode	  *mode2;   /**< The second address mode. */
 	ir_alias_relation result;   /**< The alias relation result. */
 } mem_disambig_entry;
 
@@ -699,7 +717,8 @@ static int cmp_mem_disambig_entry(const void *elt, const void *key, size_t size)
 	const mem_disambig_entry *p2 = key;
 	(void) size;
 
-	return p1->adr1 == p2->adr1 && p1->adr2 == p2->adr2;
+	return p1->adr1 == p2->adr1 && p1->adr2 == p2->adr2 &&
+	       p1->mode1 == p2->mode1 && p1->mode2 == p2->mode2;
 }  /* cmp_mem_disambig_entry */
 
 /**
@@ -713,9 +732,9 @@ void mem_disambig_init(void) {
  * Determine the alias relation between two addresses.
  */
 ir_alias_relation get_alias_relation_ex(
-	ir_graph *irg,
-	ir_node *adr1, ir_mode *mode1,
-	ir_node *adr2, ir_mode *mode2)
+	const ir_graph *irg,
+	const ir_node *adr1, const ir_mode *mode1,
+	const ir_node *adr2, const ir_mode *mode2)
 {
 	mem_disambig_entry key, *entry;
 
@@ -725,15 +744,17 @@ ir_alias_relation get_alias_relation_ex(
 		return ir_may_alias;
 
 	if (get_irn_opcode(adr1) > get_irn_opcode(adr2)) {
-		ir_node *t = adr1;
+		const ir_node *t = adr1;
 		adr1 = adr2;
 		adr2 = t;
 	}
 
-	key.adr1 = adr1;
-	key.adr2 = adr2;
+	key.adr1  = adr1;
+	key.adr2  = adr2;
+	key.mode1 = mode1;
+	key.mode2 = mode2;
 	entry = set_find(result_cache, &key, sizeof(key), HASH_ENTRY(adr1, adr2));
-	if (entry)
+	if (entry != NULL)
 		return entry->result;
 
 	key.result = get_alias_relation(irg, adr1, mode1, adr2, mode2);
@@ -744,7 +765,7 @@ ir_alias_relation get_alias_relation_ex(
 
 /* Free the relation cache. */
 void mem_disambig_term(void) {
-	if (result_cache) {
+	if (result_cache != NULL) {
 		del_set(result_cache);
 		result_cache = NULL;
 	}
@@ -769,7 +790,7 @@ void mem_disambig_term(void) {
  *
  * @return non-zero if the Load/Store is a hidden cast, zero else
  */
-static int is_hidden_cast(ir_mode *mode, ir_mode *ent_mode) {
+static int is_hidden_cast(const ir_mode *mode, const ir_mode *ent_mode) {
 	if (ent_mode == NULL)
 		return false;
 
@@ -847,7 +868,16 @@ static ir_entity_usage determine_entity_usage(const ir_node *irn, ir_entity *ent
 
 		case iro_Add:
 		case iro_Sub:
+			/* Check the successor of irn. */
+			res |= determine_entity_usage(succ, entity);
+			break;
 		case iro_Sel: {
+			ir_entity *entity = get_Sel_entity(succ);
+			/* this analysis can't handle unions correctly */
+			if (is_Union_type(get_entity_owner(entity))) {
+				res |= ir_usage_unknown;
+				break;
+			}
 			/* Check the successor of irn. */
 			res |= determine_entity_usage(succ, entity);
 			break;
@@ -910,15 +940,18 @@ static ir_entity_usage determine_entity_usage(const ir_node *irn, ir_entity *ent
 static void analyse_irg_entity_usage(ir_graph *irg) {
 	ir_type *ft = get_irg_frame_type(irg);
 	ir_node *irg_frame;
-	int i;
+	int i, 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) {
-		ir_entity       *ent   = get_class_member(ft, i);
-		ir_entity_usage  flags =
-			get_entity_stickyness(ent) == stickyness_sticky ? ir_usage_unknown : 0;
+		ir_entity *ent = get_class_member(ft, i);
 
-		set_entity_usage(ent, flags);
+		/* methods can only be analyzed globally */
+		if (! is_method_entity(ent)) {
+			ir_entity_usage  flags =
+				get_entity_stickyness(ent) == stickyness_sticky ? ir_usage_unknown : 0;
+			set_entity_usage(ent, flags);
+		}
 	}
 
 	assure_irg_outs(irg);
@@ -930,7 +963,7 @@ static void analyse_irg_entity_usage(ir_graph *irg) {
 		ir_entity      *entity;
 		ir_entity_usage flags;
 
-	    if (!is_Sel(succ))
+		if (!is_Sel(succ))
 			continue;
 
 		entity = get_Sel_entity(succ);
@@ -939,6 +972,46 @@ static void analyse_irg_entity_usage(ir_graph *irg) {
 		set_entity_usage(entity, flags);
 	}
 
+	/* check inner functions accessing outer frame */
+	static_link_arg = 0;
+	for (i = get_class_n_members(ft) - 1; i >= 0; --i) {
+		ir_entity *ent = get_class_member(ft, i);
+		ir_graph  *inner_irg;
+		ir_node   *args;
+
+		if (! is_method_entity(ent))
+			continue;
+		if (get_entity_peculiarity(ent) == peculiarity_description)
+			continue;
+
+		inner_irg = get_entity_irg(ent);
+		assure_irg_outs(inner_irg);
+		args = get_irg_args(inner_irg);
+		for (j = get_irn_n_outs(args) - 1; j >= 0; --j) {
+			ir_node *arg = get_irn_out(args, j);
+
+			if (get_Proj_proj(arg) == static_link_arg) {
+				for (k = get_irn_n_outs(arg) - 1; k >= 0; --k) {
+					ir_node *succ = get_irn_out(arg, k);
+
+					if (is_Sel(succ)) {
+						ir_entity *entity = get_Sel_entity(succ);
+
+						if (get_entity_owner(entity) == ft) {
+							/* found an access to the outer frame */
+							ir_entity_usage flags;
+
+							flags  = get_entity_usage(entity);
+							flags |= determine_entity_usage(succ, entity);
+							set_entity_usage(entity, flags);
+						}
+					}
+				}
+			}
+		}
+	}
+
+
 	/* now computed */
 	irg->entity_usage_state = ir_entity_usage_computed;
 }
@@ -962,7 +1035,7 @@ void assure_irg_entity_usage_computed(ir_graph *irg) {
 /**
  * Initialize the entity_usage flag for a global type like type.
  */
-static void init_entity_usage(ir_type * tp) {
+static void init_entity_usage(ir_type *tp) {
 	int i;
 
 	/* We have to be conservative: All external visible entities are unknown */