/* a Load which value is neither used nor exception checked, remove it */
exchange(info->projs[pn_Load_M], mem);
- exchange(info->projs[pn_Load_X_regular], new_r_Jmp(current_ir_graph, get_nodes_block(load)));
+ if (info->projs[pn_Load_X_regular])
+ exchange(info->projs[pn_Load_X_regular], new_r_Jmp(current_ir_graph, get_nodes_block(load)));
exchange(load, new_Bad());
reduce_adr_usage(ptr);
}
next = ne->next;
/* check all memory Phi's */
- if (! is_Phi(phi) || get_irn_mode(phi) != mode_M)
+ if (! is_Phi(phi))
continue;
+ assert(get_irn_mode(phi) == mode_M && "DFS geturn non-memory Phi");
+
for (j = get_irn_arity(phi) - 1; j >= 0; --j) {
ir_node *pred = get_irn_n(phi, j);
node_entry *pe = get_irn_ne(pred, env);
}
}
}
+ /* no Phis no fun */
+ assert(phi_list != NULL && "DFS found a loop without Phi");
for (load = pscc->head; load; load = next) {
ir_mode *load_mode;
if (! is_SymConst(ptr) || get_SymConst_kind(ptr) != symconst_addr_ent)
continue;
ent = get_SymConst_entity(ptr);
-
load_mode = get_Load_mode(load);
- if (get_entity_address_taken(ent) == ir_address_not_taken) {
- /* Shortcut: If the addres is never taken, this address if complete alias free*/
- goto can_move;
- }
-
for (other = pscc->head; other != NULL; other = next_other) {
node_entry *ne = get_irn_ne(other, env);
next_other = ne->next;
ldst_info_t *ninfo;
phi_entry *pe;
dbg_info *db;
-can_move:
+
/* for now, we cannot handle more than one input */
if (phi_list->next != NULL)
return;
ir_node *irn, *mem;
pe->load = irn = new_rd_Load(db, current_ir_graph, pred, get_Phi_pred(phi, pos), ptr, load_mode);
- ninfo = get_ldst_info(pred, phase_obst(&env->ph));
+ ninfo = get_ldst_info(irn, phase_obst(&env->ph));
ninfo->projs[pn_Load_M] = mem = new_r_Proj(current_ir_graph, pred, irn, mode_M, pn_Load_M);
set_Phi_pred(phi, pos, mem);
process_loop(pscc, env);
}
} /* process_scc */
+
/**
* Do Tarjan's SCC algorithm and drive load/store optimization.
*
mark_irn_visited(irn);
- /* do not put blocks into the scc */
- if (is_Block(irn)) {
- n = get_irn_arity(irn);
- for (i = 0; i < n; ++i) {
- ir_node *pred = get_irn_n(irn, i);
-
- if (irn_not_visited(pred))
- dfs(pred, env);
- }
- }
- else {
- ir_node *block = get_nodes_block(irn);
-
- node->DFSnum = env->nextDFSnum++;
- node->low = node->DFSnum;
- push(env, irn);
-
- /* handle the block */
- if (irn_not_visited(block))
- dfs(block, env);
+ node->DFSnum = env->nextDFSnum++;
+ node->low = node->DFSnum;
+ push(env, irn);
+ /* handle preds */
+ if (is_Phi(irn) || is_Sync(irn)) {
n = get_irn_arity(irn);
for (i = 0; i < n; ++i) {
ir_node *pred = get_irn_n(irn, i);
if (o->DFSnum < node->DFSnum && o->in_stack)
node->low = MIN(o->DFSnum, node->low);
}
- if (node->low == node->DFSnum) {
- scc *pscc = phase_alloc(&env->ph, sizeof(*pscc));
- ir_node *x;
-
- pscc->head = NULL;
- do {
- node_entry *e;
-
- x = pop(env);
- e = get_irn_ne(x, env);
- e->pscc = pscc;
- e->next = pscc->head;
- pscc->head = x;
- } while (x != irn);
-
- process_scc(pscc, env);
+ } else if (is_fragile_op(irn)) {
+ ir_node *pred = get_fragile_op_mem(irn);
+ node_entry *o = get_irn_ne(pred, env);
+
+ if (irn_not_visited(pred)) {
+ dfs(pred, env);
+ node->low = MIN(node->low, o->low);
+ }
+ if (o->DFSnum < node->DFSnum && o->in_stack)
+ node->low = MIN(o->DFSnum, node->low);
+ } else if (is_Proj(irn)) {
+ ir_node *pred = get_Proj_pred(irn);
+ node_entry *o = get_irn_ne(pred, env);
+
+ if (irn_not_visited(pred)) {
+ dfs(pred, env);
+ node->low = MIN(node->low, o->low);
}
+ if (o->DFSnum < node->DFSnum && o->in_stack)
+ node->low = MIN(o->DFSnum, node->low);
+ }
+ else {
+ /* IGNORE predecessors */
+ }
+
+ if (node->low == node->DFSnum) {
+ scc *pscc = phase_alloc(&env->ph, sizeof(*pscc));
+ ir_node *x;
+
+ pscc->head = NULL;
+ do {
+ node_entry *e;
+
+ x = pop(env);
+ e = get_irn_ne(x, env);
+ e->pscc = pscc;
+ e->next = pscc->head;
+ pscc->head = x;
+ } while (x != irn);
+
+ process_scc(pscc, env);
}
} /* dfs */
/**
- * Do the DFS by starting at the End node of a graph.
+ * Do the DFS on the memory edges a graph.
*
* @param irg the graph to process
* @param env the loop environment
*/
static void do_dfs(ir_graph *irg, loop_env *env) {
ir_graph *rem = current_ir_graph;
- ir_node *end = get_irg_end(irg);
- int i, n;
+ ir_node *endblk, *end;
+ int i;
current_ir_graph = irg;
inc_irg_visited(irg);
- /* visit all visible nodes */
- dfs(end, env);
+ /* visit all memory nodes */
+ endblk = get_irg_end_block(irg);
+ for (i = get_Block_n_cfgpreds(endblk) - 1; i >= 0; --i) {
+ ir_node *pred = get_Block_cfgpred(endblk, i);
+
+ if (is_Return(pred))
+ dfs(get_Return_mem(pred), env);
+ else if (is_Raise(pred))
+ dfs(get_Raise_mem(pred), env);
+ else if (is_fragile_op(pred))
+ dfs(get_fragile_op_mem(pred), env);
+ else {
+ assert(0 && "Unknown EndBlock predecessor");
+ }
+ }
/* visit the keep-alives */
- n = get_End_n_keepalives(end);
- for (i = 0; i < n; ++i) {
+ end = get_irg_end(irg);
+ for (i = get_End_n_keepalives(end) - 1; i >= 0; --i) {
ir_node *ka = get_End_keepalive(end, i);
- if (irn_not_visited(ka))
+ if (is_Phi(ka) && irn_not_visited(ka))
dfs(ka, env);
}
current_ir_graph = rem;
walk_env_t env;
FIRM_DBG_REGISTER(dbg, "firm.opt.ldstopt");
- firm_dbg_set_mask(dbg, SET_LEVEL_1);
assert(get_irg_phase_state(irg) != phase_building);
assert(get_irg_pinned(irg) != op_pin_state_floats &&
edges_assure(irg);
- /* loop optimizations need dominators ... */
- assure_doms(irg);
-
/* for Phi optimization post-dominators are needed ... */
assure_postdoms(irg);
projects / libfirm / blobdiff