#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)
} /* 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 */
if (entry == NULL) {
/* new address */
- entry = obstack_alloc(&env.obst, sizeof(*entry));
+ entry = OALLOC(&env.obst, address_entry);
entry->id = env.curr_adr_id++;
ir_nodemap_insert(&env.adr_map, adr, entry);
(void)ctx;
if (is_Block(irn)) {
- block_t *entry = obstack_alloc(&env.obst, sizeof(*entry));
+ block_t *entry = OALLOC(&env.obst, block_t);
int n;
entry->memop_forward = NULL;
* @return the allocated memop
*/
static memop_t *alloc_memop(ir_node *irn) {
- memop_t *m = obstack_alloc(&env.obst, sizeof(*m));
+ memop_t *m = OALLOC(&env.obst, memop_t);
m->value.address = NULL;
m->value.value = NULL;
* @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));
+ memop_t *m = OALLOC(&env.obst, memop_t);
m->value = op->value;
m->value.value = phi;
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;
}
case pn_Call_X_except:
m->flags |= FLAG_EXCEPTION;
break;
- case pn_Call_M_regular:
+ case pn_Call_M:
m->mem = proj;
break;
}
case pn_Generic_X_except:
m->flags |= FLAG_EXCEPTION;
break;
- case pn_Generic_M_regular:
+ case pn_Generic_M:
m->mem = proj;
break;
}
/* 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;
if (bl->trans_results == NULL) {
/* allocate the translate cache */
- unsigned size = env.curr_adr_id * sizeof(bl->trans_results[0]);
- bl->trans_results = obstack_alloc(&env.obst, size);
- memset(bl->trans_results, 0, size);
+ bl->trans_results = OALLOCNZ(&env.obst, memop_t*, env.curr_adr_id);
}
/* check for partly redundant values */
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 */
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;
}
/* 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 */
}
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 */
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]));
}
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(pred, 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(pred, 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_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 */
projects / libfirm / blobdiff