X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fldstopt.c;h=156293dee344ee9a638a5a31fedbcc577fc3d7fb;hb=eb7ac83b870791219e7a50cc262f2f1ee9c01b39;hp=b77737039a3142f19b4fe7e5a479b0a812db8d6b;hpb=ca21c59ea00ff05918de26952e91ac39f1589e01;p=libfirm diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c index b77737039..156293dee 100644 --- a/ir/opt/ldstopt.c +++ b/ir/opt/ldstopt.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -35,7 +35,6 @@ #include "ircons_t.h" #include "irgmod.h" #include "irgwalk.h" -#include "irvrfy.h" #include "tv_t.h" #include "dbginfo_t.h" #include "iropt_dbg.h" @@ -49,19 +48,16 @@ #include "irphase_t.h" #include "irgopt.h" #include "set.h" +#include "be.h" #include "debug.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)) +#define IMAX(a,b) ((a) > (b) ? (a) : (b)) -#define MAX_PROJ IMAX(IMAX(pn_Load_max, pn_Store_max), pn_Call_max) +#define MAX_PROJ IMAX(IMAX((long)pn_Load_max, (long)pn_Store_max), (long)pn_Call_max) enum changes_t { DF_CHANGED = 1, /**< data flow changed */ @@ -71,14 +67,14 @@ enum changes_t { /** * walker environment */ -typedef struct _walk_env_t { +typedef struct walk_env_t { struct obstack obst; /**< list of all stores */ unsigned changes; /**< a bitmask of graph changes */ } walk_env_t; /** A Load/Store info. */ -typedef struct _ldst_info_t { - ir_node *projs[MAX_PROJ]; /**< list of Proj's of this node */ +typedef struct ldst_info_t { + 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 */ @@ -95,7 +91,7 @@ enum block_flags_t { /** * a Block info. */ -typedef struct _block_info_t { +typedef struct block_info_t { unsigned flags; /**< flags for the block */ } block_info_t; @@ -111,7 +107,7 @@ static unsigned master_visited = 0; */ static ldst_info_t *get_ldst_info(ir_node *node, struct obstack *obst) { - ldst_info_t *info = get_irn_link(node); + ldst_info_t *info = (ldst_info_t*)get_irn_link(node); if (! info) { info = OALLOCZ(obst, ldst_info_t); @@ -125,7 +121,7 @@ static ldst_info_t *get_ldst_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); + block_info_t *info = (block_info_t*)get_irn_link(node); if (! info) { info = OALLOCZ(obst, block_info_t); @@ -180,10 +176,10 @@ static unsigned update_exc(ldst_info_t *info, ir_node *block, int pos) */ static void collect_nodes(ir_node *node, void *env) { - ir_opcode opcode = get_irn_opcode(node); + walk_env_t *wenv = (walk_env_t *)env; + unsigned opcode = get_irn_opcode(node); ir_node *pred, *blk, *pred_blk; ldst_info_t *ldst_info; - walk_env_t *wenv = env; if (opcode == iro_Proj) { pred = get_Proj_pred(node); @@ -219,7 +215,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 */ @@ -271,10 +267,10 @@ static ir_entity *find_constant_entity(ir_node *ptr) int i, n; for (i = 0, n = get_Sel_n_indexs(ptr); i < n; ++i) { - ir_node *bound; - tarval *tlower, *tupper; - ir_node *index = get_Sel_index(ptr, i); - tarval *tv = computed_value(index); + ir_node *bound; + ir_tarval *tlower, *tupper; + ir_node *index = get_Sel_index(ptr, i); + ir_tarval *tv = computed_value(index); /* check if the index is constant */ if (tv == tarval_bad) @@ -288,9 +284,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 */ @@ -320,7 +316,7 @@ static ir_entity *find_constant_entity(ir_node *ptr) ir_node *l = get_Sub_left(ptr); ir_node *r = get_Sub_right(ptr); - if (get_irn_mode(l) == get_irn_mode(ptr) && is_Const(r)) + if (get_irn_mode(l) == get_irn_mode(ptr) && is_Const(r)) ptr = l; else return NULL; @@ -350,12 +346,12 @@ 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; - tarval *tv; + size_t path_len, pos, idx; + ir_tarval *tv; ir_type *tp; if (is_SymConst(ptr)) { @@ -383,17 +379,19 @@ 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 = get_irn_mode(ptr); - tarval *tmp; - - if (is_Const(r) && get_irn_mode(l) == mode) { - ptr = l; - tv = get_Const_tarval(r); - } else { - ptr = r; - tv = get_Const_tarval(l); + ir_mode *mode; + ir_tarval *tmp; + + { + ir_node *l = get_Add_left(ptr); + ir_node *r = get_Add_right(ptr); + if (is_Const(r) && get_irn_mode(l) == get_irn_mode(ptr)) { + ptr = l; + tv = get_Const_tarval(r); + } else { + ptr = r; + tv = get_Const_tarval(l); + } } ptr_arith: mode = get_tarval_mode(tv); @@ -407,9 +405,9 @@ ptr_arith: } idx = 0; for (ent = field;;) { - unsigned size; - tarval *sz, *tv_index, *tlower, *tupper; - ir_node *bound; + unsigned size; + ir_tarval *sz, *tv_index, *tlower, *tupper; + ir_node *bound; tp = get_entity_type(ent); if (! is_Array_type(tp)) @@ -433,9 +431,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 */ @@ -458,9 +456,9 @@ ptr_arith: pos = path_len - depth - idx; for (ent = field;;) { - unsigned size; - tarval *sz, *tv_index; - long index; + unsigned size; + ir_tarval *sz, *tv_index; + long index; tp = get_entity_type(ent); if (! is_Array_type(tp)) @@ -507,7 +505,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) @@ -515,9 +513,9 @@ 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; - tarval *tv; + ir_tarval *tv; ir_type *tp; - unsigned n; + size_t n; entry.next = next; if (is_SymConst(ptr)) { @@ -540,7 +538,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); @@ -573,7 +571,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; @@ -586,17 +584,19 @@ static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) } return rec_find_compound_ent_value(get_Sel_ptr(ptr), &entry); } else if (is_Add(ptr)) { - ir_node *l = get_Add_left(ptr); - ir_node *r = get_Add_right(ptr); ir_mode *mode; unsigned pos; - if (is_Const(r)) { - ptr = l; - tv = get_Const_tarval(r); - } else { - ptr = r; - tv = get_Const_tarval(l); + { + ir_node *l = get_Add_left(ptr); + ir_node *r = get_Add_right(ptr); + if (is_Const(r)) { + ptr = l; + tv = get_Const_tarval(r); + } else { + ptr = r; + tv = get_Const_tarval(l); + } } ptr_arith: mode = get_tarval_mode(tv); @@ -627,10 +627,10 @@ ptr_arith: /* fill them up */ pos = 0; for (ent = field;;) { - unsigned size; - tarval *sz, *tv_index, *tlower, *tupper; - long index; - ir_node *bound; + unsigned size; + ir_tarval *sz, *tv_index, *tlower, *tupper; + long index; + ir_node *bound; tp = get_entity_type(ent); if (! is_Array_type(tp)) @@ -657,9 +657,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 */ @@ -698,7 +698,7 @@ static void reduce_adr_usage(ir_node *ptr); */ static void handle_load_update(ir_node *load) { - ldst_info_t *info = get_irn_link(load); + ldst_info_t *info = (ldst_info_t*)get_irn_link(load); /* do NOT touch volatile loads for now */ if (get_Load_volatility(load) == volatility_is_volatile) @@ -723,19 +723,20 @@ static void handle_load_update(ir_node *load) */ static void reduce_adr_usage(ir_node *ptr) { - if (is_Proj(ptr)) { - if (get_irn_n_edges(ptr) <= 0) { - /* this Proj is dead now */ - ir_node *pred = get_Proj_pred(ptr); + ir_node *pred; + if (!is_Proj(ptr)) + return; + if (get_irn_n_edges(ptr) > 0) + return; - if (is_Load(pred)) { - ldst_info_t *info = get_irn_link(pred); - info->projs[get_Proj_proj(ptr)] = NULL; + /* this Proj is dead now */ + pred = get_Proj_pred(ptr); + if (is_Load(pred)) { + ldst_info_t *info = (ldst_info_t*)get_irn_link(pred); + info->projs[get_Proj_proj(ptr)] = NULL; - /* this node lost its result proj, handle that */ - handle_load_update(pred); - } - } + /* this node lost its result proj, handle that */ + handle_load_update(pred); } } /* reduce_adr_usage */ @@ -745,20 +746,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) { @@ -866,7 +876,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 || @@ -877,9 +890,9 @@ static int try_load_after_store(ir_node *load, /* produce a shift to adjust offset delta */ if (delta > 0) { ir_node *cnst; + ir_graph *irg = get_irn_irg(load); - /* FIXME: only true for little endian */ - cnst = new_Const_long(mode_Iu, delta * 8); + cnst = new_r_Const_long(irg, mode_Iu, delta * 8); store_value = new_r_Shr(get_nodes_block(load), store_value, cnst, store_mode); } @@ -892,14 +905,15 @@ static int try_load_after_store(ir_node *load, DBG_OPT_RAW(load, store_value); - info = get_irn_link(load); + info = (ldst_info_t*)get_irn_link(load); if (info->projs[pn_Load_M]) exchange(info->projs[pn_Load_M], get_Load_mem(load)); res = 0; /* no exception */ if (info->projs[pn_Load_X_except]) { - exchange( info->projs[pn_Load_X_except], new_Bad()); + ir_graph *irg = get_irn_irg(load); + exchange( info->projs[pn_Load_X_except], new_r_Bad(irg, mode_X)); res |= CF_CHANGED; } if (info->projs[pn_Load_X_regular]) { @@ -929,31 +943,31 @@ static int try_load_after_store(ir_node *load, static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) { unsigned res = 0; - ldst_info_t *info = get_irn_link(load); + ldst_info_t *info = (ldst_info_t*)get_irn_link(load); ir_node *pred; ir_node *ptr = get_Load_ptr(load); ir_node *mem = get_Load_mem(load); ir_mode *load_mode = get_Load_mode(load); for (pred = curr; load != pred; ) { - ldst_info_t *pred_info = get_irn_link(pred); + ldst_info_t *pred_info = (ldst_info_t*)get_irn_link(pred); /* * a Load immediately after a Store -- a read after write. * We may remove the Load, if both Load & Store does not have an - * exception handler OR they are in the same MacroBlock. In the latter + * exception handler OR they are in the same Block. In the latter * case the Load cannot throw an exception when the previous Store was * quiet. * * Why we need to check for Store Exception? If the Store cannot * be executed (ROM) the exception handler might simply jump into - * the load MacroBlock :-( + * the load Block :-( * We could make it a little bit better if we would know that the * exception handler of the Store jumps directly to the end... */ if (is_Store(pred) && ((pred_info->projs[pn_Store_X_except] == NULL && info->projs[pn_Load_X_except] == NULL) - || get_nodes_MacroBlock(load) == get_nodes_MacroBlock(pred))) + || get_nodes_block(load) == get_nodes_block(pred))) { long load_offset; ir_node *base_ptr = get_base_and_offset(ptr, &load_offset); @@ -965,14 +979,20 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) can_use_stored_value(get_Load_mode(pred), load_mode)) { /* * a Load after a Load -- a read after read. - * We may remove the second Load, if it does not have an exception handler - * OR they are in the same MacroBlock. In the later case the Load cannot - * throw an exception when the previous Load was quiet. + * We may remove the second Load, if it does not have an exception + * handler OR they are in the same Block. In the later case + * the Load cannot throw an exception when the previous Load was + * quiet. + * + * Here, there is no need to check if the previous Load has an + * exception hander because they would have exact the same + * exception... * - * 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_MacroBlock(load) == get_nodes_MacroBlock(pred)) { + if (info->projs[pn_Load_X_except] == NULL + || get_nodes_block(load) == get_nodes_block(pred)) { ir_node *value; DBG_OPT_RAR(load, pred); @@ -998,7 +1018,8 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) /* no exception */ if (info->projs[pn_Load_X_except]) { - exchange(info->projs[pn_Load_X_except], new_Bad()); + ir_graph *irg = get_irn_irg(load); + exchange(info->projs[pn_Load_X_except], new_r_Bad(irg, mode_X)); res |= CF_CHANGED; } if (info->projs[pn_Load_X_regular]) { @@ -1015,7 +1036,6 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) if (is_Store(pred)) { /* check if we can pass through this store */ ir_alias_relation rel = get_alias_relation( - current_ir_graph, get_Store_ptr(pred), get_irn_mode(get_Store_value(pred)), ptr, load_mode); @@ -1065,27 +1085,22 @@ static unsigned follow_Mem_chain(ir_node *load, ir_node *curr) */ 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; + ir_mode *c_mode = get_irn_mode(c); + ir_mode *l_mode = get_Load_mode(load); + ir_node *block = get_nodes_block(load); + dbg_info *dbgi = get_irn_dbg_info(load); + ir_node *res = copy_const_value(dbgi, c, block); if (c_mode != l_mode) { /* check, if the mode matches OR can be easily converted info */ if (is_reinterpret_cast(c_mode, l_mode)) { - /* we can safely cast */ - dbg_info *dbg = get_irn_dbg_info(load); - ir_node *block = get_nodes_block(load); - /* copy the value from the const code irg and cast it */ - res = copy_const_value(dbg, c); - res = new_rd_Conv(dbg, block, res, l_mode); + res = new_rd_Conv(dbgi, block, res, l_mode); } - } else { - /* copy the value from the const code irg */ - res = copy_const_value(get_irn_dbg_info(load), c); + return NULL; } return res; -} /* can_replace_load_by_const */ +} /** * optimize a Load @@ -1094,7 +1109,7 @@ ir_node *can_replace_load_by_const(const ir_node *load, ir_node *c) */ static unsigned optimize_load(ir_node *load) { - ldst_info_t *info = get_irn_link(load); + ldst_info_t *info = (ldst_info_t*)get_irn_link(load); ir_node *mem, *ptr, *value; ir_entity *ent; long dummy; @@ -1107,39 +1122,12 @@ static unsigned optimize_load(ir_node *load) /* the address of the load to be optimized */ ptr = get_Load_ptr(load); - /* - * Check if we can remove the exception from a Load: - * This can be done, if the address is from an Sel(Alloc) and - * the Sel type is a subtype of the allocated type. - * - * This optimizes some often used OO constructs, - * like x = new O; x->t; - */ - if (info->projs[pn_Load_X_except]) { - ir_node *addr = ptr; - - /* find base address */ - while (is_Sel(addr)) - addr = get_Sel_ptr(addr); - if (is_Alloc(skip_Proj(skip_Cast(addr)))) { - /* simple case: a direct load after an Alloc. Firm Alloc throw - * an exception in case of out-of-memory. So, there is no way for an - * exception in this load. - * This code is constructed by the "exception lowering" in the Jack compiler. - */ - 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(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); - if (! info->projs[pn_Load_res] && ! info->projs[pn_Load_X_except]) { - /* a Load which value is neither used nor exception checked, remove it */ + if (info->projs[pn_Load_res] == NULL + && info->projs[pn_Load_X_except] == NULL) { + /* the value is never used and we don't care about exceptions, remove */ exchange(info->projs[pn_Load_M], mem); if (info->projs[pn_Load_X_regular]) { @@ -1167,7 +1155,8 @@ 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]) { - exchange(info->projs[pn_Load_X_except], new_Bad()); + ir_graph *irg = get_irn_irg(load); + exchange(info->projs[pn_Load_X_except], new_r_Bad(irg, mode_X)); info->projs[pn_Load_X_except] = NULL; res |= CF_CHANGED; } @@ -1201,7 +1190,8 @@ static unsigned optimize_load(ir_node *load) if (value != NULL) { /* we completely replace the load by this value */ if (info->projs[pn_Load_X_except]) { - exchange(info->projs[pn_Load_X_except], new_Bad()); + ir_graph *irg = get_irn_irg(load); + exchange(info->projs[pn_Load_X_except], new_r_Bad(irg, mode_X)); info->projs[pn_Load_X_except] = NULL; res |= CF_CHANGED; } @@ -1272,17 +1262,16 @@ static int is_partially_same(ir_node *small, ir_node *large) static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) { unsigned res = 0; - ldst_info_t *info = get_irn_link(store); + ldst_info_t *info = (ldst_info_t*)get_irn_link(store); ir_node *pred; ir_node *ptr = get_Store_ptr(store); ir_node *mem = get_Store_mem(store); ir_node *value = get_Store_value(store); ir_mode *mode = get_irn_mode(value); ir_node *block = get_nodes_block(store); - ir_node *mblk = get_Block_MacroBlock(block); for (pred = curr; pred != store;) { - ldst_info_t *pred_info = get_irn_link(pred); + ldst_info_t *pred_info = (ldst_info_t*)get_irn_link(pred); /* * BEWARE: one might think that checking the modes is useless, because @@ -1294,9 +1283,9 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) * killed ... */ if (is_Store(pred) && get_Store_ptr(pred) == ptr && - get_nodes_MacroBlock(pred) == mblk) { + get_nodes_block(pred) == block) { /* - * a Store after a Store in the same MacroBlock -- a write after write. + * a Store after a Store in the same Block -- a write after write. */ /* @@ -1359,7 +1348,6 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) if (is_Store(pred)) { /* check if we can pass through this store */ ir_alias_relation rel = get_alias_relation( - current_ir_graph, get_Store_ptr(pred), get_irn_mode(get_Store_value(pred)), ptr, mode); @@ -1369,7 +1357,7 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) pred = skip_Proj(get_Store_mem(pred)); } else if (is_Load(pred)) { ir_alias_relation rel = get_alias_relation( - current_ir_graph, get_Load_ptr(pred), get_Load_mode(pred), + get_Load_ptr(pred), get_Load_mode(pred), ptr, mode); if (rel != ir_no_alias) break; @@ -1447,7 +1435,7 @@ static unsigned optimize_store(ir_node *store) /* a store to an entity which is never read is unnecessary */ if (entity != NULL && !(get_entity_usage(entity) & ir_usage_read)) { - ldst_info_t *info = get_irn_link(store); + ldst_info_t *info = (ldst_info_t*)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)); @@ -1492,7 +1480,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; @@ -1515,19 +1506,17 @@ 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 = get_irn_link(block); + bl_info = (block_info_t*)get_irn_link(block); if (bl_info->flags & BLOCK_HAS_EXC) return 0; @@ -1538,7 +1527,7 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) /* this is the address of the store */ ptr = get_Store_ptr(store); mode = get_irn_mode(get_Store_value(store)); - info = get_irn_link(store); + info = (ldst_info_t*)get_irn_link(store); exc = info->exc_block; for (i = 1; i < n; ++i) { @@ -1554,22 +1543,19 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) if (ptr != get_Store_ptr(pred) || mode != get_irn_mode(get_Store_value(pred))) return 0; - info = get_irn_link(pred); + info = (ldst_info_t*)get_irn_link(pred); /* check, if all stores have the same exception flow */ 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 Phi-block, else we would move a Store from end End of a block to its Start... */ - bl_info = get_irn_link(block); + bl_info = (block_info_t*)get_irn_link(block); if (bl_info->flags & BLOCK_HAS_EXC) return 0; if (block == phi_block || ! block_postdominates(phi_block, block)) @@ -1609,7 +1595,7 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) assert(is_Proj(projMs[i])); store = get_Proj_pred(projMs[i]); - info = get_irn_link(store); + info = (ldst_info_t*)get_irn_link(store); inM[i] = get_Store_mem(store); inD[i] = get_Store_value(store); @@ -1635,7 +1621,7 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) } /* fourth step: create the Store */ - store = new_rd_Store(db, block, phiM, ptr, phiD, 0); + store = new_rd_Store(db, block, phiM, ptr, phiD, cons_none); #ifdef DO_CACHEOPT co_set_irn_name(store, co_get_irn_ident(old_store)); #endif @@ -1675,7 +1661,7 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv) */ static void do_load_store_optimize(ir_node *n, void *env) { - walk_env_t *wenv = env; + walk_env_t *wenv = (walk_env_t*)env; switch (get_irn_opcode(n)) { @@ -1692,13 +1678,13 @@ static void do_load_store_optimize(ir_node *n, void *env) break; default: - ; + break; } } /* do_load_store_optimize */ /** A scc. */ typedef struct scc { - ir_node *head; /**< the head of the list */ + ir_node *head; /**< the head of the list */ } scc; /** A node entry. */ @@ -1715,7 +1701,7 @@ typedef struct node_entry { typedef struct loop_env { ir_phase ph; /**< the phase object */ ir_node **stack; /**< the node stack */ - int tos; /**< tos index */ + size_t tos; /**< tos index */ unsigned nextDFSnum; /**< the current DFS number */ unsigned POnum; /**< current post order number */ @@ -1728,10 +1714,10 @@ typedef struct loop_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); + node_entry *e = (node_entry*)phase_get_irn_data(&env->ph, irn); if (! e) { - e = phase_alloc(ph, sizeof(*e)); + e = (node_entry*)phase_alloc(ph, sizeof(*e)); memset(e, 0, sizeof(*e)); phase_set_irn_data(ph, irn, e); } @@ -1749,7 +1735,7 @@ static void push(loop_env *env, ir_node *n) node_entry *e; if (env->tos == ARR_LEN(env->stack)) { - int nlen = ARR_LEN(env->stack) * 2; + size_t nlen = ARR_LEN(env->stack) * 2; ARR_RESIZE(ir_node *, env->stack, nlen); } env->stack[env->tos++] = n; @@ -1809,8 +1795,8 @@ typedef struct avail_entry_t { */ 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; + const avail_entry_t *a = (const avail_entry_t*)elt; + const avail_entry_t *b = (const avail_entry_t*)key; (void) size; return a->ptr != b->ptr || a->mode != b->mode; @@ -1833,7 +1819,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; @@ -1857,7 +1842,7 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) if (pe->pscc != ne->pscc) { /* not in the same SCC, is region const */ - phi_entry *pe = phase_alloc(&env->ph, sizeof(*pe)); + phi_entry *pe = (phi_entry*)phase_alloc(&env->ph, sizeof(*pe)); pe->phi = phi; pe->pos = j; @@ -1879,7 +1864,7 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) next = ne->next; if (is_Load(load)) { - ldst_info_t *info = get_irn_link(load); + ldst_info_t *info = (ldst_info_t*)get_irn_link(load); ir_node *ptr = get_Load_ptr(load); /* for now, we cannot handle Loads with exceptions */ @@ -1889,7 +1874,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); @@ -1897,7 +1881,6 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) if (is_Store(other)) { ir_alias_relation rel = get_alias_relation( - current_ir_graph, get_Store_ptr(other), get_irn_mode(get_Store_value(other)), ptr, load_mode); @@ -1908,7 +1891,7 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) /* only Phis and pure Calls are allowed here, so ignore them */ } if (other == NULL) { - ldst_info_t *ninfo; + ldst_info_t *ninfo = NULL; phi_entry *pe; dbg_info *db; @@ -1926,11 +1909,11 @@ static void move_loads_out_of_loops(scc *pscc, loop_env *env) entry.ptr = ptr; entry.mode = load_mode; - res = set_find(avail, &entry, sizeof(entry), hash_cache_entry(&entry)); + res = (avail_entry_t*)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); + irn = new_rd_Load(db, pred, get_Phi_pred(phi, pos), ptr, load_mode, cons_none); entry.load = irn; set_insert(avail, &entry, sizeof(entry), hash_cache_entry(&entry)); DB((dbg, LEVEL_1, " Created %+F in %+F\n", irn, pred)); @@ -1939,7 +1922,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); } @@ -2171,7 +2159,7 @@ static void dfs(ir_node *irn, loop_env *env) } if (node->low == node->DFSnum) { - scc *pscc = phase_alloc(&env->ph, sizeof(*pscc)); + scc *pscc = (scc*)phase_alloc(&env->ph, sizeof(*pscc)); ir_node *x; pscc->head = NULL; @@ -2197,11 +2185,9 @@ static void dfs(ir_node *irn, 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; - current_ir_graph = irg; inc_irg_visited(irg); /* visit all memory nodes */ @@ -2210,13 +2196,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"); } } @@ -2229,20 +2217,8 @@ static void do_dfs(ir_graph *irg, loop_env *env) if (is_Phi(ka) && !irn_visited(ka)) dfs(ka, env); } - current_ir_graph = rem; } /* do_dfs */ -/** - * 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) -{ - (void)ph; - (void)irn; - (void)data; - return NULL; -} /* init_loop_data */ - /** * Optimize Loads/Stores in loops. * @@ -2257,13 +2233,13 @@ static int optimize_loops(ir_graph *irg) env.nextDFSnum = 0; env.POnum = 0; env.changes = 0; - phase_init(&env.ph, "ldstopt", irg, PHASE_DEFAULT_GROWTH, init_loop_data, NULL); + phase_init(&env.ph, irg, phase_irn_init_default); /* calculate the SCC's and drive loop optimization. */ do_dfs(irg, &env); DEL_ARR_F(env.stack); - phase_free(&env.ph); + phase_deinit(&env.ph); return env.changes; } /* optimize_loops */ @@ -2310,8 +2286,8 @@ 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) {