X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fcgana.c;h=b4b051201de2ac564f72601639c2212ac9b234b6;hb=f64411a2a8a4e28e70a281ac67736a1bdf996b72;hp=25acceaff9d6b64faffb280c3287062a78d18247;hpb=5afaf595a454bb6b87899b317f2ae99ed03bf62e;p=libfirm diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c index 25acceaff..b4b051201 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); @@ -180,7 +179,8 @@ static void sel_methods_walker(ir_node * node, void *env) { /* Call standard optimizations */ if (get_irn_op(node) == op_Sel) { 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); } @@ -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; + 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; + 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; }