X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Flower%2Flower_calls.c;h=990957907153bafd8bd899f3c15e50f36b859669;hb=1b4cac3471b02b63e9656cd8c876f067766fe482;hp=7e6c6de299eb11b455075f64e0054e3546410087;hpb=cdcd17c48e951c6e0201c58b94aaf52a8769703c;p=libfirm diff --git a/ir/lower/lower_calls.c b/ir/lower/lower_calls.c index 7e6c6de29..990957907 100644 --- a/ir/lower/lower_calls.c +++ b/ir/lower/lower_calls.c @@ -47,7 +47,7 @@ static pmap *lowered_mtps; /** * Default implementation for finding a pointer type for a given element type. - * Simple create a new one. + * Simply create a new one. */ static ir_type *get_pointer_type(ir_type *dest_type) { @@ -228,7 +228,6 @@ typedef struct wlk_env_t { size_t arg_shift; /**< The Argument index shift for parameters. */ struct obstack obst; /**< An obstack to allocate the data on. */ cl_entry *cl_list; /**< The call list. */ - pmap *dummy_map; /**< A map for finding the dummy arguments. */ compound_call_lowering_flags flags; ir_type *lowered_mtp; /**< The lowered method type of the current irg if any. */ bool only_local_mem:1;/**< Set if only local memory access was found. */ @@ -494,32 +493,22 @@ static void do_copy_return_opt(ir_node *n, void *ctx) /** * Return a Sel node that selects a dummy argument of type tp. - * Dummy arguments are only needed once and we use a map - * to store them. - * We could even assign all dummy arguments the same offset - * in the frame type ... * * @param irg the graph * @param block the block where a newly create Sel should be placed * @param tp the type of the dummy entity that should be create - * @param env the environment */ -static ir_node *get_dummy_sel(ir_graph *irg, ir_node *block, ir_type *tp, - wlk_env *env) +static ir_node *get_dummy_sel(ir_graph *irg, ir_node *block, ir_type *tp) { - /* use a map the check if we already create such an entity */ - ir_entity *ent = pmap_get(ir_entity, env->dummy_map, tp); - if (ent == NULL) { - ir_type *ft = get_irg_frame_type(irg); - ident *dummy_id = id_unique("dummy.%u"); - ent = new_entity(ft, dummy_id, tp); - pmap_insert(env->dummy_map, tp, ent); - - if (get_type_state(ft) == layout_fixed) { - /* Fix the layout again */ - panic("Fixed layout not implemented"); - } + ir_type *ft = get_irg_frame_type(irg); + ident *dummy_id = id_unique("dummy.%u"); + ir_entity *ent = new_entity(ft, dummy_id, tp); + + if (get_type_state(ft) == layout_fixed) { + /* Fix the layout again */ + panic("Fixed layout not implemented"); } + return new_r_simpleSel(block, get_irg_no_mem(irg), get_irg_frame(irg), ent); } @@ -527,8 +516,7 @@ static ir_node *get_dummy_sel(ir_graph *irg, ir_node *block, ir_type *tp, * Add the hidden parameter from the CopyB node to the Call node. */ static void add_hidden_param(ir_graph *irg, size_t n_com, ir_node **ins, - cl_entry *entry, wlk_env *env, - ir_type *ctp) + cl_entry *entry, ir_type *ctp) { ir_node *p, *n; size_t n_args; @@ -567,21 +555,21 @@ static void add_hidden_param(ir_graph *irg, size_t n_com, ir_node **ins, /* now create dummy entities for function with ignored return value */ if (n_args < n_com) { - size_t i; - size_t j; + size_t i; + size_t j; for (j = i = 0; i < get_method_n_ress(ctp); ++i) { ir_type *rtp = get_method_res_type(ctp, i); if (is_compound_type(rtp)) { if (ins[j] == NULL) - ins[j] = get_dummy_sel(irg, get_nodes_block(entry->call), rtp, env); + ins[j] = get_dummy_sel(irg, get_nodes_block(entry->call), rtp); ++j; } } } } -static void fix_compound_ret(wlk_env *env, cl_entry *entry, ir_type *ctp) +static void fix_compound_ret(cl_entry *entry, ir_type *ctp) { ir_node *call = entry->call; ir_graph *irg = get_irn_irg(call); @@ -602,7 +590,7 @@ static void fix_compound_ret(wlk_env *env, cl_entry *entry, ir_type *ctp) new_in[pos++] = get_Call_mem(call); new_in[pos++] = get_Call_ptr(call); assert(pos == n_Call_max+1); - add_hidden_param(irg, n_com, &new_in[pos], entry, env, ctp); + add_hidden_param(irg, n_com, &new_in[pos], entry, ctp); pos += n_com; /* copy all other parameters */ @@ -614,7 +602,7 @@ static void fix_compound_ret(wlk_env *env, cl_entry *entry, ir_type *ctp) set_irn_in(call, pos, new_in); } -static ir_entity *create_compound_arg_entitiy(ir_graph *irg, ir_type *type) +static ir_entity *create_compound_arg_entity(ir_graph *irg, ir_type *type) { ir_type *frame = get_irg_frame_type(irg); ident *id = id_unique("$compound_param.%u"); @@ -647,7 +635,7 @@ static void fix_compound_params(cl_entry *entry, ir_type *ctp) continue; arg = get_Call_param(call, i); - arg_entity = create_compound_arg_entitiy(irg, type); + arg_entity = create_compound_arg_entity(irg, type); block = get_nodes_block(call); sel = new_rd_simpleSel(dbgi, block, nomem, frame, arg_entity); copyb = new_rd_CopyB(dbgi, block, mem, sel, arg, type); @@ -670,7 +658,7 @@ static void fix_calls(wlk_env *env) fix_compound_params(entry, ctp); } if (entry->has_compound_ret) { - fix_compound_ret(env, entry, ctp); + fix_compound_ret(entry, ctp); } } } @@ -689,7 +677,6 @@ static void transform_irg(compound_call_lowering_flags flags, ir_graph *irg) ir_type *mtp = get_entity_type(ent); size_t n_ress = get_method_n_ress(mtp); size_t n_params = get_method_n_params(mtp); - size_t n_ret_com = 0; size_t n_param_com = 0; ir_type *lowered_mtp, *tp, *ft; @@ -700,7 +687,8 @@ static void transform_irg(compound_call_lowering_flags flags, ir_graph *irg) wlk_env env; /* calculate the number of compound returns */ - for (n_ret_com = i = 0; i < n_ress; ++i) { + size_t n_ret_com = 0; + for (i = 0; i < n_ress; ++i) { ir_type *type = get_method_res_type(mtp, i); if (is_compound_type(type)) ++n_ret_com; @@ -731,7 +719,6 @@ static void transform_irg(compound_call_lowering_flags flags, ir_graph *irg) } obstack_init(&env.obst); env.cl_list = NULL; - env.dummy_map = pmap_create_ex(8); env.flags = flags; env.lowered_mtp = lowered_mtp; env.only_local_mem = true; @@ -846,7 +833,6 @@ static void transform_irg(compound_call_lowering_flags flags, ir_graph *irg) } } - pmap_destroy(env.dummy_map); obstack_free(&env.obst, NULL); }