X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fproc_cloning.c;h=023eb8936716a0d09479888d6f3e56058c5c20fa;hb=94e9283b212f0f10b460248de945576a0bb61703;hp=7fc28389ea2959d2930d8d0b70ea9bb760dfed45;hpb=1ec30d95387eb392ba5a1adc7958ebd91383d59c;p=libfirm diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c index 7fc28389e..023eb8936 100644 --- a/ir/opt/proc_cloning.c +++ b/ir/opt/proc_cloning.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -22,7 +22,7 @@ * @brief Procedure cloning. * @author Beyhan Veliev, Michael Beck * @version $Id$ - * @summary + * @brief * * The purpose is first to find and analyze functions, that are called * with constant parameter(s). @@ -31,9 +31,7 @@ * aren't be constant. The constant parameters of the function are placed * in the function graph. They aren't be passed as parameters. */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include @@ -50,11 +48,8 @@ #include "irnode_t.h" #include "irtools.h" #include "irgmod.h" -#include "array.h" -#include "xmalloc.h" - -/* A macro to iterate sets.*/ -#define ITERATE_SET(set_entries, entry) for(entry = set_first(set_entries); entry; entry = set_next(set_entries)) +#include "array_t.h" +#include "irpass_t.h" /** * This struct contains the information quadruple for a Call, which we need to @@ -87,7 +82,8 @@ typedef struct q_set { * * @return zero if they are identically, non-zero else */ -static int entry_cmp(const void *elt, const void *key) { +static int entry_cmp(const void *elt, const void *key) +{ const entry_t *e1 = elt; const entry_t *e2 = key; @@ -99,14 +95,16 @@ 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 int hash_entry(const entry_t *entry) +{ return HASH_PTR(entry->q.ent) ^ HASH_PTR(entry->q.tv) ^ (entry->q.pos * 9); } /** * Free memory associated with a quadruplet. */ -static void kill_entry(entry_t *entry) { +static void kill_entry(entry_t *entry) +{ if (entry->q.calls) { DEL_ARR_F(entry->q.calls); entry->q.calls = NULL; @@ -120,7 +118,8 @@ static void kill_entry(entry_t *entry) { * @param callee The entity of the callee * @param hmap The quadruple-set containing the calls with constant parameters */ -static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) { +static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) +{ ir_type *mtp; entry_t *key, *entry; ir_node *call_param; @@ -147,7 +146,7 @@ static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) { if (! hmap->map) hmap->map = new_pset(entry_cmp, 8); - key = obstack_alloc(&hmap->obst, sizeof(*key)); + key = OALLOC(&hmap->obst, entry_t); key->q.ent = callee; key->q.pos = i; @@ -178,7 +177,8 @@ static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) { * @param call A ir_node to be checked. * @param env The quadruple-set containing the calls with constant parameters */ -static void collect_irg_calls(ir_node *call, void *env) { +static void collect_irg_calls(ir_node *call, void *env) +{ q_set *hmap = env; ir_node *call_ptr; ir_entity *callee; @@ -187,17 +187,17 @@ static void collect_irg_calls(ir_node *call, void *env) { if (is_Call(call)) { call_ptr = get_Call_ptr(call); - /* Call pointer must be a SymConst*/ - if (op_SymConst != get_irn_op(call_ptr)) - return; - /* Call pointer must be the address of an entity.*/ - if (get_SymConst_kind(call_ptr) != symconst_addr_ent) + if (! is_Global(call_ptr)) return; - callee = get_SymConst_entity(call_ptr); + callee = get_Global_entity(call_ptr); + + /* we don't know which function gets finally bound to a weak symbol */ + if (get_entity_linkage(callee) & IR_LINKAGE_WEAK) + return; /* we can only clone calls to existing entities */ - if (get_entity_visibility(callee) == visibility_external_allocated) + if (get_entity_irg(callee) == NULL) return; process_call(call, callee, hmap); @@ -213,12 +213,13 @@ 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, int pos, unsigned nr) +{ char clone_postfix[32]; snprintf(clone_postfix, sizeof(clone_postfix), "_cl_%d_%u", pos, nr); - return mangle(id, new_id_from_str(clone_postfix)); + return id_mangle(id, new_id_from_str(clone_postfix)); } /** @@ -229,7 +230,8 @@ static ident *get_clone_ident(ident *id, int pos, unsigned nr) { * @param irn A node from the original method graph. * @param env The clone graph. */ -static void copy_nodes(ir_node *irn, void *env) { +static void copy_nodes(ir_node *irn, void *env) +{ ir_node *arg, *irg_args, *irn_copy; int proj_nr; ir_graph *clone_irg = env; @@ -256,7 +258,8 @@ static void copy_nodes(ir_node *irn, void *env) { * The copied nodes are set as link of their original nodes. The links of * "irn" predecessors are the predecessors of copied node. */ -static void set_preds(ir_node *irn, void *env) { +static void set_preds(ir_node *irn, void *env) +{ int i; ir_node *irn_copy, *pred, *arg; ir_graph *clone_irg = env; @@ -269,6 +272,7 @@ static void set_preds(ir_node *irn, void *env) { irn_copy = get_irn_link(irn); if (is_Block(irn)) { + set_Block_MacroBlock(irn_copy, get_irn_link(get_Block_MacroBlock(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.*/ @@ -280,7 +284,7 @@ static void set_preds(ir_node *irn, void *env) { } else { /* First we set the block our copy if it is not a block.*/ set_nodes_block(irn_copy, get_irn_link(get_nodes_block(irn))); - if (get_irn_op(irn) == op_End) { + if (is_End(irn)) { /* Handle the keep-alives. This must be done separately, because the End node was NOT copied */ for (i = 0; i < get_End_n_keepalives(irn); ++i) @@ -300,7 +304,8 @@ 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, int pos) +{ ir_node *irg_args = get_irg_args(irg), *arg = NULL; int i; @@ -317,7 +322,7 @@ static ir_node *get_irg_arg(ir_graph *irg, int pos) { * We rely on the fact the only one arg exists, so do * a cheap CSE in this case. */ - set_irn_out(irg_args, i, arg); + set_irn_out(irg_args, i, arg, 0); exchange(proj, arg); } else arg = proj; @@ -334,7 +339,8 @@ 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, quadruple_t *q) +{ ir_graph *method_irg, *clone_irg; ir_node *arg, *const_arg; @@ -346,7 +352,7 @@ static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q) { arg = get_irg_arg(get_entity_irg(q->ent), q->pos); /* we will replace the argument in position "q->pos" by this constant. */ const_arg = new_r_Const_type( - clone_irg, get_nodes_block(arg), get_irn_mode(arg), q->tv, + clone_irg, q->tv, get_method_param_type(get_entity_type(q->ent), q->pos)); /* args copy in the cloned graph will be the const. */ @@ -372,19 +378,18 @@ 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, unsigned *nr) { +static void change_entity_type(quadruple_t *q, ir_entity *ent) +{ ir_type *mtp, *new_mtp, *tp; - ident *tp_name; int i, j, n_params, n_ress; mtp = get_entity_type(q->ent); - tp_name = get_clone_ident(get_type_ident(mtp), q->pos, (*nr)++); n_params = get_method_n_params(mtp); n_ress = get_method_n_ress(mtp); /* Create the new type for our clone. It must have one parameter less then the original.*/ - new_mtp = new_type_method(tp_name, n_params - 1, n_ress); + new_mtp = new_type_method(n_params - 1, n_ress); /* We must set the type of the methods parameters.*/ for (i = j = 0; i < n_params; ++i) { @@ -409,10 +414,10 @@ static void change_entity_type(quadruple_t *q, ir_entity *ent, unsigned *nr) { * * @param q Contains information for the method to clone. */ -static ir_entity *clone_method(quadruple_t *q) { +static ir_entity *clone_method(quadruple_t *q) +{ ir_entity *new_entity; ident *clone_ident; - ir_graph *rem; symconst_symbol sym; /* A counter for the clones.*/ static unsigned nr = 0; @@ -423,23 +428,19 @@ static ir_entity *clone_method(quadruple_t *q) { new_entity = copy_entity_name(q->ent, clone_ident); /* a cloned entity is always local */ - set_entity_visibility(new_entity, visibility_local); + set_entity_visibility(new_entity, ir_visibility_local); /* set a ld name here: Should we mangle this ? */ set_entity_ld_ident(new_entity, get_entity_ident(new_entity)); /* set a new type here. */ - change_entity_type(q, new_entity, &nr); + change_entity_type(q, new_entity); /* 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; - rem = current_ir_graph; - current_ir_graph = get_const_code_irg(); - new_entity->value = new_SymConst(sym, symconst_addr_ent); - current_ir_graph = rem; /* The "new_entity" don't have this information. */ new_entity->attr.mtd_attr.param_access = NULL; @@ -455,7 +456,8 @@ 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, int pos) +{ ir_node **in; ir_type *mtp; int i, n_params, new_params = 0; @@ -465,7 +467,7 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) { ir_node *bl = get_nodes_block(call); sym.entity_p = new_entity; - callee = new_r_SymConst(irg, bl, sym, symconst_addr_ent); + callee = new_r_SymConst(irg, mode_P_code, sym, symconst_addr_ent); mtp = get_entity_type(new_entity); n_params = get_Call_n_params(call); @@ -478,7 +480,7 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) { in[new_params++] = get_Call_param(call, i); } /* Create and return the new Call. */ - return new_r_Call(irg, bl, get_Call_mem(call), + return new_r_Call(bl, get_Call_mem(call), callee, n_params - 1, in, get_entity_type(new_entity)); } @@ -489,7 +491,8 @@ static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) { * @param cloned_ent The entity of the new function that must be called * from the new Call. */ -static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent) { +static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent) +{ int pos = q->pos; ir_node *new_call, *call; int i; @@ -510,9 +513,10 @@ static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent) { * We save one instruction in every caller and param_weight instructions * in the callee. */ -static float calculate_weight(const entry_t *entry) { +static float calculate_weight(const entry_t *entry) +{ return ARR_LEN(entry->q.calls) * - (get_method_param_weight(entry->q.ent, entry->q.pos) + 1); + (float)(get_method_param_weight(entry->q.ent, entry->q.pos) + 1); } /** @@ -520,7 +524,8 @@ static float calculate_weight(const entry_t *entry) { * the next cloned entity may get invalid, so we have to check * them and may even update the list of heavy uses. */ -static void reorder_weights(q_set *hmap, float threshold) { +static void reorder_weights(q_set *hmap, float threshold) +{ entry_t **adr, *p, *entry; int i, len; ir_entity *callee; @@ -539,7 +544,7 @@ restart: /* we know, that a SymConst is here */ ptr = get_Call_ptr(call); - assert(get_irn_op(ptr) == op_SymConst); + assert(is_SymConst(ptr)); callee = get_SymConst_entity(ptr); if (callee != entry->q.ent) { @@ -592,7 +597,8 @@ restart: * call(..., Const, ...). If the weight is bigger than threshold, * clone the entity and fix the calls. */ -void proc_cloning(float threshold) { +void proc_cloning(float threshold) +{ entry_t *entry = NULL, *p; ir_graph *irg; int i; @@ -681,3 +687,30 @@ void proc_cloning(float threshold) { } obstack_free(&hmap.obst, NULL); } + +struct pass_t { + ir_prog_pass_t pass; + float threshold; +}; + +/** + * Wrapper to run proc_cloning() as an ir_prog pass. + */ +static int proc_cloning_wrapper(ir_prog *irp, void *context) +{ + struct pass_t *pass = context; + + (void)irp; + proc_cloning(pass->threshold); + return 0; +} + +/* create a ir_prog pass */ +ir_prog_pass_t *proc_cloning_pass(const char *name, float threshold) +{ + struct pass_t *pass = XMALLOCZ(struct pass_t); + + pass->threshold = threshold; + return def_prog_pass_constructor( + &pass->pass, name ? name : "cloning", proc_cloning_wrapper); +}