#include "iredges_t.h"
#include "irtools.h"
-/* Defined in iropt.c */
-pset *new_identities (void);
-void del_identities (pset *value_table);
-void add_identities (pset *value_table, ir_node *node);
-
/*------------------------------------------------------------------*/
/* apply optimizations of iropt to all nodes. */
/*------------------------------------------------------------------*/
if (optimized != n) exchange (n, optimized);
}
+/**
+ * Do local optimizations for a node.
+ *
+ * @param n the IR-node where to start. Typically the End node
+ * of a graph
+ *
+ * @note current_ir_graph must be set
+ */
static INLINE void do_local_optimize(ir_node *n) {
/* Handle graph state */
assert(get_irg_phase_state(current_ir_graph) != phase_building);
irg_walk(n, firm_clear_link, optimize_in_place_wrapper, NULL);
}
+/* Applies local optimizations (see iropt.h) to all nodes reachable from node n */
void local_optimize_node(ir_node *n) {
ir_graph *rem = current_ir_graph;
current_ir_graph = get_irn_irg(n);
*/
static void kill_dead_blocks(ir_node *block, void *env)
{
- if (get_Block_dom_depth(block) < 0)
- if (block != get_irg_end_block(current_ir_graph)) {
- /* we don't want that the end block of graphs with
- endless loops is marked bad (although it is of course */
- set_Block_dead(block);
- }
+ if (get_Block_dom_depth(block) < 0) {
+ /*
+ * Note that the new dominance code correctly handles
+ * the End block, i.e. it is always reachable from Start
+ */
+ set_Block_dead(block);
+ }
}
void
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- if (get_irg_dom_state(current_ir_graph) == dom_consistent)
+ if (get_irg_dom_state(irg) == dom_consistent)
irg_block_walk_graph(irg, NULL, kill_dead_blocks, NULL);
do_local_optimize(get_irg_end(irg));
if (optimized != n) {
const ir_edge_t *edge;
- exchange(n, optimized);
- foreach_out_edge(optimized, edge) {
+ foreach_out_edge(n, edge) {
ir_node *succ = get_edge_src_irn(edge);
if (get_irn_link(succ) != waitq) {
set_irn_link(succ, waitq);
}
}
+ exchange(n, optimized);
}
}
void optimize_graph_df(ir_graph *irg) {
- pdeq *waitq = new_pdeq();
- int state = edges_activated(irg);
+ pdeq *waitq = new_pdeq();
+ int state = edges_activated(irg);
+ ir_graph *rem = current_ir_graph;
+
+ current_ir_graph = irg;
if (! state)
edges_activate(irg);
del_identities(irg->value_table);
irg->value_table = new_identities();
- if (get_irg_dom_state(current_ir_graph) == dom_consistent)
+ if (get_irg_dom_state(irg) == dom_consistent)
irg_block_walk_graph(irg, NULL, kill_dead_blocks, NULL);
/* invalidate info */
/* finish the wait queue */
while (! pdeq_empty(waitq)) {
ir_node *n = pdeq_getl(waitq);
- opt_walker(n, waitq);
+ if (! is_Bad(n))
+ opt_walker(n, waitq);
}
del_pdeq(waitq);
if (! state)
edges_deactivate(irg);
+
+ current_ir_graph = rem;
}
/*- ... and now the keep alives. -*/
/* First pick the not marked block nodes and walk them. We must pick these
first as else we will oversee blocks reachable from Phis. */
- irn_arity = get_irn_arity(oe);
+ irn_arity = get_End_n_keepalives(oe);
for (i = 0; i < irn_arity; i++) {
- ka = get_irn_intra_n(oe, i);
- if (is_Block(ka) &&
- (get_irn_visited(ka) <= vfl)) {
- /* We must keep the block alive and copy everything reachable */
- set_irg_visited(irg, vfl);
- irg_walk(ka, copy_node, copy_preds, INT_TO_PTR(copy_node_nr));
+ ka = get_End_keepalive(oe, i);
+ if (is_Block(ka)) {
+ if (get_irn_visited(ka) <= vfl) {
+ /* We must keep the block alive and copy everything reachable */
+ set_irg_visited(irg, vfl);
+ irg_walk(ka, copy_node, copy_preds, INT_TO_PTR(copy_node_nr));
+ }
add_End_keepalive(ne, get_new_node(ka));
}
}
/* Now pick other nodes. Here we will keep all! */
- irn_arity = get_irn_arity(oe);
+ irn_arity = get_End_n_keepalives(oe);
for (i = 0; i < irn_arity; i++) {
- ka = get_irn_intra_n(oe, i);
+ ka = get_End_keepalive(oe, i);
if (!is_Block(ka)) {
if (get_irn_visited(ka) <= vfl) {
/* We didn't copy the node yet. */
graveyard_obst = irg->obst;
/* A new obstack, where the reachable nodes will be copied to. */
- rebirth_obst = xmalloc (sizeof(*rebirth_obst));
+ rebirth_obst = xmalloc(sizeof(*rebirth_obst));
current_ir_graph->obst = rebirth_obst;
obstack_init (current_ir_graph->obst);
current_ir_graph->last_node_idx = 0;
- /* We also need a new hash table for cse */
- del_identities (irg->value_table);
- irg->value_table = new_identities ();
+ /* We also need a new value table for CSE */
+ del_identities(irg->value_table);
+ irg->value_table = new_identities();
/* Copy the graph from the old to the new obstack */
- copy_graph_env(1);
+ copy_graph_env(/*copy_node_nr=*/1);
/* Free memory from old unoptimized obstack */
obstack_free(graveyard_obst, 0); /* First empty the obstack ... */
int inline_method(ir_node *call, ir_graph *called_graph) {
ir_node *pre_call;
ir_node *post_call, *post_bl;
- ir_node *in[5];
+ ir_node *in[pn_Start_max];
ir_node *end, *end_bl;
ir_node **res_pred;
ir_node **cf_pred;
ir_type *called_frame;
irg_inline_property prop = get_irg_inline_property(called_graph);
- if ( (prop != irg_inline_forced) &&
+ if ( (prop < irg_inline_forced) &&
(!get_opt_optimize() || !get_opt_inline() || (prop == irg_inline_forbidden))) return 0;
/* Do not inline variadic functions. */
graph. Both will end up being a tuple. -- */
post_bl = get_nodes_block(call);
set_irg_current_block(current_ir_graph, post_bl);
- /* XxMxPxP of Start + parameter of Call */
- in[pn_Start_X_initial_exec] = new_Jmp();
- in[pn_Start_M] = get_Call_mem(call);
- in[pn_Start_P_frame_base] = get_irg_frame(current_ir_graph);
- in[pn_Start_P_globals] = get_irg_globals(current_ir_graph);
- in[pn_Start_T_args] = new_Tuple(get_Call_n_params(call), get_Call_param_arr(call));
+ /* XxMxPxPxPxT of Start + parameter of Call */
+ in[pn_Start_X_initial_exec] = new_Jmp();
+ in[pn_Start_M] = get_Call_mem(call);
+ in[pn_Start_P_frame_base] = get_irg_frame(current_ir_graph);
+ in[pn_Start_P_globals] = get_irg_globals(current_ir_graph);
+ in[pn_Start_P_tls] = get_irg_tls(current_ir_graph);
+ in[pn_Start_T_args] = new_Tuple(get_Call_n_params(call), get_Call_param_arr(call));
/* in[pn_Start_P_value_arg_base] = ??? */
- pre_call = new_Tuple(5, in);
+ assert(pn_Start_P_value_arg_base == pn_Start_max - 1 && "pn_Start_P_value_arg_base not supported, fix");
+ pre_call = new_Tuple(pn_Start_max - 1, in);
post_call = call;
/* --
ir_graph *callee;
callee = get_entity_irg(get_SymConst_entity(get_Call_ptr(env.calls[i])));
if (((_obstack_memory_used(callee->obst) - (int)obstack_room(callee->obst)) < size) ||
- (get_irg_inline_property(callee) == irg_inline_forced)) {
+ (get_irg_inline_property(callee) >= irg_inline_forced)) {
inline_method(env.calls[i], callee);
}
}
if (callee &&
((is_smaller(callee, size) && (env->n_nodes < maxsize)) || /* small function */
- (get_irg_inline_property(callee) == irg_inline_forced))) {
+ (get_irg_inline_property(callee) >= irg_inline_forced))) {
if (!phiproj_computed) {
phiproj_computed = 1;
collect_phiprojs(current_ir_graph);
projects / libfirm / blobdiff