X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fcgana.c;h=c63da592d59853db5e822bfefc1c52c07712bcf1;hb=ebdaa596d904a0651c8d794481288d2d629bdb3a;hp=c43ed4a84465883ff6e864320ba33ea3a28e7232;hpb=23de0b554f6c6197bfe137b0dccfc0889cac5d93;p=libfirm

diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c
index c43ed4a84..c63da592d 100644
--- a/ir/ana/cgana.c
+++ b/ir/ana/cgana.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -23,7 +23,7 @@
  * @author     Hubert Schmid
  * @date       09.06.2002
  * @version    $Id$
- * @summary
+ * @brief
  *  Interprocedural analysis to estimate the calling relation.
  *
  *  This analysis computes all entities representing methods that
@@ -31,13 +31,9 @@
  *  methods that are 'free', i.e., their adress is handled by
  *  the program directly, or they are visible external.
  */
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
 
-#ifdef HAVE_STRING_H
-# include <string.h>
-#endif
+#include <string.h>
 
 #include "cgana.h"
 #include "rta.h"
@@ -50,6 +46,7 @@
 #include "ircons.h"
 #include "irgmod.h"
 #include "iropt.h"
+#include "irtools.h"
 
 #include "irflag_t.h"
 #include "dbginfo_t.h"
@@ -58,13 +55,10 @@
 #include "eset.h"
 #include "pmap.h"
 #include "array.h"
+#include "error.h"
 
 #include "irdump.h"
 
-#include "irhooks.h"
-
-
-
 /* unambiguous address used as a mark. */
 static void *MARK = &MARK;
 
@@ -80,17 +74,6 @@ static eset *entities = NULL;
 /* call target computations.                                                */
 /*--------------------------------------------------------------------------*/
 
-/** Returns the entity that contains the implementation of the inherited
- *  entity if available, else returns the entity passed. */
-static ir_entity *get_inherited_methods_implementation(ir_entity *inh_meth) {
-	assert(get_atomic_ent_value(inh_meth) && "constant entity without value");
-	assert((get_irn_op(get_atomic_ent_value(inh_meth)) == op_SymConst) &&
-	       (get_SymConst_kind(get_atomic_ent_value(inh_meth)) == symconst_addr_ent) &&
-	       "Complex constant values not supported -- address of method should be straight constant!");
-
-	return get_SymConst_entity(get_atomic_ent_value(inh_meth));
-}
-
 /** Collect the entity representing the implementation of this
  *  method (not the same if inherited) and all entities for overwriting
  *  implementations in "set".
@@ -104,18 +87,12 @@ static ir_entity *get_inherited_methods_implementation(ir_entity *inh_meth) {
  * @param size     Number of entities in set.
  * @param open
  */
-static void collect_impls(ir_entity *method, eset *set, int *size, int *open) {
+static void collect_impls(ir_entity *method, eset *set, int *size, int *open)
+{
 	int i;
-	ir_entity *impl;
-
-	/* Add the implementation to the set if it contains an irg, else
-	   remember that there are more methods called. */
-	impl = method;
-	if (get_entity_peculiarity(method) == peculiarity_inherited)
-		impl = get_inherited_methods_implementation(method);
 
-	if (get_entity_peculiarity(method) != peculiarity_description) {
-		eset_insert(set, impl);
+	if (get_entity_irg(method) != NULL) {
+		eset_insert(set, method);
 		++(*size);
 	}
 
@@ -124,17 +101,18 @@ static void collect_impls(ir_entity *method, eset *set, int *size, int *open) {
 		collect_impls(get_entity_overwrittenby(method, i), set, size, open);
 }
 
-/** Alle Methoden bestimmen, die die übergebene Methode überschreiben
- *  (und implementieren). In der zurückgegebenen Reihung kommt jede
- *  Methode nur einmal vor. Der Wert 'NULL' steht für unbekannte
- *  (externe) Methoden. Die zurückgegebene Reihung muß vom Aufrufer
- *  wieder freigegeben werden (siehe "DEL_ARR_F"). Gibt es überhaupt
- *  keine Methoden, die "method" überschreiben, so gibt die Methode
- *  "NULL" zurück.
+/** Alle Methoden bestimmen, die die �bergebene Methode �berschreiben
+ *  (und implementieren). In der zur�ckgegebenen Reihung kommt jede
+ *  Methode nur einmal vor. Der Wert 'NULL' steht f�r unbekannte
+ *  (externe) Methoden. Die zur�ckgegebene Reihung mu� vom Aufrufer
+ *  wieder freigegeben werden (siehe "DEL_ARR_F"). Gibt es �berhaupt
+ *  keine Methoden, die "method" �berschreiben, so gibt die Methode
+ *  "NULL" zur�ck.
  *
  *  @param method
  */
-static ir_entity ** get_impl_methods(ir_entity * method) {
+static ir_entity ** get_impl_methods(ir_entity * method)
+{
 	eset * set = eset_create();
 	int size = 0;
 	ir_entity ** arr;
@@ -145,7 +123,7 @@ static ir_entity ** get_impl_methods(ir_entity * method) {
 
 	/* Vorgaenger einfuegen. */
 	if (size == 0 && !open) {
-		/* keine implementierte überschriebene Methode */
+		/* keine implementierte �berschriebene Methode */
 		arr = NULL;
 	} else if (open) {
 		ir_entity * ent;
@@ -180,93 +158,95 @@ static ir_entity ** get_impl_methods(ir_entity * method) {
  *    as here we walk the type graph.  In opt_polymorphy we only apply a local
  *    pattern.
  *
- *  @param node The node to analyze
- *  @param env  A map that maps names of entities to the entities.
+ *  @param node  The node to analyze
+ *  @param env   A map that maps names of entities to the entities.
  */
-static void sel_methods_walker(ir_node * node, void *env) {
+static void sel_methods_walker(ir_node *node, void *env)
+{
 	pmap *ldname_map = env;
 	ir_entity **arr;
 
 	/* Call standard optimizations */
 	if (is_Sel(node)) {
 		ir_node *new_node = optimize_in_place(node);
-		if (node != new_node)
+		if (node != new_node) {
 			exchange(node, new_node);
+			node = new_node;
+		}
 	}
 
 	/* replace SymConst(name)-operations by SymConst(ent) */
-	if (get_irn_op(node) == op_SymConst) {
+	if (is_SymConst(node)) {
 		if (get_SymConst_kind(node) == symconst_addr_name) {
-			pmap_entry * entry = pmap_find(ldname_map, (void *) get_SymConst_name(node));
+			pmap_entry *entry = pmap_find(ldname_map, get_SymConst_name(node));
 			if (entry != NULL) { /* Method is declared in the compiled code */
-				assert(0 && "There should not be a SymConst[addr_name] addressing a method with an implementation"
+				assert(!"There should not be a SymConst[addr_name] addressing a method with an implementation"
 					"in this compilation unit.  Use a SymConst[addr_ent].");
 			}
 		}
-	}
-	else if (get_irn_op(node) == op_Sel &&
-		is_Method_type(get_entity_type(get_Sel_entity(node)))) {
-			ir_entity * ent = get_SymConst_entity(get_atomic_ent_value(get_Sel_entity(node)));
-			assert(get_entity_peculiarity(ent) != peculiarity_inherited);
-
-			if (!eset_contains(entities, ent)) {
-				/* Entity not yet handled. Find all (internal or external)
-				 * implemented methods that overwrites this entity.
-				 * This set is stored in the entity link. */
-				set_entity_link(ent, get_impl_methods(ent));
-				eset_insert(entities, ent);
-			}
+	} else if (is_Sel(node) && is_Method_type(get_entity_type(get_Sel_entity(node)))) {
+		ir_entity *ent = get_SymConst_entity(get_atomic_ent_value(get_Sel_entity(node)));
+
+		if (!eset_contains(entities, ent)) {
+			/* Entity not yet handled. Find all (internal or external)
+			 * implemented methods that overwrites this entity.
+			 * This set is stored in the entity link. */
+			set_entity_link(ent, get_impl_methods(ent));
+			eset_insert(entities, ent);
+		}
 
-			/* -- As an add on we get an optimization that removes polymorphic calls.
-			This optimization is more powerful than that in transform_node_Sel().  -- */
-			arr = get_entity_link(ent);
-			if (arr == NULL) {
-				/*
-				 * The Sel node never returns a pointer to a usable method.
-				 * We could not call it, but it may be description:
-				 * We call a method in a dead part of the program.
-				 */
-				assert (get_entity_peculiarity(ent) == peculiarity_description);
-			}
-			else if (get_opt_optimize() && get_opt_closed_world() && get_opt_dyn_meth_dispatch() &&
-				(ARR_LEN(arr) == 1 && arr[0] != NULL)) {
-					ir_node *new_node;
-
-					/*
-					 * The Sel node returns only one possible method.
-					 * So we could replace the Sel node by a SymConst.
-					 * This method must exists.
-					 */
-					set_irg_current_block(current_ir_graph, get_nodes_block(node));
-					assert(get_entity_peculiarity(get_SymConst_entity(get_atomic_ent_value(arr[0]))) ==
-						peculiarity_existent);
-					new_node = copy_const_value(get_irn_dbg_info(node), get_atomic_ent_value(arr[0]));
-					DBG_OPT_POLY(node, new_node);
-					exchange(node, new_node);
-			}
+		/* -- As an add on we get an optimization that removes polymorphic calls.
+		This optimization is more powerful than that in transform_node_Sel().  -- */
+		arr = get_entity_link(ent);
+		if (arr == NULL) {
+			/*
+			 * The Sel node never returns a pointer to a usable method.
+			 * We could not call it, but it may be description:
+			 * We call a method in a dead part of the program.
+			 */
+			assert(get_entity_irg(ent) == NULL);
+		}
+		else if (get_opt_closed_world() && get_opt_dyn_meth_dispatch() &&
+			(ARR_LEN(arr) == 1 && arr[0] != NULL)) {
+			ir_node *new_node;
+
+			/*
+			 * The Sel node returns only one possible method.
+			 * So we could replace the Sel node by a SymConst.
+			 * This method must exists.
+			 */
+			set_irg_current_block(current_ir_graph, get_nodes_block(node));
+			assert(get_entity_irg(arr[0]) != NULL);
+			new_node = copy_const_value(get_irn_dbg_info(node), get_atomic_ent_value(arr[0]));
+			DBG_OPT_POLY(node, new_node);
+			exchange(node, new_node);
+		}
 	}
 }
 
-/** Initialize auxiliary data structures.
+/**
+ * Initialize auxiliary data structures.
  *
- *  Computes a set of entities that overwrite an entity and contain
- *  an implementation. The set is stored in the entity's link field.
+ * Computes a set of entities that overwrite an entity and contain
+ * an implementation. The set is stored in the entity's link field.
  *
- *  Further replaces Sel nodes where this set contains exactly one
- *  method by SymConst nodes.
- *  Finally asserts if there is a SymConst(name) if there could be a
- *  SymConst(ent). */
-static void sel_methods_init(void) {
+ * Further replaces Sel nodes where this set contains exactly one
+ * method by SymConst nodes.
+ * Finally asserts if there is a SymConst(name) if there could be a
+ * SymConst(ent).
+ */
+static void sel_methods_init(void)
+{
 	int i;
-	pmap * ldname_map = pmap_create();   /* Map entity names to entities: to replace
-										 SymConst(name) by SymConst(ent). */
+	pmap *ldname_map = pmap_create();   /* Map entity names to entities: to replace
+	                                       SymConst(name) by SymConst(ent). */
 	assert(entities == NULL);
 	entities = eset_create();
 	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
 		ir_entity * ent = get_irg_entity(get_irp_irg(i));
 		/* only external visible methods are allowed to call by a SymConst_ptr_name */
-		if (get_entity_visibility(ent) != visibility_local) {
-			pmap_insert(ldname_map, (void *) get_entity_ld_ident(ent), ent);
+		if (entity_is_externally_visible(ent)) {
+			pmap_insert(ldname_map, (void *)get_entity_ld_ident(ent), ent);
 		}
 	}
 
@@ -287,14 +267,14 @@ static void sel_methods_init(void) {
  *
  * @param sel  the Sel node
  */
-static ir_entity ** get_Sel_arr(ir_node * sel) {
+static ir_entity ** get_Sel_arr(ir_node * sel)
+{
 	static ir_entity ** NULL_ARRAY = NULL;
 	ir_entity * ent;
 	ir_entity ** arr;
 
 	assert(is_Sel(sel));
 	ent = get_Sel_entity(sel);
-	ent = get_inherited_methods_implementation(ent);
 
 	assert(is_Method_type(get_entity_type(ent))); /* what else? */
 	arr = get_entity_link(ent);
@@ -302,7 +282,7 @@ static ir_entity ** get_Sel_arr(ir_node * sel) {
 		return arr;
 	} else {
 		/* "NULL" zeigt an, dass keine Implementierung existiert. Dies
-		 * kann für polymorphe (abstrakte) Methoden passieren. */
+		 * kann f�r polymorphe (abstrakte) Methoden passieren. */
 		if (!NULL_ARRAY) {
 			NULL_ARRAY = NEW_ARR_F(ir_entity *, 0);
 		}
@@ -315,22 +295,26 @@ static ir_entity ** get_Sel_arr(ir_node * sel) {
  *
  * @param sel  the Sel node
  */
-static int get_Sel_n_methods(ir_node * sel) {
+static int get_Sel_n_methods(ir_node * sel)
+{
 	return ARR_LEN(get_Sel_arr(sel));
 }
 
 /**
  * Returns the ith possible called method entity at a Sel node.
  */
-static ir_entity * get_Sel_method(ir_node * sel, int pos) {
+static ir_entity * get_Sel_method(ir_node * sel, int pos)
+{
 	ir_entity ** arr = get_Sel_arr(sel);
 	assert(pos >= 0 && pos < ARR_LEN(arr));
 	return arr[pos];
 }
 
+/* forward */
 static void free_mark(ir_node * node, eset * set);
 
-static void free_mark_proj(ir_node * node, long n, eset * set) {
+static void free_mark_proj(ir_node * node, long n, eset * set)
+{
 	assert(get_irn_mode(node) == mode_T);
 	if (get_irn_link(node) == MARK) {
 		/* already visited */
@@ -343,7 +327,7 @@ static void free_mark_proj(ir_node * node, long n, eset * set) {
 		 * op_Tuple oder ein Knoten, der in "free_ana_walker" behandelt
 		 * wird. */
 		ir_node * pred = get_Proj_pred(node);
-		if (get_irn_link(pred) != MARK && get_irn_op(pred) == op_Tuple) {
+		if (get_irn_link(pred) != MARK && is_Tuple(pred)) {
 			free_mark_proj(get_Tuple_pred(pred, get_Proj_proj(node)), n, set);
 		} else {
 			/* nothing: da in "free_ana_walker" behandelt. */
@@ -370,7 +354,7 @@ static void free_mark_proj(ir_node * node, long n, eset * set) {
 		assert(0 && "unexpected opcode or opcode not implemented");
 		break;
 	}
-	set_irn_link(node, NULL);
+	// set_irn_link(node, NULL);
 }
 
 /**
@@ -384,7 +368,8 @@ static void free_mark_proj(ir_node * node, long n, eset * set) {
  * @param node  the current visited node
  * @param set   the set of all free methods
  */
-static void free_mark(ir_node *node, eset * set) {
+static void free_mark(ir_node *node, eset * set)
+{
 	int i;
 
 	if (get_irn_link(node) == MARK)
@@ -394,23 +379,20 @@ static void free_mark(ir_node *node, eset * set) {
 
 	switch (get_irn_opcode(node)) {
 	case iro_Sel: {
-		ir_entity * ent = get_Sel_entity(node);
-		if (is_Method_type(get_entity_type(ent))) {
+		ir_entity *ent = get_Sel_entity(node);
+		if (is_method_entity(ent)) {
 			for (i = get_Sel_n_methods(node) - 1; i >= 0; --i) {
 				eset_insert(set, get_Sel_method(node, i));
 			}
 		}
 		break;
-				  }
+	}
 	case iro_SymConst:
 		if (get_SymConst_kind(node) == symconst_addr_ent) {
-			ir_entity * ent = get_SymConst_entity(node);
-			if (is_Method_type(get_entity_type(ent))) {
+			ir_entity *ent = get_SymConst_entity(node);
+			if (is_method_entity(ent)) {
 				eset_insert(set, ent);
 			}
-		} else {
-			assert(get_SymConst_kind(node) == symconst_addr_name);
-			/* nothing: SymConst points to extern method */
 		}
 		break;
 
@@ -419,23 +401,20 @@ static void free_mark(ir_node *node, eset * set) {
 			free_mark(get_Phi_pred(node, i), set);
 		}
 		break;
-	case iro_Id:
-		free_mark(get_Id_pred(node), set);
-		break;
 	case iro_Proj:
 		free_mark_proj(get_Proj_pred(node), get_Proj_proj(node), set);
 		break;
 	default:
-		/* nothing: Wird unten behandelt! */
+		/* nothing: */
 		break;
 	}
-	set_irn_link(node, NULL);
 }
 
 /**
  * post-walker. Find method addresses.
  */
-static void free_ana_walker(ir_node *node, void *env) {
+static void free_ana_walker(ir_node *node, void *env)
+{
 	eset *set = env;
 	int i;
 
@@ -454,9 +433,9 @@ static void free_ana_walker(ir_node *node, void *env) {
 	case iro_Tuple:
 		/* nothing */
 		break;
-		/* Sonderbehandlung, da der Funktionszeigereingang natürlich kein
-		 * Verräter ist. */
 	case iro_Call:
+		/* we must handle Call nodes specially, because their call address input
+		   do not expose a method address. */
 		set_irn_link(node, MARK);
 		for (i = get_Call_n_params(node) - 1; i >= 0; --i) {
 			ir_node *pred = get_Call_param(node, i);
@@ -465,19 +444,61 @@ static void free_ana_walker(ir_node *node, void *env) {
 			}
 		}
 		break;
-		/* other nodes: Alle anderen Knoten nehmen wir als Verräter an, bis
-		 * jemand das Gegenteil implementiert. */
 	default:
+		/* other nodes: Alle anderen Knoten nehmen wir als Verr�ter an, bis
+		 * jemand das Gegenteil implementiert. */
 		set_irn_link(node, MARK);
 		for (i = get_irn_arity(node) - 1; i >= 0; --i) {
-			ir_node * pred = get_irn_n(node, i);
+			ir_node *pred = get_irn_n(node, i);
 			if (mode_is_reference(get_irn_mode(pred))) {
 				free_mark(pred, set);
 			}
 		}
 		break;
 	}
-	set_irn_link(node, NULL);
+}
+
+/**
+ * Add all method addresses in global new style initializers to the set.
+ *
+ * @note
+ * We do NOT check the type here, just it it's an entity address.
+ * The reason for this is code like:
+ *
+ * void *p = function;
+ *
+ * which is sometimes used to anchor functions.
+ */
+static void add_method_address_inititializer(ir_initializer_t *initializer,
+                                             eset *set)
+{
+	ir_node *n;
+	size_t  i;
+
+	switch (initializer->kind) {
+	case IR_INITIALIZER_CONST:
+		n = initializer->consti.value;
+
+		/* let's check if it's the address of a function */
+		if (is_Global(n)) {
+			ir_entity *ent = get_Global_entity(n);
+
+			if (is_Method_type(get_entity_type(ent)))
+				eset_insert(set, ent);
+		}
+		return;
+	case IR_INITIALIZER_TARVAL:
+	case IR_INITIALIZER_NULL:
+		return;
+	case IR_INITIALIZER_COMPOUND:
+		for (i = 0; i < initializer->compound.n_initializers; ++i) {
+			ir_initializer_t *sub_initializer
+				= initializer->compound.initializers[i];
+			add_method_address_inititializer(sub_initializer, set);
+		}
+		return;
+	}
+	panic("invalid initializer found");
 }
 
 /**
@@ -497,39 +518,25 @@ static void add_method_address(ir_entity *ent, eset *set)
 	ir_type *tp;
 	int i;
 
-	/* do not check uninitialized values */
-	if (get_entity_variability(ent) == variability_uninitialized)
+	/* ignore methods: these of course reference it's address
+	 * TODO: remove this later once this incorrect self-intialisation is gone
+	 */
+	tp = get_entity_type(ent);
+	if (is_Method_type(tp))
 		return;
 
-	if (is_atomic_entity(ent)) {
-		tp = get_entity_type(ent);
-
-		/* ignore methods: these of course reference it's address */
-		if (is_Method_type(tp))
-			return;
-
-		/* let's check if it's the address of a function */
-		n = get_atomic_ent_value(ent);
-		if (get_irn_op(n) == op_SymConst) {
-			if (get_SymConst_kind(n) == symconst_addr_ent) {
-				ent = get_SymConst_entity(n);
-
-				if (is_Method_type(get_entity_type(ent)))
-					eset_insert(set, ent);
-			}
-		}
-	} else {
+	if (ent->initializer != NULL) {
+		add_method_address_inititializer(get_entity_initializer(ent), set);
+	} 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);
 
 			/* let's check if it's the address of a function */
-			if (get_irn_op(n) == op_SymConst) {
-				if (get_SymConst_kind(n) == symconst_addr_ent) {
-					ir_entity *ent = get_SymConst_entity(n);
+			if (is_Global(n)) {
+				ir_entity *ent = get_Global_entity(n);
 
-					if (is_Method_type(get_entity_type(ent)))
-						eset_insert(set, ent);
-				}
+				if (is_Method_type(get_entity_type(ent)))
+					eset_insert(set, ent);
 			}
 		}
 	}
@@ -539,58 +546,61 @@ static void add_method_address(ir_entity *ent, eset *set)
  * returns a list of 'free' methods, i.e., the methods that can be called
  * from external or via function pointers.
  *
- * Die Datenstrukturen für sel-Methoden (sel_methods) muß vor dem
+ * Die Datenstrukturen für sel-Methoden (sel_methods) muß vor dem
  * Aufruf von "get_free_methods" aufgebaut sein. Die (internen)
- * SymConst(name)-Operationen müssen in passende SymConst(ent)-Operationen
+ * SymConst(name)-Operationen müssen in passende SymConst(ent)-Operationen
  * umgewandelt worden sein, d.h. SymConst-Operationen verweisen immer
  * auf eine echt externe Methode.
  */
-static ir_entity ** get_free_methods(void)
+static ir_entity **get_free_methods(int *length)
 {
 	eset *free_set = eset_create();
 	int i;
-	ir_entity **arr = NEW_ARR_F(ir_entity *, 0);
+	ir_entity **arr;
 	ir_entity *ent;
 	ir_graph *irg;
-	ir_type *glob;
+	ir_type *tp;
 
 	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+		ir_linkage linkage;
 		irg = get_irp_irg(i);
 		ent = get_irg_entity(irg);
-		/* insert "external visible" methods. */
-		if (get_entity_visibility(ent) != visibility_local) {
-			eset_insert(free_set, ent);
-		}
-		/* Finde alle Methoden die in dieser Methode extern sichtbar werden,
-		   z.B. da die Adresse einer Methode abgespeichert wird. */
-		irg_walk_graph(irg, NULL, free_ana_walker, free_set);
-	}
+		linkage = get_entity_linkage(ent);
 
-	/* insert sticky methods, too */
-	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-		ent = get_irg_entity(get_irp_irg(i));
-		/* insert "sticky" methods. */
-		if (get_entity_stickyness (ent) == stickyness_sticky) {
+		if (!(linkage & IR_LINKAGE_LOCAL)
+				|| (linkage & IR_LINKAGE_HIDDEN_USER)) {
 			eset_insert(free_set, ent);
 		}
-	}
 
-	/* insert all methods the initializes global variables */
-	glob = get_glob_type();
-	for (i = get_class_n_members(glob) - 1; i >= 0; --i) {
-		ent = get_class_member(glob, i);
+		ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
+		/* Find all method entities that gets "visible" through this graphs,
+		 * for instance because their address is stored. */
+		irg_walk_graph(irg, firm_clear_link, free_ana_walker, free_set);
+		ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
+	}
 
+	/* insert all methods that are used in global variables initializers */
+	tp = get_glob_type();
+	for (i = get_class_n_members(tp) - 1; i >= 0; --i) {
+		ent = get_class_member(tp, i);
+		add_method_address(ent, free_set);
+	}
+	tp = get_tls_type();
+	for (i = get_struct_n_members(tp) - 1; i >= 0; --i) {
+		ent = get_struct_member(tp, i);
 		add_method_address(ent, free_set);
 	}
 
 	/* the main program is even then "free", if it's not external visible. */
 	irg = get_irp_main_irg();
-	if (irg)
+	if (irg != NULL)
 		eset_insert(free_set, get_irg_entity(irg));
 
 	/* Finally, transform the set into an array. */
-	for (ent = eset_first(free_set); ent; ent = eset_next(free_set)) {
-		ARR_APP1(ir_entity *, arr, ent);
+	*length = eset_count(free_set);
+	arr = XMALLOCN(ir_entity*, *length);
+	for (i = 0, ent = eset_first(free_set); ent; ent = eset_next(free_set)) {
+		arr[i++] = ent;
 	}
 	eset_destroy(free_set);
 
@@ -603,7 +613,8 @@ static ir_entity ** get_free_methods(void)
 
 static void callee_ana_node(ir_node * node, eset * methods);
 
-static void callee_ana_proj(ir_node * node, long n, eset * methods) {
+static void callee_ana_proj(ir_node *node, long n, eset *methods)
+{
 	assert(get_irn_mode(node) == mode_T);
 	if (get_irn_link(node) == MARK) {
 		/* already visited */
@@ -615,32 +626,26 @@ static void callee_ana_proj(ir_node * node, long n, eset * methods) {
 	case iro_Proj: {
 		/* proj_proj: in einem "sinnvollen" Graphen kommt jetzt ein
 		 * op_Tuple oder ein Knoten, der eine "freie Methode"
-		 * zurückgibt. */
-		ir_node * pred = get_Proj_pred(node);
+		 * zur�ckgibt. */
+		ir_node *pred = get_Proj_pred(node);
 		if (get_irn_link(pred) != MARK) {
-			if (get_irn_op(pred) == op_Tuple) {
+			if (is_Tuple(pred)) {
 				callee_ana_proj(get_Tuple_pred(pred, get_Proj_proj(node)), n, methods);
 			} else {
-				eset_insert(methods, MARK); /* free method -> unknown */
+				eset_insert(methods, unknown_entity); /* free method -> unknown */
 			}
 		}
 		break;
-				   }
+	}
 
 	case iro_Tuple:
 		callee_ana_node(get_Tuple_pred(node, n), methods);
 		break;
 
-	case iro_Id:
-		callee_ana_proj(get_Id_pred(node), n, methods);
-		break;
-
 	default:
-		eset_insert(methods, MARK); /* free method -> unknown */
+		eset_insert(methods, unknown_entity); /* free method -> unknown */
 		break;
 	}
-
-	set_irn_link(node, NULL);
 }
 
 /**
@@ -649,7 +654,8 @@ static void callee_ana_proj(ir_node * node, long n, eset * methods) {
  * @param node     the node representing the call address
  * @param methods  after call contains the set of all possibly called entities
  */
-static void callee_ana_node(ir_node *node, eset *methods) {
+static void callee_ana_node(ir_node *node, eset *methods)
+{
 	int i;
 
 	assert(mode_is_reference(get_irn_mode(node)) || is_Bad(node));
@@ -663,28 +669,28 @@ static void callee_ana_node(ir_node *node, eset *methods) {
 	switch (get_irn_opcode(node)) {
 	case iro_Const:
 		/* A direct address call. We tread this as an external
-		call and ignore it completely. */
-		eset_insert(methods, MARK); /* free method -> unknown */
+		   call and ignore it completely. */
+		eset_insert(methods, unknown_entity); /* free method -> unknown */
 		break;
 	case iro_SymConst:
 		if (get_SymConst_kind(node) == symconst_addr_ent) {
 			ir_entity *ent = get_SymConst_entity(node);
-			assert(ent && is_Method_type(get_entity_type(ent)));
+			assert(ent && is_method_entity(ent));
 			eset_insert(methods, ent);
 		} else {
 			assert(get_SymConst_kind(node) == symconst_addr_name);
-			/* externe Methode (wegen fix_symconst!) */
-			eset_insert(methods, MARK); /* free method -> unknown */
+			/* external method (because fix_symconst()!) */
+			eset_insert(methods, unknown_entity); /* free method -> unknown */
 		}
 		break;
 	case iro_Sel:
-		/* polymorphe Methode */
+		/* polymorphic method */
 		for (i = get_Sel_n_methods(node) - 1; i >= 0; --i) {
-			ir_entity * ent = get_Sel_method(node, i);
-			if (ent) {
+			ir_entity *ent = get_Sel_method(node, i);
+			if (ent != NULL) {
 				eset_insert(methods, ent);
 			} else {
-				eset_insert(methods, MARK);
+				eset_insert(methods, unknown_entity);
 			}
 		}
 		break;
@@ -704,13 +710,6 @@ static void callee_ana_node(ir_node *node, eset *methods) {
 		callee_ana_node(get_Mux_true(node), methods);
 		break;
 
-	case iro_Psi:
-		for (i = get_Psi_n_conds(node) - 1; i >= 0; --i) {
-			callee_ana_node(get_Psi_val(node, i), methods);
-		}
-		callee_ana_node(get_Psi_default(node), methods);
-		break;
-
 	case iro_Id:
 		callee_ana_node(get_Id_pred(node), methods);
 		break;
@@ -723,60 +722,40 @@ static void callee_ana_node(ir_node *node, eset *methods) {
 	case iro_Sub:
 	case iro_Conv:
 		/* extern */
-		eset_insert(methods, MARK); /* free method -> unknown */
+		eset_insert(methods, unknown_entity); /* free method -> unknown */
 		break;
 
 	default:
 		assert(0 && "invalid opcode or opcode not implemented");
 		break;
 	}
-
-	set_irn_link(node, NULL);
 }
 
 /**
- * Walker: Analyses every call node and calculates an array of possible
+ * Walker: Analyses every Call node and calculates an array of possible
  * callees for that call.
  */
-static void callee_walker(ir_node * call, void * env) {
+static void callee_walker(ir_node *call, void *env)
+{
 	(void) env;
 	if (is_Call(call)) {
-		eset * methods = eset_create();
-		ir_entity * ent;
-		ir_entity ** arr = NEW_ARR_F(ir_entity *, 0);
-		assert(get_irn_op(get_Call_ptr(call)) != op_Id);
+		eset *methods = eset_create();
+		ir_entity *ent;
+		ir_entity **arr;
+		int i;
+
 		callee_ana_node(get_Call_ptr(call), methods);
-		if (eset_contains(methods, MARK)) { /* unknown method */
-			ARR_APP1(ir_entity *, arr, unknown_entity);
-		}
-		for (ent = eset_first(methods); ent; ent = eset_next(methods)) {
-			if (ent != MARK) {
-				ARR_APP1(ir_entity *, arr, ent);
+		arr = NEW_ARR_F(ir_entity *, eset_count(methods));
+		for (i = 0, ent = eset_first(methods); ent; ent = eset_next(methods)) {
+			arr[i] = ent;
+			/* we want the unknown_entity on the zero position for easy tests later */
+			if (ent == unknown_entity) {
+				arr[i] = arr[0];
+				arr[0] = unknown_entity;
 			}
+			++i;
 		}
-#if 0  /* This generates Bad nodes when we don't want it.
-		  Call it with a check for valid cgana information in local_optimize. */
-		if (ARR_LEN(arr) == 0 && get_opt_optimize() && get_opt_closed_world() && get_opt_dyn_meth_dispatch()) {
-			/* Kann vorkommen, wenn der Vorgänger beispielsweise eine
-			 * Sel-Operation war, die keine Methoden zurückgeben
-			 * konnte. Wir ersetzen die Call-Operation ebenfalls durch
-			 * eine Bad-Operation. Die Verlinkung muss wiederhergestellt
-			 * werden! */
-			ir_node *mem = get_Call_mem(call);
-			ir_node *blk = get_nodes_block(call);
-			turn_into_tuple (call, pn_Call_max);
-			set_Tuple_pred(call, pn_Call_M_regular       , mem);
-			set_Tuple_pred(call, pn_Call_T_result        , new_Bad());
-			set_Tuple_pred(call, pn_Call_P_value_res_base, new_Bad());
-			set_Tuple_pred(call, pn_Call_X_regular       , new_r_Jmp(current_ir_graph, blk));
-			set_Tuple_pred(call, pn_Call_X_except        , new_Bad());  /* new_Jmp() ?? new_Raise() ?? */
-			set_Tuple_pred(call, pn_Call_M_except        , new_Bad());
-
-		} else
-#endif
-		{
-			set_Call_callee_arr(call, ARR_LEN(arr), arr);
-		}
+		set_Call_callee_arr(call, ARR_LEN(arr), arr);
 		DEL_ARR_F(arr);
 		eset_destroy(methods);
 	}
@@ -785,7 +764,8 @@ static void callee_walker(ir_node * call, void * env) {
 /**
  * Walker: Removes all tuple.
  */
-static void remove_Tuples(ir_node *proj, void *env) {
+static void remove_Tuples(ir_node *proj, void *env)
+{
 	ir_node *nn;
 	(void) env;
 	if (! is_Proj(proj)) return;
@@ -795,13 +775,15 @@ static void remove_Tuples(ir_node *proj, void *env) {
 }
 
 
-/* Bestimmt für jede Call-Operation die Menge der aufrufbaren Methode
- * und speichert das Ergebnis in der Call-Operation. (siehe
- * "set_Call_callee"). "sel_methods" wird für den Aufbau benötigt und
- * muss bereits aufgebaut sein. */
-static void callee_ana(void) {
+/**
+ * Determine for every Call the set of possibly called methods and stores it
+ * inside the Call (@see set_Call_callee()).
+ * Uses the sel_methods set with much be already calculated.
+ */
+static void callee_ana(void)
+{
 	int i;
-	/* Alle Graphen analysieren. */
+	/* analyse all graphs */
 	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
 		ir_graph *irg = get_irp_irg(i);
 		irg_walk_graph(irg, callee_walker, remove_Tuples, NULL);
@@ -815,7 +797,8 @@ static void callee_ana(void) {
 /*--------------------------------------------------------------------------*/
 
 /** Frees intermediate data structures. */
-static void sel_methods_dispose(void) {
+static void sel_methods_dispose(void)
+{
 	ir_entity * ent;
 	assert(entities);
 	for (ent = eset_first(entities); ent; ent = eset_next(entities)) {
@@ -833,7 +816,8 @@ static void sel_methods_dispose(void) {
 /* Freeing the callee arrays.                                               */
 /*--------------------------------------------------------------------------*/
 
-static void destruct_walker(ir_node * node, void * env) {
+static void destruct_walker(ir_node * node, void * env)
+{
 	(void) env;
 	if (is_Call(node)) {
 		remove_Call_callee_arr(node);
@@ -844,32 +828,23 @@ static void destruct_walker(ir_node * node, void * env) {
 /* Main drivers.                                                            */
 /*--------------------------------------------------------------------------*/
 
-void cgana(int *length, ir_entity ***free_methods) {
-	ir_entity ** free_meths, **p;
-
+void cgana(int *length, ir_entity ***free_methods)
+{
 	/* Optimize Sel/SymConst nodes and compute all methods that implement an entity. */
 	sel_methods_init();
-	free_meths = get_free_methods();
+	*free_methods = get_free_methods(length);
 	callee_ana();
 	sel_methods_dispose();
-
-	/* Convert the flexible array to an array that can be handled
-	   by standard C. */
-	p = xmalloc(sizeof(*p) * ARR_LEN(free_meths));
-	memcpy(p, free_meths, ARR_LEN(free_meths) * sizeof(*p));
-
-	*length       = ARR_LEN(free_meths);
-	*free_methods = p;
-
-	DEL_ARR_F(free_meths);
 }
 
-void free_callee_info(ir_graph *irg) {
+void free_callee_info(ir_graph *irg)
+{
 	irg_walk_graph(irg, destruct_walker, NULL, NULL);
 	set_irg_callee_info_state(irg, irg_callee_info_none);
 }
 
-void free_irp_callee_info(void) {
+void free_irp_callee_info(void)
+{
 	int i;
 	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
 		free_callee_info(get_irp_irg(i));
@@ -890,7 +865,8 @@ void free_irp_callee_info(void) {
  *   by Const nodes referring to the entity that implements the method in
  *   the type given by the Alloc node.
  */
-void opt_call_addrs(void) {
+void opt_call_addrs(void)
+{
 	sel_methods_init();
 	sel_methods_dispose();
 }