X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fldstopt.c;h=ce87077cee99c0da417db2cbf5a88973f94542c6;hb=81d44459b367b64abbb26feeb7c2f31738f542c0;hp=3463b60da32487ca51dcbdd3a06a815311ba47d4;hpb=c71681c22466590a76c12aa0fdc805cb837af2a0;p=libfirm diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c index 3463b60da..ce87077ce 100644 --- a/ir/opt/ldstopt.c +++ b/ir/opt/ldstopt.c @@ -23,9 +23,7 @@ * @author Michael Beck * @version $Id$ */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif +#include "config.h" #include @@ -42,13 +40,12 @@ #include "dbginfo_t.h" #include "iropt_dbg.h" #include "irflag_t.h" -#include "array.h" +#include "array_t.h" #include "irhooks.h" #include "iredges.h" #include "irtools.h" #include "opt_polymorphy.h" #include "irmemory.h" -#include "xmalloc.h" #include "irphase_t.h" #include "irgopt.h" #include "debug.h" @@ -856,29 +853,32 @@ static int try_load_after_store(ir_node *load, store_mode = get_irn_mode(get_Store_value(store)); store_mode_len = get_mode_size_bytes(store_mode); delta = load_offset - store_offset; - if (delta < 0 || delta + load_mode_len > store_mode_len) - return 0; + store_value = get_Store_value(store); - if (get_mode_arithmetic(store_mode) != irma_twos_complement || - get_mode_arithmetic(load_mode) != irma_twos_complement) - return 0; + if (delta != 0 || store_mode != load_mode) { + if (delta < 0 || delta + load_mode_len > store_mode_len) + return 0; + + if (get_mode_arithmetic(store_mode) != irma_twos_complement || + get_mode_arithmetic(load_mode) != irma_twos_complement) + return 0; - store_value = get_Store_value(store); - /* produce a shift to adjust offset delta */ - if (delta > 0) { - ir_node *cnst; + /* produce a shift to adjust offset delta */ + if (delta > 0) { + ir_node *cnst; - /* FIXME: only true for little endian */ - cnst = new_Const_long(mode_Iu, delta * 8); - store_value = new_r_Shr(current_ir_graph, get_nodes_block(load), - store_value, cnst, store_mode); - } + /* FIXME: only true for little endian */ + cnst = new_Const_long(mode_Iu, delta * 8); + store_value = new_r_Shr(current_ir_graph, get_nodes_block(load), + store_value, cnst, store_mode); + } - /* add an convert if needed */ - if (store_mode != load_mode) { - store_value = new_r_Conv(current_ir_graph, get_nodes_block(load), - store_value, load_mode); + /* add an convert if needed */ + if (store_mode != load_mode) { + store_value = new_r_Conv(current_ir_graph, get_nodes_block(load), + store_value, load_mode); + } } DBG_OPT_RAW(load, store_value); @@ -1148,54 +1148,48 @@ static unsigned optimize_load(ir_node *load) value = NULL; /* check if we can determine the entity that will be loaded */ ent = find_constant_entity(ptr); - if (ent != NULL) { - if ((allocation_static == get_entity_allocation(ent)) && - (visibility_external_allocated != get_entity_visibility(ent))) { - /* a static allocation that is not external: there should be NO exception - * when loading even if we cannot replace the load itself. */ - - /* no exception, clear the info field as it might be checked later again */ - if (info->projs[pn_Load_X_except]) { - exchange(info->projs[pn_Load_X_except], new_Bad()); - info->projs[pn_Load_X_except] = NULL; - res |= CF_CHANGED; - } - if (info->projs[pn_Load_X_regular]) { - exchange(info->projs[pn_Load_X_regular], new_r_Jmp(current_ir_graph, get_nodes_block(load))); - info->projs[pn_Load_X_regular] = NULL; - res |= CF_CHANGED; - } + if (ent != NULL && + allocation_static == get_entity_allocation(ent) && + visibility_external_allocated != get_entity_visibility(ent)) { + /* a static allocation that is not external: there should be NO exception + * when loading even if we cannot replace the load itself. */ + + /* no exception, clear the info field as it might be checked later again */ + if (info->projs[pn_Load_X_except]) { + exchange(info->projs[pn_Load_X_except], new_Bad()); + info->projs[pn_Load_X_except] = NULL; + res |= CF_CHANGED; + } + if (info->projs[pn_Load_X_regular]) { + exchange(info->projs[pn_Load_X_regular], new_r_Jmp(current_ir_graph, get_nodes_block(load))); + info->projs[pn_Load_X_regular] = NULL; + res |= CF_CHANGED; + } - if (variability_constant == get_entity_variability(ent)) { - if (is_atomic_entity(ent)) { - /* Might not be atomic after - lowering of Sels. In this - case we could also load, but - it's more complicated. */ - /* more simpler case: we load the content of a constant value: - * replace it by the constant itself - */ - value = get_atomic_ent_value(ent); - } else { - if (ent->has_initializer) { - /* new style initializer */ - value = find_compound_ent_value(ptr); - } else { - /* old style initializer */ - compound_graph_path *path = get_accessed_path(ptr); - - if (path != NULL) { - assert(is_proper_compound_graph_path(path, get_compound_graph_path_length(path)-1)); - - value = get_compound_ent_value_by_path(ent, path); - DB((dbg, LEVEL_1, " Constant access at %F%F resulted in %+F\n", ent, path, value)); - free_compound_graph_path(path); - } - } + if (variability_constant == get_entity_variability(ent)) { + if (is_atomic_entity(ent)) { + /* Might not be atomic after lowering of Sels. In this case we + * could also load, but it's more complicated. */ + /* more simpler case: we load the content of a constant value: + * replace it by the constant itself */ + value = get_atomic_ent_value(ent); + } else if (ent->has_initializer) { + /* new style initializer */ + value = find_compound_ent_value(ptr); + } else { + /* old style initializer */ + compound_graph_path *path = get_accessed_path(ptr); + + if (path != NULL) { + assert(is_proper_compound_graph_path(path, get_compound_graph_path_length(path)-1)); + + value = get_compound_ent_value_by_path(ent, path); + DB((dbg, LEVEL_1, " Constant access at %F%F resulted in %+F\n", ent, path, value)); + free_compound_graph_path(path); } - if (value != NULL) - value = can_replace_load_by_const(load, value); } + if (value != NULL) + value = can_replace_load_by_const(load, value); } } } @@ -1250,6 +1244,21 @@ static int is_completely_overwritten(ir_mode *old_mode, ir_mode *new_mode) return get_mode_size_bits(new_mode) >= get_mode_size_bits(old_mode); } /* is_completely_overwritten */ +/** + * Check whether small is a part of large (starting at same address). + */ +static int is_partially_same(ir_node *small, ir_node *large) +{ + ir_mode *sm = get_irn_mode(small); + ir_mode *lm = get_irn_mode(large); + + /* FIXME: Check endianness */ + return is_Conv(small) && get_Conv_op(small) == large + && get_mode_size_bytes(sm) < get_mode_size_bytes(lm) + && get_mode_arithmetic(sm) == irma_twos_complement + && get_mode_arithmetic(lm) == irma_twos_complement; +} /* is_partially_same */ + /** * follow the memory chain as long as there are only Loads and alias free Stores. * @@ -1274,24 +1283,55 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) { * if the pointers are identical, they refer to the same object. * This is only true in strong typed languages, not is C were the following * is possible *(ir_type1 *)p = a; *(ir_type2 *)p = b ... - * However, if the mode that is written have a bigger or equal size the the old - * one, the old value is completely overwritten and can be killed ... + * However, if the size of the mode that is written is bigger or equal the + * size of the old one, the old value is completely overwritten and can be + * killed ... */ if (is_Store(pred) && get_Store_ptr(pred) == ptr && - get_nodes_MacroBlock(pred) == mblk && - is_completely_overwritten(get_irn_mode(get_Store_value(pred)), mode)) { + get_nodes_MacroBlock(pred) == mblk) { /* * a Store after a Store in the same MacroBlock -- a write after write. - * We may remove the first Store, if it does not have an exception handler. + */ + + /* + * We may remove the first Store, if the old value is completely + * overwritten or the old value is a part of the new value, + * and if it does not have an exception handler. * * TODO: What, if both have the same exception handler ??? */ - if (get_Store_volatility(pred) != volatility_is_volatile && !pred_info->projs[pn_Store_X_except]) { - DBG_OPT_WAW(pred, store); - exchange(pred_info->projs[pn_Store_M], get_Store_mem(pred)); - kill_node(pred); - reduce_adr_usage(ptr); - return DF_CHANGED; + if (get_Store_volatility(pred) != volatility_is_volatile + && !pred_info->projs[pn_Store_X_except]) { + ir_node *predvalue = get_Store_value(pred); + ir_mode *predmode = get_irn_mode(predvalue); + + if(is_completely_overwritten(predmode, mode) + || is_partially_same(predvalue, value)) { + DBG_OPT_WAW(pred, store); + exchange(pred_info->projs[pn_Store_M], get_Store_mem(pred)); + kill_node(pred); + reduce_adr_usage(ptr); + return DF_CHANGED; + } + } + + /* + * We may remove the Store, if the old value already contains + * the new value, and if it does not have an exception handler. + * + * TODO: What, if both have the same exception handler ??? + */ + if (get_Store_volatility(store) != volatility_is_volatile + && !info->projs[pn_Store_X_except]) { + ir_node *predvalue = get_Store_value(pred); + + if(is_partially_same(value, predvalue)) { + DBG_OPT_WAW(pred, store); + exchange(info->projs[pn_Store_M], mem); + kill_node(store); + reduce_adr_usage(ptr); + return DF_CHANGED; + } } } else if (is_Load(pred) && get_Load_ptr(pred) == ptr && value == pred_info->projs[pn_Load_res]) { @@ -1587,7 +1627,7 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) } /* fourth step: create the Store */ - store = new_rd_Store(db, current_ir_graph, block, phiM, ptr, phiD); + store = new_rd_Store(db, current_ir_graph, block, phiM, ptr, phiD, 0); #ifdef DO_CACHEOPT co_set_irn_name(store, co_get_irn_ident(old_store)); #endif @@ -1838,7 +1878,7 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) { ir_node *pred = get_Block_cfgpred_block(blk, pos); ir_node *irn, *mem; - pe->load = irn = new_rd_Load(db, current_ir_graph, pred, get_Phi_pred(phi, pos), ptr, load_mode); + pe->load = irn = new_rd_Load(db, current_ir_graph, pred, get_Phi_pred(phi, pos), ptr, load_mode, 0); ninfo = get_ldst_info(irn, phase_obst(&env->ph)); ninfo->projs[pn_Load_M] = mem = new_r_Proj(current_ir_graph, pred, irn, mode_M, pn_Load_M); @@ -2041,7 +2081,7 @@ static void dfs(ir_node *irn, loop_env *env) ir_node *pred = get_irn_n(irn, i); node_entry *o = get_irn_ne(pred, env); - if (irn_not_visited(pred)) { + if (!irn_visited(pred)) { dfs(pred, env); node->low = MIN(node->low, o->low); } @@ -2052,7 +2092,7 @@ static void dfs(ir_node *irn, loop_env *env) ir_node *pred = get_fragile_op_mem(irn); node_entry *o = get_irn_ne(pred, env); - if (irn_not_visited(pred)) { + if (!irn_visited(pred)) { dfs(pred, env); node->low = MIN(node->low, o->low); } @@ -2062,7 +2102,7 @@ static void dfs(ir_node *irn, loop_env *env) ir_node *pred = get_Proj_pred(irn); node_entry *o = get_irn_ne(pred, env); - if (irn_not_visited(pred)) { + if (!irn_visited(pred)) { dfs(pred, env); node->low = MIN(node->low, o->low); } @@ -2128,7 +2168,7 @@ static void do_dfs(ir_graph *irg, loop_env *env) { for (i = get_End_n_keepalives(end) - 1; i >= 0; --i) { ir_node *ka = get_End_keepalive(end, i); - if (is_Phi(ka) && irn_not_visited(ka)) + if (is_Phi(ka) && !irn_visited(ka)) dfs(ka, env); } current_ir_graph = rem; @@ -2171,7 +2211,7 @@ static int optimize_loops(ir_graph *irg) { /* * do the load store optimization */ -void optimize_load_store(ir_graph *irg) { +int optimize_load_store(ir_graph *irg) { walk_env_t env; FIRM_DBG_REGISTER(dbg, "firm.opt.ldstopt"); @@ -2218,4 +2258,5 @@ void optimize_load_store(ir_graph *irg) { have Bad() predecessors. */ set_irg_doms_inconsistent(irg); } + return env.changes != 0; } /* optimize_load_store */