X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fcgana.c;h=afa74dd7aa2c9dbb79c2225a82cde2f544f3348a;hb=d2dc2564b47d9c113d7e6e598574e9733627fcca;hp=25acceaff9d6b64faffb280c3287062a78d18247;hpb=5afaf595a454bb6b87899b317f2ae99ed03bf62e;p=libfirm

diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c
index 25acceaff..afa74dd7a 100644
--- a/ir/ana/cgana.c
+++ b/ir/ana/cgana.c
@@ -54,8 +54,7 @@
 
 
 
-/* Eindeutige Adresse zur Markierung von besuchten Knoten und zur
- * Darstellung der unbekannten Methode. */
+/* unambiguous address used as a mark. */
 static void *MARK = &MARK;
 
 static eset *entities = NULL;
@@ -82,7 +81,7 @@ static entity *get_inherited_methods_implementation(entity *inh_meth) {
 }
 
 /** Collect the entity representing the implementation of this
- *  entity (not the same if inherited) and all entities for overwriting
+ *  method (not the same if inherited) and all entities for overwriting
  *  implementations in "set".
  *  If the implementation of the method is not included in the
  *  compilation unit "open" is set to true.
@@ -94,7 +93,7 @@ static entity *get_inherited_methods_implementation(entity *inh_meth) {
  * @param size     Number of entities in set.
  * @param open
  */
-static void collect_impls(entity *method, eset *set, int *size, bool *open) {
+static void collect_impls(entity *method, eset *set, int *size, int *open) {
   int i;
   entity *impl;
 
@@ -128,7 +127,7 @@ static entity ** get_impl_methods(entity * method) {
   eset * set = eset_create();
   int size = 0;
   entity ** arr;
-  bool open = false;
+  int open = 0;
 
   /* Collect all method entities that can be called here */
   collect_impls(method, set, &size, &open);
@@ -178,9 +177,10 @@ static void sel_methods_walker(ir_node * node, void *env) {
   entity **arr;
 
   /* Call standard optimizations */
-  if (get_irn_op(node) == op_Sel) {
+  if (is_Sel(node)) {
     ir_node *new_node = optimize_in_place(node);
-    if (node != new_node) exchange(node, new_node);
+    if (node != new_node)
+      exchange(node, new_node);
   }
 
   /* replace SymConst(name)-operations by SymConst(ent) */
@@ -229,7 +229,7 @@ static void sel_methods_walker(ir_node * node, void *env) {
       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_atomic_ent_value(arr[0]));
+      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);
     }
@@ -281,7 +281,7 @@ static entity ** get_Sel_arr(ir_node * sel) {
   entity * ent;
   entity ** arr;
 
-  assert(sel && get_irn_op(sel) == op_Sel);
+  assert(is_Sel(sel));
   ent = get_Sel_entity(sel);
   ent = get_inherited_methods_implementation(ent);
 
@@ -469,6 +469,62 @@ static void free_ana_walker(ir_node *node, void *env) {
   set_irn_link(node, NULL);
 }
 
+/**
+ * Add all method addresses in global 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(entity *ent, eset *set)
+{
+  ir_node *n;
+  ir_type *tp;
+  int i;
+
+  /* do not check uninitialized values */
+  if (get_entity_variability(ent) == variability_uninitialized)
+    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 {
+    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) {
+          entity *ent = get_SymConst_entity(n);
+
+          if (is_Method_type(get_entity_type(ent)))
+            eset_insert(set, ent);
+        }
+      }
+    }
+  }
+}
+
 /**
  * returns a list of 'free' methods, i.e., the methods that can be called
  * from external or via function pointers.
@@ -481,43 +537,52 @@ static void free_ana_walker(ir_node *node, void *env) {
  */
 static entity ** get_free_methods(void)
 {
-  eset * set = eset_create();
+  eset *free_set = eset_create();
   int i;
-  entity ** arr = NEW_ARR_F(entity *, 0);
-  entity * ent;
+  entity **arr = NEW_ARR_F(entity *, 0);
+  entity *ent;
+  ir_graph *irg;
+  ir_type *glob;
 
   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-    ir_graph * irg = get_irp_irg(i);
-    entity * ent = get_irg_entity(irg);
+    irg = get_irp_irg(i);
+    ent = get_irg_entity(irg);
     /* insert "external visible" methods. */
     if (get_entity_visibility(ent) != visibility_local) {
-      eset_insert(set, ent);
+      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, set);
+    irg_walk_graph(irg, NULL, free_ana_walker, free_set);
   }
 
   /* insert sticky methods, too */
   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-    entity * ent = get_irg_entity(get_irp_irg(i));
+    ent = get_irg_entity(get_irp_irg(i));
     /* insert "sticky" methods. */
     if (get_entity_stickyness (ent) == stickyness_sticky) {
-      eset_insert(set, ent);
+      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);
+
+    add_method_address(ent, free_set);
+  }
 
   /* the main program is even then "free", if it's not external visible. */
-  if (get_irp_main_irg())
-    eset_insert(set, get_irg_entity(get_irp_main_irg()));
+  irg = get_irp_main_irg();
+  if (irg)
+    eset_insert(free_set, get_irg_entity(irg));
 
   /* Finally, transform the set into an array. */
-  for (ent = eset_first(set); ent; ent = eset_next(set)) {
+  for (ent = eset_first(free_set); ent; ent = eset_next(free_set)) {
     ARR_APP1(entity *, arr, ent);
   }
-  eset_destroy(set);
+  eset_destroy(free_set);
 
   return arr;
 }
@@ -581,6 +646,11 @@ static void callee_ana_node(ir_node * node, eset * methods) {
   set_irn_link(node, MARK);
 
   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 */
+    break;
   case iro_SymConst:
     if (get_SymConst_kind(node) == symconst_addr_ent) {
       entity * ent = get_SymConst_entity(node);
@@ -644,7 +714,7 @@ static void callee_ana_node(ir_node * node, eset * methods) {
 
 /* */
 static void callee_walker(ir_node * call, void * env) {
-  if (get_irn_op(call) == op_Call) {
+  if (is_Call(call)) {
     eset * methods = eset_create();
     entity * ent;
     entity ** arr = NEW_ARR_F(entity *, 0);
@@ -702,8 +772,9 @@ static void callee_ana(void) {
   int i;
   /* Alle Graphen analysieren. */
   for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
-    irg_walk_graph(get_irp_irg(i), callee_walker, remove_Tuples, NULL);
-    set_irg_callee_info_state(get_irp_irg(i), irg_callee_info_consistent);
+    ir_graph *irg = get_irp_irg(i);
+    irg_walk_graph(irg, callee_walker, remove_Tuples, NULL);
+    set_irg_callee_info_state(irg, irg_callee_info_consistent);
   }
   set_irp_callee_info_state(irg_callee_info_consistent);
 }
@@ -732,7 +803,7 @@ static void sel_methods_dispose(void) {
 /*--------------------------------------------------------------------------*/
 
 static void destruct_walker(ir_node * node, void * env) {
-  if (get_irn_op(node) == op_Call) {
+  if (is_Call(node)) {
     remove_Call_callee_arr(node);
   }
 }