/* Interprocedural analyses.
- Copyright (C) 2005 Free Software Foundation, Inc.
+ Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "ipa-prop.h"
#include "tree-flow.h"
#include "tree-pass.h"
+#include "tree-inline.h"
#include "flags.h"
#include "timevar.h"
+#include "flags.h"
+#include "diagnostic.h"
-/* This file contains interfaces that can be used for various IPA
- optimizations:
-
- - ipa_methodlist interface - It is used to create and handle a temporary
- worklist used in the propagation stage of IPCP. (can be used for more
- IPA optimizations).
-
- - ipa_callsite interface - for each callsite this interface creates and
- handles ipa_edge structure associated with it.
-
- - ipa_method interface - for each method this interface creates and
- handles ipa_node structure associated with it. */
-
-/* ipa_methodlist interface. */
-
-/* Create a new worklist node. */
-static inline ipa_methodlist_p
-ipa_create_methodlist_node (void)
-{
- return (ipa_methodlist_p) xcalloc (1, sizeof (struct ipa_methodlist));
-}
-
-/* Return true if worklist WL is empty. */
-bool
-ipa_methodlist_not_empty (ipa_methodlist_p wl)
-{
- return (wl != NULL);
-}
-
-/* Return the method in worklist element WL. */
-static inline struct cgraph_node *
-ipa_methodlist_method (ipa_methodlist_p wl)
-{
- return wl->method_p;
-}
-
-/* Make worklist element WL point to method MT in the callgraph. */
-static inline void
-ipa_methodlist_method_set (ipa_methodlist_p wl, struct cgraph_node *mt)
-{
- wl->method_p = mt;
-}
+/* Vector where the parameter infos are actually stored. */
+VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
+/* Vector where the parameter infos are actually stored. */
+VEC (ipa_edge_args_t, heap) *ipa_edge_args_vector;
-/* Return the next element in the worklist following worklist
- element WL. */
-static inline ipa_methodlist_p
-ipa_methodlist_next_method (ipa_methodlist_p wl)
-{
- return wl->next_method;
-}
+/* Holders of ipa cgraph hooks: */
+static struct cgraph_edge_hook_list *edge_removal_hook_holder;
+static struct cgraph_node_hook_list *node_removal_hook_holder;
+static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
+static struct cgraph_2node_hook_list *node_duplication_hook_holder;
-/* Set worklist element WL1 to point to worklist element WL2. */
-static inline void
-ipa_methodlist_next_method_set (ipa_methodlist_p wl1, ipa_methodlist_p wl2)
-{
- wl1->next_method = wl2;
-}
+/* Initialize worklist to contain all functions. */
-/* Initialize worklist to contain all methods. */
-ipa_methodlist_p
-ipa_methodlist_init (void)
+struct ipa_func_list *
+ipa_init_func_list (void)
{
struct cgraph_node *node;
- ipa_methodlist_p wl;
+ struct ipa_func_list * wl;
wl = NULL;
for (node = cgraph_nodes; node; node = node->next)
- ipa_add_method (&wl, node);
+ if (node->analyzed)
+ {
+ /* Unreachable nodes should have been eliminated before ipcp and
+ inlining. */
+ gcc_assert (node->needed || node->reachable);
+ ipa_push_func_to_list (&wl, node);
+ }
return wl;
}
-/* Add method MT to the worklist. Set worklist element WL
+/* Add cgraph node MT to the worklist. Set worklist element WL
to point to MT. */
+
void
-ipa_add_method (ipa_methodlist_p * wl, struct cgraph_node *mt)
+ipa_push_func_to_list (struct ipa_func_list **wl, struct cgraph_node *mt)
{
- ipa_methodlist_p temp;
+ struct ipa_func_list *temp;
- temp = ipa_create_methodlist_node ();
- ipa_methodlist_method_set (temp, mt);
- ipa_methodlist_next_method_set (temp, *wl);
+ temp = XCNEW (struct ipa_func_list);
+ temp->node = mt;
+ temp->next = *wl;
*wl = temp;
}
-/* Remove a method from the worklist. WL points to the first
+/* Remove a function from the worklist. WL points to the first
element in the list, which is removed. */
+
struct cgraph_node *
-ipa_remove_method (ipa_methodlist_p * wl)
+ipa_pop_func_from_list (struct ipa_func_list ** wl)
{
- ipa_methodlist_p first;
- struct cgraph_node *return_method;
+ struct ipa_func_list *first;
+ struct cgraph_node *return_func;
first = *wl;
- *wl = ipa_methodlist_next_method (*wl);
- return_method = ipa_methodlist_method (first);
+ *wl = (*wl)->next;
+ return_func = first->node;
free (first);
- return return_method;
+ return return_func;
}
-/* ipa_method interface. */
+/* Return index of the formal whose tree is PTREE in function which corresponds
+ to INFO. */
-/* Return number of formals of method MT. */
-int
-ipa_method_formal_count (struct cgraph_node *mt)
-{
- return IPA_NODE_REF (mt)->ipa_arg_num;
-}
-
-/* Set number of formals of method MT to I. */
-void
-ipa_method_formal_count_set (struct cgraph_node *mt, int i)
-{
- IPA_NODE_REF (mt)->ipa_arg_num = i;
-}
-
-/* Return whether I-th formal of MT is modified in MT. */
-static inline bool
-ipa_method_is_modified (struct cgraph_node *mt, int i)
-{
- return IPA_NODE_REF (mt)->ipa_mod[i];
-}
-
-/* Return the tree of I-th formal of MT. */
-tree
-ipa_method_get_tree (struct cgraph_node *mt, int i)
-{
- return IPA_NODE_REF (mt)->ipa_param_tree[i];
-}
-
-/* Create tree map structure for MT. */
-static inline void
-ipa_method_tree_map_create (struct cgraph_node *mt)
-{
- IPA_NODE_REF (mt)->ipa_param_tree =
- xcalloc (ipa_method_formal_count (mt), sizeof (tree));
-}
-
-/* Create modify structure for MT. */
-static inline void
-ipa_method_modify_create (struct cgraph_node *mt)
-{
- ((struct ipa_node *) mt->aux)->ipa_mod =
- xcalloc (ipa_method_formal_count (mt), sizeof (bool));
-}
-
-/* Set modify of I-th formal of MT to VAL. */
-static inline void
-ipa_method_modify_set (struct cgraph_node *mt, int i, bool val)
-{
- IPA_NODE_REF (mt)->ipa_mod[i] = val;
-}
-
-/* Return index of the formal whose tree is PTREE in method MT. */
static int
-ipa_method_tree_map (struct cgraph_node *mt, tree ptree)
+ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
{
int i, count;
- count = ipa_method_formal_count (mt);
+ count = ipa_get_param_count (info);
for (i = 0; i < count; i++)
- if (IPA_NODE_REF (mt)->ipa_param_tree[i] == ptree)
+ if (ipa_get_param(info, i) == ptree)
return i;
return -1;
}
-/* Insert the formal trees to the ipa_param_tree array in method MT. */
-void
-ipa_method_compute_tree_map (struct cgraph_node *mt)
+/* Populate the param_decl field in parameter descriptors of INFO that
+ corresponds to NODE. */
+
+static void
+ipa_populate_param_decls (struct cgraph_node *node,
+ struct ipa_node_params *info)
{
tree fndecl;
tree fnargs;
tree parm;
int param_num;
- ipa_method_tree_map_create (mt);
- fndecl = mt->decl;
+ fndecl = node->decl;
fnargs = DECL_ARGUMENTS (fndecl);
param_num = 0;
for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
{
- IPA_NODE_REF (mt)->ipa_param_tree[param_num] = parm;
+ info->params[param_num].decl = parm;
param_num++;
}
}
-/* Count number of formals in MT. Insert the result to the
- ipa_node. */
-void
-ipa_method_formal_compute_count (struct cgraph_node *mt)
+/* Count number of formal parameters in NOTE. Store the result to the
+ appropriate field of INFO. */
+
+static void
+ipa_count_formal_params (struct cgraph_node *node,
+ struct ipa_node_params *info)
{
tree fndecl;
tree fnargs;
tree parm;
int param_num;
- fndecl = mt->decl;
+ fndecl = node->decl;
fnargs = DECL_ARGUMENTS (fndecl);
param_num = 0;
for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
param_num++;
- ipa_method_formal_count_set (mt, param_num);
+ ipa_set_param_count (info, param_num);
}
-/* Check STMT to detect whether a formal is modified within MT,
- the appropriate entry is updated in the ipa_mod array of ipa_node
- (associated with MT). */
-static void
-ipa_method_modify_stmt (struct cgraph_node *mt, tree stmt)
+/* Initialize the ipa_node_params structure associated with NODE by counting
+ the function parameters, creating the descriptors and populating their
+ param_decls. */
+
+void
+ipa_initialize_node_params (struct cgraph_node *node)
{
- int i, j;
+ struct ipa_node_params *info = IPA_NODE_REF (node);
- switch (TREE_CODE (stmt))
+ if (!info->params)
{
- case MODIFY_EXPR:
- if (TREE_CODE (TREE_OPERAND (stmt, 0)) == PARM_DECL)
- {
- i = ipa_method_tree_map (mt, TREE_OPERAND (stmt, 0));
- if (i >= 0)
- ipa_method_modify_set (mt, i, true);
- }
- break;
- case ASM_EXPR:
- /* Asm code could modify any of the parameters. */
- for (j = 0; j < ipa_method_formal_count (mt); j++)
- ipa_method_modify_set (mt, j, true);
- break;
- default:
- break;
+ ipa_count_formal_params (node, info);
+ info->params = XCNEWVEC (struct ipa_param_descriptor,
+ ipa_get_param_count (info));
+ ipa_populate_param_decls (node, info);
}
}
-/* Initialize ipa_mod array of MT. */
-static void
-ipa_method_modify_init (struct cgraph_node *mt)
+/* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
+ parameters. If OP is a parameter declaration, mark it as modified in the
+ info structure passed in DATA. */
+
+static bool
+visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
+ tree op, void *data)
{
- int i, count;
+ struct ipa_node_params *info = (struct ipa_node_params *) data;
- ipa_method_modify_create (mt);
- count = ipa_method_formal_count (mt);
- for (i = 0; i < count; i++)
- ipa_method_modify_set (mt, i, false);
+ if (TREE_CODE (op) == PARM_DECL)
+ {
+ int index = ipa_get_param_decl_index (info, op);
+ gcc_assert (index >= 0);
+ info->params[index].modified = true;
+ }
+
+ return false;
}
-/* The modify computation driver for MT. Compute which formal arguments
- of method MT are locally modified. Formals may be modified in MT
- if their address is taken, or if
- they appear on the left hand side of an assignment. */
+/* Compute which formal parameters of function associated with NODE are locally
+ modified or their address is taken. Note that this does not apply on
+ parameters with SSA names but those can and should be analyzed
+ differently. */
+
void
-ipa_method_compute_modify (struct cgraph_node *mt)
+ipa_detect_param_modifications (struct cgraph_node *node)
{
- tree decl;
- tree body;
- int j, count;
+ tree decl = node->decl;
basic_block bb;
struct function *func;
- block_stmt_iterator bsi;
- tree stmt, parm_tree;
-
- ipa_method_modify_init (mt);
- decl = mt->decl;
- count = ipa_method_formal_count (mt);
- /* ??? Handle pending sizes case. Set all parameters
- of the method to be modified. */
- if (DECL_UNINLINABLE (decl))
+ gimple_stmt_iterator gsi;
+ struct ipa_node_params *info = IPA_NODE_REF (node);
+
+ if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
+ return;
+
+ func = DECL_STRUCT_FUNCTION (decl);
+ FOR_EACH_BB_FN (bb, func)
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info, NULL,
+ visit_store_addr_for_mod_analysis,
+ visit_store_addr_for_mod_analysis);
+
+ info->modification_analysis_done = 1;
+}
+
+/* Count number of arguments callsite CS has and store it in
+ ipa_edge_args structure corresponding to this callsite. */
+
+void
+ipa_count_arguments (struct cgraph_edge *cs)
+{
+ gimple stmt;
+ int arg_num;
+
+ stmt = cs->call_stmt;
+ gcc_assert (is_gimple_call (stmt));
+ arg_num = gimple_call_num_args (stmt);
+ if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
+ <= (unsigned) cgraph_edge_max_uid)
+ VEC_safe_grow_cleared (ipa_edge_args_t, heap,
+ ipa_edge_args_vector, cgraph_edge_max_uid + 1);
+ ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
+}
+
+/* Print the jump functions of all arguments on all call graph edges going from
+ NODE to file F. */
+
+void
+ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
+{
+ int i, count;
+ struct cgraph_edge *cs;
+ struct ipa_jump_func *jump_func;
+ enum jump_func_type type;
+
+ fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
+ for (cs = node->callees; cs; cs = cs->next_callee)
{
- for (j = 0; j < count; j++)
- ipa_method_modify_set (mt, j, true);
- return;
+ if (!ipa_edge_args_info_available_for_edge_p (cs))
+ continue;
+
+ fprintf (f, " callsite %s ", cgraph_node_name (node));
+ fprintf (f, "-> %s :: \n", cgraph_node_name (cs->callee));
+
+ count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
+ for (i = 0; i < count; i++)
+ {
+ jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
+ type = jump_func->type;
+
+ fprintf (f, " param %d: ", i);
+ if (type == IPA_JF_UNKNOWN)
+ fprintf (f, "UNKNOWN\n");
+ else if (type == IPA_JF_CONST)
+ {
+ tree val = jump_func->value.constant;
+ fprintf (f, "CONST: ");
+ print_generic_expr (f, val, 0);
+ fprintf (f, "\n");
+ }
+ else if (type == IPA_JF_CONST_MEMBER_PTR)
+ {
+ fprintf (f, "CONST MEMBER PTR: ");
+ print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
+ fprintf (f, ", ");
+ print_generic_expr (f, jump_func->value.member_cst.delta, 0);
+ fprintf (f, "\n");
+ }
+ else if (type == IPA_JF_PASS_THROUGH)
+ {
+ fprintf (f, "PASS THROUGH: ");
+ fprintf (f, "%d\n", jump_func->value.formal_id);
+ }
+ }
}
- /* Formals whose address is taken are considered modified. */
- for (j = 0; j < count; j++)
+}
+
+/* Print ipa_jump_func data structures of all nodes in the call graph to F. */
+
+void
+ipa_print_all_jump_functions (FILE *f)
+{
+ struct cgraph_node *node;
+
+ fprintf (f, "\nJump functions:\n");
+ for (node = cgraph_nodes; node; node = node->next)
{
- parm_tree = ipa_method_get_tree (mt, j);
- if (TREE_ADDRESSABLE (parm_tree))
- ipa_method_modify_set (mt, j, true);
+ ipa_print_node_jump_functions (f, node);
}
- body = DECL_SAVED_TREE (decl);
- if (body != NULL)
+}
+
+/* Determine the jump functions of scalar arguments. Scalar means SSA names
+ and constants of a number of selected types. INFO is the ipa_node_params
+ structure associated with the caller, FUNCTIONS is a pointer to an array of
+ jump function structures associated with CALL which is the call statement
+ being examined.*/
+
+static void
+compute_scalar_jump_functions (struct ipa_node_params *info,
+ struct ipa_jump_func *functions,
+ gimple call)
+{
+ tree arg;
+ unsigned num = 0;
+
+ for (num = 0; num < gimple_call_num_args (call); num++)
{
- func = DECL_STRUCT_FUNCTION (decl);
- FOR_EACH_BB_FN (bb, func)
- {
- for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
- {
- stmt = bsi_stmt (bsi);
- ipa_method_modify_stmt (mt, stmt);
- }
- }
+ arg = gimple_call_arg (call, num);
+
+ if (is_gimple_ip_invariant (arg))
+ {
+ functions[num].type = IPA_JF_CONST;
+ functions[num].value.constant = arg;
+ }
+ else if ((TREE_CODE (arg) == SSA_NAME) && SSA_NAME_IS_DEFAULT_DEF (arg))
+ {
+ int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
+
+ if (index >= 0)
+ {
+ functions[num].type = IPA_JF_PASS_THROUGH;
+ functions[num].value.formal_id = index;
+ }
+ }
}
}
+/* Inspect the given TYPE and return true iff it has the same structure (the
+ same number of fields of the same types) as a C++ member pointer. If
+ METHOD_PTR and DELTA are non-NULL, store the trees representing the
+ corresponding fields there. */
+
+static bool
+type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
+{
+ tree fld;
+
+ if (TREE_CODE (type) != RECORD_TYPE)
+ return false;
+
+ fld = TYPE_FIELDS (type);
+ if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
+ || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
+ return false;
+
+ if (method_ptr)
+ *method_ptr = fld;
+
+ fld = TREE_CHAIN (fld);
+ if (!fld || INTEGRAL_TYPE_P (fld))
+ return false;
+ if (delta)
+ *delta = fld;
+
+ if (TREE_CHAIN (fld))
+ return false;
+
+ return true;
+}
-/* ipa_callsite interface. */
+/* Go through arguments of the CALL and for every one that looks like a member
+ pointer, check whether it can be safely declared pass-through and if so,
+ mark that to the corresponding item of jump FUNCTIONS. Return true iff
+ there are non-pass-through member pointers within the arguments. INFO
+ describes formal parameters of the caller. */
-/* Return number of arguments in callsite CS. */
-int
-ipa_callsite_param_count (struct cgraph_edge *cs)
+static bool
+compute_pass_through_member_ptrs (struct ipa_node_params *info,
+ struct ipa_jump_func *functions,
+ gimple call)
{
- return IPA_EDGE_REF (cs)->ipa_param_num;
+ bool undecided_members = false;
+ unsigned num;
+ tree arg;
+
+ for (num = 0; num < gimple_call_num_args (call); num++)
+ {
+ arg = gimple_call_arg (call, num);
+
+ if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
+ {
+ if (TREE_CODE (arg) == PARM_DECL)
+ {
+ int index = ipa_get_param_decl_index (info, arg);
+
+ gcc_assert (index >=0);
+ if (!ipa_is_param_modified (info, index))
+ {
+ functions[num].type = IPA_JF_PASS_THROUGH;
+ functions[num].value.formal_id = index;
+ }
+ else
+ undecided_members = true;
+ }
+ else
+ undecided_members = true;
+ }
+ }
+
+ return undecided_members;
}
-/* Set number of arguments in callsite CS to I. */
-void
-ipa_callsite_param_count_set (struct cgraph_edge *cs, int i)
+/* Simple function filling in a member pointer constant jump function (with PFN
+ and DELTA as the constant value) into JFUNC. */
+
+static void
+fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
+ tree pfn, tree delta)
{
- IPA_EDGE_REF (cs)->ipa_param_num = i;
+ jfunc->type = IPA_JF_CONST_MEMBER_PTR;
+ jfunc->value.member_cst.pfn = pfn;
+ jfunc->value.member_cst.delta = delta;
}
-/* Return the jump function (ipa_jump_func struct) for argument I of
- callsite CS. */
-struct ipa_jump_func *
-ipa_callsite_param (struct cgraph_edge *cs, int i)
+/* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
+ return the rhs of its defining statement. */
+
+static inline tree
+get_ssa_def_if_simple_copy (tree rhs)
{
- return &(IPA_EDGE_REF (cs)->ipa_param_map[i]);
+ while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
+ {
+ gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
+
+ if (gimple_assign_single_p (def_stmt))
+ rhs = gimple_assign_rhs1 (def_stmt);
+ else
+ break;
+ }
+ return rhs;
}
-/* return the callee (cgraph_node) of callsite CS. */
-struct cgraph_node *
-ipa_callsite_callee (struct cgraph_edge *cs)
+/* Traverse statements from CALL backwards, scanning whether the argument ARG
+ which is a member pointer is filled in with constant values. If it is, fill
+ the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
+ fields of the record type of the member pointer. To give an example, we
+ look for a pattern looking like the following:
+
+ D.2515.__pfn ={v} printStuff;
+ D.2515.__delta ={v} 0;
+ i_1 = doprinting (D.2515); */
+
+static void
+determine_cst_member_ptr (gimple call, tree arg, tree method_field,
+ tree delta_field, struct ipa_jump_func *jfunc)
{
- return cs->callee;
+ gimple_stmt_iterator gsi;
+ tree method = NULL_TREE;
+ tree delta = NULL_TREE;
+
+ gsi = gsi_for_stmt (call);
+
+ gsi_prev (&gsi);
+ for (; !gsi_end_p (gsi); gsi_prev (&gsi))
+ {
+ gimple stmt = gsi_stmt (gsi);
+ tree lhs, rhs, fld;
+
+ if (!gimple_assign_single_p (stmt))
+ return;
+
+ lhs = gimple_assign_lhs (stmt);
+ rhs = gimple_assign_rhs1 (stmt);
+
+ if (TREE_CODE (lhs) != COMPONENT_REF
+ || TREE_OPERAND (lhs, 0) != arg)
+ continue;
+
+ fld = TREE_OPERAND (lhs, 1);
+ if (!method && fld == method_field)
+ {
+ rhs = get_ssa_def_if_simple_copy (rhs);
+ if (TREE_CODE (rhs) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
+ && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
+ {
+ method = TREE_OPERAND (rhs, 0);
+ if (delta)
+ {
+ fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
+ return;
+ }
+ }
+ else
+ return;
+ }
+
+ if (!delta && fld == delta_field)
+ {
+ rhs = get_ssa_def_if_simple_copy (rhs);
+ if (TREE_CODE (rhs) == INTEGER_CST)
+ {
+ delta = rhs;
+ if (method)
+ {
+ fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
+ return;
+ }
+ }
+ else
+ return;
+ }
+ }
+
+ return;
}
-/* Set field 'type' of jump function (ipa_jump_func struct) of argument I
- in callsite CS. */
-static inline void
-ipa_callsite_param_set_type (struct cgraph_edge *cs, int i,
- enum jump_func_type type1)
+/* Go through the arguments of the CALL and for every member pointer within
+ tries determine whether it is a constant. If it is, create a corresponding
+ constant jump function in FUNCTIONS which is an array of jump functions
+ associated with the call. */
+
+static void
+compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
+ gimple call)
{
- IPA_EDGE_REF (cs)->ipa_param_map[i].type = type1;
+ unsigned num;
+ tree arg, method_field, delta_field;
+
+ for (num = 0; num < gimple_call_num_args (call); num++)
+ {
+ arg = gimple_call_arg (call, num);
+
+ if (functions[num].type == IPA_JF_UNKNOWN
+ && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
+ &delta_field))
+ determine_cst_member_ptr (call, arg, method_field, delta_field,
+ &functions[num]);
+ }
}
-/* Set FORMAL as 'info_type' field of jump function (ipa_jump_func struct)
- of argument I of callsite CS. */
-static inline void
-ipa_callsite_param_set_info_type_formal (struct cgraph_edge *cs, int i,
- unsigned int formal)
+/* Compute jump function for all arguments of callsite CS and insert the
+ information in the jump_functions array in the ipa_edge_args corresponding
+ to this callsite. */
+
+void
+ipa_compute_jump_functions (struct cgraph_edge *cs)
{
- ipa_callsite_param (cs, i)->info_type.formal_id = formal;
+ struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
+ struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
+ gimple call;
+
+ if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
+ return;
+ arguments->jump_functions = XCNEWVEC (struct ipa_jump_func,
+ ipa_get_cs_argument_count (arguments));
+
+ call = cs->call_stmt;
+ gcc_assert (is_gimple_call (call));
+
+ /* We will deal with constants and SSA scalars first: */
+ compute_scalar_jump_functions (info, arguments->jump_functions, call);
+
+ /* Let's check whether there are any potential member pointers and if so,
+ whether we can determine their functions as pass_through. */
+ if (!compute_pass_through_member_ptrs (info, arguments->jump_functions, call))
+ return;
+
+ /* Finally, let's check whether we actually pass a new constant member
+ pointer here... */
+ compute_cst_member_ptr_arguments (arguments->jump_functions, call);
}
-/* Set int-valued INFO_TYPE1 as 'info_type' field of
- jump function (ipa_jump_func struct) of argument I of callsite CS. */
-static inline void
-ipa_callsite_param_set_info_type (struct cgraph_edge *cs, int i, tree info_type1)
+/* If RHS looks like a rhs of a statement loading pfn from a member pointer
+ formal parameter, return the parameter, otherwise return NULL. */
+
+static tree
+ipa_get_member_ptr_load_param (tree rhs)
{
- ipa_callsite_param (cs, i)->info_type.value = info_type1;
+ tree rec, fld;
+ tree ptr_field;
+
+ if (TREE_CODE (rhs) != COMPONENT_REF)
+ return NULL_TREE;
+
+ rec = TREE_OPERAND (rhs, 0);
+ if (TREE_CODE (rec) != PARM_DECL
+ || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, NULL))
+ return NULL_TREE;
+
+ fld = TREE_OPERAND (rhs, 1);
+ if (fld == ptr_field)
+ return rec;
+ else
+ return NULL_TREE;
}
-/* Allocate space for callsite CS. */
-static inline void
-ipa_callsite_param_map_create (struct cgraph_edge *cs)
+/* If STMT looks like a statement loading a value from a member pointer formal
+ parameter, this function returns that parameter. */
+
+static tree
+ipa_get_stmt_member_ptr_load_param (gimple stmt)
{
- IPA_EDGE_REF (cs)->ipa_param_map =
- xcalloc (ipa_callsite_param_count (cs), sizeof (struct ipa_jump_func));
+ tree rhs;
+
+ if (!gimple_assign_single_p (stmt))
+ return NULL_TREE;
+
+ rhs = gimple_assign_rhs1 (stmt);
+ return ipa_get_member_ptr_load_param (rhs);
}
-/* Return the call expr tree related to callsite CS. */
-static inline tree
-ipa_callsite_tree (struct cgraph_edge *cs)
+/* Returns true iff T is an SSA_NAME defined by a statement. */
+
+static bool
+ipa_is_ssa_with_stmt_def (tree t)
{
- return cs->call_stmt;
+ if (TREE_CODE (t) == SSA_NAME
+ && !SSA_NAME_IS_DEFAULT_DEF (t))
+ return true;
+ else
+ return false;
}
-/* Return the caller (cgraph_node) of CS. */
-static inline struct cgraph_node *
-ipa_callsite_caller (struct cgraph_edge *cs)
+/* Creates a new note describing a call to a parameter number FORMAL_ID and
+ attaches it to the linked list of INFO. It also sets the called flag of the
+ parameter. STMT is the corresponding call statement. */
+
+static void
+ipa_note_param_call (struct ipa_node_params *info, int formal_id,
+ gimple stmt)
{
- return cs->caller;
+ struct ipa_param_call_note *note;
+ basic_block bb = gimple_bb (stmt);
+
+ info->params[formal_id].called = 1;
+
+ note = XCNEW (struct ipa_param_call_note);
+ note->formal_id = formal_id;
+ note->stmt = stmt;
+ note->count = bb->count;
+ note->frequency = compute_call_stmt_bb_frequency (current_function_decl, bb);
+
+ note->next = info->param_calls;
+ info->param_calls = note;
+
+ return;
}
-/* Count number of arguments callsite CS has and store it in
- ipa_edge structure corresponding to this callsite. */
-void
-ipa_callsite_compute_count (struct cgraph_edge *cs)
+/* Analyze the CALL and examine uses of formal parameters of the caller
+ (described by INFO). Currently it checks whether the call calls a pointer
+ that is a formal parameter and if so, the parameter is marked with the
+ called flag and a note describing the call is created. This is very simple
+ for ordinary pointers represented in SSA but not-so-nice when it comes to
+ member pointers. The ugly part of this function does nothing more than
+ tries to match the pattern of such a call. An example of such a pattern is
+ the gimple dump below, the call is on the last line:
+
+ <bb 2>:
+ f$__delta_5 = f.__delta;
+ f$__pfn_24 = f.__pfn;
+ D.2496_3 = (int) f$__pfn_24;
+ D.2497_4 = D.2496_3 & 1;
+ if (D.2497_4 != 0)
+ goto <bb 3>;
+ else
+ goto <bb 4>;
+
+ <bb 3>:
+ D.2500_7 = (unsigned int) f$__delta_5;
+ D.2501_8 = &S + D.2500_7;
+ D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
+ D.2503_10 = *D.2502_9;
+ D.2504_12 = f$__pfn_24 + -1;
+ D.2505_13 = (unsigned int) D.2504_12;
+ D.2506_14 = D.2503_10 + D.2505_13;
+ D.2507_15 = *D.2506_14;
+ iftmp.11_16 = (String:: *) D.2507_15;
+
+ <bb 4>:
+ # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
+ D.2500_19 = (unsigned int) f$__delta_5;
+ D.2508_20 = &S + D.2500_19;
+ D.2493_21 = iftmp.11_1 (D.2508_20, 4);
+
+ Such patterns are results of simple calls to a member pointer:
+
+ int doprinting (int (MyString::* f)(int) const)
+ {
+ MyString S ("somestring");
+
+ return (S.*f)(4);
+ }
+*/
+
+static void
+ipa_analyze_call_uses (struct ipa_node_params *info, gimple call)
{
- tree call_tree;
- tree arg;
- int arg_num;
+ tree target = gimple_call_fn (call);
+ gimple def;
+ tree var;
+ tree n1, n2;
+ gimple d1, d2;
+ tree rec, rec2, cond;
+ gimple branch;
+ int index;
+ basic_block bb, virt_bb, join;
+
+ if (TREE_CODE (target) != SSA_NAME)
+ return;
+
+ var = SSA_NAME_VAR (target);
+ if (SSA_NAME_IS_DEFAULT_DEF (target))
+ {
+ /* assuming TREE_CODE (var) == PARM_DECL */
+ index = ipa_get_param_decl_index (info, var);
+ if (index >= 0)
+ ipa_note_param_call (info, index, call);
+ return;
+ }
+
+ /* Now we need to try to match the complex pattern of calling a member
+ pointer. */
+
+ if (!POINTER_TYPE_P (TREE_TYPE (target))
+ || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
+ return;
+
+ def = SSA_NAME_DEF_STMT (target);
+ if (gimple_code (def) != GIMPLE_PHI)
+ return;
+
+ if (gimple_phi_num_args (def) != 2)
+ return;
+
+ /* First, we need to check whether one of these is a load from a member
+ pointer that is a parameter to this function. */
+ n1 = PHI_ARG_DEF (def, 0);
+ n2 = PHI_ARG_DEF (def, 1);
+ if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
+ return;
+ d1 = SSA_NAME_DEF_STMT (n1);
+ d2 = SSA_NAME_DEF_STMT (n2);
+
+ if ((rec = ipa_get_stmt_member_ptr_load_param (d1)))
+ {
+ if (ipa_get_stmt_member_ptr_load_param (d2))
+ return;
+
+ bb = gimple_bb (d1);
+ virt_bb = gimple_bb (d2);
+ }
+ else if ((rec = ipa_get_stmt_member_ptr_load_param (d2)))
+ {
+ bb = gimple_bb (d2);
+ virt_bb = gimple_bb (d1);
+ }
+ else
+ return;
+
+ /* Second, we need to check that the basic blocks are laid out in the way
+ corresponding to the pattern. */
+
+ join = gimple_bb (def);
+ if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
+ || single_pred (virt_bb) != bb
+ || single_succ (virt_bb) != join)
+ return;
+
+ /* Third, let's see that the branching is done depending on the least
+ significant bit of the pfn. */
+
+ branch = last_stmt (bb);
+ if (gimple_code (branch) != GIMPLE_COND)
+ return;
+
+ if (gimple_cond_code (branch) != NE_EXPR
+ || !integer_zerop (gimple_cond_rhs (branch)))
+ return;
+
+ cond = gimple_cond_lhs (branch);
+ if (!ipa_is_ssa_with_stmt_def (cond))
+ return;
+
+ def = SSA_NAME_DEF_STMT (cond);
+ if (!is_gimple_assign (def)
+ || gimple_assign_rhs_code (def) != BIT_AND_EXPR
+ || !integer_onep (gimple_assign_rhs2 (def)))
+ return;
- call_tree = get_call_expr_in (ipa_callsite_tree (cs));
- gcc_assert (TREE_CODE (call_tree) == CALL_EXPR);
- arg = TREE_OPERAND (call_tree, 1);
- arg_num = 0;
- for (; arg != NULL_TREE; arg = TREE_CHAIN (arg))
- arg_num++;
- ipa_callsite_param_count_set (cs, arg_num);
+ cond = gimple_assign_rhs1 (def);
+ if (!ipa_is_ssa_with_stmt_def (cond))
+ return;
+
+ def = SSA_NAME_DEF_STMT (cond);
+
+ if (is_gimple_assign (def)
+ && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
+ {
+ cond = gimple_assign_rhs1 (def);
+ if (!ipa_is_ssa_with_stmt_def (cond))
+ return;
+ def = SSA_NAME_DEF_STMT (cond);
+ }
+
+ rec2 = ipa_get_stmt_member_ptr_load_param (def);
+ if (rec != rec2)
+ return;
+
+ index = ipa_get_param_decl_index (info, rec);
+ if (index >= 0 && !ipa_is_param_modified (info, index))
+ ipa_note_param_call (info, index, call);
+
+ return;
}
-/* Compute jump function for all arguments of callsite CS
- and insert the information in the ipa_param_map array
- in the ipa_edge corresponding to this callsite. (Explanation
- on jump functions is in ipa-prop.h). */
+/* Analyze the statement STMT with respect to formal parameters (described in
+ INFO) and their uses. Currently it only checks whether formal parameters
+ are called. */
+
+static void
+ipa_analyze_stmt_uses (struct ipa_node_params *info, gimple stmt)
+{
+ if (is_gimple_call (stmt))
+ ipa_analyze_call_uses (info, stmt);
+}
+
+/* Scan the function body of NODE and inspect the uses of formal parameters.
+ Store the findings in various structures of the associated ipa_node_params
+ structure, such as parameter flags, notes etc. */
+
void
-ipa_callsite_compute_param (struct cgraph_edge *cs)
+ipa_analyze_params_uses (struct cgraph_node *node)
{
- tree call_tree;
- tree arg, cst_decl, arg_type, formal_type;
- int arg_num;
- int i;
- struct cgraph_node *mt;
+ tree decl = node->decl;
+ basic_block bb;
+ struct function *func;
+ gimple_stmt_iterator gsi;
+ struct ipa_node_params *info = IPA_NODE_REF (node);
- if (ipa_callsite_param_count (cs) == 0)
+ if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
return;
- ipa_callsite_param_map_create (cs);
- call_tree = get_call_expr_in (ipa_callsite_tree (cs));
- gcc_assert (TREE_CODE (call_tree) == CALL_EXPR);
- arg = TREE_OPERAND (call_tree, 1);
- arg_num = 0;
- for (; arg != NULL_TREE; arg = TREE_CHAIN (arg))
+ func = DECL_STRUCT_FUNCTION (decl);
+ FOR_EACH_BB_FN (bb, func)
{
- /* If the formal parameter was passed as argument, we store
- FORMAL_IPATYPE and its index in the caller as the jump function
- of this argument. */
- if (TREE_CODE (TREE_VALUE (arg)) == PARM_DECL)
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- mt = ipa_callsite_caller (cs);
- i = ipa_method_tree_map (mt, TREE_VALUE (arg));
- if (i < 0 || ipa_method_is_modified (mt, i))
- ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE);
- else
- {
- arg_type = TREE_TYPE (TREE_VALUE (arg));
- formal_type = TREE_TYPE (ipa_method_get_tree (cs->callee, arg_num));
- if (TYPE_NAME (arg_type) == TYPE_NAME (formal_type)
- && TYPE_CONTEXT (arg_type) == TYPE_CONTEXT (formal_type)
- && attribute_list_equal (TYPE_ATTRIBUTES (arg_type),
- TYPE_ATTRIBUTES (formal_type)))
- {
- ipa_callsite_param_set_type (cs, arg_num, FORMAL_IPATYPE);
- ipa_callsite_param_set_info_type_formal (cs, arg_num, i);
- }
- else
- ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE);
- }
+ gimple stmt = gsi_stmt (gsi);
+ ipa_analyze_stmt_uses (info, stmt);
}
- /* If a constant value was passed as argument,
- we store CONST_IPATYPE and its value as the jump function
- of this argument. */
- else if (TREE_CODE (TREE_VALUE (arg)) == INTEGER_CST
- || TREE_CODE (TREE_VALUE (arg)) == REAL_CST)
+ }
+
+ info->uses_analysis_done = 1;
+}
+
+/* Update the jump functions associated with call graph edge E when the call
+ graph edge CS is being inlined, assuming that E->caller is already (possibly
+ indirectly) inlined into CS->callee and that E has not been inlined. */
+
+static void
+update_jump_functions_after_inlining (struct cgraph_edge *cs,
+ struct cgraph_edge *e)
+{
+ struct ipa_edge_args *top = IPA_EDGE_REF (cs);
+ struct ipa_edge_args *args = IPA_EDGE_REF (e);
+ int count = ipa_get_cs_argument_count (args);
+ int i;
+
+ for (i = 0; i < count; i++)
+ {
+ struct ipa_jump_func *src, *dst = ipa_get_ith_jump_func (args, i);
+
+ if (dst->type != IPA_JF_PASS_THROUGH)
+ continue;
+
+ /* We must check range due to calls with variable number of arguments: */
+ if (dst->value.formal_id >= (unsigned) ipa_get_cs_argument_count (top))
{
- arg_type = TREE_TYPE (TREE_VALUE (arg));
- formal_type = TREE_TYPE (ipa_method_get_tree (cs->callee, arg_num));
- if (TYPE_NAME (arg_type) == TYPE_NAME (formal_type)
- && TYPE_CONTEXT (arg_type) == TYPE_CONTEXT (formal_type)
- && attribute_list_equal (TYPE_ATTRIBUTES (arg_type),
- TYPE_ATTRIBUTES (formal_type)))
- {
- ipa_callsite_param_set_type (cs, arg_num, CONST_IPATYPE);
- ipa_callsite_param_set_info_type (cs, arg_num, TREE_VALUE (arg));
- }
- else
- ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE);
+ dst->type = IPA_JF_UNKNOWN;
+ continue;
}
- /* This is for the case of Fortran. If the address of a const_decl
- was passed as argument then we store
- CONST_IPATYPE_REF/CONST_IPATYPE_REF and the constant
- value as the jump function corresponding to this argument. */
- else if (TREE_CODE (TREE_VALUE (arg)) == ADDR_EXPR
- && TREE_CODE (TREE_OPERAND (TREE_VALUE (arg), 0)) ==
- CONST_DECL)
+
+ src = ipa_get_ith_jump_func (top, dst->value.formal_id);
+ *dst = *src;
+ }
+}
+
+/* Print out a debug message to file F that we have discovered that an indirect
+ call described by NT is in fact a call of a known constant function described
+ by JFUNC. NODE is the node where the call is. */
+
+static void
+print_edge_addition_message (FILE *f, struct ipa_param_call_note *nt,
+ struct ipa_jump_func *jfunc,
+ struct cgraph_node *node)
+{
+ fprintf (f, "ipa-prop: Discovered an indirect call to a known target (");
+ if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
+ {
+ print_node_brief (f, "", jfunc->value.member_cst.pfn, 0);
+ print_node_brief (f, ", ", jfunc->value.member_cst.delta, 0);
+ }
+ else
+ print_node_brief(f, "", jfunc->value.constant, 0);
+
+ fprintf (f, ") in %s: ", cgraph_node_name (node));
+ print_gimple_stmt (f, nt->stmt, 2, TDF_SLIM);
+}
+
+/* Update the param called notes associated with NODE when CS is being inlined,
+ assuming NODE is (potentially indirectly) inlined into CS->callee.
+ Moreover, if the callee is discovered to be constant, create a new cgraph
+ edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
+ unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
+
+static bool
+update_call_notes_after_inlining (struct cgraph_edge *cs,
+ struct cgraph_node *node,
+ VEC (cgraph_edge_p, heap) **new_edges)
+{
+ struct ipa_node_params *info = IPA_NODE_REF (node);
+ struct ipa_edge_args *top = IPA_EDGE_REF (cs);
+ struct ipa_param_call_note *nt;
+ bool res = false;
+
+ for (nt = info->param_calls; nt; nt = nt->next)
+ {
+ struct ipa_jump_func *jfunc;
+
+ if (nt->processed)
+ continue;
+
+ /* We must check range due to calls with variable number of arguments: */
+ if (nt->formal_id >= (unsigned) ipa_get_cs_argument_count (top))
{
- cst_decl = TREE_OPERAND (TREE_VALUE (arg), 0);
- arg_type = TREE_TYPE (DECL_INITIAL (cst_decl));
- formal_type =
- TREE_TYPE (TREE_TYPE (ipa_method_get_tree (cs->callee, arg_num)));
- if (TREE_CODE (DECL_INITIAL (cst_decl)) == INTEGER_CST
- || TREE_CODE (DECL_INITIAL (cst_decl)) == REAL_CST)
- {
- if (TYPE_NAME (arg_type) == TYPE_NAME (formal_type)
- && TYPE_CONTEXT (arg_type) == TYPE_CONTEXT (formal_type)
- && attribute_list_equal (TYPE_ATTRIBUTES (arg_type),
- TYPE_ATTRIBUTES (formal_type)))
+ nt->processed = true;
+ continue;
+ }
- {
- ipa_callsite_param_set_type (cs, arg_num,
- CONST_IPATYPE_REF);
- ipa_callsite_param_set_info_type (cs, arg_num, DECL_INITIAL (cst_decl));
+ jfunc = ipa_get_ith_jump_func (top, nt->formal_id);
+ if (jfunc->type == IPA_JF_PASS_THROUGH)
+ nt->formal_id = jfunc->value.formal_id;
+ else if (jfunc->type == IPA_JF_CONST
+ || jfunc->type == IPA_JF_CONST_MEMBER_PTR)
+ {
+ struct cgraph_node *callee;
+ struct cgraph_edge *new_indirect_edge;
+ tree decl;
- }
- else
- ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE);
- }
+ nt->processed = true;
+ if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
+ decl = jfunc->value.member_cst.pfn;
+ else
+ decl = jfunc->value.constant;
+
+ if (TREE_CODE (decl) != ADDR_EXPR)
+ continue;
+ decl = TREE_OPERAND (decl, 0);
+
+ if (TREE_CODE (decl) != FUNCTION_DECL)
+ continue;
+ callee = cgraph_node (decl);
+ if (!callee || !callee->local.inlinable)
+ continue;
+
+ res = true;
+ if (dump_file)
+ print_edge_addition_message (dump_file, nt, jfunc, node);
+
+ new_indirect_edge = cgraph_create_edge (node, callee, nt->stmt,
+ nt->count, nt->frequency,
+ nt->loop_nest);
+ new_indirect_edge->indirect_call = 1;
+ ipa_check_create_edge_args ();
+ if (new_edges)
+ VEC_safe_push (cgraph_edge_p, heap, *new_edges, new_indirect_edge);
+ top = IPA_EDGE_REF (cs);
}
- else
- ipa_callsite_param_set_type (cs, arg_num, UNKNOWN_IPATYPE);
- arg_num++;
}
+ return res;
}
-/* Return type of jump function JF. */
-enum jump_func_type
-get_type (struct ipa_jump_func *jf)
+/* Recursively traverse subtree of NODE (including node) made of inlined
+ cgraph_edges when CS has been inlined and invoke
+ update_call_notes_after_inlining on all nodes and
+ update_jump_functions_after_inlining on all non-inlined edges that lead out
+ of this subtree. Newly discovered indirect edges will be added to
+ *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
+ created. */
+
+static bool
+propagate_info_to_inlined_callees (struct cgraph_edge *cs,
+ struct cgraph_node *node,
+ VEC (cgraph_edge_p, heap) **new_edges)
{
- return jf->type;
+ struct cgraph_edge *e;
+ bool res;
+
+ res = update_call_notes_after_inlining (cs, node, new_edges);
+
+ for (e = node->callees; e; e = e->next_callee)
+ if (!e->inline_failed)
+ res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
+ else
+ update_jump_functions_after_inlining (cs, e);
+
+ return res;
}
-/* Return info type of jump function JF. */
-union parameter_info *
-ipa_jf_get_info_type (struct ipa_jump_func *jf)
+/* Update jump functions and call note functions on inlining the call site CS.
+ CS is expected to lead to a node already cloned by
+ cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
+ *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
+ created. */
+
+bool
+ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
+ VEC (cgraph_edge_p, heap) **new_edges)
{
- return &(jf->info_type);
+ /* Do nothing if the preparation phase has not been carried out yet
+ (i.e. during early inlining). */
+ if (!ipa_node_params_vector)
+ return false;
+ gcc_assert (ipa_edge_args_vector);
+
+ return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
}
-/* Allocate and initialize ipa_node structure.
- cgraph_node NODE points to the new allocated ipa_node. */
+/* Frees all dynamically allocated structures that the argument info points
+ to. */
+
void
-ipa_node_create (struct cgraph_node *node)
+ipa_free_edge_args_substructures (struct ipa_edge_args *args)
{
- node->aux = xcalloc (1, sizeof (struct ipa_node));
+ if (args->jump_functions)
+ free (args->jump_functions);
+
+ memset (args, 0, sizeof (*args));
}
-/* Allocate and initialize ipa_node structure for all
- nodes in callgraph. */
+/* Free all ipa_edge structures. */
+
void
-ipa_nodes_create (void)
+ipa_free_all_edge_args (void)
{
- struct cgraph_node *node;
+ int i;
+ struct ipa_edge_args *args;
- for (node = cgraph_nodes; node; node = node->next)
- ipa_node_create (node);
+ for (i = 0;
+ VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
+ i++)
+ ipa_free_edge_args_substructures (args);
+
+ VEC_free (ipa_edge_args_t, heap, ipa_edge_args_vector);
+ ipa_edge_args_vector = NULL;
}
-/* Allocate and initialize ipa_edge structure. */
+/* Frees all dynamically allocated structures that the param info points
+ to. */
+
void
-ipa_edges_create (void)
+ipa_free_node_params_substructures (struct ipa_node_params *info)
{
- struct cgraph_node *node;
- struct cgraph_edge *cs;
+ if (info->params)
+ free (info->params);
- for (node = cgraph_nodes; node; node = node->next)
- for (cs = node->callees; cs; cs = cs->next_callee)
- cs->aux = xcalloc (1, sizeof (struct ipa_edge));
+ while (info->param_calls)
+ {
+ struct ipa_param_call_note *note = info->param_calls;
+ info->param_calls = note->next;
+ free (note);
+ }
+
+ memset (info, 0, sizeof (*info));
}
-/* Free ipa_node structure. */
+/* Free all ipa_node_params structures. */
+
void
-ipa_nodes_free (void)
+ipa_free_all_node_params (void)
{
- struct cgraph_node *node;
+ int i;
+ struct ipa_node_params *info;
- for (node = cgraph_nodes; node; node = node->next)
+ for (i = 0;
+ VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
+ i++)
+ ipa_free_node_params_substructures (info);
+
+ VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
+ ipa_node_params_vector = NULL;
+}
+
+/* Hook that is called by cgraph.c when an edge is removed. */
+
+static void
+ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
+{
+ /* During IPA-CP updating we can be called on not-yet analyze clones. */
+ if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
+ <= (unsigned)cs->uid)
+ return;
+ ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
+}
+
+/* Hook that is called by cgraph.c when a node is removed. */
+
+static void
+ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
+{
+ ipa_free_node_params_substructures (IPA_NODE_REF (node));
+}
+
+/* Helper function to duplicate an array of size N that is at SRC and store a
+ pointer to it to DST. Nothing is done if SRC is NULL. */
+
+static void *
+duplicate_array (void *src, size_t n)
+{
+ void *p;
+
+ if (!src)
+ return NULL;
+
+ p = xcalloc (1, n);
+ memcpy (p, src, n);
+ return p;
+}
+
+/* Hook that is called by cgraph.c when a node is duplicated. */
+
+static void
+ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
+ __attribute__((unused)) void *data)
+{
+ struct ipa_edge_args *old_args, *new_args;
+ int arg_count;
+
+ ipa_check_create_edge_args ();
+
+ old_args = IPA_EDGE_REF (src);
+ new_args = IPA_EDGE_REF (dst);
+
+ arg_count = ipa_get_cs_argument_count (old_args);
+ ipa_set_cs_argument_count (new_args, arg_count);
+ new_args->jump_functions = (struct ipa_jump_func *)
+ duplicate_array (old_args->jump_functions,
+ sizeof (struct ipa_jump_func) * arg_count);
+}
+
+/* Hook that is called by cgraph.c when a node is duplicated. */
+
+static void
+ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
+ __attribute__((unused)) void *data)
+{
+ struct ipa_node_params *old_info, *new_info;
+ struct ipa_param_call_note *note;
+ int param_count;
+
+ ipa_check_create_node_params ();
+ old_info = IPA_NODE_REF (src);
+ new_info = IPA_NODE_REF (dst);
+ param_count = ipa_get_param_count (old_info);
+
+ ipa_set_param_count (new_info, param_count);
+ new_info->params = (struct ipa_param_descriptor *)
+ duplicate_array (old_info->params,
+ sizeof (struct ipa_param_descriptor) * param_count);
+ new_info->ipcp_orig_node = old_info->ipcp_orig_node;
+ new_info->count_scale = old_info->count_scale;
+
+ for (note = old_info->param_calls; note; note = note->next)
{
- free (node->aux);
- node->aux = NULL;
+ struct ipa_param_call_note *nn;
+
+ nn = (struct ipa_param_call_note *)
+ xcalloc (1, sizeof (struct ipa_param_call_note));
+ memcpy (nn, note, sizeof (struct ipa_param_call_note));
+ nn->next = new_info->param_calls;
+ new_info->param_calls = nn;
}
}
-/* Free ipa_edge structure. */
+/* Register our cgraph hooks if they are not already there. */
+
void
-ipa_edges_free (void)
+ipa_register_cgraph_hooks (void)
{
- struct cgraph_node *node;
- struct cgraph_edge *cs;
+ if (!edge_removal_hook_holder)
+ edge_removal_hook_holder =
+ cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
+ if (!node_removal_hook_holder)
+ node_removal_hook_holder =
+ cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
+ if (!edge_duplication_hook_holder)
+ edge_duplication_hook_holder =
+ cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
+ if (!node_duplication_hook_holder)
+ node_duplication_hook_holder =
+ cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
+}
- for (node = cgraph_nodes; node; node = node->next)
- for (cs = node->callees; cs; cs = cs->next_callee)
- {
- free (cs->aux);
- cs->aux = NULL;
- }
+/* Unregister our cgraph hooks if they are not already there. */
+
+static void
+ipa_unregister_cgraph_hooks (void)
+{
+ cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
+ edge_removal_hook_holder = NULL;
+ cgraph_remove_node_removal_hook (node_removal_hook_holder);
+ node_removal_hook_holder = NULL;
+ cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
+ edge_duplication_hook_holder = NULL;
+ cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
+ node_duplication_hook_holder = NULL;
}
-/* Free ipa data structures of ipa_node and ipa_edge. */
+/* Free all ipa_node_params and all ipa_edge_args structures if they are no
+ longer needed after ipa-cp. */
+
void
-ipa_free (void)
+free_all_ipa_structures_after_ipa_cp (void)
{
- struct cgraph_node *node;
- struct cgraph_edge *cs;
-
- for (node = cgraph_nodes; node; node = node->next)
+ if (!flag_indirect_inlining)
{
- if (node->aux == NULL)
- continue;
- if (IPA_NODE_REF (node)->ipcp_cval)
- free (IPA_NODE_REF (node)->ipcp_cval);
- if (IPA_NODE_REF (node)->ipa_param_tree)
- free (IPA_NODE_REF (node)->ipa_param_tree);
- if (IPA_NODE_REF (node)->ipa_mod)
- free (IPA_NODE_REF (node)->ipa_mod);
- for (cs = node->callees; cs; cs = cs->next_callee)
- {
- if (cs->aux)
- if (IPA_EDGE_REF (cs)->ipa_param_map)
- free (IPA_EDGE_REF (cs)->ipa_param_map);
- }
+ ipa_free_all_edge_args ();
+ ipa_free_all_node_params ();
+ ipa_unregister_cgraph_hooks ();
}
}
-/* Print ipa_tree_map data structures of all methods in the
+/* Free all ipa_node_params and all ipa_edge_args structures if they are no
+ longer needed after indirect inlining. */
+
+void
+free_all_ipa_structures_after_iinln (void)
+{
+ ipa_free_all_edge_args ();
+ ipa_free_all_node_params ();
+ ipa_unregister_cgraph_hooks ();
+}
+
+/* Print ipa_tree_map data structures of all functions in the
callgraph to F. */
+
void
-ipa_method_tree_print (FILE * f)
+ipa_print_node_params (FILE * f, struct cgraph_node *node)
{
int i, count;
tree temp;
- struct cgraph_node *node;
+ struct ipa_node_params *info;
- fprintf (f, "\nPARAM TREE MAP PRINT\n");
- for (node = cgraph_nodes; node; node = node->next)
+ if (!node->analyzed)
+ return;
+ info = IPA_NODE_REF (node);
+ fprintf (f, " function %s Trees :: \n", cgraph_node_name (node));
+ count = ipa_get_param_count (info);
+ for (i = 0; i < count; i++)
{
- fprintf (f, "method %s Trees :: \n", cgraph_node_name (node));
- count = ipa_method_formal_count (node);
- for (i = 0; i < count; i++)
- {
- temp = ipa_method_get_tree (node, i);
- if (TREE_CODE (temp) == PARM_DECL)
- fprintf (f, " param [%d] : %s\n", i,
- (*lang_hooks.decl_printable_name) (temp, 2));
- }
-
+ temp = ipa_get_param (info, i);
+ if (TREE_CODE (temp) == PARM_DECL)
+ fprintf (f, " param %d : %s", i,
+ (*lang_hooks.decl_printable_name) (temp, 2));
+ if (ipa_is_param_modified (info, i))
+ fprintf (f, " modified");
+ if (ipa_is_param_called (info, i))
+ fprintf (f, " called");
+ fprintf (f, "\n");
}
}
-/* Print ipa_modify data structures of all methods in the
+/* Print ipa_tree_map data structures of all functions in the
callgraph to F. */
+
void
-ipa_method_modify_print (FILE * f)
+ipa_print_all_params (FILE * f)
{
- int i, count;
- bool temp;
struct cgraph_node *node;
- fprintf (f, "\nMODIFY PRINT\n");
+ fprintf (f, "\nFunction parameters:\n");
for (node = cgraph_nodes; node; node = node->next)
- {
- fprintf (f, "method %s :: \n", cgraph_node_name (node));
- count = ipa_method_formal_count (node);
- for (i = 0; i < count; i++)
- {
- temp = ipa_method_is_modified (node, i);
- if (temp)
- fprintf (f, " param [%d] true \n", i);
- else
- fprintf (f, " param [%d] false \n", i);
- }
- }
+ ipa_print_node_params (f, node);
}