X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fldstopt.c;h=ac7137e26a52f93095466f9407069dc674b46b72;hb=32ea6ea0320f551448bb66e534e3351977464d42;hp=39ce34c98dada2515d0286fb168a38ae8491becc;hpb=ab00cc504101ea199f9cd73118141f7806dde875;p=libfirm diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c index 39ce34c98..ac7137e26 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,15 +40,15 @@ #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 "irpass.h" #include "opt_polymorphy.h" #include "irmemory.h" -#include "xmalloc.h" #include "irphase_t.h" #include "irgopt.h" +#include "set.h" #include "debug.h" /** The debug handle. */ @@ -111,12 +109,12 @@ static unsigned master_visited = 0; /** * get the Load/Store info of a node */ -static ldst_info_t *get_ldst_info(ir_node *node, struct obstack *obst) { +static ldst_info_t *get_ldst_info(ir_node *node, struct obstack *obst) +{ ldst_info_t *info = get_irn_link(node); if (! info) { - info = obstack_alloc(obst, sizeof(*info)); - memset(info, 0, sizeof(*info)); + info = OALLOCZ(obst, ldst_info_t); set_irn_link(node, info); } return info; @@ -125,12 +123,12 @@ static ldst_info_t *get_ldst_info(ir_node *node, struct obstack *obst) { /** * get the Block info of a node */ -static block_info_t *get_block_info(ir_node *node, struct obstack *obst) { +static block_info_t *get_block_info(ir_node *node, struct obstack *obst) +{ block_info_t *info = get_irn_link(node); if (! info) { - info = obstack_alloc(obst, sizeof(*info)); - memset(info, 0, sizeof(*info)); + info = OALLOCZ(obst, block_info_t); set_irn_link(node, info); } return info; @@ -257,10 +255,7 @@ static ir_entity *find_constant_entity(ir_node *ptr) { for (;;) { if (is_SymConst(ptr) && get_SymConst_kind(ptr) == symconst_addr_ent) { - ir_entity *ent = get_SymConst_entity(ptr); - if (variability_constant == get_entity_variability(ent)) - return ent; - return NULL; + return get_SymConst_entity(ptr); } else if (is_Sel(ptr)) { ir_entity *ent = get_Sel_entity(ptr); ir_type *tp = get_entity_owner(ent); @@ -302,7 +297,7 @@ static ir_entity *find_constant_entity(ir_node *ptr) } } - if (variability_constant == get_entity_variability(ent)) + if (get_entity_linkage(ent) & IR_LINKAGE_CONSTANT) return ent; /* try next */ @@ -340,7 +335,8 @@ static ir_entity *find_constant_entity(ir_node *ptr) /** * Return the Selection index of a Sel node from dimension n */ -static long get_Sel_array_index_long(ir_node *n, int dim) { +static long get_Sel_array_index_long(ir_node *n, int dim) +{ ir_node *index = get_Sel_index(n, dim); assert(is_Const(index)); return get_tarval_long(get_Const_tarval(index)); @@ -354,7 +350,8 @@ static long get_Sel_array_index_long(ir_node *n, int dim) { * @param depth current depth in steps upward from the root * of the address */ -static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) { +static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) +{ compound_graph_path *res = NULL; ir_entity *root, *field, *ent; int path_len, pos, idx; @@ -364,7 +361,7 @@ static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) { if (is_SymConst(ptr)) { /* a SymConst. If the depth is 0, this is an access to a global * entity and we don't need a component path, else we know - * at least it's length. + * at least its length. */ assert(get_SymConst_kind(ptr) == symconst_addr_ent); root = get_SymConst_entity(ptr); @@ -386,11 +383,12 @@ static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) { set_compound_graph_path_array_index(res, pos, get_Sel_array_index_long(ptr, 0)); } } else if (is_Add(ptr)) { - ir_node *l = get_Add_left(ptr); - ir_node *r = get_Add_right(ptr); - ir_mode *mode; + ir_node *l = get_Add_left(ptr); + ir_node *r = get_Add_right(ptr); + ir_mode *mode = get_irn_mode(ptr); + tarval *tmp; - if (is_Const(r)) { + if (is_Const(r) && get_irn_mode(l) == mode) { ptr = l; tv = get_Const_tarval(r); } else { @@ -399,6 +397,7 @@ static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) { } ptr_arith: mode = get_tarval_mode(tv); + tmp = tv; /* ptr must be a Sel or a SymConst, this was checked in find_constant_entity() */ if (is_Sel(ptr)) { @@ -419,10 +418,10 @@ ptr_arith: size = get_type_size_bytes(get_entity_type(ent)); sz = new_tarval_from_long(size, mode); - tv_index = tarval_div(tv, sz); - tv = tarval_mod(tv, sz); + tv_index = tarval_div(tmp, sz); + tmp = tarval_mod(tmp, sz); - if (tv_index == tarval_bad || tv == tarval_bad) + if (tv_index == tarval_bad || tmp == tarval_bad) return NULL; assert(get_array_n_dimensions(tp) == 1 && "multiarrays not implemented"); @@ -442,7 +441,7 @@ ptr_arith: /* ok, bounds check finished */ ++idx; } - if (! tarval_is_null(tv)) { + if (! tarval_is_null(tmp)) { /* access to some struct/union member */ return NULL; } @@ -499,8 +498,10 @@ ptr_arith: * Returns an access path or NULL. The access path is only * valid, if the graph is in phase_high and _no_ address computation is used. */ -static compound_graph_path *get_accessed_path(ir_node *ptr) { - return rec_get_accessed_path(ptr, 0); +static compound_graph_path *get_accessed_path(ir_node *ptr) +{ + compound_graph_path *gr = rec_get_accessed_path(ptr, 0); + return gr; } /* get_accessed_path */ typedef struct path_entry { @@ -509,7 +510,8 @@ typedef struct path_entry { long index; } path_entry; -static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) { +static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) +{ path_entry entry, *p; ir_entity *ent, *field; ir_initializer_t *initializer; @@ -683,7 +685,8 @@ ptr_arith: return NULL; } -static ir_node *find_compound_ent_value(ir_node *ptr) { +static ir_node *find_compound_ent_value(ir_node *ptr) +{ return rec_find_compound_ent_value(ptr, NULL); } @@ -691,9 +694,10 @@ static ir_node *find_compound_ent_value(ir_node *ptr) { static void reduce_adr_usage(ir_node *ptr); /** - * Update a Load that may lost it's usage. + * Update a Load that may have lost its users. */ -static void handle_load_update(ir_node *load) { +static void handle_load_update(ir_node *load) +{ ldst_info_t *info = get_irn_link(load); /* do NOT touch volatile loads for now */ @@ -704,20 +708,21 @@ static void handle_load_update(ir_node *load) { ir_node *ptr = get_Load_ptr(load); ir_node *mem = get_Load_mem(load); - /* a Load which value is neither used nor exception checked, remove it */ + /* a Load whose value is neither used nor exception checked, remove it */ exchange(info->projs[pn_Load_M], mem); if (info->projs[pn_Load_X_regular]) - exchange(info->projs[pn_Load_X_regular], new_r_Jmp(current_ir_graph, get_nodes_block(load))); + exchange(info->projs[pn_Load_X_regular], new_r_Jmp(get_nodes_block(load))); kill_node(load); reduce_adr_usage(ptr); } } /* handle_load_update */ /** - * A Use of an address node is vanished. Check if this was a Proj + * A use of an address node has vanished. Check if this was a Proj * node and update the counters. */ -static void reduce_adr_usage(ir_node *ptr) { +static void reduce_adr_usage(ir_node *ptr) +{ if (is_Proj(ptr)) { if (get_irn_n_edges(ptr) <= 0) { /* this Proj is dead now */ @@ -727,7 +732,7 @@ static void reduce_adr_usage(ir_node *ptr) { ldst_info_t *info = get_irn_link(pred); info->projs[get_Proj_proj(ptr)] = NULL; - /* this node lost it's result proj, handle that */ + /* this node lost its result proj, handle that */ handle_load_update(pred); } } @@ -738,7 +743,8 @@ static void reduce_adr_usage(ir_node *ptr) { * Check, if an already existing value of mode old_mode can be converted * into the needed one new_mode without loss. */ -static int can_use_stored_value(ir_mode *old_mode, ir_mode *new_mode) { +static int can_use_stored_value(ir_mode *old_mode, ir_mode *new_mode) +{ if (old_mode == new_mode) return 1; @@ -754,7 +760,8 @@ static int can_use_stored_value(ir_mode *old_mode, ir_mode *new_mode) { /** * Check whether a Call is at least pure, ie. does only read memory. */ -static unsigned is_Call_pure(ir_node *call) { +static unsigned is_Call_pure(ir_node *call) +{ ir_type *call_tp = get_Call_type(call); unsigned prop = get_method_additional_properties(call_tp); @@ -856,29 +863,31 @@ 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; - 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; - /* 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); - } + /* produce a shift to adjust offset delta */ + if (delta > 0) { + ir_node *cnst; - /* 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); + /* FIXME: only true for little endian */ + cnst = new_Const_long(mode_Iu, delta * 8); + store_value = new_r_Shr(get_nodes_block(load), + store_value, cnst, store_mode); + } + + /* add an convert if needed */ + if (store_mode != load_mode) { + store_value = new_r_Conv(get_nodes_block(load), store_value, load_mode); + } } DBG_OPT_RAW(load, store_value); @@ -894,7 +903,7 @@ static int try_load_after_store(ir_node *load, 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))); + exchange( info->projs[pn_Load_X_regular], new_r_Jmp(get_nodes_block(load))); res |= CF_CHANGED; } @@ -917,7 +926,8 @@ static int try_load_after_store(ir_node *load, * * INC_MASTER() must be called before dive into */ -static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) { +static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) +{ unsigned res = 0; ldst_info_t *info = get_irn_link(load); ir_node *pred; @@ -971,13 +981,13 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) { if (info->projs[pn_Load_res]) { if (pred_info->projs[pn_Load_res] == NULL) { /* create a new Proj again */ - pred_info->projs[pn_Load_res] = new_r_Proj(current_ir_graph, get_nodes_block(pred), pred, get_Load_mode(pred), pn_Load_res); + pred_info->projs[pn_Load_res] = new_r_Proj(get_nodes_block(pred), pred, get_Load_mode(pred), pn_Load_res); } value = pred_info->projs[pn_Load_res]; /* add an convert if needed */ if (get_Load_mode(pred) != load_mode) { - value = new_r_Conv(current_ir_graph, get_nodes_block(load), value, load_mode); + value = new_r_Conv(get_nodes_block(load), value, load_mode); } exchange(info->projs[pn_Load_res], value); @@ -992,7 +1002,7 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) { 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))); + exchange( info->projs[pn_Load_X_regular], new_r_Jmp(get_nodes_block(load))); res |= CF_CHANGED; } @@ -1053,7 +1063,8 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) { * Check if we can replace the load by a given const from * the const code irg. */ -ir_node *can_replace_load_by_const(const ir_node *load, ir_node *c) { +ir_node *can_replace_load_by_const(const ir_node *load, ir_node *c) +{ ir_mode *c_mode = get_irn_mode(c); ir_mode *l_mode = get_Load_mode(load); ir_node *res = NULL; @@ -1067,7 +1078,7 @@ ir_node *can_replace_load_by_const(const ir_node *load, ir_node *c) { /* copy the value from the const code irg and cast it */ res = copy_const_value(dbg, c); - res = new_rd_Conv(dbg, current_ir_graph, block, res, l_mode); + res = new_rd_Conv(dbg, block, res, l_mode); } } else { /* copy the value from the const code irg */ @@ -1118,14 +1129,14 @@ static unsigned optimize_load(ir_node *load) */ exchange(info->projs[pn_Load_X_except], new_Bad()); info->projs[pn_Load_X_except] = NULL; - exchange(info->projs[pn_Load_X_regular], new_r_Jmp(current_ir_graph, get_nodes_block(load))); + exchange(info->projs[pn_Load_X_regular], new_r_Jmp(get_nodes_block(load))); info->projs[pn_Load_X_regular] = NULL; res |= CF_CHANGED; } } /* The mem of the Load. Must still be returned after optimization. */ - mem = get_Load_mem(load); + mem = get_Load_mem(load); if (! info->projs[pn_Load_res] && ! info->projs[pn_Load_X_except]) { /* a Load which value is neither used nor exception checked, remove it */ @@ -1133,7 +1144,7 @@ static unsigned optimize_load(ir_node *load) if (info->projs[pn_Load_X_regular]) { /* should not happen, but if it does, remove it */ - exchange(info->projs[pn_Load_X_regular], new_r_Jmp(current_ir_graph, get_nodes_block(load))); + exchange(info->projs[pn_Load_X_regular], new_r_Jmp(get_nodes_block(load))); res |= CF_CHANGED; } kill_node(load); @@ -1148,53 +1159,42 @@ 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. */ + if (ent != NULL + && get_entity_visibility(ent) != ir_visibility_external) { + /* 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; - } + /* 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(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); - free_compound_graph_path(path); - } - } + if (get_entity_linkage(ent) & IR_LINKAGE_CONSTANT) { + if (ent->initializer != NULL) { + /* new style initializer */ + value = find_compound_ent_value(ptr); + } else if (entity_has_compound_ent_values(ent)) { + /* 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); } } } @@ -1206,7 +1206,7 @@ static unsigned optimize_load(ir_node *load) 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))); + exchange(info->projs[pn_Load_X_regular], new_r_Jmp(get_nodes_block(load))); info->projs[pn_Load_X_regular] = NULL; res |= CF_CHANGED; } @@ -1249,12 +1249,28 @@ 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. * * INC_MASTER() must be called before dive into */ -static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) { +static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) +{ unsigned res = 0; ldst_info_t *info = get_irn_link(store); ir_node *pred; @@ -1273,24 +1289,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]) { @@ -1386,7 +1433,8 @@ static ir_entity *find_entity(ir_node *ptr) * * @param store the Store node */ -static unsigned optimize_store(ir_node *store) { +static unsigned optimize_store(ir_node *store) +{ ir_node *ptr; ir_node *mem; ir_entity *entity; @@ -1401,6 +1449,7 @@ static unsigned optimize_store(ir_node *store) { if (entity != NULL && !(get_entity_usage(entity) & ir_usage_read)) { ldst_info_t *info = get_irn_link(store); if (info->projs[pn_Store_X_except] == NULL) { + DB((dbg, LEVEL_1, " Killing useless %+F to never read entity %+F\n", store, entity)); exchange(info->projs[pn_Store_M], get_Store_mem(store)); kill_node(store); reduce_adr_usage(ptr); @@ -1569,10 +1618,10 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) block = get_nodes_block(phi); /* second step: create a new memory Phi */ - phiM = new_rd_Phi(get_irn_dbg_info(phi), current_ir_graph, block, n, inM, mode_M); + phiM = new_rd_Phi(get_irn_dbg_info(phi), block, n, inM, mode_M); /* third step: create a new data Phi */ - phiD = new_rd_Phi(get_irn_dbg_info(phi), current_ir_graph, block, n, inD, mode); + phiD = new_rd_Phi(get_irn_dbg_info(phi), block, n, inD, mode); /* rewire memory and kill the node */ for (i = n - 1; i >= 0; --i) { @@ -1586,19 +1635,19 @@ 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, block, phiM, ptr, phiD, 0); #ifdef DO_CACHEOPT co_set_irn_name(store, co_get_irn_ident(old_store)); #endif - projM = new_rd_Proj(NULL, current_ir_graph, block, store, mode_M, pn_Store_M); + projM = new_rd_Proj(NULL, block, store, mode_M, pn_Store_M); info = get_ldst_info(store, &wenv->obst); info->projs[pn_Store_M] = projM; /* fifths step: repair exception flow */ if (exc) { - ir_node *projX = new_rd_Proj(NULL, current_ir_graph, block, store, mode_X, pn_Store_X_except); + ir_node *projX = new_rd_Proj(NULL, block, store, mode_X, pn_Store_X_except); info->projs[pn_Store_X_except] = projX; info->exc_block = exc; @@ -1624,7 +1673,8 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) /** * walker, do the optimizations */ -static void do_load_store_optimize(ir_node *n, void *env) { +static void do_load_store_optimize(ir_node *n, void *env) +{ walk_env_t *wenv = env; switch (get_irn_opcode(n)) { @@ -1655,7 +1705,6 @@ typedef struct scc { typedef struct node_entry { unsigned DFSnum; /**< the DFS number of this node */ unsigned low; /**< the low number of this node */ - ir_node *header; /**< the header of this node */ int in_stack; /**< flag, set if the node is on the stack */ ir_node *next; /**< link to the next node the the same scc */ scc *pscc; /**< the scc of this node */ @@ -1676,7 +1725,8 @@ typedef struct loop_env { /** * Gets the node_entry of a node */ -static node_entry *get_irn_ne(ir_node *irn, loop_env *env) { +static node_entry *get_irn_ne(ir_node *irn, loop_env *env) +{ ir_phase *ph = &env->ph; node_entry *e = phase_get_irn_data(&env->ph, irn); @@ -1694,7 +1744,8 @@ static node_entry *get_irn_ne(ir_node *irn, loop_env *env) { * @param env the loop environment * @param n the node to push */ -static void push(loop_env *env, ir_node *n) { +static void push(loop_env *env, ir_node *n) +{ node_entry *e; if (env->tos == ARR_LEN(env->stack)) { @@ -1713,7 +1764,8 @@ static void push(loop_env *env, ir_node *n) { * * @return The topmost node */ -static ir_node *pop(loop_env *env) { +static ir_node *pop(loop_env *env) +{ ir_node *n = env->stack[--env->tos]; node_entry *e = get_irn_ne(n, env); @@ -1728,7 +1780,8 @@ static ir_node *pop(loop_env *env) { * @param irn the node to check * @param header_block the header block of the induction variable */ -static int is_rc(ir_node *irn, ir_node *header_block) { +static int is_rc(ir_node *irn, ir_node *header_block) +{ ir_node *block = get_nodes_block(irn); return (block != header_block) && block_dominates(block, header_block); @@ -1742,17 +1795,50 @@ struct phi_entry { phi_entry *next; }; +/** + * An entry in the avail set. + */ +typedef struct avail_entry_t { + ir_node *ptr; /**< the address pointer */ + ir_mode *mode; /**< the load mode */ + ir_node *load; /**< the associated Load */ +} avail_entry_t; + +/** + * Compare two avail entries. + */ +static int cmp_avail_entry(const void *elt, const void *key, size_t size) +{ + const avail_entry_t *a = elt; + const avail_entry_t *b = key; + (void) size; + + return a->ptr != b->ptr || a->mode != b->mode; +} /* cmp_avail_entry */ + +/** + * Calculate the hash value of an avail entry. + */ +static unsigned hash_cache_entry(const avail_entry_t *entry) +{ + return get_irn_idx(entry->ptr) * 9 + HASH_PTR(entry->mode); +} /* hash_cache_entry */ + /** * Move loops out of loops if possible. * * @param pscc the loop described by an SCC * @param env the loop environment */ -static void move_loads_out_of_loops(scc *pscc, loop_env *env) { +static void move_loads_out_of_loops(scc *pscc, loop_env *env) +{ ir_node *phi, *load, *next, *other, *next_other; ir_entity *ent; int j; phi_entry *phi_list = NULL; + set *avail; + + avail = new_set(cmp_avail_entry, 8); /* collect all outer memories */ for (phi = pscc->head; phi != NULL; phi = next) { @@ -1763,7 +1849,7 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) { if (! is_Phi(phi)) continue; - assert(get_irn_mode(phi) == mode_M && "DFS geturn non-memory Phi"); + assert(get_irn_mode(phi) == mode_M && "DFS return non-memory Phi"); for (j = get_irn_arity(phi) - 1; j >= 0; --j) { ir_node *pred = get_irn_n(phi, j); @@ -1783,6 +1869,10 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) { /* no Phis no fun */ assert(phi_list != NULL && "DFS found a loop without Phi"); + /* for now, we cannot handle more than one input (only reducible cf) */ + if (phi_list->next != NULL) + return; + for (load = pscc->head; load; load = next) { ir_mode *load_mode; node_entry *ne = get_irn_ne(load, env); @@ -1796,10 +1886,10 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) { if (info->projs[pn_Load_res] == NULL || info->projs[pn_Load_X_regular] != NULL || info->projs[pn_Load_X_except] != NULL) continue; - /* for now, we can only handle Load(Global) */ + /* for now, we can only move Load(Global) */ if (! is_Global(ptr)) continue; - ent = get_Global_entity(ptr); + ent = get_Global_entity(ptr); load_mode = get_Load_mode(load); for (other = pscc->head; other != NULL; other = next_other) { node_entry *ne = get_irn_ne(other, env); @@ -1815,17 +1905,13 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) { if (rel != ir_no_alias) break; } - /* only pure Calls are allowed here, so ignore them */ + /* only Phis and pure Calls are allowed here, so ignore them */ } if (other == NULL) { ldst_info_t *ninfo; phi_entry *pe; dbg_info *db; - /* for now, we cannot handle more than one input */ - if (phi_list->next != NULL) - return; - /* yep, no aliasing Store found, Load can be moved */ DB((dbg, LEVEL_1, " Found a Load that could be moved: %+F\n", load)); @@ -1836,16 +1922,26 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) { ir_node *blk = get_nodes_block(phi); ir_node *pred = get_Block_cfgpred_block(blk, pos); ir_node *irn, *mem; + avail_entry_t entry, *res; - pe->load = irn = new_rd_Load(db, current_ir_graph, pred, get_Phi_pred(phi, pos), ptr, load_mode); + entry.ptr = ptr; + entry.mode = load_mode; + res = set_find(avail, &entry, sizeof(entry), hash_cache_entry(&entry)); + if (res != NULL) { + irn = res->load; + } else { + irn = new_rd_Load(db, pred, get_Phi_pred(phi, pos), ptr, load_mode, 0); + entry.load = irn; + set_insert(avail, &entry, sizeof(entry), hash_cache_entry(&entry)); + DB((dbg, LEVEL_1, " Created %+F in %+F\n", irn, pred)); + } + pe->load = irn; 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); + ninfo->projs[pn_Load_M] = mem = new_r_Proj(pred, irn, mode_M, pn_Load_M); set_Phi_pred(phi, pos, mem); - ninfo->projs[pn_Load_res] = new_r_Proj(current_ir_graph, pred, irn, load_mode, pn_Load_res); - - DB((dbg, LEVEL_1, " Created %+F in %+F\n", irn, pred)); + ninfo->projs[pn_Load_res] = new_r_Proj(pred, irn, load_mode, pn_Load_res); } /* now kill the old Load */ @@ -1856,6 +1952,7 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) { } } } + del_set(avail); } /* move_loads_out_of_loops */ /** @@ -1864,7 +1961,8 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) { * @param pscc the SCC * @param env the loop environment */ -static void process_loop(scc *pscc, loop_env *env) { +static void process_loop(scc *pscc, loop_env *env) +{ ir_node *irn, *next, *header = NULL; node_entry *b, *h = NULL; int j, only_phi, num_outside, process = 0; @@ -1878,13 +1976,12 @@ static void process_loop(scc *pscc, loop_env *env) { next = e->next; b = get_irn_ne(block, env); - if (header) { + if (header != NULL) { if (h->POnum < b->POnum) { header = block; h = b; } - } - else { + } else { header = block; h = b; } @@ -1939,10 +2036,12 @@ static void process_loop(scc *pscc, loop_env *env) { /* not a memory loop */ goto fail; } - if (! out_rc) { + if (out_rc == NULL) { + /* first region constant */ out_rc = pred; ++num_outside; } else if (out_rc != pred) { + /* another region constant */ ++num_outside; } } @@ -1962,22 +2061,20 @@ static void process_loop(scc *pscc, loop_env *env) { for (irn = pscc->head; irn; irn = next) { node_entry *e = get_irn_ne(irn, env); next = e->next; - e->header = NULL; exchange(irn, out_rc); } env->changes |= DF_CHANGED; return; } - /* set the header for every node in this scc */ +#ifdef DEBUG_libfirm for (irn = pscc->head; irn; irn = next) { node_entry *e = get_irn_ne(irn, env); - e->header = header; next = e->next; DB((dbg, LEVEL_2, " %+F,", irn)); } DB((dbg, LEVEL_2, "\n")); - +#endif move_loads_out_of_loops(pscc, env); fail: @@ -1990,7 +2087,8 @@ fail: * @param pscc the SCC * @param env the loop environment */ -static void process_scc(scc *pscc, loop_env *env) { +static void process_scc(scc *pscc, loop_env *env) +{ ir_node *head = pscc->head; node_entry *e = get_irn_ne(head, env); @@ -2040,7 +2138,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); } @@ -2051,7 +2149,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); } @@ -2061,7 +2159,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); } @@ -2097,7 +2195,8 @@ static void dfs(ir_node *irn, loop_env *env) * @param irg the graph to process * @param env the loop environment */ -static void do_dfs(ir_graph *irg, loop_env *env) { +static void do_dfs(ir_graph *irg, loop_env *env) +{ ir_graph *rem = current_ir_graph; ir_node *endblk, *end; int i; @@ -2127,7 +2226,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; @@ -2136,7 +2235,8 @@ static void do_dfs(ir_graph *irg, loop_env *env) { /** * Initialize new phase data. We do this always explicit, so return NULL here */ -static void *init_loop_data(ir_phase *ph, const ir_node *irn, void *data) { +static void *init_loop_data(ir_phase *ph, const ir_node *irn, void *data) +{ (void)ph; (void)irn; (void)data; @@ -2148,7 +2248,8 @@ static void *init_loop_data(ir_phase *ph, const ir_node *irn, void *data) { * * @param irg the graph */ -static int optimize_loops(ir_graph *irg) { +static int optimize_loops(ir_graph *irg) +{ loop_env env; env.stack = NEW_ARR_F(ir_node *, 128); @@ -2170,7 +2271,8 @@ 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"); @@ -2217,4 +2319,10 @@ void optimize_load_store(ir_graph *irg) { have Bad() predecessors. */ set_irg_doms_inconsistent(irg); } + return env.changes != 0; } /* optimize_load_store */ + +ir_graph_pass_t *optimize_load_store_pass(const char *name) +{ + return def_graph_pass_ret(name ? name : "ldst", optimize_load_store); +} /* optimize_load_store_pass */