X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Ffunccall.c;h=7992636b69afae242190e502deaab7625f60f6f9;hb=2a8124bbe0acbc7398d8fc1998c80afa39e77213;hp=7cd066fecb8544cae8ee38da174c8175fe96c4c3;hpb=a999e1baedb84dc9b83059708699dac1c7fdb9a2;p=libfirm diff --git a/ir/opt/funccall.c b/ir/opt/funccall.c index 7cd066fec..7992636b6 100644 --- a/ir/opt/funccall.c +++ b/ir/opt/funccall.c @@ -39,6 +39,8 @@ #include "dbginfo_t.h" #include "irflag_t.h" #include "ircons.h" +#include "iredges_t.h" +#include "analyze_irg_args.h" #include "irhooks.h" #include "debug.h" @@ -88,8 +90,8 @@ static void collect_const_and_pure_calls(ir_node *node, void *env) { /* set the link to NULL for all non-const/pure calls */ set_irn_link(call, NULL); ptr = get_Call_ptr(call); - if (is_SymConst_addr_ent(ptr)) { - ent = get_SymConst_entity(ptr); + if (is_Global(ptr)) { + ent = get_Global_entity(ptr); prop = get_entity_additional_properties(ent); if ((prop & (mtp_property_const|mtp_property_pure)) == 0) @@ -169,8 +171,8 @@ static void fix_const_call_list(ir_graph *irg, ir_node *call_list, ir_node *proj current_ir_graph = irg; - /* First step: fix all calls by removing it's memory input. - It's original memory input is preserved in their link fields. */ + /* First step: fix all calls by removing their memory input. + * The original memory input is preserved in their link fields. */ for (call = call_list; call; call = next) { next = get_irn_link(call); mem = get_Call_mem(call); @@ -179,7 +181,7 @@ static void fix_const_call_list(ir_graph *irg, ir_node *call_list, ir_node *proj set_Call_mem(call, get_irg_no_mem(irg)); /* - * Sorrily we cannot simply set the node to 'float'. + * Unfortunately we cannot simply set the node to 'float'. * There is a reason for that: * * - The call might be inside a loop/if that is NOT entered @@ -205,7 +207,7 @@ static void fix_const_call_list(ir_graph *irg, ir_node *call_list, ir_node *proj mem = get_irn_link(call); /* beware of calls in the pure call list */ - if (! mem || get_irn_op(mem) == op_Call) + if (!mem || is_Call(mem)) continue; assert(get_irn_mode(mem) == mode_M); @@ -259,8 +261,8 @@ static void collect_nothrow_calls(ir_node *node, void *env) { /* set the link to NULL for all non-const/pure calls */ set_irn_link(call, NULL); ptr = get_Call_ptr(call); - if (is_SymConst_addr_ent(ptr)) { - ent = get_SymConst_entity(ptr); + if (is_Global(ptr)) { + ent = get_Global_entity(ptr); prop = get_entity_additional_properties(ent); if ((prop & mtp_property_nothrow) == 0) @@ -461,8 +463,7 @@ static unsigned _follow_mem(ir_node *node) { case iro_Call: /* A call is only tolerable if its either constant or pure. */ ptr = get_Call_ptr(node); - if (get_irn_op(ptr) == op_SymConst && - get_SymConst_kind(ptr) == symconst_addr_ent) { + if (is_SymConst(ptr) && get_SymConst_kind(ptr) == symconst_addr_ent) { ir_entity *ent = get_SymConst_entity(ptr); ir_graph *irg = get_entity_irg(ent); @@ -575,12 +576,17 @@ static unsigned check_const_or_pure_function(ir_graph *irg, int top) { if (prop != mtp_no_property) { /* check, if a keep-alive exists */ for (j = get_End_n_keepalives(end) - 1; j >= 0; --j) { - ir_node *mem = get_End_keepalive(end, j); + ir_node *kept = get_End_keepalive(end, j); - if (mode_M != get_irn_mode(mem)) + if (is_Block(kept)) { + prop = mtp_no_property; + break; + } + + if (mode_M != get_irn_mode(kept)) continue; - prop = max_property(prop, follow_mem(mem, prop)); + prop = max_property(prop, follow_mem(kept, prop)); if (prop == mtp_no_property) break; } @@ -675,8 +681,8 @@ static int is_malloc_call_result(const ir_node *node) { if (is_alloc_entity != NULL && is_Call(node)) { ir_node *ptr = get_Call_ptr(node); - if (is_SymConst_addr_ent(ptr)) { - ir_entity *ent = get_SymConst_entity(ptr); + if (is_Global(ptr)) { + ir_entity *ent = get_Global_entity(ptr); return is_alloc_entity(ent); } } @@ -692,6 +698,94 @@ static unsigned update_property(unsigned orig_prop, unsigned call_prop) { return r | t; } /** update_property */ +/** + * Check if a node is stored. + */ +static int is_stored(const ir_node *n) { + const ir_edge_t *edge; + const ir_node *ptr; + + foreach_out_edge(n, edge) { + const ir_node *succ = get_edge_src_irn(edge); + + switch (get_irn_opcode(succ)) { + case iro_Return: + case iro_Load: + case iro_Cmp: + /* ok */ + break; + case iro_Store: + if (get_Store_value(succ) == n) + return 1; + /* ok if its only the address input */ + break; + case iro_Sel: + case iro_Cast: + case iro_Confirm: + if (is_stored(succ)) + return 1; + break; + case iro_Call: + ptr = get_Call_ptr(succ); + if (is_Global(ptr)) { + ir_entity *ent = get_Global_entity(ptr); + int i; + + /* we know the called entity */ + for (i = get_Call_n_params(succ) - 1; i >= 0; --i) { + if (get_Call_param(succ, i) == n) { + /* n is the i'th param of the call */ + if (get_method_param_access(ent, i) & ptr_access_store) { + /* n is store in ent */ + return 1; + } + } + } + } else { + /* unknown call address */ + return 1; + } + break; + default: + /* bad, potential alias */ + return 1; + } + } + return 0; +} /* is_stored */ + +/** + * Check that the return value of an irg is not stored anywhere. + * + * return ~mtp_property_malloc if return values are stored, ~0 else + */ +static unsigned check_stored_result(ir_graph *irg) { + ir_node *end_blk = get_irg_end_block(irg); + int i, j; + unsigned res = ~0; + int old_edges = edges_assure_kind(irg, EDGE_KIND_NORMAL); + + for (i = get_Block_n_cfgpreds(end_blk) - 1; i >= 0; --i) { + ir_node *pred = get_Block_cfgpred(end_blk, i); + + if (! is_Return(pred)) + continue; + for (j = get_Return_n_ress(pred) - 1; j >= 0; --j) { + const ir_node *irn = get_Return_res(pred, j); + + if (is_stored(irn)) { + /* bad, might create an alias */ + res = ~mtp_property_malloc; + goto finish; + } + } + } +finish: + if (! old_edges) + edges_deactivate_kind(irg, EDGE_KIND_NORMAL); + return res; +} /* check_stored_result */ + /** * Check if a graph represents a nothrow or a malloc function. * @@ -699,9 +793,11 @@ static unsigned update_property(unsigned orig_prop, unsigned call_prop) { * @param top if set, this is the top call */ static unsigned check_nothrow_or_malloc(ir_graph *irg, int top) { - ir_node *end_blk = get_irg_end_block(irg); - int i, j; - unsigned curr_prop = mtp_property_malloc | mtp_property_nothrow; + ir_node *end_blk = get_irg_end_block(irg); + ir_entity *ent; + ir_type *mtp; + int i, j; + unsigned curr_prop = mtp_property_malloc | mtp_property_nothrow; if (IS_IRG_READY(irg)) { /* already checked */ @@ -714,6 +810,12 @@ static unsigned check_nothrow_or_malloc(ir_graph *irg, int top) { } SET_IRG_BUSY(irg); + ent = get_irg_entity(irg); + mtp = get_entity_type(ent); + + if (get_method_n_ress(mtp) <= 0) + curr_prop &= ~mtp_property_malloc; + for (i = get_Block_n_cfgpreds(end_blk) - 1; i >= 0; --i) { ir_node *pred = get_Block_cfgpred(end_blk, i); @@ -721,16 +823,21 @@ static unsigned check_nothrow_or_malloc(ir_graph *irg, int top) { if (curr_prop & mtp_property_malloc) { /* check, if malloc is called here */ for (j = get_Return_n_ress(pred) - 1; j >= 0; --j) { - const ir_node *res = get_Return_res(pred, j); - //const ir_node *irn = skip_Proj_const(res); + ir_node *res = get_Return_res(pred, j); + + /* skip Confirms and Casts */ + res = skip_HighLevel_ops(res); + /* skip Proj's */ + while (is_Proj(res)) + res = get_Proj_pred(res); if (is_malloc_call_result(res)) { /* ok, this is a malloc */ } else if (is_Call(res)) { ir_node *ptr = get_Call_ptr(res); - if (is_SymConst_addr_ent(ptr)) { + if (is_Global(ptr)) { /* a direct call */ - ir_entity *ent = get_SymConst_entity(ptr); + ir_entity *ent = get_Global_entity(ptr); ir_graph *callee = get_entity_irg(ent); if (callee == irg) { @@ -771,6 +878,9 @@ static unsigned check_nothrow_or_malloc(ir_graph *irg, int top) { /* unknown call */ curr_prop &= ~mtp_property_malloc; } + } else { + /* unknown return value */ + curr_prop &= ~mtp_property_malloc; } } } @@ -781,18 +891,20 @@ static unsigned check_nothrow_or_malloc(ir_graph *irg, int top) { if (is_Call(pred)) { ir_node *ptr = get_Call_ptr(pred); - if (is_SymConst_addr_ent(ptr)) { + if (is_Global(ptr)) { /* a direct call */ - ir_entity *ent = get_SymConst_entity(ptr); + ir_entity *ent = get_Global_entity(ptr); ir_graph *callee = get_entity_irg(ent); if (callee == irg) { /* A self-recursive call. The property did not depend on this call. */ } else if (callee != NULL) { - unsigned prop = check_nothrow_or_malloc(callee, /*top=*/0); + /* Note: we check here for nothrow only, so do NOT reset the malloc property */ + unsigned prop = check_nothrow_or_malloc(callee, /*top=*/0) | mtp_property_malloc; curr_prop = update_property(curr_prop, prop); } else { - curr_prop = update_property(curr_prop, get_entity_additional_properties(ent)); + if ((get_entity_additional_properties(ent) & mtp_property_nothrow) == 0) + curr_prop &= ~mtp_property_nothrow; } } else if (get_opt_closed_world() && is_Sel(ptr) && @@ -834,6 +946,17 @@ static unsigned check_nothrow_or_malloc(ir_graph *irg, int top) { break; } } + + if (curr_prop & mtp_property_malloc) { + /* + * Note that the malloc property means not only return newly allocated + * memory, but also that this memory is ALIAS FREE. + * To ensure that, we do NOT allow that the returned memory is somewhere + * stored. + */ + curr_prop &= check_stored_result(irg); + } + if (curr_prop != mtp_no_property) { if (top || (curr_prop & mtp_temporary) == 0) { /* We use the temporary flag here to mark an optimistic result. @@ -852,7 +975,7 @@ static unsigned check_nothrow_or_malloc(ir_graph *irg, int top) { /* * optimize function calls by handling const functions */ -void optimize_funccalls(int force_run) +void optimize_funccalls(int force_run, check_alloc_entity_func callback) { int i, last_idx; unsigned num_const = 0; @@ -860,6 +983,8 @@ void optimize_funccalls(int force_run) unsigned num_nothrow = 0; unsigned num_malloc = 0; + is_alloc_entity = callback; + /* prepare: mark all graphs as not analyzed */ last_idx = get_irp_last_idx(); ready_set = rbitset_malloc(last_idx);