X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fproc_cloning.c;h=d61b23375b178548ccbffa2617a9db870b943956;hb=8d40867b11db9064f88bc3fd928e034058873631;hp=5e886c353a92ece563d7eea897470cc40366fe8d;hpb=ce6161a7e42a48f7422b7babcc64d8ace18e2687;p=libfirm diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c index 5e886c353..d61b23375 100644 --- a/ir/opt/proc_cloning.c +++ b/ir/opt/proc_cloning.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. * @@ -21,7 +21,6 @@ * @file * @brief Procedure cloning. * @author Beyhan Veliev, Michael Beck - * @version $Id$ * @brief * * The purpose is first to find and analyze functions, that are called @@ -57,7 +56,7 @@ */ typedef struct quadruple { ir_entity *ent; /**< The entity of our Call. */ - int pos; /**< Position of a constant argument of our Call. */ + size_t pos; /**< Position of a constant argument of our Call. */ ir_tarval *tv; /**< The tarval of this argument if Const node. */ ir_node **calls; /**< The list of all calls with the same characteristics */ } quadruple_t; @@ -95,9 +94,9 @@ static int entry_cmp(const void *elt, const void *key) * * @param entry The element to be hashed. */ -static int hash_entry(const entry_t *entry) +static unsigned hash_entry(const entry_t *entry) { - return HASH_PTR(entry->q.ent) ^ HASH_PTR(entry->q.tv) ^ (entry->q.pos * 9); + return hash_ptr(entry->q.ent) ^ hash_ptr(entry->q.tv) ^ (unsigned)(entry->q.pos * 9); } /** @@ -120,26 +119,22 @@ static void kill_entry(entry_t *entry) */ static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) { - ir_type *mtp; entry_t *key, *entry; ir_node *call_param; - int i, n_params; + size_t i, n_params; n_params = get_Call_n_params(call); - /* Beware: we cannot clone variadic parameters as well as the + /* TODO + * Beware: we cannot clone variadic parameters as well as the * last non-variadic one, which might be needed for the va_start() * magic */ - mtp = get_Call_type(call); - if (get_method_variadicity(mtp) != variadicity_non_variadic) { - n_params = get_method_first_variadic_param_index(mtp) - 1; - } /* In this for loop we collect the calls, that have an constant parameter. */ - for (i = n_params - 1; i >= 0; --i) { - call_param = get_Call_param(call, i); + for (i = n_params; i > 0;) { + call_param = get_Call_param(call, --i); if (is_Const(call_param)) { /* we have found a Call to collect and we save the informations, which we need.*/ @@ -187,10 +182,10 @@ static void collect_irg_calls(ir_node *call, void *env) if (is_Call(call)) { call_ptr = get_Call_ptr(call); - if (! is_Global(call_ptr)) + if (! is_SymConst_addr_ent(call_ptr)) return; - callee = get_Global_entity(call_ptr); + callee = get_SymConst_entity(call_ptr); /* we don't know which function gets finally bound to a weak symbol */ if (get_entity_linkage(callee) & IR_LINKAGE_WEAK) @@ -213,11 +208,11 @@ static void collect_irg_calls(ir_node *call, void *env) * @param pos The "pos" from our quadruplet. * @param nr A counter for the clones. */ -static ident *get_clone_ident(ident *id, int pos, unsigned nr) +static ident *get_clone_ident(ident *id, size_t pos, size_t nr) { char clone_postfix[32]; - snprintf(clone_postfix, sizeof(clone_postfix), "_cl_%d_%u", pos, nr); + ir_snprintf(clone_postfix, sizeof(clone_postfix), "_cl_%zu_%zu", pos, nr); return id_mangle(id, new_id_from_str(clone_postfix)); } @@ -272,10 +267,11 @@ static void set_preds(ir_node *irn, void *env) irn_copy = (ir_node*)get_irn_link(irn); if (is_Block(irn)) { - for (i = get_Block_n_cfgpreds(irn) - 1; i >= 0; i--) { + ir_graph *const irg = get_Block_irg(irn); + for (i = get_Block_n_cfgpreds(irn) - 1; i >= 0; --i) { pred = get_Block_cfgpred(irn, i); /* "End" block must be handled extra, because it is not matured.*/ - if (get_irg_end_block(current_ir_graph) == irn) + if (get_irg_end_block(irg) == irn) add_immBlock_pred(get_irg_end_block(clone_irg), (ir_node*)get_irn_link(pred)); else set_Block_cfgpred(irn_copy, i, (ir_node*)get_irn_link(pred)); @@ -303,22 +299,21 @@ static void set_preds(ir_node *irn, void *env) * @param irg irg that must be cloned. * @param pos The position of the argument. */ -static ir_node *get_irg_arg(ir_graph *irg, int pos) +static ir_node *get_irg_arg(ir_graph *irg, size_t pos) { ir_node *irg_args = get_irg_args(irg), *arg = NULL; - int i; /* Call algorithm that computes the out edges */ assure_irg_outs(irg); /* Search the argument with the number pos.*/ - for (i = get_irn_n_outs(irg_args) - 1; i >= 0; --i) { + for (unsigned i = get_irn_n_outs(irg_args); i-- > 0; ) { ir_node *proj = get_irn_out(irg_args, i); - if (pos == get_Proj_proj(proj)) { + if ((int)pos == get_Proj_proj(proj)) { if (arg) { /* * More than one arg node found: - * We rely on the fact the only one arg exists, so do + * We rely on the fact that only one arg exists, so do * a cheap CSE in this case. */ set_irn_out(irg_args, i, arg, 0); @@ -338,7 +333,7 @@ static ir_node *get_irg_arg(ir_graph *irg, int pos) * @param ent The entity of the method that must be cloned. * @param q Our quadruplet. */ -static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q) +static void create_clone_proc_irg(ir_entity *ent, const quadruple_t *q) { ir_graph *method_irg, *clone_irg; ir_node *arg, *const_arg; @@ -375,10 +370,10 @@ static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q) * @param ent The entity of the clone. * @param nr A pointer to the counter of clones. **/ -static void change_entity_type(quadruple_t *q, ir_entity *ent) +static void change_entity_type(const quadruple_t *q, ir_entity *ent) { ir_type *mtp, *new_mtp, *tp; - int i, j, n_params, n_ress; + size_t i, j, n_params, n_ress; mtp = get_entity_type(q->ent); n_params = get_method_n_params(mtp); @@ -390,11 +385,11 @@ static void change_entity_type(quadruple_t *q, ir_entity *ent) /* We must set the type of the methods parameters.*/ for (i = j = 0; i < n_params; ++i) { - if (i == q->pos) - /* This is the position of the argument, that we have - replaced. */ - continue; - + if (i == q->pos) { + /* This is the position of the argument, that we have + replaced. */ + continue; + } tp = get_method_param_type(mtp, i); set_method_param_type(new_mtp, j++, tp); } @@ -411,13 +406,12 @@ static void change_entity_type(quadruple_t *q, ir_entity *ent) * * @param q Contains information for the method to clone. */ -static ir_entity *clone_method(quadruple_t *q) +static ir_entity *clone_method(const quadruple_t *q) { ir_entity *new_entity; ident *clone_ident; - symconst_symbol sym; /* A counter for the clones.*/ - static unsigned nr = 0; + static size_t nr = 0; /* We get a new ident for our clone method.*/ clone_ident = get_clone_ident(get_entity_ident(q->ent), q->pos, nr); @@ -436,9 +430,6 @@ static ir_entity *clone_method(quadruple_t *q) /* We need now a new ir_graph for our clone method. */ create_clone_proc_irg(new_entity, q); - /* We must set the atomic value of our "new_entity". */ - sym.entity_p = new_entity; - /* The "new_entity" don't have this information. */ new_entity->attr.mtd_attr.param_access = NULL; new_entity->attr.mtd_attr.param_weight = NULL; @@ -453,10 +444,10 @@ static ir_entity *clone_method(quadruple_t *q) * @param new_entity The entity of the cloned function. * @param pos The position of the replaced parameter of this call. **/ -static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) +static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, size_t pos) { ir_node **in; - int i, n_params, new_params = 0; + size_t i, n_params, new_params = 0; ir_node *callee; symconst_symbol sym; ir_graph *irg = get_irn_irg(call); @@ -470,7 +461,7 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) /* we save the parameters of the new call in the array "in" without the * parameter in position "pos", that is replaced with a constant.*/ - for (i = 0; i < n_params; i++){ + for (i = 0; i < n_params; ++i) { if (pos != i) in[new_params++] = get_Call_param(call, i); } @@ -488,9 +479,9 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) */ static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent) { - int pos = q->pos; + size_t pos = q->pos; ir_node *new_call, *call; - int i; + size_t i; /* We iterate the list of the "call".*/ for (i = 0; i < ARR_LEN(q->calls); ++i) { @@ -522,7 +513,7 @@ static float calculate_weight(const entry_t *entry) static void reorder_weights(q_set *hmap, float threshold) { entry_t **adr, *p, *entry; - int i, len; + size_t i, len; ir_entity *callee; restart: @@ -580,7 +571,6 @@ restart: hmap->heavy_uses = entry->next; entry->next = *adr; *adr = entry; - entry = hmap->heavy_uses; /* we have changed the list, check the next one */ goto restart; @@ -594,18 +584,22 @@ restart: */ void proc_cloning(float threshold) { - entry_t *entry = NULL, *p; - ir_graph *irg; - int i; + entry_t *p; + size_t i, n; q_set hmap; + DEBUG_ONLY(firm_dbg_module_t *dbg;) + + /* register a debug mask */ + FIRM_DBG_REGISTER(dbg, "firm.opt.proc_cloning"); + obstack_init(&hmap.obst); hmap.map = NULL; hmap.heavy_uses = NULL; /* initially fill our map by visiting all irgs */ - for (i = get_irp_n_irgs() - 1; i >= 0; --i) { - irg = get_irp_irg(i); + for (i = 0, n = get_irp_n_irgs(); i < n; ++i) { + ir_graph *irg = get_irp_irg(i); irg_walk_graph(irg, collect_irg_calls, NULL, &hmap); } @@ -617,7 +611,7 @@ void proc_cloning(float threshold) /* We iterate the set and arrange the element of the set in a list. The elements are arranged dependent of their value descending.*/ if (hmap.map) { - foreach_pset(hmap.map, entry_t*, entry) { + foreach_pset(hmap.map, entry_t, entry) { entry->weight = calculate_weight(entry); /* @@ -653,18 +647,22 @@ void proc_cloning(float threshold) hmap.map = NULL; } +#ifdef DEBUG_libfirm /* Print some information about the list. */ - printf("-----------------\n"); - for (entry = hmap.heavy_uses; entry; entry = entry->next) { - printf("\nweight: is %f\n", entry->weight); - ir_printf("Call for Method %E\n", entry->q.ent); - printf("Position %i\n", entry->q.pos); - ir_printf("Value %T\n", entry->q.tv); + DB((dbg, LEVEL_2, "-----------------\n")); + for (entry_t *entry = hmap.heavy_uses; entry; entry = entry->next) { + DB((dbg, LEVEL_2, "\nweight: is %f\n", entry->weight)); + DB((dbg, LEVEL_2, "Call for Method %E\n", entry->q.ent)); + DB((dbg, LEVEL_2, "Position %zu\n", entry->q.pos)); + DB((dbg, LEVEL_2, "Value %T\n", entry->q.tv)); } - - entry = hmap.heavy_uses; +#endif + entry_t *const entry = hmap.heavy_uses; if (entry) { - ir_entity *ent = clone_method(&entry->q); + quadruple_t *qp = &entry->q; + + ir_entity *ent = clone_method(qp); + DB((dbg, LEVEL_1, "Cloned <%+F, %zu, %T> info %+F\n", qp->ent, qp->pos, qp->tv, ent)); hmap.heavy_uses = entry->next;