X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fldstopt.c;h=d8cd2d3b69578cf645f411909671dc82f50521dc;hb=1a9f131ae86314af2426a62983fcea597233ae01;hp=15964a359d7f71fadb5461172c654f51fe78c706;hpb=e88385016800d3c56c3fa09770e9f7995c42e106;p=libfirm diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c index 15964a359..d8cd2d3b6 100644 --- a/ir/opt/ldstopt.c +++ b/ir/opt/ldstopt.c @@ -48,15 +48,13 @@ #include "irphase_t.h" #include "irgopt.h" #include "set.h" +#include "be.h" #include "debug.h" +#include "opt_manage.h" /** The debug handle. */ DEBUG_ONLY(static firm_dbg_module_t *dbg;) -#ifdef DO_CACHEOPT -#include "cacheopt/cachesim.h" -#endif - #undef IMAX #define IMAX(a,b) ((a) > (b) ? (a) : (b)) @@ -77,7 +75,7 @@ typedef struct walk_env_t { /** A Load/Store info. */ typedef struct ldst_info_t { - ir_node *projs[MAX_PROJ]; /**< list of Proj's of this node */ + ir_node *projs[MAX_PROJ+1]; /**< list of Proj's of this node */ ir_node *exc_block; /**< the exception block if available */ int exc_idx; /**< predecessor index in the exception block */ unsigned visited; /**< visited counter for breaking loops */ @@ -218,7 +216,7 @@ static void collect_nodes(ir_node *node, void *env) if (is_Proj(proj)) { pred = get_Proj_pred(proj); - is_exc = get_Proj_proj(proj) == pn_Generic_X_except; + is_exc = is_x_except_Proj(proj); } /* ignore Bad predecessors, they will be removed later */ @@ -287,9 +285,9 @@ static ir_entity *find_constant_entity(ir_node *ptr) if (tlower == tarval_bad || tupper == tarval_bad) return NULL; - if (tarval_cmp(tv, tlower) & pn_Cmp_Lt) + if (tarval_cmp(tv, tlower) == ir_relation_less) return NULL; - if (tarval_cmp(tupper, tv) & pn_Cmp_Lt) + if (tarval_cmp(tupper, tv) == ir_relation_less) return NULL; /* ok, bounds check finished */ @@ -349,11 +347,11 @@ 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, size_t depth) { compound_graph_path *res = NULL; ir_entity *root, *field, *ent; - int path_len, pos, idx; + size_t path_len, pos, idx; ir_tarval *tv; ir_type *tp; @@ -434,9 +432,9 @@ ptr_arith: if (tlower == tarval_bad || tupper == tarval_bad) return NULL; - if (tarval_cmp(tv_index, tlower) & pn_Cmp_Lt) + if (tarval_cmp(tv_index, tlower) == ir_relation_less) return NULL; - if (tarval_cmp(tupper, tv_index) & pn_Cmp_Lt) + if (tarval_cmp(tupper, tv_index) == ir_relation_less) return NULL; /* ok, bounds check finished */ @@ -508,7 +506,7 @@ static compound_graph_path *get_accessed_path(ir_node *ptr) typedef struct path_entry { ir_entity *ent; struct path_entry *next; - long index; + size_t index; } path_entry; static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) @@ -518,7 +516,7 @@ static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) ir_initializer_t *initializer; ir_tarval *tv; ir_type *tp; - unsigned n; + size_t n; entry.next = next; if (is_SymConst(ptr)) { @@ -541,7 +539,7 @@ static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) continue; } } - if (p->index >= (int) n) + if (p->index >= n) return NULL; initializer = get_initializer_compound_value(initializer, p->index); @@ -574,7 +572,7 @@ static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) assert(get_Sel_n_indexs(ptr) == 1 && "multi dim arrays not implemented"); entry.index = get_Sel_array_index_long(ptr, 0) - get_array_lower_bound_int(tp, 0); } else { - int i, n_members = get_compound_n_members(tp); + size_t i, n_members = get_compound_n_members(tp); for (i = 0; i < n_members; ++i) { if (get_compound_member(tp, i) == field) break; @@ -660,9 +658,9 @@ ptr_arith: if (tlower == tarval_bad || tupper == tarval_bad) return NULL; - if (tarval_cmp(tv_index, tlower) & pn_Cmp_Lt) + if (tarval_cmp(tv_index, tlower) == ir_relation_less) return NULL; - if (tarval_cmp(tupper, tv_index) & pn_Cmp_Lt) + if (tarval_cmp(tupper, tv_index) == ir_relation_less) return NULL; /* ok, bounds check finished */ @@ -749,20 +747,29 @@ static void reduce_adr_usage(ir_node *ptr) */ static int can_use_stored_value(ir_mode *old_mode, ir_mode *new_mode) { + unsigned old_size; + unsigned new_size; if (old_mode == new_mode) - return 1; + return true; + + old_size = get_mode_size_bits(old_mode); + new_size = get_mode_size_bits(new_mode); /* if both modes are two-complement ones, we can always convert the - Stored value into the needed one. */ - if (get_mode_size_bits(old_mode) >= get_mode_size_bits(new_mode) && + Stored value into the needed one. (on big endian machines we currently + only support this for modes of same size) */ + if (old_size >= new_size && get_mode_arithmetic(old_mode) == irma_twos_complement && - get_mode_arithmetic(new_mode) == irma_twos_complement) - return 1; - return 0; -} /* can_use_stored_value */ + get_mode_arithmetic(new_mode) == irma_twos_complement && + (!be_get_backend_param()->byte_order_big_endian + || old_size == new_size)) { + return true; + } + return false; +} /** - * Check whether a Call is at least pure, ie. does only read memory. + * Check whether a Call is at least pure, i.e. does only read memory. */ static unsigned is_Call_pure(ir_node *call) { @@ -870,7 +877,10 @@ static int try_load_after_store(ir_node *load, store_value = get_Store_value(store); if (delta != 0 || store_mode != load_mode) { - if (delta < 0 || delta + load_mode_len > store_mode_len) + /* TODO: implement for big-endian */ + if (delta < 0 || delta + load_mode_len > store_mode_len + || (be_get_backend_param()->byte_order_big_endian + && load_mode_len != store_mode_len)) return 0; if (get_mode_arithmetic(store_mode) != irma_twos_complement || @@ -883,7 +893,6 @@ static int try_load_after_store(ir_node *load, ir_node *cnst; ir_graph *irg = get_irn_irg(load); - /* FIXME: only true for little endian */ cnst = new_r_Const_long(irg, mode_Iu, delta * 8); store_value = new_r_Shr(get_nodes_block(load), store_value, cnst, store_mode); @@ -905,7 +914,7 @@ static int try_load_after_store(ir_node *load, /* no exception */ if (info->projs[pn_Load_X_except]) { ir_graph *irg = get_irn_irg(load); - exchange( info->projs[pn_Load_X_except], new_r_Bad(irg)); + exchange( info->projs[pn_Load_X_except], new_r_Bad(irg, mode_X)); res |= CF_CHANGED; } if (info->projs[pn_Load_X_regular]) { @@ -979,6 +988,9 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) * Here, there is no need to check if the previous Load has an * exception hander because they would have exact the same * exception... + * + * TODO: implement load-after-load with different mode for big + * endian */ if (info->projs[pn_Load_X_except] == NULL || get_nodes_block(load) == get_nodes_block(pred)) { @@ -1008,7 +1020,7 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) /* no exception */ if (info->projs[pn_Load_X_except]) { ir_graph *irg = get_irn_irg(load); - exchange(info->projs[pn_Load_X_except], new_r_Bad(irg)); + exchange(info->projs[pn_Load_X_except], new_r_Bad(irg, mode_X)); res |= CF_CHANGED; } if (info->projs[pn_Load_X_regular]) { @@ -1085,8 +1097,9 @@ ir_node *can_replace_load_by_const(const ir_node *load, ir_node *c) if (is_reinterpret_cast(c_mode, l_mode)) { /* copy the value from the const code irg and cast it */ res = new_rd_Conv(dbgi, block, res, l_mode); + } else { + return NULL; } - return NULL; } return res; } @@ -1145,7 +1158,7 @@ static unsigned optimize_load(ir_node *load) /* no exception, clear the info field as it might be checked later again */ if (info->projs[pn_Load_X_except]) { ir_graph *irg = get_irn_irg(load); - exchange(info->projs[pn_Load_X_except], new_r_Bad(irg)); + exchange(info->projs[pn_Load_X_except], new_r_Bad(irg, mode_X)); info->projs[pn_Load_X_except] = NULL; res |= CF_CHANGED; } @@ -1156,7 +1169,7 @@ static unsigned optimize_load(ir_node *load) } if (get_entity_linkage(ent) & IR_LINKAGE_CONSTANT) { - if (ent->initializer != NULL) { + if (has_entity_initializer(ent)) { /* new style initializer */ value = find_compound_ent_value(ptr); } else if (entity_has_compound_ent_values(ent)) { @@ -1171,8 +1184,20 @@ static unsigned optimize_load(ir_node *load) free_compound_graph_path(path); } } - if (value != NULL) + if (value != NULL) { + ir_graph *irg = get_irn_irg(load); value = can_replace_load_by_const(load, value); + if (value != NULL && is_Sel(ptr) && + !is_irg_state(irg, IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING)) { + /* frontend has inserted masking operations after bitfield accesses, + * so we might have to shift the const. */ + unsigned char bit_offset = get_entity_offset_bits_remainder(get_Sel_entity(ptr)); + ir_tarval *tv_old = get_Const_tarval(value); + ir_tarval *tv_offset = new_tarval_from_long(bit_offset, mode_Bu); + ir_tarval *tv_new = tarval_shl(tv_old, tv_offset); + value = new_r_Const(irg, tv_new); + } + } } } } @@ -1180,7 +1205,7 @@ static unsigned optimize_load(ir_node *load) /* we completely replace the load by this value */ if (info->projs[pn_Load_X_except]) { ir_graph *irg = get_irn_irg(load); - exchange(info->projs[pn_Load_X_except], new_r_Bad(irg)); + exchange(info->projs[pn_Load_X_except], new_r_Bad(irg, mode_X)); info->projs[pn_Load_X_except] = NULL; res |= CF_CHANGED; } @@ -1469,7 +1494,10 @@ static unsigned optimize_store(ir_node *store) static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) { int i, n; - ir_node *store, *old_store, *ptr, *block, *phi_block, *phiM, *phiD, *exc, *projM; + ir_node *store, *ptr, *block, *phi_block, *phiM, *phiD, *exc, *projM; +#ifdef DO_CACHEOPT + ir_node *old_store; +#endif ir_mode *mode; ir_node **inM, **inD, **projMs; int *idx; @@ -1492,16 +1520,14 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) return 0; store = skip_Proj(projM); +#ifdef DO_CACHEOPT old_store = store; +#endif if (!is_Store(store)) return 0; block = get_nodes_block(store); - /* abort on dead blocks */ - if (is_Block_dead(block)) - return 0; - /* check if the block is post dominated by Phi-block and has no exception exit */ bl_info = (block_info_t*)get_irn_link(block); @@ -1537,10 +1563,7 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) if (exc != info->exc_block) return 0; - /* abort on dead blocks */ block = get_nodes_block(pred); - if (is_Block_dead(block)) - return 0; /* check if the block is post dominated by Phi-block and has no exception exit. Note that block must be different from @@ -1669,7 +1692,7 @@ static void do_load_store_optimize(ir_node *n, void *env) break; default: - ; + break; } } /* do_load_store_optimize */ @@ -1810,7 +1833,6 @@ static unsigned hash_cache_entry(const avail_entry_t *entry) 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; @@ -1866,7 +1888,6 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) /* for now, we can only move Load(Global) */ if (! is_Global(ptr)) continue; - 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); @@ -1915,7 +1936,12 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) ninfo = get_ldst_info(irn, phase_obst(&env->ph)); ninfo->projs[pn_Load_M] = mem = new_r_Proj(irn, mode_M, pn_Load_M); - set_Phi_pred(phi, pos, mem); + if (res == NULL) { + /* irn is from cache, so do not set phi pred again. + * There might be other Loads between phi and irn already. + */ + set_Phi_pred(phi, pos, mem); + } ninfo->projs[pn_Load_res] = new_r_Proj(irn, load_mode, pn_Load_res); } @@ -2184,13 +2210,15 @@ static void do_dfs(ir_graph *irg, loop_env *env) ir_node *pred = get_Block_cfgpred(endblk, i); pred = skip_Proj(pred); - if (is_Return(pred)) + if (is_Return(pred)) { dfs(get_Return_mem(pred), env); - else if (is_Raise(pred)) + } else if (is_Raise(pred)) { dfs(get_Raise_mem(pred), env); - else if (is_fragile_op(pred)) + } else if (is_fragile_op(pred)) { dfs(get_fragile_op_mem(pred), env); - else { + } else if (is_Bad(pred)) { + /* ignore non-optimized block predecessor */ + } else { assert(0 && "Unknown EndBlock predecessor"); } } @@ -2233,9 +2261,10 @@ static int optimize_loops(ir_graph *irg) /* * do the load store optimization */ -int optimize_load_store(ir_graph *irg) +static ir_graph_state_t do_loadstore_opt(ir_graph *irg) { walk_env_t env; + ir_graph_state_t res = 0; FIRM_DBG_REGISTER(dbg, "firm.opt.ldstopt"); @@ -2243,16 +2272,7 @@ int optimize_load_store(ir_graph *irg) assert(get_irg_pinned(irg) != op_pin_state_floats && "LoadStore optimization needs pinned graph"); - /* we need landing pads */ - remove_critical_cf_edges(irg); - - edges_assure(irg); - - /* for Phi optimization post-dominators are needed ... */ - assure_postdoms(irg); - if (get_opt_alias_analysis()) { - assure_irg_entity_usage_computed(irg); assure_irp_globals_entity_usage_computed(); } @@ -2272,17 +2292,31 @@ int optimize_load_store(ir_graph *irg) /* Handle graph state */ if (env.changes) { - set_irg_outs_inconsistent(irg); set_irg_entity_usage_state(irg, ir_entity_usage_not_computed); + edges_deactivate(irg); } if (env.changes & CF_CHANGED) { - /* is this really needed: Yes, control flow changed, block might - have Bad() predecessors. */ + /* control flow changed, block might have Bad() predecessors. */ set_irg_doms_inconsistent(irg); + } else { + res |= IR_GRAPH_STATE_CONSISTENT_DOMINANCE | IR_GRAPH_STATE_NO_BAD_BLOCKS; } - return env.changes != 0; -} /* optimize_load_store */ + + return res; +} + +optdesc_t opt_loadstore = { + "load-store", + IR_GRAPH_STATE_NO_UNREACHABLE_BLOCKS | IR_GRAPH_STATE_CONSISTENT_OUT_EDGES | IR_GRAPH_STATE_NO_CRITICAL_EDGES | IR_GRAPH_STATE_CONSISTENT_DOMINANCE | IR_GRAPH_STATE_CONSISTENT_ENTITY_USAGE, + do_loadstore_opt, +}; + +int optimize_load_store(ir_graph *irg) +{ + perform_irg_optimization(irg, &opt_loadstore); + return 1; +} ir_graph_pass_t *optimize_load_store_pass(const char *name) {