X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fescape_ana.c;h=d8d6d6db76cb208c1cc061aa559903cdb1821250;hb=7b1dc982307121e3a7ddf3796bf339b9bdb6ad55;hp=8c53f3742b382747f3e2cb6a7b2038f66abb0887;hpb=629ae37a01e0b2a044025152cde4a7668ad25f6c;p=libfirm diff --git a/ir/opt/escape_ana.c b/ir/opt/escape_ana.c index 8c53f3742..d8d6d6db7 100644 --- a/ir/opt/escape_ana.c +++ b/ir/opt/escape_ana.c @@ -1,3 +1,22 @@ +/* + * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. + * + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. + * + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. + */ + /* * Project: libFIRM * File name: ir/opt/escape_ana.c @@ -7,7 +26,6 @@ * Created: 03.11.2005 * CVS-ID: $Id$ * Copyright: (c) 1999-2005 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ /** @@ -15,11 +33,12 @@ * * A fast and simple Escape analysis. */ - #ifdef HAVE_CONFIG_H # include "config.h" #endif +#include "iroptimize.h" + #include "irgraph_t.h" #include "irnode_t.h" #include "type_t.h" @@ -28,22 +47,22 @@ #include "analyze_irg_args.h" #include "irgmod.h" #include "ircons.h" -#include "escape_ana.h" #include "debug.h" /** * walker environment */ typedef struct _walk_env { - ir_node *found_allocs; /**< list of all found non-escaped allocs */ - ir_node *dead_allocs; /**< list of all found dead alloc */ - unsigned nr_removed; /**< number of removed allocs (placed of frame) */ - unsigned nr_changed; /**< number of changed allocs (allocated on stack now) */ - unsigned nr_deads; /**< number of dead allocs */ + ir_node *found_allocs; /**< list of all found non-escaped allocs */ + ir_node *dead_allocs; /**< list of all found dead alloc */ + check_alloc_entity_func callback; /**< callback that checks a given entity for allocation */ + unsigned nr_removed; /**< number of removed allocs (placed of frame) */ + unsigned nr_changed; /**< number of changed allocs (allocated on stack now) */ + unsigned nr_deads; /**< number of dead allocs */ /* these fields are only used in the global escape analysis */ - ir_graph *irg; /**< the irg for this environment */ - struct _walk_env *next; /**< for linking environments */ + ir_graph *irg; /**< the irg for this environment */ + struct _walk_env *next; /**< for linking environments */ } walk_env_t; @@ -128,7 +147,7 @@ static int can_escape(ir_node *n) { case iro_Call: { /* most complicated case */ ir_node *ptr = get_Call_ptr(succ); - entity *ent; + ir_entity *ent; if (get_irn_op(ptr) == op_SymConst && get_SymConst_kind(ptr) == symconst_addr_ent) { @@ -176,7 +195,9 @@ static int can_escape(ir_node *n) { case iro_Raise: /* Hmm: if we do NOT leave the method, it's local */ - return is_method_leaving_raise(succ); + if (is_method_leaving_raise(succ)) + return 1; + break; case iro_Tuple: { ir_node *proj; @@ -229,7 +250,7 @@ static void find_allocations(ir_node *alloc, void *ctx) ir_node *adr; walk_env_t *env = ctx; - if (get_irn_op(alloc) != op_Alloc) + if (! is_Alloc(alloc)) return; /* we searching only for heap allocations */ @@ -264,13 +285,68 @@ static void find_allocations(ir_node *alloc, void *ctx) } /** - * do the necessary graph transformations + * walker: search for allocation Call nodes and follow the usages + */ +static void find_allocation_calls(ir_node *call, void *ctx) +{ + int i; + ir_node *adr; + ir_entity *ent; + walk_env_t *env = ctx; + + if (! is_Call(call)) + return; + adr = get_Call_ptr(call); + if (! is_SymConst(adr) || get_SymConst_kind(adr) != symconst_addr_ent) + return; + ent = get_SymConst_entity(adr); + if (! env->callback(ent)) + return; + + adr = NULL; + for (i = get_irn_n_outs(call) - 1; i >= 0; --i) { + ir_node *res_proj = get_irn_out(call, i); + + if (get_Proj_proj(res_proj) == pn_Call_T_result) { + for (i = get_irn_n_outs(res_proj) - 1; i >= 0; --i) { + ir_node *proj = get_irn_out(res_proj, i); + + if (get_Proj_proj(proj) == 0) { + /* found first result */ + adr = proj; + break; + } + } + break; + } + } + + if (! adr) { + /* + * bad: no-one wants the result, should NOT happen but + * if it does we could delete it. + */ + set_irn_link(call, env->dead_allocs); + env->dead_allocs = call; + + return; + } + + if (! can_escape(adr)) { + set_irn_link(call, env->found_allocs); + env->found_allocs = call; + } +} + +/** + * Do the necessary graph transformations to transform + * Alloc nodes. */ static void transform_allocs(ir_graph *irg, walk_env_t *env) { - ir_node *alloc, *next, *mem, *sel, *size; - type *ftp, *atp, *tp; - entity *ent; + ir_node *alloc, *next, *mem, *sel, *size, *blk; + ir_type *ftp, *atp, *tp; + ir_entity *ent; char name[128]; unsigned nr = 0; dbg_info *dbg; @@ -282,8 +358,10 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env) DBG((dbgHandle, LEVEL_1, "%+F allocation of %+F unused, deleted.\n", irg, alloc)); mem = get_Alloc_mem(alloc); + blk = get_nodes_block(alloc); turn_into_tuple(alloc, pn_Alloc_max); set_Tuple_pred(alloc, pn_Alloc_M, mem); + set_Tuple_pred(alloc, pn_Alloc_X_regular, new_r_Jmp(irg, blk)); set_Tuple_pred(alloc, pn_Alloc_X_except, new_r_Bad(irg)); ++env->nr_deads; @@ -297,7 +375,7 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env) atp = get_Alloc_type(alloc); tp = NULL; - if (get_irn_op(size) == op_SymConst && get_SymConst_kind(size) == symconst_type_size) { + if (is_SymConst(size) && get_SymConst_kind(size) == symconst_type_size) { /* if the size is a type size and the types matched */ assert(atp == get_SymConst_type(size)); tp = atp; @@ -328,6 +406,7 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env) turn_into_tuple(alloc, pn_Alloc_max); set_Tuple_pred(alloc, pn_Alloc_M, mem); + set_Tuple_pred(alloc, pn_Alloc_X_regular, new_r_Jmp(irg, blk)); set_Tuple_pred(alloc, pn_Alloc_X_except, new_r_Bad(irg)); set_Tuple_pred(alloc, pn_Alloc_res, sel); @@ -356,8 +435,44 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env) } } +/** + * Do the necessary graph transformations to transform + * Call nodes. + */ +static void transform_alloc_calls(ir_graph *irg, walk_env_t *env) +{ + ir_node *call, *next, *mem, *blk; + ir_type *ftp; + + /* kill all dead allocs */ + for (call = env->dead_allocs; call; call = next) { + next = get_irn_link(call); + + DBG((dbgHandle, LEVEL_1, "%+F allocation of %+F unused, deleted.\n", irg, call)); + + mem = get_Call_mem(call); + blk = get_nodes_block(call); + turn_into_tuple(call, pn_Call_max); + set_Tuple_pred(call, pn_Call_M_regular, mem); + set_Tuple_pred(call, pn_Call_X_regular, new_r_Jmp(irg, blk)); + set_Tuple_pred(call, pn_Call_X_except, new_r_Bad(irg)); + set_Tuple_pred(call, pn_Call_T_result, new_r_Bad(irg)); + set_Tuple_pred(call, pn_Call_M_except, mem); + set_Tuple_pred(call, pn_Call_P_value_res_base, new_r_Bad(irg)); + + ++env->nr_deads; + } + + /* convert all non-escaped heap allocs into frame variables */ + ftp = get_irg_frame_type(irg); + for (call = env->found_allocs; call; call = next) { + next = get_irn_link(call); + } +} + + /* Do simple and fast escape analysis for one graph. */ -void escape_enalysis_irg(ir_graph *irg) +void escape_enalysis_irg(ir_graph *irg, check_alloc_entity_func callback) { walk_env_t env; @@ -372,22 +487,30 @@ void escape_enalysis_irg(ir_graph *irg) env.found_allocs = NULL; env.dead_allocs = NULL; + env.callback = callback; env.nr_removed = 0; env.nr_changed = 0; env.nr_deads = 0; - irg_walk_graph(irg, NULL, find_allocations, &env); - - transform_allocs(irg, &env); + if (callback) { + /* search for Calls */ + irg_walk_graph(irg, NULL, find_allocation_calls, &env); + transform_alloc_calls(irg, &env); + } else { + /* search for Alloc nodes */ + irg_walk_graph(irg, NULL, find_allocations, &env); + transform_allocs(irg, &env); + } } /* Do simple and fast escape analysis for all graphs. */ -void escape_analysis(int run_scalar_replace) +void escape_analysis(int run_scalar_replace, check_alloc_entity_func callback) { ir_graph *irg; int i; struct obstack obst; walk_env_t *env, *elist; + (void) run_scalar_replace; if (get_irp_callee_info_state() != irg_callee_info_consistent) { assert(! "need callee info"); @@ -408,14 +531,20 @@ void escape_analysis(int run_scalar_replace) env = obstack_alloc(&obst, sizeof(*env)); env->found_allocs = NULL; env->dead_allocs = NULL; + env->callback = callback; for (i = get_irp_n_irgs() - 1; i >= 0; --i) { irg = get_irp_irg(i); - if (get_irg_outs_state(irg) != outs_consistent) - compute_irg_outs(irg); + assure_irg_outs(irg); - irg_walk_graph(irg, NULL, find_allocations, env); + if (callback) { + /* search for Calls */ + irg_walk_graph(irg, NULL, find_allocation_calls, env); + } else { + /* search for Alloc nodes */ + irg_walk_graph(irg, NULL, find_allocations, env); + } if (env->found_allocs || env->dead_allocs) { env->nr_removed = 0; @@ -428,11 +557,18 @@ void escape_analysis(int run_scalar_replace) env = obstack_alloc(&obst, sizeof(*env)); env->found_allocs = NULL; env->dead_allocs = NULL; + env->callback = callback; } } - for (env = elist; env; env = env->next) { - transform_allocs(env->irg, env); + if (callback) { + for (env = elist; env; env = env->next) { + transform_alloc_calls(env->irg, env); + } + } else { + for (env = elist; env; env = env->next) { + transform_allocs(env->irg, env); + } } obstack_free(&obst, NULL);