X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firmemory.c;h=8f30cbd5d41ea335450fe6acb9dd15c30e5b92b1;hb=24be66840a207d58dd74a2e41086a652b301641c;hp=42ed60c5cfabe1fda7754579254757a91234bf1f;hpb=ef54cbf0090a37e4767f18009d52d94171892f21;p=libfirm

diff --git a/ir/ana/irmemory.c b/ir/ana/irmemory.c
index 42ed60c5c..8f30cbd5d 100644
--- a/ir/ana/irmemory.c
+++ b/ir/ana/irmemory.c
@@ -57,19 +57,22 @@ static DISAMBIGUATOR_FUNC language_disambuigator = NULL;
 static unsigned global_mem_disamgig_opt = aa_opt_no_opt;
 
 /* Returns a human readable name for an alias relation. */
-const char *get_ir_alias_relation_name(ir_alias_relation rel) {
+const char *get_ir_alias_relation_name(ir_alias_relation rel)
+{
 #define X(a) case a: return #a
 	switch (rel) {
 	X(ir_no_alias);
 	X(ir_may_alias);
 	X(ir_sure_alias);
-	default: assert(0); return "UNKNOWN";
+	default:
+		panic("UNKNOWN alias relation");
 	}
 #undef X
 }
 
 /* Get the memory disambiguator options for a graph. */
-unsigned get_irg_memory_disambiguator_options(const 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;
@@ -77,12 +80,14 @@ unsigned get_irg_memory_disambiguator_options(const ir_graph *irg) {
 }  /* get_irg_memory_disambiguator_options */
 
 /*  Set the memory disambiguator options for a graph. */
-void set_irg_memory_disambiguator_options(ir_graph *irg, unsigned options) {
+void set_irg_memory_disambiguator_options(ir_graph *irg, unsigned options)
+{
 	irg->mem_disambig_opt = options & ~aa_opt_inherited;
 }  /* set_irg_memory_disambiguator_options */
 
 /* Set the global disambiguator options for all graphs not having local options. */
-void set_irp_memory_disambiguator_options(unsigned options) {
+void set_irp_memory_disambiguator_options(unsigned options)
+{
 	global_mem_disamgig_opt = options;
 }  /* set_irp_memory_disambiguator_options */
 
@@ -94,7 +99,8 @@ void set_irp_memory_disambiguator_options(unsigned options) {
  *
  * @return the base address.
  */
-static ir_node *find_base_adr(const 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)) {
@@ -113,7 +119,8 @@ static ir_node *find_base_adr(const 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(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;
 
@@ -134,7 +141,8 @@ static ir_alias_relation check_const(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(const ir_node *idx1, const 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)) {
@@ -181,7 +189,7 @@ static ir_alias_relation different_index(const ir_node *idx1, const ir_node *idx
 				}
 
 				/* m1 is now the signed one */
-				if (tarval_cmp(tv1, get_tarval_null(m1)) & (pn_Cmp_Eq|pn_Cmp_Gt)) {
+				if (!tarval_is_negative(tv1)) {
 					/* tv1 is signed, but >= 0, simply cast into unsigned */
 					tv1 = tarval_convert_to(tv1, m2);
 				} else {
@@ -293,7 +301,8 @@ static ir_alias_relation different_index(const ir_node *idx1, const ir_node *idx
  * @param adr1  The first address.
  * @param adr2  The second address.
  */
-static ir_alias_relation different_sel_offsets(const ir_node *sel1, const 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;
@@ -396,7 +405,8 @@ static ir_alias_relation different_types(const ir_node *adr1, const ir_node *adr
  *
  * @param node  the Proj node to test
  */
-static int is_malloc_Result(const ir_node *node) {
+static int is_malloc_Result(const ir_node *node)
+{
 	node = get_Proj_pred(node);
 	if (! is_Proj(node))
 		return 0;
@@ -451,7 +461,8 @@ ir_storage_class_class_t classify_pointer(const ir_graph *irg, const ir_node *ir
 /**
  * If adr represents a Bitfield Sel, skip it
  */
-static const ir_node *skip_Bitfield_Sels(const 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);
@@ -692,7 +703,8 @@ ir_alias_relation get_alias_relation(
 }  /* get_alias_relation */
 
 /* Set a source language specific memory disambiguator function. */
-void set_language_memory_disambiguator(DISAMBIGUATOR_FUNC func) {
+void set_language_memory_disambiguator(DISAMBIGUATOR_FUNC func)
+{
 	language_disambuigator = func;
 }  /* set_language_memory_disambiguator */
 
@@ -713,7 +725,8 @@ typedef struct mem_disambig_entry {
 /**
  * Compare two relation cache entries.
  */
-static int cmp_mem_disambig_entry(const void *elt, const void *key, size_t size) {
+static int cmp_mem_disambig_entry(const void *elt, const void *key, size_t size)
+{
 	const mem_disambig_entry *p1 = elt;
 	const mem_disambig_entry *p2 = key;
 	(void) size;
@@ -725,7 +738,8 @@ static int cmp_mem_disambig_entry(const void *elt, const void *key, size_t size)
 /**
  * Initialize the relation cache.
  */
-void mem_disambig_init(void) {
+void mem_disambig_init(void)
+{
 	result_cache = new_set(cmp_mem_disambig_entry, 8);
 }  /* mem_disambig_init */
 
@@ -765,7 +779,8 @@ ir_alias_relation get_alias_relation_ex(
 }  /* get_alias_relation_ex */
 
 /* Free the relation cache. */
-void mem_disambig_term(void) {
+void mem_disambig_term(void)
+{
 	if (result_cache != NULL) {
 		del_set(result_cache);
 		result_cache = NULL;
@@ -791,7 +806,8 @@ void mem_disambig_term(void) {
  *
  * @return non-zero if the Load/Store is a hidden cast, zero else
  */
-static int is_hidden_cast(const ir_mode *mode, const ir_mode *ent_mode) {
+static int is_hidden_cast(const ir_mode *mode, const ir_mode *ent_mode)
+{
 	if (ent_mode == NULL)
 		return false;
 
@@ -811,7 +827,8 @@ static int is_hidden_cast(const ir_mode *mode, const ir_mode *ent_mode) {
  *
  * @param irn  the node
  */
-static ir_entity_usage determine_entity_usage(const ir_node *irn, ir_entity *entity) {
+static ir_entity_usage determine_entity_usage(const ir_node *irn, ir_entity *entity)
+{
 	int       i;
 	ir_mode   *emode, *mode;
 	ir_node   *value;
@@ -938,7 +955,8 @@ static ir_entity_usage determine_entity_usage(const ir_node *irn, ir_entity *ent
 /**
  * Update the usage flags of all frame entities.
  */
-static void analyse_irg_entity_usage(ir_graph *irg) {
+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;
@@ -949,8 +967,9 @@ static void analyse_irg_entity_usage(ir_graph *irg) {
 
 		/* 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;
+			ir_entity_usage flags = 0;
+			if (get_entity_linkage(ent) & IR_LINKAGE_HIDDEN_USER)
+				flags = ir_usage_unknown;
 			set_entity_usage(ent, flags);
 		}
 	}
@@ -982,10 +1001,11 @@ static void analyse_irg_entity_usage(ir_graph *irg) {
 
 		if (! is_method_entity(ent))
 			continue;
-		if (get_entity_peculiarity(ent) == peculiarity_description)
-			continue;
 
 		inner_irg = get_entity_irg(ent);
+		if (inner_irg == NULL)
+			continue;
+
 		assure_irg_outs(inner_irg);
 		args = get_irg_args(inner_irg);
 		for (j = get_irn_n_outs(args) - 1; j >= 0; --j) {
@@ -1017,15 +1037,18 @@ static void analyse_irg_entity_usage(ir_graph *irg) {
 	irg->entity_usage_state = ir_entity_usage_computed;
 }
 
-ir_entity_usage_computed_state get_irg_entity_usage_state(const ir_graph *irg) {
+ir_entity_usage_computed_state get_irg_entity_usage_state(const ir_graph *irg)
+{
 	return irg->entity_usage_state;
 }
 
-void set_irg_entity_usage_state(ir_graph *irg, ir_entity_usage_computed_state state) {
+void set_irg_entity_usage_state(ir_graph *irg, ir_entity_usage_computed_state state)
+{
 	irg->entity_usage_state = state;
 }
 
-void assure_irg_entity_usage_computed(ir_graph *irg) {
+void assure_irg_entity_usage_computed(ir_graph *irg)
+{
 	if (irg->entity_usage_state != ir_entity_usage_not_computed)
 		return;
 
@@ -1036,18 +1059,16 @@ 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 */
 	for (i = get_compound_n_members(tp) - 1; i >= 0; --i) {
 		ir_entity       *ent  = get_compound_member(tp, i);
 		ir_entity_usage flags = ir_usage_none;
-		ir_visibility   vis   = get_entity_visibility(ent);
 
-		if (vis == visibility_external_visible   ||
-		    vis == visibility_external_allocated ||
-		    get_entity_stickyness(ent) == stickyness_sticky) {
+		if (entity_is_externally_visible(ent)) {
 			flags |= ir_usage_unknown;
 		}
 		set_entity_usage(ent, flags);
@@ -1093,29 +1114,21 @@ static void check_initializer_nodes(ir_initializer_t *initializer)
  *
  * @param ent  the entity
  */
-static void check_initializer(ir_entity *ent) {
+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 are always initialized with "themself". This does not
-	   count as a taken address. */
+	 * count as a taken address.
+	 * TODO: this initialisation with "themself" is wrong and should be removed
+	 */
 	if (is_Method_type(get_entity_type(ent)))
 		return;
 
-	if (ent->has_initializer) {
-		check_initializer_nodes(ent->attr.initializer);
-	} else if (is_atomic_entity(ent)) {
-		/* let's check if it's an address */
-		n = get_atomic_ent_value(ent);
-		if (is_Global(n)) {
-			ir_entity *ent = get_Global_entity(n);
-			set_entity_usage(ent, ir_usage_unknown);
-		}
-	} else {
+	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);
 
@@ -1126,7 +1139,7 @@ static void check_initializer(ir_entity *ent) {
 			}
 		}
 	}
-}  /* check_initializer */
+}
 
 
 /**
@@ -1134,7 +1147,8 @@ static void check_initializer(ir_entity *ent) {
  *
  * @param tp  a compound type
  */
-static void check_initializers(ir_type *tp) {
+static void check_initializers(ir_type *tp)
+{
 	int i;
 
 	for (i = get_compound_n_members(tp) - 1; i >= 0; --i) {
@@ -1150,7 +1164,8 @@ 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(ir_type *tp)
+{
 	int i;
 	for (i = get_compound_n_members(tp) - 1; i >= 0; --i) {
 		ir_entity *ent = get_compound_member(tp, i);
@@ -1175,7 +1190,8 @@ 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 *env)
+{
 	ir_node *tls = env;
 	ir_entity *ent;
 	ir_entity_usage flags;
@@ -1197,16 +1213,17 @@ static void check_global_address(ir_node *irn, void *env) {
 /**
  * Update the entity usage flags of all global entities.
  */
-static void analyse_irp_globals_entity_usage(void) {
+static void analyse_irp_globals_entity_usage(void)
+{
 	int i;
 	ir_segment_t s;
 
-	for (s = IR_SEGMENT_FIRST; s < IR_SEGMENT_COUNT; ++s) {
+	for (s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
 		ir_type *type = get_segment_type(s);
 		init_entity_usage(type);
 	}
 
-	for (s = IR_SEGMENT_FIRST; s < IR_SEGMENT_COUNT; ++s) {
+	for (s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
 		ir_type *type = get_segment_type(s);
 		check_initializers(type);
 	}
@@ -1221,7 +1238,7 @@ static void analyse_irp_globals_entity_usage(void) {
 #ifdef DEBUG_libfirm
 	if (firm_dbg_get_mask(dbg) & LEVEL_1) {
 		ir_segment_t s;
-		for (s = IR_SEGMENT_FIRST; s < IR_SEGMENT_COUNT; ++s) {
+		for (s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
 			print_entity_usage_flags(get_segment_type(s));
 		}
 	}
@@ -1232,24 +1249,28 @@ static void analyse_irp_globals_entity_usage(void) {
 }
 
 /* Returns the current address taken state of the globals. */
-ir_entity_usage_computed_state get_irp_globals_entity_usage_state(void) {
+ir_entity_usage_computed_state get_irp_globals_entity_usage_state(void)
+{
 	return irp->globals_entity_usage_state;
 }
 
 /* Sets the current address taken state of the graph. */
-void set_irp_globals_entity_usage_state(ir_entity_usage_computed_state state) {
+void set_irp_globals_entity_usage_state(ir_entity_usage_computed_state state)
+{
 	irp->globals_entity_usage_state = state;
 }
 
 /* Assure that the address taken flag is computed for the globals. */
-void assure_irp_globals_entity_usage_computed(void) {
+void assure_irp_globals_entity_usage_computed(void)
+{
 	if (irp->globals_entity_usage_state != ir_entity_usage_not_computed)
 		return;
 
 	analyse_irp_globals_entity_usage();
 }
 
-void firm_init_memory_disambiguator(void) {
+void firm_init_memory_disambiguator(void)
+{
 	FIRM_DBG_REGISTER(dbg, "firm.ana.irmemory");
 	FIRM_DBG_REGISTER(dbgcall, "firm.opt.cc");
 }
@@ -1263,18 +1284,15 @@ static pmap *mtp_map;
  *
  * @param tp  the type to clone
  */
-static ir_type *clone_type_and_cache(ir_type *tp) {
-	static ident *prefix = NULL;
+static ir_type *clone_type_and_cache(ir_type *tp)
+{
 	ir_type *res;
 	pmap_entry *e = pmap_find(mtp_map, tp);
 
 	if (e)
 		return e->value;
 
-	if (prefix == NULL)
-		prefix = new_id_from_chars("C", 1);
-
-	res = clone_type_method(tp, prefix);
+	res = clone_type_method(tp);
 	pmap_insert(mtp_map, tp, res);
 
 	return res;
@@ -1284,7 +1302,8 @@ static ir_type *clone_type_and_cache(ir_type *tp) {
  * Walker: clone all call types of Calls to methods having the
  * mtp_property_private property set.
  */
-static void update_calls_to_private(ir_node *call, void *env) {
+static void update_calls_to_private(ir_node *call, void *env)
+{
 	(void) env;
 	if (is_Call(call)) {
 		ir_node *ptr = get_Call_ptr(call);
@@ -1306,7 +1325,8 @@ static void update_calls_to_private(ir_node *call, void *env) {
 }  /* update_calls_to_private */
 
 /* Mark all private methods, i.e. those of which all call sites are known. */
-void mark_private_methods(void) {
+void mark_private_methods(void)
+{
 	int i;
 	int changed = 0;
 
@@ -1320,11 +1340,8 @@ void mark_private_methods(void) {
 		ir_entity       *ent   = get_irg_entity(irg);
 		ir_entity_usage  flags = get_entity_usage(ent);
 
-		/* If an entity is sticky, it might be called from external
-		   places (like inline assembler), so do NOT mark it as private. */
-		if (get_entity_visibility(ent) == visibility_local &&
-		    !(flags & ir_usage_address_taken) &&
-		    get_entity_stickyness(ent) != stickyness_sticky) {
+		if (!entity_is_externally_visible(ent) &&
+		    !(flags & ir_usage_address_taken)) {
 			ir_type *mtp = get_entity_type(ent);
 
 			set_entity_additional_property(ent, mtp_property_private);
@@ -1347,6 +1364,7 @@ void mark_private_methods(void) {
 }  /* mark_private_methods */
 
 /* create a pass for mark_private_methods() */
-ir_prog_pass_t *mark_private_methods_pass(const char *name) {
+ir_prog_pass_t *mark_private_methods_pass(const char *name)
+{
 	return def_prog_pass(name ? name : "mark_private_methods", mark_private_methods);
 }  /* mark_private_methods_pass */