X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fircgopt.c;h=c95e0a52a640e3d9ff65541254f709bc60e2f218;hb=e1d0a7c980faef658ffd4fd63a43e74b764a7dfe;hp=11d708f64f06d64fdd1706f8611b9fbe7fff5132;hpb=d92c40358495a9da07dcb03c9ad418bf460825b0;p=libfirm diff --git a/ir/opt/ircgopt.c b/ir/opt/ircgopt.c index 11d708f64..c95e0a52a 100644 --- a/ir/opt/ircgopt.c +++ b/ir/opt/ircgopt.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. * @@ -27,7 +27,7 @@ /* * Entfernen von nicht erreichbaren (aufrufbaren) Methoden. Die Menge - * der nicht erreichbaren Methoden wird aus der Abschätzung der + * der nicht erreichbaren Methoden wird aus der Abschätzung der * Aufrufrelation bestimmt. */ #include "config.h" @@ -43,14 +43,16 @@ #include "ircons.h" #include "cgana.h" #include "irtools.h" +#include "irpass.h" DEBUG_ONLY(static firm_dbg_module_t *dbg); /** * Walker: adds Call operations to a head's link list. */ -static void collect_call(ir_node *node, void *env) { - ir_node *head = env; +static void collect_call(ir_node *node, void *env) +{ + ir_node *head = (ir_node*)env; if (is_Call(node)) { set_irn_link(node, get_irn_link(head)); @@ -58,29 +60,11 @@ static void collect_call(ir_node *node, void *env) { } } -/** - * Type walker, set the peculiarity of entities which graphs - * gets removed to peculiarity_description. - */ -static void make_entity_to_description(type_or_ent tore, void *env) { - if (is_entity(tore.ent)) { - ir_entity *ent = tore.ent; - - if ((is_Method_type(get_entity_type(ent))) && - (get_entity_peculiarity(ent) != peculiarity_description) && - (get_entity_visibility(ent) != visibility_external_allocated) ) { - ir_entity *impl = get_SymConst_entity(get_atomic_ent_value(ent)); - if (get_entity_link(impl) != env) { - set_entity_peculiarity(ent, peculiarity_description); - } - } - } -} - /* garbage collect methods: mark and remove */ -void gc_irgs(int n_keep, ir_entity ** keep_arr) { +void gc_irgs(size_t n_keep, ir_entity ** keep_arr) +{ void * MARK = &MARK; /* @@@ gefaehrlich!!! Aber wir markieren hoechstens zu viele ... */ - int i; + size_t i, n; FIRM_DBG_REGISTER(dbg, "firm.opt.cgopt"); @@ -94,62 +78,62 @@ void gc_irgs(int n_keep, ir_entity ** keep_arr) { /* Mark entities that are alive. */ if (n_keep > 0) { ir_entity **marked = NEW_ARR_F(ir_entity *, n_keep); - for (i = 0; i < n_keep; ++i) { - marked[i] = keep_arr[i]; - set_entity_link(marked[i], MARK); - DB((dbg, LEVEL_1, " method %+F kept alive.\n", marked[i])); + size_t idx; + + for (idx = 0; idx < n_keep; ++idx) { + marked[idx] = keep_arr[idx]; + set_entity_link(marked[idx], MARK); + DB((dbg, LEVEL_1, " method %+F kept alive.\n", marked[idx])); } - for (i = 0; i < ARR_LEN(marked); ++i) { - /* check for extern methods, these don't have an IRG */ - if (get_entity_visibility(marked[i]) != visibility_external_allocated) { - ir_graph *irg = get_entity_irg(marked[i]); - ir_node *node = get_irg_end(irg); + for (idx = 0; idx < ARR_LEN(marked); ++idx) { + ir_graph *irg = get_entity_irg(marked[idx]); + ir_node *node; + + if (irg == NULL) + continue; + + node = get_irg_end(irg); - /* collect calls */ - ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); - irg_walk_graph(irg, firm_clear_link, collect_call, node); + /* collect calls */ + ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); + irg_walk_graph(irg, firm_clear_link, collect_call, node); - /* iterate calls */ - for (node = get_irn_link(node); node; node = get_irn_link(node)) { - int i; - assert(is_Call(node)); + /* iterate calls */ + for (node = (ir_node*)get_irn_link(node); node != NULL; + node = (ir_node*)get_irn_link(node)) { + size_t i; + assert(is_Call(node)); - for (i = get_Call_n_callees(node) - 1; i >= 0; --i) { - ir_entity *ent = get_Call_callee(node, i); + for (i = get_Call_n_callees(node); i > 0;) { + ir_entity *ent = get_Call_callee(node, --i); - if (get_entity_irg(ent) && get_entity_link(ent) != MARK) { - set_entity_link(ent, MARK); - ARR_APP1(ir_entity *, marked, ent); + if (get_entity_irg(ent) && get_entity_link(ent) != MARK) { + set_entity_link(ent, MARK); + ARR_APP1(ir_entity *, marked, ent); - DB((dbg, LEVEL_1, " method %+F can be called from Call %+F: kept alive.\n", - ent, node)); - } + DB((dbg, LEVEL_1, " method %+F can be called from Call %+F: kept alive.\n", + ent, node)); } } - ir_free_resources(irg, IR_RESOURCE_IRN_LINK); } + ir_free_resources(irg, IR_RESOURCE_IRN_LINK); } DEL_ARR_F(marked); } /* clean */ - type_walk(make_entity_to_description, NULL, MARK); - 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); ir_entity *ent = get_irg_entity(irg); - /* Removing any graph invalidates all interprocedural loop trees. */ - if (get_irg_loopinfo_state(irg) == loopinfo_ip_consistent || - get_irg_loopinfo_state(irg) == loopinfo_ip_inconsistent) { - free_loop_information(irg); - } - if ((get_entity_visibility(ent) == visibility_local) && (get_entity_link(ent) != MARK)) { - DB((dbg, LEVEL_1, " freeing method %+F\n", ent)); - remove_irp_irg(irg); - set_entity_peculiarity(ent, peculiarity_description); - } - set_entity_link(ent, NULL); + if (get_entity_link(ent) == MARK) + continue; + + DB((dbg, LEVEL_1, " freeing method %+F\n", ent)); + remove_irp_irg(irg); + + free_entity(ent); } } @@ -159,20 +143,20 @@ void gc_irgs(int n_keep, ir_entity ** keep_arr) { static void pass_wrapper(void) { ir_entity **keep_methods; - int arr_len; + size_t arr_len; /* Analysis that finds the free methods, i.e. methods that are dereferenced. Optimizes polymorphic calls :-). */ - cgana(&arr_len, &keep_methods); + arr_len = cgana(&keep_methods); /* Remove methods that are never called. */ gc_irgs(arr_len, keep_methods); - free(keep_methods); + xfree(keep_methods); } -ir_prog_pass_t *gc_irgs_pass(const char *name, int verify, int dump) +ir_prog_pass_t *gc_irgs_pass(const char *name) { - return def_prog_pass(name ? name : "cgana", verify, dump, pass_wrapper); + return def_prog_pass(name ? name : "cgana", pass_wrapper); }