X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fcgana.c;h=e70ece616459637104a35e28d14479a393a7fe2a;hb=6ccff2965d94c272f71df2a1655336af47bb7753;hp=ec7aad85ff4d0f7393b2d2233f2d362653cc4ff0;hpb=9d4e23060441530a20af5d331268435bfe18f305;p=libfirm diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c index ec7aad85f..e70ece616 100644 --- a/ir/ana/cgana.c +++ b/ir/ana/cgana.c @@ -22,7 +22,6 @@ * @brief Intraprozedural analyses to estimate the call graph. * @author Hubert Schmid * @date 09.06.2002 - * @version $Id$ * @brief * Interprocedural analysis to estimate the calling relation. * @@ -36,7 +35,6 @@ #include #include "cgana.h" -#include "rta.h" #include "xmalloc.h" #include "irnode_t.h" @@ -76,66 +74,56 @@ static eset *entities = NULL; /** Collect the entity representing the implementation of this * 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. + * implementations in parameter set. * A recursive descend in the overwritten relation. * Cycle-free, therefore must terminate. * - * @param method + * @param method the overwritten method * @param set A set of entities. - * @param size Number of entities in set. - * @param open + * + * @return Number of entities in set. */ -static void collect_impls(ir_entity *method, eset *set, int *size, int *open) +static size_t collect_impls(ir_entity *method, eset *set) { - int i; + size_t i; + size_t size = 0; if (get_entity_irg(method) != NULL) { + /* has an implementation */ eset_insert(set, method); - ++(*size); + ++size; } /*- recursive descent -*/ - for (i = get_entity_n_overwrittenby(method) - 1; i >= 0; --i) - collect_impls(get_entity_overwrittenby(method, i), set, size, open); + for (i = get_entity_n_overwrittenby(method); i > 0;) + size += collect_impls(get_entity_overwrittenby(method, --i), set); + return size; } -/** 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. +/** + * Determine all methods that overwrite the given method (and implement it). + * The returned array must be freed by the caller (see DEL_ARR_F). + * If the set of overwriting methods is empty, returns NULL. * - * @param method + * @param method the 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; - int open = 0; + ir_entity **arr; + eset *set = eset_create(); + size_t size; /* Collect all method entities that can be called here */ - collect_impls(method, set, &size, &open); + size = collect_impls(method, set); - /* Vorgaenger einfuegen. */ - if (size == 0 && !open) { - /* keine implementierte �berschriebene Methode */ + if (size == 0) { + /* no overwriting methods found */ arr = NULL; - } else if (open) { - ir_entity * ent; - arr = NEW_ARR_F(ir_entity *, size + 1); - arr[0] = NULL; /* Represents open method */ - for (ent = (ir_entity*) eset_first(set); size > 0; ent = (ir_entity*) eset_next(set), --size) - arr[size] = ent; } else { ir_entity * ent; arr = NEW_ARR_F(ir_entity *, size); - for (size -= 1, ent = (ir_entity*) eset_first(set); size >= 0; ent = (ir_entity*) eset_next(set), --size) - arr[size] = ent; + for (ent = (ir_entity*) eset_first(set); size > 0; ent = (ir_entity*) eset_next(set)) + arr[--size] = ent; } eset_destroy(set); return arr; @@ -360,8 +348,6 @@ static void free_mark_proj(ir_node * node, long n, eset * set) */ static void free_mark(ir_node *node, eset * set) { - size_t i, n; - if (get_irn_link(node) == MARK) return; /* already visited */ @@ -371,6 +357,7 @@ static void free_mark(ir_node *node, eset * set) case iro_Sel: { ir_entity *ent = get_Sel_entity(node); if (is_method_entity(ent)) { + size_t i, n; for (i = 0, n = get_Sel_n_methods(node); i < n; ++i) { eset_insert(set, get_Sel_method(node, i)); } @@ -409,7 +396,6 @@ static void free_mark(ir_node *node, eset * set) static void free_ana_walker(ir_node *node, void *env) { eset *set = (eset*) env; - int i; if (get_irn_link(node) == MARK) { /* already visited */ @@ -427,17 +413,21 @@ static void free_ana_walker(ir_node *node, void *env) /* nothing */ break; case iro_Call: + { + size_t i, n; /* 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) { + for (i = 0, n = get_Call_n_params(node); i < n; ++i) { ir_node *pred = get_Call_param(node, i); if (mode_is_reference(get_irn_mode(pred))) { free_mark(pred, set); } } break; - default: + } + default: { + int i; /* other nodes: Alle anderen Knoten nehmen wir als Verr�ter an, bis * jemand das Gegenteil implementiert. */ set_irn_link(node, MARK); @@ -449,13 +439,14 @@ static void free_ana_walker(ir_node *node, void *env) } break; } + } } /** * 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. + * We do NOT check the type here, just if it's an entity address. * The reason for this is code like: * * void *p = function; @@ -473,8 +464,8 @@ static void add_method_address_inititializer(ir_initializer_t *initializer, 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_SymConst_addr_ent(n)) { + ir_entity *ent = get_SymConst_entity(n); if (is_Method_type(get_entity_type(ent))) eset_insert(set, ent); @@ -498,7 +489,7 @@ static void add_method_address_inititializer(ir_initializer_t *initializer, * 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. + * We do NOT check the type here, just if it's an entity address. * The reason for this is code like: * * void *p = function; @@ -509,7 +500,7 @@ static void add_method_address(ir_entity *ent, eset *set) { ir_type *tp; - /* ignore methods: these of course reference it's address + /* ignore methods: these of course reference their addresses * TODO: remove this later once this incorrect self-initialisation is gone */ tp = get_entity_type(ent); @@ -524,11 +515,11 @@ static void add_method_address(ir_entity *ent, eset *set) ir_node *irn = get_compound_ent_value(ent, i); /* let's check if it's the address of a function */ - if (is_Global(irn)) { - ir_entity *ent = get_Global_entity(irn); + if (is_SymConst_addr_ent(irn)) { + ir_entity *ent2 = get_SymConst_entity(irn); - if (is_Method_type(get_entity_type(ent))) - eset_insert(set, ent); + if (is_Method_type(get_entity_type(ent2))) + eset_insert(set, ent2); } } } @@ -547,8 +538,7 @@ static void add_method_address(ir_entity *ent, eset *set) static size_t get_free_methods(ir_entity ***free_methods) { eset *free_set = eset_create(); - size_t i, n; - int j; + size_t i, n, j, m; ir_entity **arr; ir_entity *ent; ir_graph *irg; @@ -574,13 +564,13 @@ static size_t get_free_methods(ir_entity ***free_methods) /* insert all methods that are used in global variables initializers */ tp = get_glob_type(); - for (j = get_class_n_members(tp) - 1; j >= 0; --j) { + for (j = 0, m = get_class_n_members(tp); j < m; ++j) { ent = get_class_member(tp, j); add_method_address(ent, free_set); } tp = get_tls_type(); - for (j = get_class_n_members(tp) - 1; j >= 0; --j) { - ent = get_class_member(tp, j); + for (j = 0, m = get_compound_n_members(tp); j < m; ++j) { + ent = get_compound_member(tp, j); add_method_address(ent, free_set); }