X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fopt_inline.c;h=165cff25955c951818c053f5575575943978ced3;hb=38249b0311df91904bb3a566a770efe650f40efc;hp=6452610c81899ec1ebf43d63c18d5fd2d91e6787;hpb=6be3a86348690a845e539da3954f6792465b4f05;p=libfirm diff --git a/ir/opt/opt_inline.c b/ir/opt/opt_inline.c index 6452610c8..165cff259 100644 --- a/ir/opt/opt_inline.c +++ b/ir/opt/opt_inline.c @@ -23,9 +23,7 @@ * @author Michael Beck, Goetz Lindenmaier * @version $Id$ */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif +#include "config.h" #include #include @@ -41,13 +39,13 @@ #include "irgmod.h" #include "irgwalk.h" -#include "adt/array.h" -#include "adt/list.h" -#include "adt/pset.h" -#include "adt/pmap.h" -#include "adt/pdeq.h" -#include "adt/xmalloc.h" -#include "adt/pqueue.h" +#include "array_t.h" +#include "list.h" +#include "pset.h" +#include "pmap.h" +#include "pdeq.h" +#include "xmalloc.h" +#include "pqueue.h" #include "irouts.h" #include "irloop_t.h" @@ -94,7 +92,7 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg;) * accesses. This function is called for all Phi and Block nodes * in a Block. */ -static INLINE int +static inline int compute_new_arity(ir_node *b) { int i, res, irn_arity; int irg_v, block_v; @@ -472,7 +470,7 @@ void dead_node_elimination(ir_graph *irg) { graveyard_obst = irg->obst; /* A new obstack, where the reachable nodes will be copied to. */ - rebirth_obst = xmalloc(sizeof(*rebirth_obst)); + rebirth_obst = XMALLOC(struct obstack); irg->obst = rebirth_obst; obstack_init(irg->obst); irg->last_node_idx = 0; @@ -663,7 +661,7 @@ static void dead_node_subst_hook(void *context, ir_graph *irg, ir_node *old, ir_ * Make a new Survive DCE environment. */ survive_dce_t *new_survive_dce(void) { - survive_dce_t *res = xmalloc(sizeof(res[0])); + survive_dce_t *res = XMALLOC(survive_dce_t); obstack_init(&res->obst); res->places = pmap_create(); res->new_places = NULL; @@ -676,10 +674,6 @@ survive_dce_t *new_survive_dce(void) { res->dead_node_elim_subst.context = res; res->dead_node_elim_subst.next = NULL; -#ifndef FIRM_ENABLE_HOOKS - assert(0 && "need hooks enabled"); -#endif - register_hook(hook_dead_node_elim, &res->dead_node_elim); register_hook(hook_dead_node_elim_subst, &res->dead_node_elim_subst); return res; @@ -1068,8 +1062,8 @@ int inline_method(ir_node *call, ir_graph *called_graph) { arity = get_Block_n_cfgpreds(end_bl); /* arity = n_exc + n_ret */ n_res = get_method_n_ress(get_Call_type(call)); - res_pred = xmalloc(n_res * sizeof(*res_pred)); - cf_pred = xmalloc(arity * sizeof(*res_pred)); + res_pred = XMALLOCN(ir_node*, n_res); + cf_pred = XMALLOCN(ir_node*, arity); set_irg_current_block(irg, post_bl); /* just to make sure */ @@ -1209,9 +1203,9 @@ int inline_method(ir_node *call, ir_graph *called_graph) { n_exc++; } } - main_end_bl = get_irg_end_block(irg); + main_end_bl = get_irg_end_block(irg); main_end_bl_arity = get_irn_arity(main_end_bl); - end_preds = xmalloc((n_exc + main_end_bl_arity) * sizeof(*end_preds)); + end_preds = XMALLOCN(ir_node*, n_exc + main_end_bl_arity); for (i = 0; i < main_end_bl_arity; ++i) end_preds[i] = get_irn_n(main_end_bl, i); @@ -1460,7 +1454,7 @@ static void collect_calls2(ir_node *call, void *ctx) { * Returns TRUE if the number of callers is 0 in the irg's environment, * hence this irg is a leave. */ -INLINE static int is_leave(ir_graph *irg) { +inline static int is_leave(ir_graph *irg) { inline_irg_env *env = get_irg_link(irg); return env->n_call_nodes == 0; } @@ -1469,7 +1463,7 @@ INLINE static int is_leave(ir_graph *irg) { * Returns TRUE if the number of nodes in the callee is * smaller then size in the irg's environment. */ -INLINE static int is_smaller(ir_graph *callee, unsigned size) { +inline static int is_smaller(ir_graph *callee, unsigned size) { inline_irg_env *env = get_irg_link(callee); return env->n_nodes < size; } @@ -2012,8 +2006,7 @@ static ir_graph **create_irg_list(void) { compute_callgraph(); last_irg = 0; - irgs = xmalloc(n_irgs * sizeof(*irgs)); - memset(irgs, 0, sizeof(n_irgs * sizeof(*irgs))); + irgs = XMALLOCNZ(ir_graph*, n_irgs); callgraph_walk(NULL, callgraph_walker, NULL); assert(n_irgs == last_irg); @@ -2022,8 +2015,7 @@ static ir_graph **create_irg_list(void) { } /** - * Push a call onto the priority list if its - * benefice is big enough. + * Push a call onto the priority list if its benefice is big enough. * * @param pqueue the priority queue of calls * @param call the call entry @@ -2033,24 +2025,16 @@ static ir_graph **create_irg_list(void) { static void maybe_push_call(pqueue_t *pqueue, call_entry *call, int inline_threshold) { - int benefice; ir_graph *callee = call->callee; irg_inline_property prop = get_irg_inline_property(callee); + int benefice = calc_inline_benefice(call, callee); - if (prop & irg_inline_forced) { - /* give them a big benefice, so forced are inline first */ - benefice = 100000 + call->loop_depth; - call->benefice = benefice; - DB((dbg, LEVEL_2, "In %+F Call %+F to %+F is forced\n", - get_irn_irg(call->call), call->call, callee)); - } else { - benefice = calc_inline_benefice(call, callee); - DB((dbg, LEVEL_2, "In %+F Call %+F to %+F has benefice %d\n", - get_irn_irg(call->call), call->call, callee, benefice)); - } + DB((dbg, LEVEL_2, "In %+F Call %+F to %+F has benefice %d\n", + get_irn_irg(call->call), call->call, callee, benefice)); - if (benefice < inline_threshold && !(prop & irg_inline_forced)) + if (prop < irg_inline_forced && benefice < inline_threshold) { return; + } pqueue_put(pqueue, call, benefice); } @@ -2100,13 +2084,12 @@ static void inline_into(ir_graph *irg, unsigned maxsize, ir_graph *callee = curr_call->callee; ir_node *call_node = curr_call->call; inline_irg_env *callee_env = get_irg_link(callee); + irg_inline_property prop = get_irg_inline_property(callee); int loop_depth; const call_entry *centry; pmap_entry *e; - /* we need a hard limit here, else it would be possible to inline - * recursive functions forever. */ - if (env->n_nodes + callee_env->n_nodes > maxsize) { + if ((prop < irg_inline_forced) && env->n_nodes + callee_env->n_nodes > maxsize) { DB((dbg, LEVEL_2, "%+F: too big (%d) + %+F (%d)\n", irg, env->n_nodes, callee, callee_env->n_nodes)); continue; @@ -2284,22 +2267,18 @@ void inline_functions(unsigned maxsize, int inline_threshold) { env = get_irg_link(irg); if (env->got_inline) { /* this irg got calls inlined: optimize it */ - - if (0) { - /* scalar replacement does not work well with Tuple nodes, so optimize them away */ - optimize_graph_df(irg); - + if (get_opt_combo()) { + if (env->local_vars) { + scalar_replacement_opt(irg); + } + combo(irg); + } else { if (env->local_vars) { if (scalar_replacement_opt(irg)) { optimize_graph_df(irg); } } optimize_cf(irg); - } else { - if (env->local_vars) { - scalar_replacement_opt(irg); - } - combo(irg); } } if (env->got_inline || (env->n_callers_orig != env->n_callers)) {