#include "raw_bitset.h"
#include "debug.h"
#include "error.h"
+#include "irpass.h"
/* maximum number of output Proj's */
#define MAX_PROJ (pn_Load_max > pn_Store_max ? pn_Load_max : pn_Store_max)
block_t *forward_next; /**< next block entry for forward iteration */
block_t *backward_next; /**< next block entry for backward iteration */
memop_t *avail; /**< used locally for the avail map */
+ memop_t **trans_results; /**< used to cached translated nodes due antic calculation. */
};
/**
#endif
} ldst_env;
+/* the one and only environment */
+static ldst_env env;
+
#ifdef DEBUG_libfirm
static firm_dbg_module_t *dbg;
-/* the one and only environment */
-static ldst_env env;
-
/**
* Dumps the block list.
*
* @param ldst environment
*/
-static void dump_block_list(ldst_env *env) {
+static void dump_block_list(ldst_env *env)
+{
block_t *entry;
memop_t *op;
int i;
}
DB((dbg, LEVEL_2, "\n}\n\n"));
}
-}
+} /* dump_block_list */
/**
* Dumps the current set.
* @param bl current block
* @param s name of the set
*/
-static void dump_curr(block_t *bl, const char *s) {
- unsigned pos = 0;
+static void dump_curr(block_t *bl, const char *s)
+{
unsigned end = env.rbs_size - 1;
+ unsigned pos;
int i;
DB((dbg, LEVEL_2, "%s[%+F] = {", s, bl->block));
i = 0;
- for (pos = rbitset_next(env.curr_set, pos, 1); pos != end; pos = rbitset_next(env.curr_set, pos + 1, 1)) {
+ for (pos = rbitset_next(env.curr_set, 0, 1); pos < end; pos = rbitset_next(env.curr_set, pos + 1, 1)) {
memop_t *op = env.curr_id_2_memop[pos];
if (i == 0) {
i = (i + 1) & 3;
}
DB((dbg, LEVEL_2, "\n}\n"));
-}
+} /* dump_curr */
#else
-#define dump_block_list()
-#define dump_curr(bl, s)
+static void dump_block_list(ldst_env *env)
+{
+ (void) env;
+}
+static void dump_curr(block_t *bl, const char *s)
+{
+ (void) bl;
+ (void) s;
+}
#endif /* DEBUG_libfirm */
/** Get the block entry for a block node */
-static block_t *get_block_entry(const ir_node *block) {
+static block_t *get_block_entry(const ir_node *block)
+{
assert(is_Block(block));
return get_irn_link(block);
-}
+} /* get_block_entry */
/** Get the memop entry for a memory operation node */
-static memop_t *get_irn_memop(const ir_node *irn) {
+static memop_t *get_irn_memop(const ir_node *irn)
+{
assert(! is_Block(irn));
return get_irn_link(irn);
-}
+} /* get_irn_memop */
/**
* Walk over the memory edges from definition to users.
* @param post post walker function
* @param ctx context parameter for the walker functions
*/
-static void walk_memory(ir_node *irn, irg_walk_func *pre, irg_walk_func *post, void *ctx) {
+static void walk_memory(ir_node *irn, irg_walk_func *pre, irg_walk_func *post, void *ctx)
+{
int i;
ir_mode *mode;
}
if (post)
post(irn, ctx);
-}
+} /* walk_memory */
/**
* Walks over all memory nodes of a graph.
* @param post post walker function
* @param ctx context parameter for the walker functions
*/
-static void walk_memory_irg(ir_graph *irg, irg_walk_func pre, irg_walk_func post, void *ctx) {
+static void walk_memory_irg(ir_graph *irg, irg_walk_func pre, irg_walk_func post, void *ctx)
+{
inc_irg_visited(irg);
ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
walk_memory(get_irg_initial_mem(irg), pre, post, ctx);
ir_free_resources(irg, IR_RESOURCE_IRN_VISITED);
-}
+} /* walk_memory_irg */
/**
- * Walker: allocate an block entry for every block.
+ * Register an address and allocate a (sparse, 0..n) ID for it.
+ *
+ * @param adr the IR-node representing the address
+ *
+ * @return the allocated id
*/
-static void prepare_blocks(ir_node *block, void *ctx) {
+static unsigned register_address(ir_node *adr)
+{
+ address_entry *entry;
+
+ /* skip Confirms and Casts */
+restart:
+ if (is_Confirm(adr)) {
+ adr = get_Confirm_value(adr);
+ goto restart;
+ }
+ if (is_Cast(adr)) {
+ adr = get_Cast_op(adr);
+ goto restart;
+ }
+
+ entry = ir_nodemap_get(&env.adr_map, adr);
+
+ if (entry == NULL) {
+ /* new address */
+ entry = OALLOC(&env.obst, address_entry);
+
+ entry->id = env.curr_adr_id++;
+ ir_nodemap_insert(&env.adr_map, adr, entry);
+
+ DB((dbg, LEVEL_3, "ADDRESS %+F has ID %u\n", adr, entry->id));
+#ifdef DEBUG_libfirm
+ ARR_APP1(ir_node *, env.id_2_address, adr);
+#endif
+ }
+ return entry->id;
+} /* register_address */
+
+
+/**
+ * translate an address through a Phi node into a given predecessor
+ * block.
+ *
+ * @param address the address
+ * @param block the block
+ * @param pos the position of the predecessor in block
+ */
+static ir_node *phi_translate(ir_node *address, const ir_node *block, int pos)
+{
+ if (is_Phi(address) && get_nodes_block(address) == block)
+ address = get_Phi_pred(address, pos);
+ return address;
+} /* phi_translate */
+
+/**
+ * Walker: allocate an block entry for every block
+ * and register all potential addresses.
+ */
+static void prepare_blocks(ir_node *irn, void *ctx)
+{
(void)ctx;
- if (is_Block(block)) {
- block_t *entry = obstack_alloc(&env.obst, sizeof(*entry));
+ if (is_Block(irn)) {
+ block_t *entry = OALLOC(&env.obst, block_t);
int n;
entry->memop_forward = NULL;
entry->id_2_memop_avail = NULL;
entry->anticL_in = NULL;
entry->id_2_memop_antic = NULL;
- entry->block = block;
+ entry->block = irn;
entry->forward_next = NULL;
entry->backward_next = NULL;
entry->avail = NULL;
- set_irn_link(block, entry);
+ entry->trans_results = NULL;
+ set_irn_link(irn, entry);
- set_Block_phis(block, NULL);
+ set_Block_phis(irn, NULL);
/* use block marks to track unreachable blocks */
- set_Block_mark(block, 0);
+ set_Block_mark(irn, 0);
- n = get_Block_n_cfgpreds(block);
+ n = get_Block_n_cfgpreds(irn);
if (n > env.max_cfg_preds)
env.max_cfg_preds = n;
+ } else {
+ ir_mode *mode = get_irn_mode(irn);
+
+ if (mode_is_reference(mode)) {
+ /*
+ * Register ALL possible addresses: this is overkill yet but
+ * simpler then doing it for all possible translated addresses
+ * (which would be sufficient in the moment.
+ */
+ (void)register_address(irn);
+ }
}
-}
+} /* prepare_blocks */
/**
* Post-Walker, link in all Phi's
*/
-static void link_phis(ir_node *irn, void *ctx) {
+static void link_phis(ir_node *irn, void *ctx)
+{
(void)ctx;
if (is_Phi(irn)) {
ir_node *block = get_nodes_block(irn);
add_Block_phi(block, irn);
}
-}
+} /* link_phis */
/**
* Block walker: creates the inverse post-order list for the CFG.
*/
-static void inverse_post_order(ir_node *block, void *ctx) {
+static void inverse_post_order(ir_node *block, void *ctx)
+{
block_t *entry = get_block_entry(block);
(void)ctx;
/* remember the first visited (last in list) entry, needed for later */
if (env.backward == NULL)
env.backward = entry;
-}
+} /* inverse_post_order */
/**
* Block walker: create backward links for the memops of a block.
*/
-static void collect_backward(ir_node *block, void *ctx) {
+static void collect_backward(ir_node *block, void *ctx)
+{
block_t *entry = get_block_entry(block);
memop_t *last, *op;
last = op;
}
entry->memop_backward = last;
-}
+} /* collect_backward */
/**
* Allocate a memop.
*
- * @param irn the IR-node representing the memop
+ * @param irn the IR-node representing the memop or NULL
+ * if this is a translated (virtual) memop
+ *
+ * @return the allocated memop
*/
-static memop_t *alloc_memop(ir_node *irn) {
- memop_t *m = obstack_alloc(&env.obst, sizeof(*m));
+static memop_t *alloc_memop(ir_node *irn)
+{
+ memop_t *m = OALLOC(&env.obst, memop_t);
m->value.address = NULL;
m->value.value = NULL;
memset(m->projs, 0, sizeof(m->projs));
- set_irn_link(irn, m);
+ if (irn != NULL)
+ set_irn_link(irn, m);
return m;
-}
+} /* alloc_memop */
/**
* Create a memop for a Phi-replacement.
* @param op the memop to clone
* @param phi the Phi-node representing the new value
*/
-static memop_t *clone_memop_phi(memop_t *op, ir_node *phi) {
- memop_t *m = obstack_alloc(&env.obst, sizeof(*m));
+static memop_t *clone_memop_phi(memop_t *op, ir_node *phi)
+{
+ memop_t *m = OALLOC(&env.obst, memop_t);
m->value = op->value;
m->value.value = phi;
set_irn_link(phi, m);
return m;
-}
-
-/**
- * Register an address and allocate an ID for it.
- *
- * @param adr the IR-node representing the address
- */
-static unsigned register_address(ir_node *adr) {
- address_entry *entry;
-
- /* skip Confirms and Casts */
-restart:
- if (is_Confirm(adr)) {
- adr = get_Confirm_value(adr);
- goto restart;
- }
- if (is_Cast(adr)) {
- adr = get_Cast_op(adr);
- goto restart;
- }
-
- entry = ir_nodemap_get(&env.adr_map, adr);
-
- if (entry == NULL) {
- /* new address */
- entry = obstack_alloc(&env.obst, sizeof(*entry));
-
- entry->id = env.curr_adr_id++;
- ir_nodemap_insert(&env.adr_map, adr, entry);
-
- DB((dbg, LEVEL_3, "ADDRESS %+F has ID %u\n", adr, entry->id));
-#ifdef DEBUG_libfirm
- ARR_APP1(ir_node *, env.id_2_address, adr);
-#endif
- }
- return entry->id;
-}
+} /* clone_memop_phi */
/**
* Return the memory properties of a call node.
*
* return a bitset of mtp_property_const and mtp_property_pure
*/
-static unsigned get_Call_memory_properties(ir_node *call) {
+static unsigned get_Call_memory_properties(ir_node *call)
+{
ir_type *call_tp = get_Call_type(call);
unsigned prop = get_method_additional_properties(call_tp);
}
}
return prop & (mtp_property_const|mtp_property_pure);
-}
+} /* get_Call_memory_properties */
/**
* Returns an entity if the address ptr points to a constant one.
}
}
- if (variability_constant == get_entity_variability(ent))
+ if (get_entity_linkage(ent) == IR_LINKAGE_CONSTANT)
return ent;
/* try next */
/**
* 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));
* @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;
* 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) {
+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 */
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;
return NULL;
} /* rec_find_compound_ent_value */
-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);
} /* find_compound_ent_value */
*
* @param op the Load memop
*/
-static void mark_replace_load(memop_t *op, ir_node *def) {
+static void mark_replace_load(memop_t *op, ir_node *def)
+{
op->replace = def;
op->flags |= FLAG_KILLED_NODE;
env.changed = 1;
*
* @param op the Store memop
*/
-static void mark_remove_store(memop_t *op) {
+static void mark_remove_store(memop_t *op)
+{
op->flags |= FLAG_KILLED_NODE;
env.changed = 1;
} /* mark_remove_store */
*
* @param m the memop
*/
-static void update_Load_memop(memop_t *m) {
+static void update_Load_memop(memop_t *m)
+{
int i;
ir_node *load = m->node;
ir_node *ptr;
/* check if we can determine the entity that will be loaded */
ent = find_constant_entity(ptr);
- if (ent != NULL &&
- allocation_static == get_entity_allocation(ent) &&
- visibility_external_allocated != get_entity_visibility(ent)) {
+ 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. */
ir_node *value = NULL;
env.changed = 1;
}
if (m->projs[pn_Load_X_regular]) {
- exchange(m->projs[pn_Load_X_regular], new_r_Jmp(current_ir_graph, get_nodes_block(load)));
+ exchange(m->projs[pn_Load_X_regular], new_r_Jmp(get_nodes_block(load)));
m->projs[pn_Load_X_regular] = NULL;
env.changed = 1;
}
- 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) {
+ if (get_entity_linkage(ent) & IR_LINKAGE_CONSTANT) {
+ if (ent->initializer) {
/* new style initializer */
value = find_compound_ent_value(ptr);
- } else {
+ } else if (entity_has_compound_ent_values(ent)) {
/* old style initializer */
compound_graph_path *path = get_accessed_path(ptr);
/* no user, KILL it */
mark_replace_load(m, NULL);
}
-}
+} /* update_Load_memop */
/**
* Update a memop for a Store.
*
* @param m the memop
*/
-static void update_Store_memop(memop_t *m) {
+static void update_Store_memop(memop_t *m)
+{
int i;
ir_node *store = m->node;
ir_node *adr = get_Store_ptr(store);
}
m->value.value = get_Store_value(store);
m->value.mode = get_irn_mode(m->value.value);
-}
+} /* update_Store_memop */
/**
* Update a memop for a Call.
*
* @param m the memop
*/
-static void update_Call_memop(memop_t *m) {
+static void update_Call_memop(memop_t *m)
+{
ir_node *call = m->node;
unsigned prop = get_Call_memory_properties(call);
int i;
case pn_Call_X_except:
m->flags |= FLAG_EXCEPTION;
break;
- case pn_Call_M_regular:
+ case pn_Call_M:
m->mem = proj;
break;
}
}
-}
+} /* update_Call_memop */
/**
* Update a memop for a Div/Mod/Quot/DivMod.
*
* @param m the memop
*/
-static void update_DivOp_memop(memop_t *m) {
+static void update_DivOp_memop(memop_t *m)
+{
ir_node *div = m->node;
int i;
case pn_Generic_X_except:
m->flags |= FLAG_EXCEPTION;
break;
- case pn_Generic_M_regular:
+ case pn_Generic_M:
m->mem = proj;
break;
}
}
-}
+} /* update_DivOp_memop */
/**
* Update a memop for a Phi.
*
* @param m the memop
*/
-static void update_Phi_memop(memop_t *m) {
+static void update_Phi_memop(memop_t *m)
+{
/* the Phi is it's own mem */
m->mem = m->node;
-}
+} /* update_Phi_memop */
/**
* Memory walker: collect all memory ops and build topological lists.
*/
-static void collect_memops(ir_node *irn, void *ctx) {
+static void collect_memops(ir_node *irn, void *ctx)
+{
memop_t *op;
ir_node *block;
block_t *entry;
entry->memop_backward = op;
}
}
-}
+} /* collect_memops */
/**
* Find an address in the current set.
*
* @param value the value to be searched for
+ *
+ * @return a memop for the value or NULL if the value does
+ * not exists in the set or cannot be converted into
+ * the requested mode
*/
-static memop_t *find_address(const value_t *value) {
+static memop_t *find_address(const value_t *value)
+{
if (rbitset_is_set(env.curr_set, value->id)) {
memop_t *res = env.curr_id_2_memop[value->id];
return res;
}
return NULL;
-}
+} /* find_address */
/**
* Find an address in the avail_out set.
*
* @param bl the block
- * @param value the value to be searched for
*/
-static memop_t *find_address_avail(const block_t *bl, const value_t *value) {
- if (rbitset_is_set(bl->avail_out, value->id)) {
- memop_t *res = bl->id_2_memop_avail[value->id];
+static memop_t *find_address_avail(const block_t *bl, unsigned id, const ir_mode *mode)
+{
+ if (rbitset_is_set(bl->avail_out, id)) {
+ memop_t *res = bl->id_2_memop_avail[id];
- if (res->value.mode == value->mode)
+ if (res->value.mode == mode)
return res;
/* allow hidden casts */
if (get_mode_arithmetic(res->value.mode) == irma_twos_complement &&
- get_mode_arithmetic(value->mode) == irma_twos_complement &&
- get_mode_size_bits(res->value.mode) == get_mode_size_bits(value->mode))
+ get_mode_arithmetic(mode) == irma_twos_complement &&
+ get_mode_size_bits(res->value.mode) == get_mode_size_bits(mode))
return res;
}
return NULL;
-}
+} /* find_address_avail */
/**
* Kill all addresses from the current set.
*/
-static void kill_all(void) {
+static void kill_all(void)
+{
rbitset_clear_all(env.curr_set, env.rbs_size);
/* set sentinel */
rbitset_set(env.curr_set, env.rbs_size - 1);
-}
+} /* kill_all */
/**
* Kill memops that are not alias free due to a Store value from the current set.
*
* @param value the Store value
*/
-static void kill_memops(const value_t *value) {
- unsigned pos = 0;
+static void kill_memops(const value_t *value)
+{
unsigned end = env.rbs_size - 1;
+ unsigned pos;
- for (pos = rbitset_next(env.curr_set, pos, 1); pos != end; pos = rbitset_next(env.curr_set, pos + 1, 1)) {
+ for (pos = rbitset_next(env.curr_set, 0, 1); pos < end; pos = rbitset_next(env.curr_set, pos + 1, 1)) {
memop_t *op = env.curr_id_2_memop[pos];
if (ir_no_alias != get_alias_relation(current_ir_graph, value->address, value->mode,
DB((dbg, LEVEL_2, "KILLING %+F because of possible alias address %+F\n", op->node, value->address));
}
}
-}
+} /* kill_memops */
/**
* Add the value of a memop to the current set.
*
* @param op the memory op
*/
-static void add_memop(memop_t *op) {
+static void add_memop(memop_t *op)
+{
rbitset_set(env.curr_set, op->value.id);
env.curr_id_2_memop[op->value.id] = op;
-}
+} /* add_memop */
/**
* Add the value of a memop to the avail_out set.
* @param bl the block
* @param op the memory op
*/
-static void add_memop_avail(block_t *bl, memop_t *op) {
+static void add_memop_avail(block_t *bl, memop_t *op)
+{
rbitset_set(bl->avail_out, op->value.id);
bl->id_2_memop_avail[op->value.id] = op;
-}
+} /* add_memop_avail */
/**
* Check, if we can convert a value of one mode to another mode
* without changing the representation of bits.
+ *
+ * @param from the original mode
+ * @param to the destination mode
*/
-static int can_convert_to(const ir_mode *from, const ir_mode *to) {
+static int can_convert_to(const ir_mode *from, const ir_mode *to)
+{
if (get_mode_arithmetic(from) == irma_twos_complement &&
get_mode_arithmetic(to) == irma_twos_complement &&
get_mode_size_bits(from) == get_mode_size_bits(to))
return 1;
return 0;
-}
+} /* can_convert_to */
/**
- * Add a Conv if needed.
+ * Add a Conv to the requested mode if needed.
+ *
+ * @param irn the IR-node to convert
+ * @param mode the destination mode
+ *
+ * @return the possible converted node or NULL
+ * if the conversion is not possible
*/
-static ir_node *conv_to(ir_node *irn, ir_mode *mode) {
+static ir_node *conv_to(ir_node *irn, ir_mode *mode)
+{
ir_mode *other = get_irn_mode(irn);
if (other != mode) {
/* different modes: check if conversion is possible without changing the bits */
if (can_convert_to(other, mode)) {
ir_node *block = get_nodes_block(irn);
- return new_r_Conv(current_ir_graph, block, irn, mode);
+ return new_r_Conv(block, irn, mode);
}
/* otherwise not possible ... yet */
return NULL;
}
return irn;
-}
+} /* conv_to */
/**
* Update the address of an value if this address was a load result
*
* @param value the value whose address is updated
*/
-static void update_address(value_t *value) {
+static void update_address(value_t *value)
+{
if (is_Proj(value->address)) {
ir_node *load = get_Proj_pred(value->address);
value->address = op->replace;
}
}
-}
+} /* update_address */
/**
* Do forward dataflow analysis on the given block and calculate the
*
* @param bl the block
*/
-static void calc_gen_kill_avail(block_t *bl) {
+static void calc_gen_kill_avail(block_t *bl)
+{
memop_t *op;
ir_node *def;
kill_all();
}
}
-}
+} /* calc_gen_kill_avail */
#define BYTE_SIZE(x) (((x) + 7) >> 3)
*
* @param block the block
*/
-static void forward_avail(block_t *bl) {
+static void forward_avail(block_t *bl)
+{
/* fill the data from the current block */
env.curr_id_2_memop = bl->id_2_memop_avail;
env.curr_set = bl->avail_out;
calc_gen_kill_avail(bl);
dump_curr(bl, "Avail_out");
-}
+} /* forward_avail */
/**
* Do backward dataflow analysis on a given block to calculate the antic set
*
* @return non-zero if the set has changed since last iteration
*/
-static int backward_antic(block_t *bl) {
+static int backward_antic(block_t *bl)
+{
memop_t *op;
- int n = get_Block_n_cfg_outs(bl->block);
+ ir_node *block = bl->block;
+ int n = get_Block_n_cfg_outs(block);
+
+ if (n == 1) {
+ ir_node *succ = get_Block_cfg_out(block, 0);
+ block_t *succ_bl = get_block_entry(succ);
+ int pred_pos = get_Block_cfgpred_pos(succ, block);
+ unsigned end = env.rbs_size - 1;
+ unsigned pos;
- if (n >= 1) {
- ir_node *succ = get_Block_cfg_out(bl->block, 0);
+ kill_all();
+
+ if (bl->trans_results == NULL) {
+ /* allocate the translate cache */
+ bl->trans_results = OALLOCNZ(&env.obst, memop_t*, env.curr_adr_id);
+ }
+
+ /* check for partly redundant values */
+ for (pos = rbitset_next(succ_bl->anticL_in, 0, 1);
+ pos < end;
+ pos = rbitset_next(succ_bl->anticL_in, pos + 1, 1)) {
+ /*
+ * do Phi-translation here: Note that at this point the nodes are
+ * not changed, so we can safely cache the results.
+ * However: Loads of Load results ARE bad, because we have no way
+ to translate them yet ...
+ */
+ memop_t *op = bl->trans_results[pos];
+ if (op == NULL) {
+ /* not yet translated */
+ ir_node *adr, *trans_adr;
+
+ op = succ_bl->id_2_memop_antic[pos];
+ adr = op->value.address;
+
+ trans_adr = phi_translate(adr, succ, pred_pos);
+ if (trans_adr != adr) {
+ /* create a new entry for the translated one */
+ memop_t *new_op;
+
+ new_op = alloc_memop(NULL);
+ new_op->value.address = trans_adr;
+ new_op->value.id = register_address(trans_adr);
+ new_op->value.mode = op->value.mode;
+ new_op->node = op->node; /* we need the node to decide if Load/Store */
+ new_op->flags = op->flags;
+
+ bl->trans_results[pos] = new_op;
+ op = new_op;
+ }
+ }
+ env.curr_id_2_memop[op->value.id] = op;
+ rbitset_set(env.curr_set, op->value.id);
+ }
+ } else if (n > 1) {
+ ir_node *succ = get_Block_cfg_out(block, 0);
block_t *succ_bl = get_block_entry(succ);
int i;
- rbitset_cpy(env.curr_set, succ_bl->anticL_in, env.rbs_size);
+ rbitset_copy(env.curr_set, succ_bl->anticL_in, env.rbs_size);
memcpy(env.curr_id_2_memop, succ_bl->id_2_memop_antic, env.rbs_size * sizeof(env.curr_id_2_memop[0]));
+ /* Hmm: probably we want kill merges of Loads ans Stores here */
for (i = n - 1; i > 0; --i) {
ir_node *succ = get_Block_cfg_out(bl->block, i);
block_t *succ_bl = get_block_entry(succ);
memcpy(bl->id_2_memop_antic, env.curr_id_2_memop, env.rbs_size * sizeof(env.curr_id_2_memop[0]));
if (! rbitset_equal(bl->anticL_in, env.curr_set, env.rbs_size)) {
/* changed */
- rbitset_cpy(bl->anticL_in, env.curr_set, env.rbs_size);
+ rbitset_copy(bl->anticL_in, env.curr_set, env.rbs_size);
dump_curr(bl, "AnticL_in*");
return 1;
}
dump_curr(bl, "AnticL_in");
return 0;
-}
+} /* backward_antic */
/**
* Replace a Load memop by a already known value.
*
* @param op the Load memop
*/
-static void replace_load(memop_t *op) {
+static void replace_load(memop_t *op)
+{
ir_node *load = op->node;
ir_node *def = skip_Id(op->replace);
ir_node *proj;
/* a hidden cast */
dbg_info *db = get_irn_dbg_info(load);
ir_node *block = get_nodes_block(proj);
- def = new_rd_Conv(db, current_ir_graph, block, def, mode);
+ def = new_rd_Conv(db, block, def, mode);
}
exchange(proj, def);
}
}
proj = op->projs[pn_Load_X_regular];
if (proj != NULL) {
- exchange(proj, new_r_Jmp(current_ir_graph, get_nodes_block(load)));
+ exchange(proj, new_r_Jmp(get_nodes_block(load)));
}
-}
+} /* replace_load */
/**
* Remove a Store memop.
*
* @param op the Store memop
*/
-static void remove_store(memop_t *op) {
+static void remove_store(memop_t *op)
+{
ir_node *store = op->node;
ir_node *proj;
}
proj = op->projs[pn_Store_X_regular];
if (proj != NULL) {
- exchange(proj, new_r_Jmp(current_ir_graph, get_nodes_block(store)));
+ exchange(proj, new_r_Jmp(get_nodes_block(store)));
}
-}
+} /* remove_store */
/**
*
* @param bl the block
*/
-static void do_replacements(block_t *bl) {
+static void do_replacements(block_t *bl)
+{
memop_t *op;
for (op = bl->memop_forward; op != NULL; op = op->next) {
}
}
}
-}
+} /* do_replacements */
/**
* Calculate the Avail_out sets for all basic blocks.
*/
-static void calcAvail(void) {
+static void calcAvail(void)
+{
memop_t **tmp_memop = env.curr_id_2_memop;
unsigned *tmp_set = env.curr_set;
block_t *bl;
/* restore the current sets */
env.curr_id_2_memop = tmp_memop;
env.curr_set = tmp_set;
-}
+} /* calcAvail */
/**
* Calculate the Antic_in sets for all basic blocks.
*/
-static void calcAntic(void) {
+static void calcAntic(void)
+{
int i, need_iter;
/* calculate antic_out */
++i;
} while (need_iter);
DB((dbg, LEVEL_2, "Get anticipated Load set after %d iterations\n", i));
-}
+} /* calcAntic */
/**
* Return the node representing the last memory in a block.
*
* @param bl the block
*/
-static ir_node *find_last_memory(block_t *bl) {
+static ir_node *find_last_memory(block_t *bl)
+{
for (;;) {
if (bl->memop_backward != NULL) {
return bl->memop_backward->mem;
/* if there is NO memory in this block, go to the dominator */
bl = get_block_entry(get_Block_idom(bl->block));
}
-}
+} /* find_last_memory */
/**
* Reroute all memory users of old memory
* @param omem the old memory IR-node
* @param nmem the new memory IR-node
*/
-static void reroute_all_mem_users(ir_node *omem, ir_node *nmem) {
+static void reroute_all_mem_users(ir_node *omem, ir_node *nmem)
+{
int i;
for (i = get_irn_n_outs(omem) - 1; i >= 0; --i) {
/* all edges previously point to omem now point to nmem */
nmem->out = omem->out;
-}
+} /* reroute_all_mem_users */
/**
* Reroute memory users of old memory that are dominated by a given block
* @param nmem the new memory IR-node
* @param pass_bl the block the memory must pass
*/
-static void reroute_mem_through(ir_node *omem, ir_node *nmem, ir_node *pass_bl) {
+static void reroute_mem_through(ir_node *omem, ir_node *nmem, ir_node *pass_bl)
+{
int i, j, n = get_irn_n_outs(omem);
ir_def_use_edge *edges = NEW_ARR_D(ir_def_use_edge, &env.obst, n + 1);
/* first entry is used for the length */
edges[0].pos = j;
nmem->out = edges;
-}
-
-/**
- * translate an address through a Phi node into a given predecessor
- * block.
- *
- * @param address the address
- * @param block the block
- * @param pos the position of the predecessor in block
- */
-static ir_node *phi_translate(ir_node *address, ir_node *block, int pos) {
- if (is_Phi(address) && get_nodes_block(address) == block)
- address = get_Phi_pred(address, pos);
- return address;
-}
-
-/**
- * Get the effective block of an address in the pos'th predecessor
- * of the given block.
- *
- * @param address the address
- * @param block the block
- * @param pos the position of the predecessor in block
- */
-static ir_node *get_effective_block(ir_node *address, ir_node *block, int pos) {
- address = phi_translate(address, block, pos);
- return get_nodes_block(address);
-}
+} /* reroute_mem_through */
/**
* insert Loads, making partly redundant Loads fully redundant
*/
-static int insert_Load(block_t *bl) {
+static int insert_Load(block_t *bl)
+{
ir_node *block = bl->block;
int i, n = get_Block_n_cfgpreds(block);
- unsigned pos = 0;
unsigned end = env.rbs_size - 1;
+ unsigned pos;
DB((dbg, LEVEL_3, "processing %+F\n", block));
}
if (n > 1) {
- int i, pos;
ir_node **ins;
+ int pos;
NEW_ARR_A(ir_node *, ins, n);
block_t *pred_bl = get_block_entry(pred);
int need_phi = 0;
memop_t *first = NULL;
- ir_mode *mode;
+ ir_mode *mode = NULL;
for (i = 0; i < n; ++i) {
memop_t *mop;
}
if (need_phi) {
/* build a Phi */
- ir_node *phi = new_r_Phi(current_ir_graph, bl->block, n, ins, mode);
+ ir_node *phi = new_r_Phi(bl->block, n, ins, mode);
memop_t *phiop = alloc_memop(phi);
phiop->value = first->value;
ir_node *pred = get_Block_cfgpred_block(bl->block, 0);
block_t *pred_bl = get_block_entry(pred);
- rbitset_cpy(env.curr_set, pred_bl->avail_out, env.rbs_size);
+ rbitset_copy(env.curr_set, pred_bl->avail_out, env.rbs_size);
memcpy(env.curr_id_2_memop, pred_bl->id_2_memop_avail, env.rbs_size * sizeof(bl->id_2_memop_avail[0]));
}
if (n > 1) {
/* check for partly redundant values */
- for (pos = rbitset_next(bl->anticL_in, pos, 1); pos != end; pos = rbitset_next(bl->anticL_in, pos + 1, 1)) {
+ for (pos = rbitset_next(bl->anticL_in, 0, 1);
+ pos < end;
+ pos = rbitset_next(bl->anticL_in, pos + 1, 1)) {
memop_t *op = bl->id_2_memop_antic[pos];
int have_some, all_same;
ir_node *first;
for (i = n - 1; i >= 0; --i) {
ir_node *pred = get_Block_cfgpred_block(block, i);
block_t *pred_bl = get_block_entry(pred);
- memop_t *e = find_address_avail(pred_bl, &op->value);
ir_mode *mode = op->value.mode;
+ memop_t *e;
+ ir_node *adr;
+ adr = phi_translate(op->value.address, block, i);
+ DB((dbg, LEVEL_3, ".. using address %+F in pred %d\n", adr, i));
+ e = find_address_avail(pred_bl, register_address(adr), mode);
if (e == NULL) {
- ir_node *ef_block = get_effective_block(op->value.address, block, i);
+ ir_node *ef_block = get_nodes_block(adr);
if (! block_dominates(ef_block, pred)) {
/* cannot place a copy here */
have_some = 0;
- DB((dbg, LEVEL_3, "%+F is cannot be moved into predecessor %+F\n", op->node, pred));
+ DB((dbg, LEVEL_3, "%+F cannot be moved into predecessor %+F\n", op->node, pred));
break;
}
DB((dbg, LEVEL_3, "%+F is not available in predecessor %+F\n", op->node, pred));
assert(last_mem != NULL);
adr = phi_translate(op->value.address, block, i);
- load = new_rd_Load(db, current_ir_graph, pred, last_mem, adr, mode, cons_none);
- def = new_r_Proj(current_ir_graph, pred, load, mode, pn_Load_res);
+ load = new_rd_Load(db, pred, last_mem, adr, mode, cons_none);
+ def = new_r_Proj(load, mode, pn_Load_res);
DB((dbg, LEVEL_1, "Created new %+F in %+F for party redundant %+F\n", load, pred, op->node));
new_op = alloc_memop(load);
- new_op->mem = new_r_Proj(current_ir_graph, pred, load, mode_M, pn_Load_M);
+ new_op->mem = new_r_Proj(load, mode_M, pn_Load_M);
new_op->value.address = adr;
new_op->value.id = op->value.id;
new_op->value.mode = mode;
}
in[i] = conv_to(pred_bl->avail->value.value, mode);
}
- phi = new_r_Phi(current_ir_graph, block, n, in, mode);
+ phi = new_r_Phi(block, n, in, mode);
DB((dbg, LEVEL_1, "Created new %+F in %+F for now redundant %+F\n", phi, block, op->node));
phi_op = clone_memop_phi(op, phi);
if (!rbitset_equal(bl->avail_out, env.curr_set, env.rbs_size)) {
/* the avail set has changed */
- rbitset_cpy(bl->avail_out, env.curr_set, env.rbs_size);
+ rbitset_copy(bl->avail_out, env.curr_set, env.rbs_size);
dump_curr(bl, "Avail_out*");
return 1;
}
dump_curr(bl, "Avail_out");
return 0;
-}
+} /* insert_Load */
/**
* Insert Loads upwards.
*/
-static void insert_Loads_upwards(void) {
+static void insert_Loads_upwards(void)
+{
int i, need_iter;
block_t *bl;
} while (need_iter);
DB((dbg, LEVEL_2, "Finished Load inserting after %d iterations\n", i));
-}
+} /* insert_Loads_upwards */
/**
- * kill unreachable control flow.
+ * Kill unreachable control flow.
+ *
+ * @param irg the graph to operate on
*/
-static void kill_unreachable_blocks(ir_graph *irg) {
+static void kill_unreachable_blocks(ir_graph *irg)
+{
block_t *bl;
ir_node **ins;
int changed = 0;
/* this transformation do NOT invalidate the dominance */
}
-}
+} /* kill_unreachable_blocks */
-int opt_ldst(ir_graph *irg) {
+int opt_ldst(ir_graph *irg)
+{
block_t *bl;
ir_graph *rem = current_ir_graph;
/* create address sets: for now, only the existing addresses are allowed plus one
needed for the sentinel */
- env.rbs_size = env.n_mem_ops + 1;
+ env.rbs_size = env.curr_adr_id + 1;
/* create the current set */
env.curr_set = rbitset_obstack_alloc(&env.obst, env.rbs_size);
}
// dump_block_list(&env);
+ (void) dump_block_list;
calcAvail();
calcAntic();
current_ir_graph = rem;
return env.changed != 0;
-}
+} /* opt_ldst */
+
+ir_graph_pass_t *opt_ldst_pass(const char *name)
+{
+ return def_graph_pass_ret(name ? name : "ldst_df", opt_ldst);
+} /* opt_ldst_pass */