X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fcgana.c;h=0ffdd8b9fc0928c451fe01f4a7bb686c0d00fed5;hb=3d4caa9272d4bcfad93c55428478aa420b21b296;hp=5e541cf5f7065f5aafd171acce813ecb731bf722;hpb=ce6161a7e42a48f7422b7babcc64d8ace18e2687;p=libfirm diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c index 5e541cf5f..0ffdd8b9f 100644 --- a/ir/ana/cgana.c +++ b/ir/ana/cgana.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -76,66 +76,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; @@ -227,12 +217,12 @@ static void sel_methods_walker(ir_node *node, void *env) */ static void sel_methods_init(void) { - int i; + size_t i, n; 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) { + for (i = 0, n = get_irp_n_irgs(); i < n; ++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 (entity_is_externally_visible(ent)) { @@ -285,7 +275,7 @@ static ir_entity ** get_Sel_arr(ir_node * sel) * * @param sel the Sel node */ -static int get_Sel_n_methods(ir_node * sel) +static size_t get_Sel_n_methods(ir_node * sel) { return ARR_LEN(get_Sel_arr(sel)); } @@ -293,10 +283,10 @@ static int get_Sel_n_methods(ir_node * 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, size_t pos) { ir_entity ** arr = get_Sel_arr(sel); - assert(pos >= 0 && pos < ARR_LEN(arr)); + assert(pos < ARR_LEN(arr)); return arr[pos]; } @@ -360,7 +350,7 @@ static void free_mark_proj(ir_node * node, long n, eset * set) */ static void free_mark(ir_node *node, eset * set) { - int i; + size_t i, n; if (get_irn_link(node) == MARK) return; /* already visited */ @@ -371,7 +361,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)) { - for (i = get_Sel_n_methods(node) - 1; i >= 0; --i) { + for (i = 0, n = get_Sel_n_methods(node); i < n; ++i) { eset_insert(set, get_Sel_method(node, i)); } } @@ -387,10 +377,13 @@ static void free_mark(ir_node *node, eset * set) break; case iro_Phi: - for (i = get_Phi_n_preds(node) - 1; i >= 0; --i) { + { + int i, n; + for (i = 0, n = get_Phi_n_preds(node); i < n; ++i) { free_mark(get_Phi_pred(node, i), set); } break; + } case iro_Proj: free_mark_proj(get_Proj_pred(node), get_Proj_proj(node), set); break; @@ -424,16 +417,19 @@ 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: /* other nodes: Alle anderen Knoten nehmen wir als Verr�ter an, bis * jemand das Gegenteil implementiert. */ @@ -452,7 +448,7 @@ static void free_ana_walker(ir_node *node, void *env) * 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; @@ -495,7 +491,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; @@ -504,12 +500,10 @@ static void add_method_address_inititializer(ir_initializer_t *initializer, */ static void add_method_address(ir_entity *ent, eset *set) { - ir_node *n; ir_type *tp; - int i; - /* ignore methods: these of course reference it's address - * TODO: remove this later once this incorrect self-intialisation is gone + /* ignore methods: these of course reference their addresses + * TODO: remove this later once this incorrect self-initialisation is gone */ tp = get_entity_type(ent); if (is_Method_type(tp)) @@ -518,12 +512,13 @@ static void add_method_address(ir_entity *ent, eset *set) 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); + size_t i, n; + for (i = 0, n = get_compound_ent_n_values(ent); i < n; ++i) { + ir_node *irn = get_compound_ent_value(ent, i); /* let's check if it's the address of a function */ - if (is_Global(n)) { - ir_entity *ent = get_Global_entity(n); + if (is_Global(irn)) { + ir_entity *ent = get_Global_entity(irn); if (is_Method_type(get_entity_type(ent))) eset_insert(set, ent); @@ -542,23 +537,23 @@ static void add_method_address(ir_entity *ent, eset *set) * umgewandelt worden sein, d.h. SymConst-Operationen verweisen immer * auf eine echt externe Methode. */ -static ir_entity **get_free_methods(int *length) +static size_t get_free_methods(ir_entity ***free_methods) { eset *free_set = eset_create(); - int i; + size_t i, n, j, m; ir_entity **arr; ir_entity *ent; ir_graph *irg; ir_type *tp; + size_t length; - for (i = get_irp_n_irgs() - 1; i >= 0; --i) { + for (i = 0, n = get_irp_n_irgs(); i < n; ++i) { ir_linkage linkage; irg = get_irp_irg(i); ent = get_irg_entity(irg); linkage = get_entity_linkage(ent); - if (entity_is_externally_visible(ent) - || (linkage & IR_LINKAGE_HIDDEN_USER)) { + if ((linkage & IR_LINKAGE_HIDDEN_USER) || entity_is_externally_visible(ent)) { eset_insert(free_set, ent); } @@ -571,13 +566,13 @@ static ir_entity **get_free_methods(int *length) /* 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); + 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 (i = get_class_n_members(tp) - 1; i >= 0; --i) { - ent = get_class_member(tp, i); + for (j = 0, m = get_compound_n_members(tp); j < m; ++j) { + ent = get_compound_member(tp, j); add_method_address(ent, free_set); } @@ -587,14 +582,15 @@ static ir_entity **get_free_methods(int *length) eset_insert(free_set, get_irg_entity(irg)); /* Finally, transform the set into an array. */ - *length = eset_count(free_set); - arr = XMALLOCN(ir_entity*, *length); + length = eset_count(free_set); + arr = XMALLOCN(ir_entity*, length); for (i = 0, ent = (ir_entity*) eset_first(free_set); ent; ent = (ir_entity*) eset_next(free_set)) { arr[i++] = ent; } eset_destroy(free_set); - return arr; + *free_methods = arr; + return length; } /*--------------------------------------------------------------------------*/ @@ -646,8 +642,6 @@ static void callee_ana_proj(ir_node *node, long n, 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)); /* Beware of recursion */ if (get_irn_link(node) == MARK) { @@ -670,9 +664,10 @@ static void callee_ana_node(ir_node *node, eset *methods) break; } - case iro_Sel: + case iro_Sel: { /* polymorphic method */ - for (i = get_Sel_n_methods(node) - 1; i >= 0; --i) { + size_t i, n; + for (i = 0, n = get_Sel_n_methods(node); i < n; ++i) { ir_entity *ent = get_Sel_method(node, i); if (ent != NULL) { eset_insert(methods, ent); @@ -681,16 +676,19 @@ static void callee_ana_node(ir_node *node, eset *methods) } } break; + } case iro_Bad: /* nothing */ break; - case iro_Phi: + case iro_Phi: { + int i; for (i = get_Phi_n_preds(node) - 1; i >= 0; --i) { callee_ana_node(get_Phi_pred(node, i), methods); } break; + } case iro_Mux: callee_ana_node(get_Mux_false(node), methods); @@ -729,7 +727,7 @@ static void callee_walker(ir_node *call, void *env) eset *methods = eset_create(); ir_entity *ent; ir_entity **arr; - int i; + size_t i; callee_ana_node(get_Call_ptr(call), methods); arr = NEW_ARR_F(ir_entity *, eset_count(methods)); @@ -769,9 +767,9 @@ static void remove_Tuples(ir_node *proj, void *env) */ static void callee_ana(void) { - int i; + size_t i, n; /* analyse all graphs */ - for (i = get_irp_n_irgs() - 1; i >= 0; --i) { + for (i = 0, n = get_irp_n_irgs(); i < n; ++i) { 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); @@ -815,13 +813,15 @@ static void destruct_walker(ir_node * node, void * env) /* Main drivers. */ /*--------------------------------------------------------------------------*/ -void cgana(int *length, ir_entity ***free_methods) +size_t cgana(ir_entity ***free_methods) { + size_t length; /* Optimize Sel/SymConst nodes and compute all methods that implement an entity. */ sel_methods_init(); - *free_methods = get_free_methods(length); + length = get_free_methods(free_methods); callee_ana(); sel_methods_dispose(); + return length; } void free_callee_info(ir_graph *irg) @@ -832,8 +832,8 @@ void free_callee_info(ir_graph *irg) void free_irp_callee_info(void) { - int i; - for (i = get_irp_n_irgs() - 1; i >= 0; --i) { + size_t i, n; + for (i = 0, n = get_irp_n_irgs(); i < n; ++i) { free_callee_info(get_irp_irg(i)); } }