-}
-
-/**
- * Make a new Survive DCE environment.
- */
-survive_dce_t *new_survive_dce(void) {
- survive_dce_t *res = xmalloc(sizeof(res[0]));
- obstack_init(&res->obst);
- res->places = pmap_create();
- res->new_places = NULL;
-
- res->dead_node_elim.hook._hook_dead_node_elim = dead_node_hook;
- res->dead_node_elim.context = res;
- res->dead_node_elim.next = NULL;
-
- res->dead_node_elim_subst.hook._hook_dead_node_elim_subst = dead_node_subst_hook;
- res->dead_node_elim_subst.context = res;
- res->dead_node_elim_subst.next = NULL;
-
-#ifndef FIRM_ENABLE_HOOKS
- assert(0 && "need hooks enabled");
-#endif
-
- register_hook(hook_dead_node_elim, &res->dead_node_elim);
- register_hook(hook_dead_node_elim_subst, &res->dead_node_elim_subst);
- return res;
-}
-
-/**
- * Free a Survive DCE environment.
- */
-void free_survive_dce(survive_dce_t *sd) {
- obstack_free(&sd->obst, NULL);
- pmap_destroy(sd->places);
- unregister_hook(hook_dead_node_elim, &sd->dead_node_elim);
- unregister_hook(hook_dead_node_elim_subst, &sd->dead_node_elim_subst);
- xfree(sd);
-}
-
-/**
- * Register a node pointer to be patched upon DCE.
- * When DCE occurs, the node pointer specified by @p place will be
- * patched to the new address of the node it is pointing to.
- *
- * @param sd The Survive DCE environment.
- * @param place The address of the node pointer.
- */
-void survive_dce_register_irn(survive_dce_t *sd, ir_node **place) {
- if (*place != NULL) {
- ir_node *irn = *place;
- survive_dce_list_t *curr = pmap_get(sd->places, irn);
- survive_dce_list_t *nw = obstack_alloc(&sd->obst, sizeof(nw[0]));
-
- nw->next = curr;
- nw->place = place;
-
- pmap_insert(sd->places, irn, nw);
- }
-}
-
-/*--------------------------------------------------------------------*/
-/* Functionality for inlining */
-/*--------------------------------------------------------------------*/
-
-/**
- * Copy node for inlineing. Updates attributes that change when
- * inlineing but not for dead node elimination.
- *
- * Copies the node by calling copy_node() and then updates the entity if
- * it's a local one. env must be a pointer of the frame type of the
- * inlined procedure. The new entities must be in the link field of
- * the entities.
- */
-static INLINE void
-copy_node_inline(ir_node *n, void *env) {
- ir_node *nn;
- ir_type *frame_tp = (ir_type *)env;
-
- copy_node(n, NULL);
- if (is_Sel(n)) {
- nn = get_new_node (n);
- assert(is_Sel(nn));
- if (get_entity_owner(get_Sel_entity(n)) == frame_tp) {
- set_Sel_entity(nn, get_entity_link(get_Sel_entity(n)));
- }
- } else if (is_Block(n)) {
- nn = get_new_node (n);
- nn->attr.block.irg = current_ir_graph;
- }
-}
-
-/**
- * Walker: checks if P_value_arg_base is used.
- */
-static void find_addr(ir_node *node, void *env) {
- int *allow_inline = env;
- if (is_Proj(node) &&
- is_Start(get_Proj_pred(node)) &&
- get_Proj_proj(node) == pn_Start_P_value_arg_base) {
- *allow_inline = 0;
- }
-}
-
-/**
- * Check if we can inline a given call.
- * Currently, we cannot inline two cases:
- * - call with compound arguments
- * - graphs that take the address of a parameter
- *
- * check these conditions here
- */
-static int can_inline(ir_node *call, ir_graph *called_graph) {
- ir_type *call_type = get_Call_type(call);
- int params, ress, i, res;
- assert(is_Method_type(call_type));
-
- params = get_method_n_params(call_type);
- ress = get_method_n_ress(call_type);
-
- /* check parameters for compound arguments */
- for (i = 0; i < params; ++i) {
- ir_type *p_type = get_method_param_type(call_type, i);
-
- if (is_compound_type(p_type))
- return 0;
- }
-
- /* check results for compound arguments */
- for (i = 0; i < ress; ++i) {
- ir_type *r_type = get_method_res_type(call_type, i);
-
- if (is_compound_type(r_type))
- return 0;
- }
-
- res = 1;
- irg_walk_graph(called_graph, find_addr, NULL, &res);
-
- return res;
-}
-
-enum exc_mode {
- exc_handler = 0, /**< There is a handler. */
- exc_to_end = 1, /**< Branches to End. */
- exc_no_handler = 2 /**< Exception handling not represented. */
-};
-
-/* Inlines a method at the given call site. */
-int inline_method(ir_node *call, ir_graph *called_graph) {
- ir_node *pre_call;
- ir_node *post_call, *post_bl;
- ir_node *in[pn_Start_max];
- ir_node *end, *end_bl;
- ir_node **res_pred;
- ir_node **cf_pred;
- ir_node *ret, *phi;
- int arity, n_ret, n_exc, n_res, i, n, j, rem_opt, irn_arity;
- enum exc_mode exc_handling;
- ir_type *called_frame, *curr_frame;
- irg_inline_property prop = get_irg_inline_property(called_graph);
- ir_entity *ent;
-
- if (prop == irg_inline_forbidden)
- return 0;
-
- ent = get_irg_entity(called_graph);
-
- /* Do not inline variadic functions. */
- if (get_method_variadicity(get_entity_type(ent)) == variadicity_variadic)
- return 0;
-
- assert(get_method_n_params(get_entity_type(ent)) ==
- get_method_n_params(get_Call_type(call)));
-
- /*
- * We cannot inline a recursive call. The graph must be copied before
- * the call the inline_method() using create_irg_copy().
- */
- if (called_graph == current_ir_graph)
- return 0;
-
- /*
- * currently, we cannot inline two cases:
- * - call with compound arguments
- * - graphs that take the address of a parameter
- */
- if (! can_inline(call, called_graph))
- return 0;
-
- /* -- Turn off optimizations, this can cause problems when allocating new nodes. -- */
- rem_opt = get_opt_optimize();
- set_optimize(0);
-
- /* Handle graph state */
- assert(get_irg_phase_state(current_ir_graph) != phase_building);
- assert(get_irg_pinned(current_ir_graph) == op_pin_state_pinned);
- assert(get_irg_pinned(called_graph) == op_pin_state_pinned);
- set_irg_outs_inconsistent(current_ir_graph);
- set_irg_extblk_inconsistent(current_ir_graph);
- set_irg_doms_inconsistent(current_ir_graph);
- set_irg_loopinfo_inconsistent(current_ir_graph);
- set_irg_callee_info_state(current_ir_graph, irg_callee_info_inconsistent);
-
- /* -- Check preconditions -- */
- assert(is_Call(call));
-
- /* here we know we WILL inline, so inform the statistics */
- hook_inline(call, called_graph);
-
- /* -- Decide how to handle exception control flow: Is there a handler
- for the Call node, or do we branch directly to End on an exception?
- exc_handling:
- 0 There is a handler.
- 1 Branches to End.
- 2 Exception handling not represented in Firm. -- */
- {
- ir_node *proj, *Mproj = NULL, *Xproj = NULL;
- for (proj = get_irn_link(call); proj; proj = get_irn_link(proj)) {
- long proj_nr = get_Proj_proj(proj);
- if (proj_nr == pn_Call_X_except) Xproj = proj;
- if (proj_nr == pn_Call_M_except) Mproj = proj;
- }
- if (Mproj) { assert(Xproj); exc_handling = exc_handler; } /* Mproj */
- else if (Xproj) { exc_handling = exc_to_end; } /* !Mproj && Xproj */
- else { exc_handling = exc_no_handler; } /* !Mproj && !Xproj */
- }
-
- /* --
- the procedure and later replaces the Start node of the called graph.
- Post_call is the old Call node and collects the results of the called
- graph. Both will end up being a tuple. -- */
- post_bl = get_nodes_block(call);
- set_irg_current_block(current_ir_graph, post_bl);
- /* 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] = ??? */
- 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;
-
- /* --
- The new block gets the ins of the old block, pre_call and all its
- predecessors and all Phi nodes. -- */
- part_block(pre_call);
-
- /* -- Prepare state for dead node elimination -- */
- /* Visited flags in calling irg must be >= flag in called irg.
- Else walker and arity computation will not work. */
- if (get_irg_visited(current_ir_graph) <= get_irg_visited(called_graph))
- set_irg_visited(current_ir_graph, get_irg_visited(called_graph)+1);
- if (get_irg_block_visited(current_ir_graph)< get_irg_block_visited(called_graph))
- set_irg_block_visited(current_ir_graph, get_irg_block_visited(called_graph));
- /* Set pre_call as new Start node in link field of the start node of
- calling graph and pre_calls block as new block for the start block
- of calling graph.
- Further mark these nodes so that they are not visited by the
- copying. */
- set_irn_link(get_irg_start(called_graph), pre_call);
- set_irn_visited(get_irg_start(called_graph), get_irg_visited(current_ir_graph));
- set_irn_link(get_irg_start_block(called_graph), get_nodes_block(pre_call));
- set_irn_visited(get_irg_start_block(called_graph), get_irg_visited(current_ir_graph));
- set_irn_link(get_irg_bad(called_graph), get_irg_bad(current_ir_graph));
- set_irn_visited(get_irg_bad(called_graph), get_irg_visited(current_ir_graph));
-
- /* Initialize for compaction of in arrays */
- inc_irg_block_visited(current_ir_graph);
-
- /* -- Replicate local entities of the called_graph -- */
- /* copy the entities. */
- called_frame = get_irg_frame_type(called_graph);
- curr_frame = get_irg_frame_type(current_ir_graph);
- for (i = 0, n = get_class_n_members(called_frame); i < n; ++i) {
- ir_entity *new_ent, *old_ent;
- old_ent = get_class_member(called_frame, i);
- new_ent = copy_entity_own(old_ent, curr_frame);
- set_entity_link(old_ent, new_ent);
- }
-
- /* visited is > than that of called graph. With this trick visited will
- remain unchanged so that an outer walker, e.g., searching the call nodes
- to inline, calling this inline will not visit the inlined nodes. */
- set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1);
-
- /* -- Performing dead node elimination inlines the graph -- */
- /* Copies the nodes to the obstack of current_ir_graph. Updates links to new
- entities. */
- irg_walk(get_irg_end(called_graph), copy_node_inline, copy_preds,
- get_irg_frame_type(called_graph));
-
- /* Repair called_graph */
- set_irg_visited(called_graph, get_irg_visited(current_ir_graph));
- set_irg_block_visited(called_graph, get_irg_block_visited(current_ir_graph));
- set_Block_block_visited(get_irg_start_block(called_graph), 0);
-
- /* -- Merge the end of the inlined procedure with the call site -- */
- /* We will turn the old Call node into a Tuple with the following
- predecessors:
- -1: Block of Tuple.
- 0: Phi of all Memories of Return statements.
- 1: Jmp from new Block that merges the control flow from all exception
- predecessors of the old end block.
- 2: Tuple of all arguments.
- 3: Phi of Exception memories.
- In case the old Call directly branches to End on an exception we don't
- need the block merging all exceptions nor the Phi of the exception
- memories.
- */
-
- /* -- Precompute some values -- */
- end_bl = get_new_node(get_irg_end_block(called_graph));
- end = get_new_node(get_irg_end(called_graph));
- arity = get_irn_arity(end_bl); /* arity = n_exc + n_ret */
- n_res = get_method_n_ress(get_Call_type(call));
-
- res_pred = xmalloc(n_res * sizeof(*res_pred));
- cf_pred = xmalloc(arity * sizeof(*res_pred));
-
- set_irg_current_block(current_ir_graph, post_bl); /* just to make sure */
-
- /* -- archive keepalives -- */
- irn_arity = get_irn_arity(end);
- for (i = 0; i < irn_arity; i++) {
- ir_node *ka = get_End_keepalive(end, i);
- if (! is_Bad(ka))
- add_End_keepalive(get_irg_end(current_ir_graph), ka);
- }
-
- /* The new end node will die. We need not free as the in array is on the obstack:
- copy_node() only generated 'D' arrays. */
-
- /* -- Replace Return nodes by Jump nodes. -- */
- n_ret = 0;
- for (i = 0; i < arity; i++) {
- ir_node *ret;
- ret = get_irn_n(end_bl, i);
- if (is_Return(ret)) {
- cf_pred[n_ret] = new_r_Jmp(current_ir_graph, get_nodes_block(ret));
- n_ret++;
- }
- }
- set_irn_in(post_bl, n_ret, cf_pred);
-
- /* -- Build a Tuple for all results of the method.
- Add Phi node if there was more than one Return. -- */
- turn_into_tuple(post_call, pn_Call_max);
- /* First the Memory-Phi */
- n_ret = 0;
- for (i = 0; i < arity; i++) {
- ret = get_irn_n(end_bl, i);
- if (is_Return(ret)) {
- cf_pred[n_ret] = get_Return_mem(ret);
- n_ret++;
- }
- }
- phi = new_Phi(n_ret, cf_pred, mode_M);
- set_Tuple_pred(call, pn_Call_M_regular, phi);
- /* Conserve Phi-list for further inlinings -- but might be optimized */
- if (get_nodes_block(phi) == post_bl) {
- set_irn_link(phi, get_irn_link(post_bl));
- set_irn_link(post_bl, phi);
- }
- /* Now the real results */
- if (n_res > 0) {
- for (j = 0; j < n_res; j++) {
- n_ret = 0;
- for (i = 0; i < arity; i++) {
- ret = get_irn_n(end_bl, i);
- if (is_Return(ret)) {
- cf_pred[n_ret] = get_Return_res(ret, j);
- n_ret++;
- }
- }
- if (n_ret > 0)
- phi = new_Phi(n_ret, cf_pred, get_irn_mode(cf_pred[0]));
- else
- phi = new_Bad();
- res_pred[j] = phi;
- /* Conserve Phi-list for further inlinings -- but might be optimized */
- if (get_nodes_block(phi) == post_bl) {
- set_Phi_next(phi, get_Block_phis(post_bl));
- set_Block_phis(post_bl, phi);
- }
- }
- set_Tuple_pred(call, pn_Call_T_result, new_Tuple(n_res, res_pred));
- } else {
- set_Tuple_pred(call, pn_Call_T_result, new_Bad());
- }
- /* handle the regular call */
- set_Tuple_pred(call, pn_Call_X_regular, new_Jmp());
-
- /* For now, we cannot inline calls with value_base */
- set_Tuple_pred(call, pn_Call_P_value_res_base, new_Bad());
-
- /* Finally the exception control flow.
- We have two (three) possible situations:
- First if the Call branches to an exception handler: We need to add a Phi node to
- collect the memory containing the exception objects. Further we need
- to add another block to get a correct representation of this Phi. To
- this block we add a Jmp that resolves into the X output of the Call
- when the Call is turned into a tuple.
- Second the Call branches to End, the exception is not handled. Just
- add all inlined exception branches to the End node.
- Third: there is no Exception edge at all. Handle as case two. */
- if (exc_handling == exc_handler) {
- n_exc = 0;
- for (i = 0; i < arity; i++) {
- ir_node *ret, *irn;
- ret = get_irn_n(end_bl, i);
- irn = skip_Proj(ret);
- if (is_fragile_op(irn) || is_Raise(irn)) {
- cf_pred[n_exc] = ret;
- ++n_exc;
- }
- }
- if (n_exc > 0) {
- new_Block(n_exc, cf_pred); /* watch it: current_block is changed! */
- set_Tuple_pred(call, pn_Call_X_except, new_Jmp());
- /* The Phi for the memories with the exception objects */
- n_exc = 0;
- for (i = 0; i < arity; i++) {
- ir_node *ret;
- ret = skip_Proj(get_irn_n(end_bl, i));
- if (is_Call(ret)) {
- cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_block(ret), ret, mode_M, 3);
- n_exc++;
- } else if (is_fragile_op(ret)) {
- /* We rely that all cfops have the memory output at the same position. */
- cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_block(ret), ret, mode_M, 0);
- n_exc++;
- } else if (is_Raise(ret)) {
- cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_block(ret), ret, mode_M, 1);
- n_exc++;
- }
- }
- set_Tuple_pred(call, pn_Call_M_except, new_Phi(n_exc, cf_pred, mode_M));
- } else {
- set_Tuple_pred(call, pn_Call_X_except, new_Bad());
- set_Tuple_pred(call, pn_Call_M_except, new_Bad());
- }
- } else {
- ir_node *main_end_bl;
- int main_end_bl_arity;
- ir_node **end_preds;
-
- /* assert(exc_handling == 1 || no exceptions. ) */
- n_exc = 0;
- for (i = 0; i < arity; i++) {
- ir_node *ret = get_irn_n(end_bl, i);
- ir_node *irn = skip_Proj(ret);
-
- if (is_fragile_op(irn) || is_Raise(irn)) {
- cf_pred[n_exc] = ret;
- n_exc++;
- }
- }
- main_end_bl = get_irg_end_block(current_ir_graph);
- main_end_bl_arity = get_irn_arity(main_end_bl);
- end_preds = xmalloc((n_exc + main_end_bl_arity) * sizeof(*end_preds));
-
- for (i = 0; i < main_end_bl_arity; ++i)
- end_preds[i] = get_irn_n(main_end_bl, i);
- for (i = 0; i < n_exc; ++i)
- end_preds[main_end_bl_arity + i] = cf_pred[i];
- set_irn_in(main_end_bl, n_exc + main_end_bl_arity, end_preds);
- set_Tuple_pred(call, pn_Call_X_except, new_Bad());
- set_Tuple_pred(call, pn_Call_M_except, new_Bad());
- free(end_preds);
- }
- free(res_pred);
- free(cf_pred);
-
- /* -- Turn CSE back on. -- */
- set_optimize(rem_opt);
-
- return 1;
-}
-
-/********************************************************************/
-/* Apply inlineing to small methods. */
-/********************************************************************/
-
-/** Represents a possible inlinable call in a graph. */
-typedef struct _call_entry call_entry;
-struct _call_entry {
- ir_node *call; /**< the Call */
- ir_graph *callee; /**< the callee called here */
- call_entry *next; /**< for linking the next one */
- unsigned weight; /**< the weight of the call */
-};
-
-/**
- * environment for inlining small irgs
- */
-typedef struct _inline_env_t {
- struct obstack obst; /**< an obstack where call_entries are allocated on. */
- call_entry *head; /**< the head of the call entry list */
- call_entry *tail; /**< the tail of the call entry list */
-} inline_env_t;
-
-/**
- * Returns the irg called from a Call node. If the irg is not
- * known, NULL is returned.
- *
- * @param call the call node
- */
-static ir_graph *get_call_called_irg(ir_node *call) {
- ir_node *addr;
-
- addr = get_Call_ptr(call);
- if (is_Global(addr)) {
- ir_entity *ent = get_Global_entity(addr);
- return get_entity_irg(ent);
- }
-
- return NULL;
-}
-
-/**
- * Walker: Collect all calls to known graphs inside a graph.
- */
-static void collect_calls(ir_node *call, void *env) {
- if (is_Call(call)) {
- ir_graph *called_irg = get_call_called_irg(call);
-
- if (called_irg != NULL) {
- /* The Call node calls a locally defined method. Remember to inline. */
- inline_env_t *ienv = env;
- call_entry *entry = obstack_alloc(&ienv->obst, sizeof(*entry));
- entry->call = call;
- entry->callee = called_irg;
- entry->next = NULL;
- entry->weight = 0;
-
- if (ienv->tail == NULL)
- ienv->head = entry;
- else
- ienv->tail->next = entry;
- ienv->tail = entry;
- }
- }
-}
-
-/**
- * Inlines all small methods at call sites where the called address comes
- * from a Const node that references the entity representing the called
- * method.
- * The size argument is a rough measure for the code size of the method:
- * Methods where the obstack containing the firm graph is smaller than
- * size are inlined.
- */
-void inline_small_irgs(ir_graph *irg, int size) {
- ir_graph *rem = current_ir_graph;
- inline_env_t env;
- call_entry *entry;
- DEBUG_ONLY(firm_dbg_module_t *dbg;)