#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"
#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(pn_Load_max, pn_Store_max), pn_Call_max)
enum changes_t {
DF_CHANGED = 1, /**< data flow changed */
/**
* 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 {
+typedef struct ldst_info_t {
ir_node *projs[MAX_PROJ]; /**< 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 */
/**
* a Block info.
*/
-typedef struct _block_info_t {
+typedef struct block_info_t {
unsigned flags; /**< flags for the block */
} block_info_t;
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;
*/
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 = 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 */
/*
* 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);
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...
*/
- 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);
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(get_nodes_block(pred), pred, get_Load_mode(pred), pn_Load_res);
+ pred_info->projs[pn_Load_res] = new_r_Proj(pred, get_Load_mode(pred), pn_Load_res);
}
value = pred_info->projs[pn_Load_res];
/* 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]) {
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);
* 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.
*/
/*
co_set_irn_name(store, co_get_irn_ident(old_store));
#endif
- projM = new_rd_Proj(NULL, block, store, mode_M, pn_Store_M);
+ projM = new_rd_Proj(NULL, 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, block, store, mode_X, pn_Store_X_except);
+ ir_node *projX = new_rd_Proj(NULL, store, mode_X, pn_Store_X_except);
info->projs[pn_Store_X_except] = projX;
info->exc_block = exc;
/** 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. */
/* 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;
pe->load = irn;
ninfo = get_ldst_info(irn, phase_obst(&env->ph));
- ninfo->projs[pn_Load_M] = mem = new_r_Proj(pred, irn, mode_M, pn_Load_M);
+ ninfo->projs[pn_Load_M] = mem = new_r_Proj(irn, mode_M, pn_Load_M);
set_Phi_pred(phi, pos, mem);
- ninfo->projs[pn_Load_res] = new_r_Proj(pred, irn, load_mode, pn_Load_res);
+ ninfo->projs[pn_Load_res] = new_r_Proj(irn, load_mode, pn_Load_res);
}
/* now kill the old Load */
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.
*
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 */
projects / libfirm / blobdiff