#include "tree-flow.h"
#include "tree-pass.h"
#include "tree-inline.h"
-#include "gimple.h"
#include "flags.h"
#include "timevar.h"
#include "flags.h"
#include "diagnostic.h"
-#include "tree-pretty-print.h"
-#include "gimple-pretty-print.h"
#include "lto-streamer.h"
/* Vector where the parameter infos are actually stored. */
/* Vector where the parameter infos are actually stored. */
VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
-/* Bitmap with all UIDs of call graph edges that have been already processed
- by indirect inlining. */
-static bitmap iinlining_processed_edges;
-
/* 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;
int index = ipa_get_param_decl_index (info, op);
gcc_assert (index >= 0);
info->params[index].modified = true;
- info->params[index].used = true;
- }
-
- return false;
-}
-
-/* Callback of walk_stmt_load_store_addr_ops for the visit_load.
- If OP is a parameter declaration, mark it as used in the info structure
- passed in DATA. */
-
-static bool
-visit_load_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
- tree op, void *data)
-{
- struct ipa_node_params *info = (struct ipa_node_params *) data;
-
- op = get_base_address (op);
- if (op
- && TREE_CODE (op) == PARM_DECL)
- {
- int index = ipa_get_param_decl_index (info, op);
- gcc_assert (index >= 0);
- info->params[index].used = true;
}
return false;
struct function *func;
gimple_stmt_iterator gsi;
struct ipa_node_params *info = IPA_NODE_REF (node);
- int i;
if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
return;
- for (i = 0; i < ipa_get_param_count (info); i++)
- {
- tree parm = ipa_get_param (info, i);
- /* For SSA regs see if parameter is used. For non-SSA we compute
- the flag during modification analysis. */
- if (is_gimple_reg (parm)
- && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
- info->params[i].used = true;
- }
-
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,
- visit_load_for_mod_analysis,
- visit_store_addr_for_mod_analysis,
- visit_store_addr_for_mod_analysis);
- for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
- walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
- visit_load_for_mod_analysis,
- visit_store_addr_for_mod_analysis,
- visit_store_addr_for_mod_analysis);
- }
+ 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;
}
ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
}
-/* Print the jump functions associated with call graph edge CS to file F. */
-
-static void
-ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
-{
- int i, count;
-
- count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
- for (i = 0; i < count; i++)
- {
- struct ipa_jump_func *jump_func;
- enum jump_func_type type;
-
- 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_KNOWN_TYPE)
- {
- tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
- fprintf (f, "KNOWN TYPE, type in binfo is: ");
- print_generic_expr (f, binfo_type, 0);
- fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
- }
- else if (type == IPA_JF_CONST)
- {
- tree val = jump_func->value.constant;
- fprintf (f, "CONST: ");
- print_generic_expr (f, val, 0);
- if (TREE_CODE (val) == ADDR_EXPR
- && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
- {
- fprintf (f, " -> ");
- print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
- 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, op %s ",
- jump_func->value.pass_through.formal_id,
- tree_code_name[(int)
- jump_func->value.pass_through.operation]);
- if (jump_func->value.pass_through.operation != NOP_EXPR)
- print_generic_expr (dump_file,
- jump_func->value.pass_through.operand, 0);
- fprintf (dump_file, "\n");
- }
- else if (type == IPA_JF_ANCESTOR)
- {
- fprintf (f, "ANCESTOR: ");
- fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
- jump_func->value.ancestor.formal_id,
- jump_func->value.ancestor.offset);
- print_generic_expr (f, jump_func->value.ancestor.type, 0);
- fprintf (dump_file, "\n");
- }
- }
-}
-
-
/* 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;
- int i;
+ 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)
if (!ipa_edge_args_info_available_for_edge_p (cs))
continue;
- fprintf (f, " callsite %s/%i -> %s/%i : \n",
- cgraph_node_name (node), node->uid,
- cgraph_node_name (cs->callee), cs->callee->uid);
- ipa_print_node_jump_functions_for_edge (f, cs);
- }
+ fprintf (f, " callsite %s ", cgraph_node_name (node));
+ fprintf (f, "-> %s :: \n", cgraph_node_name (cs->callee));
- for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++)
- {
- if (!ipa_edge_args_info_available_for_edge_p (cs))
- continue;
-
- if (cs->call_stmt)
+ count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
+ for (i = 0; i < count; i++)
{
- fprintf (f, " indirect callsite %d for stmt ", i);
- print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
+ 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);
+ if (TREE_CODE (val) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
+ {
+ fprintf (f, " -> ");
+ print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
+ 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, op %s ",
+ jump_func->value.pass_through.formal_id,
+ tree_code_name[(int)
+ jump_func->value.pass_through.operation]);
+ if (jump_func->value.pass_through.operation != NOP_EXPR)
+ print_generic_expr (dump_file,
+ jump_func->value.pass_through.operand, 0);
+ fprintf (dump_file, "\n");
+ }
+ else if (type == IPA_JF_ANCESTOR)
+ {
+ fprintf (f, "ANCESTOR: ");
+ fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC"\n",
+ jump_func->value.ancestor.formal_id,
+ jump_func->value.ancestor.offset);
+ }
}
- else
- fprintf (f, " indirect callsite %d :\n", i);
- ipa_print_node_jump_functions_for_edge (f, cs);
-
}
}
}
}
-/* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
- of an assignment statement STMT, try to find out whether NAME can be
- described by a (possibly polynomial) pass-through jump-function or an
- ancestor jump function and if so, write the appropriate function into
- JFUNC */
+/* Determine whether passing ssa name NAME constitutes a polynomial
+ pass-through function or getting an address of an acestor and if so, write
+ such a jump function to JFUNC. INFO describes the caller. */
static void
-compute_complex_assign_jump_func (struct ipa_node_params *info,
- struct ipa_jump_func *jfunc,
- gimple stmt, tree name)
+compute_complex_pass_through (struct ipa_node_params *info,
+ struct ipa_jump_func *jfunc,
+ tree name)
{
HOST_WIDE_INT offset, size, max_size;
tree op1, op2, type;
int index;
+ gimple stmt = SSA_NAME_DEF_STMT (name);
+ if (!is_gimple_assign (stmt))
+ return;
op1 = gimple_assign_rhs1 (stmt);
op2 = gimple_assign_rhs2 (stmt);
- if (TREE_CODE (op1) == SSA_NAME
- && SSA_NAME_IS_DEFAULT_DEF (op1))
+ if (op2)
{
- index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
- if (index < 0)
+ if (TREE_CODE (op1) != SSA_NAME
+ || !SSA_NAME_IS_DEFAULT_DEF (op1)
+ || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
+ && !useless_type_conversion_p (TREE_TYPE (name),
+ TREE_TYPE (op1)))
+ || !is_gimple_ip_invariant (op2))
return;
- if (op2)
+ index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
+ if (index >= 0)
{
- if (!is_gimple_ip_invariant (op2)
- || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
- && !useless_type_conversion_p (TREE_TYPE (name),
- TREE_TYPE (op1))))
- return;
-
jfunc->type = IPA_JF_PASS_THROUGH;
jfunc->value.pass_through.formal_id = index;
jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
jfunc->value.pass_through.operand = op2;
}
- else if (gimple_assign_unary_nop_p (stmt))
- {
- jfunc->type = IPA_JF_PASS_THROUGH;
- jfunc->value.pass_through.formal_id = index;
- jfunc->value.pass_through.operation = NOP_EXPR;
- }
return;
}
if (TREE_CODE (op1) != ADDR_EXPR)
return;
-
op1 = TREE_OPERAND (op1, 0);
type = TREE_TYPE (op1);
- if (TREE_CODE (type) != RECORD_TYPE)
- return;
+
op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
if (TREE_CODE (op1) != INDIRECT_REF
/* If this is a varying address, punt. */
}
-/* Given that an actual argument is an SSA_NAME that is a result of a phi
- statement PHI, try to find out whether NAME is in fact a
- multiple-inheritance typecast from a descendant into an ancestor of a formal
- parameter and thus can be described by an ancestor jump function and if so,
- write the appropriate function into JFUNC.
-
- Essentially we want to match the following pattern:
-
- if (obj_2(D) != 0B)
- goto <bb 3>;
- else
- goto <bb 4>;
-
- <bb 3>:
- iftmp.1_3 = &obj_2(D)->D.1762;
-
- <bb 4>:
- # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
- D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
- return D.1879_6; */
-
-static void
-compute_complex_ancestor_jump_func (struct ipa_node_params *info,
- struct ipa_jump_func *jfunc,
- gimple phi)
-{
- HOST_WIDE_INT offset, size, max_size;
- gimple assign, cond;
- basic_block phi_bb, assign_bb, cond_bb;
- tree tmp, parm, expr;
- int index, i;
-
- if (gimple_phi_num_args (phi) != 2
- || !integer_zerop (PHI_ARG_DEF (phi, 1)))
- return;
-
- tmp = PHI_ARG_DEF (phi, 0);
- if (TREE_CODE (tmp) != SSA_NAME
- || SSA_NAME_IS_DEFAULT_DEF (tmp)
- || !POINTER_TYPE_P (TREE_TYPE (tmp))
- || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
- return;
-
- assign = SSA_NAME_DEF_STMT (tmp);
- assign_bb = gimple_bb (assign);
- if (!single_pred_p (assign_bb)
- || !gimple_assign_single_p (assign))
- return;
- expr = gimple_assign_rhs1 (assign);
-
- if (TREE_CODE (expr) != ADDR_EXPR)
- return;
- expr = TREE_OPERAND (expr, 0);
- expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
-
- if (TREE_CODE (expr) != INDIRECT_REF
- /* If this is a varying address, punt. */
- || max_size == -1
- || max_size != size)
- return;
- parm = TREE_OPERAND (expr, 0);
- if (TREE_CODE (parm) != SSA_NAME
- || !SSA_NAME_IS_DEFAULT_DEF (parm))
- return;
-
- index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
- if (index < 0)
- return;
-
- cond_bb = single_pred (assign_bb);
- cond = last_stmt (cond_bb);
- if (!cond
- || gimple_code (cond) != GIMPLE_COND
- || gimple_cond_code (cond) != NE_EXPR
- || gimple_cond_lhs (cond) != parm
- || !integer_zerop (gimple_cond_rhs (cond)))
- return;
-
-
- phi_bb = gimple_bb (phi);
- for (i = 0; i < 2; i++)
- {
- basic_block pred = EDGE_PRED (phi_bb, i)->src;
- if (pred != assign_bb && pred != cond_bb)
- return;
- }
-
- jfunc->type = IPA_JF_ANCESTOR;
- jfunc->value.ancestor.formal_id = index;
- jfunc->value.ancestor.offset = offset;
- jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
-}
-
-/* Given OP whch is passed as an actual argument to a called function,
- determine if it is possible to construct a KNOWN_TYPE jump function for it
- and if so, create one and store it to JFUNC. */
-
-static void
-compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
-{
- tree binfo;
-
- if (TREE_CODE (op) != ADDR_EXPR)
- return;
-
- op = TREE_OPERAND (op, 0);
- binfo = gimple_get_relevant_ref_binfo (op, NULL_TREE);
- if (binfo)
- {
- jfunc->type = IPA_JF_KNOWN_TYPE;
- jfunc->value.base_binfo = binfo;
- }
-}
-
-
/* 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
}
}
else
- {
- gimple stmt = SSA_NAME_DEF_STMT (arg);
- if (is_gimple_assign (stmt))
- compute_complex_assign_jump_func (info, &functions[num],
- stmt, arg);
- else if (gimple_code (stmt) == GIMPLE_PHI)
- compute_complex_ancestor_jump_func (info, &functions[num],
- stmt);
- }
+ compute_complex_pass_through (info, &functions[num], arg);
}
- else
- compute_known_type_jump_func (arg, &functions[num]);
}
}
information in the jump_functions array in the ipa_edge_args corresponding
to this callsite. */
-static void
-ipa_compute_jump_functions_for_edge (struct cgraph_edge *cs)
+void
+ipa_compute_jump_functions (struct cgraph_edge *cs)
{
struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
compute_cst_member_ptr_arguments (arguments->jump_functions, call);
}
-/* Compute jump functions for all edges - both direct and indirect - outgoing
- from NODE. Also count the actual arguments in the process. */
-
-void
-ipa_compute_jump_functions (struct cgraph_node *node)
-{
- struct cgraph_edge *cs;
-
- for (cs = node->callees; cs; cs = cs->next_callee)
- {
- /* We do not need to bother analyzing calls to unknown
- functions unless they may become known during lto/whopr. */
- if (!cs->callee->analyzed && !flag_lto && !flag_whopr)
- continue;
- ipa_count_arguments (cs);
- if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
- != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
- ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
- ipa_compute_jump_functions_for_edge (cs);
- }
-
- for (cs = node->indirect_calls; cs; cs = cs->next_callee)
- {
- ipa_count_arguments (cs);
- ipa_compute_jump_functions_for_edge (cs);
- }
-}
-
/* If RHS looks like a rhs of a statement loading pfn from a member
pointer formal parameter, return the parameter, otherwise return
NULL. If USE_DELTA, then we look for a use of the delta field
return false;
}
-/* Find the indirect call graph edge corresponding to STMT and add to it all
- information necessary to describe a call to a parameter number PARAM_INDEX.
- NODE is the caller. POLYMORPHIC should be set to true iff the call is a
- virtual one. */
+/* 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 cgraph_node *node, int param_index, gimple stmt,
- bool polymorphic)
+ipa_note_param_call (struct ipa_node_params *info, int formal_id,
+ gimple stmt)
{
- struct cgraph_edge *cs;
+ struct ipa_param_call_note *note;
+ basic_block bb = gimple_bb (stmt);
- cs = cgraph_edge (node, stmt);
- cs->indirect_info->param_index = param_index;
- cs->indirect_info->anc_offset = 0;
- cs->indirect_info->polymorphic = polymorphic;
- if (polymorphic)
- {
- tree otr = gimple_call_fn (stmt);
- tree type, token = OBJ_TYPE_REF_TOKEN (otr);
- cs->indirect_info->otr_token = tree_low_cst (token, 1);
- type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
- cs->indirect_info->otr_type = type;
- }
+ note = XCNEW (struct ipa_param_call_note);
+ note->formal_id = formal_id;
+ note->stmt = stmt;
+ note->lto_stmt_uid = gimple_uid (stmt);
+ note->count = bb->count;
+ note->frequency = compute_call_stmt_bb_frequency (current_function_decl, bb);
+ note->loop_nest = bb->loop_depth;
+
+ note->next = info->param_calls;
+ info->param_calls = note;
+
+ return;
}
-/* Analyze the CALL and examine uses of formal parameters of the caller NODE
+/* 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 an indirect call graph edge 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 trying 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:
+ 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;
*/
static void
-ipa_analyze_indirect_call_uses (struct cgraph_node *node,
- struct ipa_node_params *info,
- gimple call, tree target)
+ipa_analyze_call_uses (struct ipa_node_params *info, gimple call)
{
+ tree target = gimple_call_fn (call);
gimple def;
+ tree var;
tree n1, n2;
gimple d1, d2;
tree rec, rec2, cond;
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))
{
- tree var = SSA_NAME_VAR (target);
+ /* assuming TREE_CODE (var) == PARM_DECL */
index = ipa_get_param_decl_index (info, var);
if (index >= 0)
- ipa_note_param_call (node, index, call, false);
+ ipa_note_param_call (info, index, call);
return;
}
index = ipa_get_param_decl_index (info, rec);
if (index >= 0 && !ipa_is_param_modified (info, index))
- ipa_note_param_call (node, index, call, false);
+ ipa_note_param_call (info, index, call);
return;
}
-/* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
- object referenced in the expression is a formal parameter of the caller
- (described by INFO), create a call note for the statement. */
+/* 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_virtual_call_uses (struct cgraph_node *node,
- struct ipa_node_params *info, gimple call,
- tree target)
-{
- tree obj = OBJ_TYPE_REF_OBJECT (target);
- tree var;
- int index;
-
- if (TREE_CODE (obj) == ADDR_EXPR)
- {
- do
- {
- obj = TREE_OPERAND (obj, 0);
- }
- while (TREE_CODE (obj) == COMPONENT_REF);
- if (TREE_CODE (obj) != INDIRECT_REF)
- return;
- obj = TREE_OPERAND (obj, 0);
- }
-
- if (TREE_CODE (obj) != SSA_NAME
- || !SSA_NAME_IS_DEFAULT_DEF (obj))
- return;
-
- var = SSA_NAME_VAR (obj);
- index = ipa_get_param_decl_index (info, var);
-
- if (index >= 0)
- ipa_note_param_call (node, index, call, true);
-}
-
-/* Analyze a call statement CALL whether and how it utilizes formal parameters
- of the caller (described by INFO). */
-
-static void
-ipa_analyze_call_uses (struct cgraph_node *node,
- struct ipa_node_params *info, gimple call)
-{
- tree target = gimple_call_fn (call);
-
- if (TREE_CODE (target) == SSA_NAME)
- ipa_analyze_indirect_call_uses (node, info, call, target);
- else if (TREE_CODE (target) == OBJ_TYPE_REF)
- ipa_analyze_virtual_call_uses (node, info, call, target);
-}
-
-
-/* Analyze the call statement STMT with respect to formal parameters (described
- in INFO) of caller given by NODE. Currently it only checks whether formal
- parameters are called. */
-
-static void
-ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
- gimple stmt)
+ipa_analyze_stmt_uses (struct ipa_node_params *info, gimple stmt)
{
if (is_gimple_call (stmt))
- ipa_analyze_call_uses (node, info, stmt);
+ ipa_analyze_call_uses (info, stmt);
}
/* Scan the function body of NODE and inspect the uses of formal parameters.
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
- ipa_analyze_stmt_uses (node, info, stmt);
+ ipa_analyze_stmt_uses (info, stmt);
}
}
info->uses_analysis_done = 1;
}
-/* Update the jump function DST when the call graph edge correspondng to SRC is
- is being inlined, knowing that DST is of type ancestor and src of known
- type. */
-
-static void
-combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
- struct ipa_jump_func *dst)
-{
- tree new_binfo;
-
- new_binfo = get_binfo_at_offset (src->value.base_binfo,
- dst->value.ancestor.offset,
- dst->value.ancestor.type);
- if (new_binfo)
- {
- dst->type = IPA_JF_KNOWN_TYPE;
- dst->value.base_binfo = new_binfo;
- }
- else
- dst->type = IPA_JF_UNKNOWN;
-}
-
/* 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. */
+ indirectly) inlined into CS->callee and that E has not been inlined.
+
+ We keep pass through functions only if they do not contain any operation.
+ This is sufficient for inlining and greately simplifies things. */
static void
update_jump_functions_after_inlining (struct cgraph_edge *cs,
for (i = 0; i < count; i++)
{
- struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
+ struct ipa_jump_func *src, *dst = ipa_get_ith_jump_func (args, i);
if (dst->type == IPA_JF_ANCESTOR)
{
- struct ipa_jump_func *src;
-
- /* Variable number of arguments can cause havoc if we try to access
- one that does not exist in the inlined edge. So make sure we
- don't. */
- if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
- {
- dst->type = IPA_JF_UNKNOWN;
- continue;
- }
+ dst->type = IPA_JF_UNKNOWN;
+ continue;
+ }
- src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
- if (src->type == IPA_JF_KNOWN_TYPE)
- combine_known_type_and_ancestor_jfs (src, dst);
- else if (src->type == IPA_JF_CONST)
- {
- struct ipa_jump_func kt_func;
+ if (dst->type != IPA_JF_PASS_THROUGH)
+ continue;
- kt_func.type = IPA_JF_UNKNOWN;
- compute_known_type_jump_func (src->value.constant, &kt_func);
- if (kt_func.type == IPA_JF_KNOWN_TYPE)
- combine_known_type_and_ancestor_jfs (&kt_func, dst);
- else
- dst->type = IPA_JF_UNKNOWN;
- }
- else if (src->type == IPA_JF_PASS_THROUGH
- && src->value.pass_through.operation == NOP_EXPR)
- dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
- else if (src->type == IPA_JF_ANCESTOR)
- {
- dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
- dst->value.ancestor.offset += src->value.ancestor.offset;
- }
- else
- dst->type = IPA_JF_UNKNOWN;
- }
- else if (dst->type == IPA_JF_PASS_THROUGH)
+ /* We must check range due to calls with variable number of arguments and
+ we cannot combine jump functions with operations. */
+ if (dst->value.pass_through.operation != NOP_EXPR
+ || (dst->value.pass_through.formal_id
+ >= ipa_get_cs_argument_count (top)))
{
- struct ipa_jump_func *src;
- /* We must check range due to calls with variable number of arguments
- and we cannot combine jump functions with operations. */
- if (dst->value.pass_through.operation == NOP_EXPR
- && (dst->value.pass_through.formal_id
- < ipa_get_cs_argument_count (top)))
- {
- src = ipa_get_ith_jump_func (top,
- dst->value.pass_through.formal_id);
- *dst = *src;
- }
- else
- dst->type = IPA_JF_UNKNOWN;
+ dst->type = IPA_JF_UNKNOWN;
+ continue;
}
- }
-}
-
-/* If TARGET is an addr_expr of a function declaration, make it the destination
- of an indirect edge IE and return the edge. Otherwise, return NULL. */
-
-static struct cgraph_edge *
-make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
-{
- struct cgraph_node *callee;
-
- if (TREE_CODE (target) != ADDR_EXPR)
- return NULL;
- target = TREE_OPERAND (target, 0);
- if (TREE_CODE (target) != FUNCTION_DECL)
- return NULL;
- callee = cgraph_node (target);
- if (!callee)
- return NULL;
- cgraph_make_edge_direct (ie, callee);
- if (dump_file)
- {
- fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
- "(%s/%i -> %s/%i) for stmt ",
- ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
- cgraph_node_name (ie->caller), ie->caller->uid,
- cgraph_node_name (ie->callee), ie->callee->uid);
-
- if (ie->call_stmt)
- print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
- else
- fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
+ src = ipa_get_ith_jump_func (top, dst->value.pass_through.formal_id);
+ *dst = *src;
}
-
- if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie))
- != ipa_get_param_count (IPA_NODE_REF (callee)))
- ipa_set_called_with_variable_arg (IPA_NODE_REF (callee));
-
- return ie;
}
-/* Try to find a destination for indirect edge IE that corresponds to a simple
- call or a call of a member function pointer and where the destination is a
- pointer formal parameter described by jump function JFUNC. If it can be
- determined, return the newly direct edge, otherwise return NULL. */
+/* 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 struct cgraph_edge *
-try_make_edge_direct_simple_call (struct cgraph_edge *ie,
- struct ipa_jump_func *jfunc)
-{
- tree target;
-
- if (jfunc->type == IPA_JF_CONST)
- target = jfunc->value.constant;
- else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
- target = jfunc->value.member_cst.pfn;
- else
- return NULL;
-
- return make_edge_direct_to_target (ie, target);
-}
-
-/* Try to find a destination for indirect edge IE that corresponds to a
- virtuall call based on a formal parameter which is described by jump
- function JFUNC and if it can be determined, make it direct and return the
- direct edge. Otherwise, return NULL. */
-
-static struct cgraph_edge *
-try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
- struct ipa_jump_func *jfunc)
+static void
+print_edge_addition_message (FILE *f, struct ipa_param_call_note *nt,
+ struct ipa_jump_func *jfunc,
+ struct cgraph_node *node)
{
- tree binfo, type, target;
- HOST_WIDE_INT token;
-
- if (jfunc->type == IPA_JF_KNOWN_TYPE)
- binfo = jfunc->value.base_binfo;
- else if (jfunc->type == IPA_JF_CONST)
+ fprintf (f, "ipa-prop: Discovered an indirect call to a known target (");
+ if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
{
- tree cst = jfunc->value.constant;
- if (TREE_CODE (cst) == ADDR_EXPR)
- binfo = gimple_get_relevant_ref_binfo (TREE_OPERAND (cst, 0),
- NULL_TREE);
- else
- return NULL;
+ print_node_brief (f, "", jfunc->value.member_cst.pfn, 0);
+ print_node_brief (f, ", ", jfunc->value.member_cst.delta, 0);
}
else
- return NULL;
+ print_node_brief(f, "", jfunc->value.constant, 0);
- if (!binfo)
- return NULL;
-
- token = ie->indirect_info->otr_token;
- type = ie->indirect_info->otr_type;
- binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
- if (binfo)
- target = gimple_fold_obj_type_ref_known_binfo (token, binfo);
- else
- return NULL;
-
- if (target)
- return make_edge_direct_to_target (ie, target);
- else
- return NULL;
+ 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,
unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
static bool
-update_indirect_edges_after_inlining (struct cgraph_edge *cs,
- struct cgraph_node *node,
- VEC (cgraph_edge_p, heap) **new_edges)
+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 cgraph_edge *ie, *next_ie, *new_direct_edge;
+ struct ipa_param_call_note *nt;
bool res = false;
- ipa_check_create_edge_args ();
-
- for (ie = node->indirect_calls; ie; ie = next_ie)
+ for (nt = info->param_calls; nt; nt = nt->next)
{
- struct cgraph_indirect_call_info *ici = ie->indirect_info;
struct ipa_jump_func *jfunc;
- next_ie = ie->next_callee;
- if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
- continue;
-
- /* If we ever use indirect edges for anything other than indirect
- inlining, we will need to skip those with negative param_indices. */
- if (ici->param_index == -1)
+ if (nt->processed)
continue;
/* We must check range due to calls with variable number of arguments: */
- if (ici->param_index >= ipa_get_cs_argument_count (top))
+ if (nt->formal_id >= ipa_get_cs_argument_count (top))
{
- bitmap_set_bit (iinlining_processed_edges, ie->uid);
+ nt->processed = true;
continue;
}
- jfunc = ipa_get_ith_jump_func (top, ici->param_index);
+ jfunc = ipa_get_ith_jump_func (top, nt->formal_id);
if (jfunc->type == IPA_JF_PASS_THROUGH
&& jfunc->value.pass_through.operation == NOP_EXPR)
- ici->param_index = jfunc->value.pass_through.formal_id;
- else if (jfunc->type == IPA_JF_ANCESTOR)
+ nt->formal_id = jfunc->value.pass_through.formal_id;
+ else if (jfunc->type == IPA_JF_CONST
+ || jfunc->type == IPA_JF_CONST_MEMBER_PTR)
{
- ici->param_index = jfunc->value.ancestor.formal_id;
- ici->anc_offset += jfunc->value.ancestor.offset;
- }
- else
- /* Either we can find a destination for this edge now or never. */
- bitmap_set_bit (iinlining_processed_edges, ie->uid);
+ struct cgraph_node *callee;
+ struct cgraph_edge *new_indirect_edge;
+ tree decl;
- if (ici->polymorphic)
- new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
+ 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->lto_stmt_uid = nt->lto_stmt_uid;
+ 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
- new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
-
- if (new_direct_edge)
{
- new_direct_edge->indirect_inlining_edge = 1;
- if (new_edges)
- {
- VEC_safe_push (cgraph_edge_p, heap, *new_edges,
- new_direct_edge);
- top = IPA_EDGE_REF (cs);
- res = true;
- }
+ /* Ancestor jum functions and pass theoughs with operations should
+ not be used on parameters that then get called. */
+ gcc_assert (jfunc->type == IPA_JF_UNKNOWN);
+ nt->processed = true;
}
}
-
return res;
}
/* Recursively traverse subtree of NODE (including node) made of inlined
cgraph_edges when CS has been inlined and invoke
- update_indirect_edges_after_inlining on all nodes and
+ 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
struct cgraph_edge *e;
bool res;
- res = update_indirect_edges_after_inlining (cs, node, new_edges);
+ res = update_call_notes_after_inlining (cs, node, new_edges);
for (e = node->callees; e; e = e->next_callee)
if (!e->inline_failed)
if (info->params)
free (info->params);
+ 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));
}
static void
ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
{
- /* During IPA-CP updating we can be called on not-yet analyze clones. */
- if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
- <= (unsigned)node->uid)
- return;
ipa_free_node_params_substructures (IPA_NODE_REF (node));
}
new_args->jump_functions = (struct ipa_jump_func *)
duplicate_ggc_array (old_args->jump_functions,
sizeof (struct ipa_jump_func) * arg_count);
-
- if (iinlining_processed_edges
- && bitmap_bit_p (iinlining_processed_edges, src->uid))
- bitmap_set_bit (iinlining_processed_edges, dst->uid);
}
/* Hook that is called by cgraph.c when a node is duplicated. */
__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 ();
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)
+ {
+ 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;
+ }
}
/* Register our cgraph hooks if they are not already there. */
node_duplication_hook_holder = NULL;
}
-/* Allocate all necessary data strucutures necessary for indirect inlining. */
-
-void
-ipa_create_all_structures_for_iinln (void)
-{
- iinlining_processed_edges = BITMAP_ALLOC (NULL);
-}
-
/* Free all ipa_node_params and all ipa_edge_args structures if they are no
longer needed after ipa-cp. */
void
-ipa_free_all_structures_after_ipa_cp (void)
+free_all_ipa_structures_after_ipa_cp (void)
{
if (!flag_indirect_inlining)
{
longer needed after indirect inlining. */
void
-ipa_free_all_structures_after_iinln (void)
+free_all_ipa_structures_after_iinln (void)
{
- BITMAP_FREE (iinlining_processed_edges);
-
ipa_free_all_edge_args ();
ipa_free_all_node_params ();
ipa_unregister_cgraph_hooks ();
if (!node->analyzed)
return;
info = IPA_NODE_REF (node);
- fprintf (f, " function %s parameter descriptors:\n",
- cgraph_node_name (node));
+ fprintf (f, " function %s Trees :: \n", cgraph_node_name (node));
count = ipa_get_param_count (info);
for (i = 0; i < count; i++)
{
: "(unnamed)"));
if (ipa_is_param_modified (info, i))
fprintf (f, " modified");
- if (ipa_is_param_used (info, i))
- fprintf (f, " used");
fprintf (f, "\n");
}
}
if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr)))
expr = fold_convert (ptrtype, expr);
expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr,
- build_int_cst (sizetype,
+ build_int_cst (size_type_node,
adj->offset / BITS_PER_UNIT));
if (!adj->by_ref)
expr = fold_build1 (INDIRECT_REF, adj->type, expr);
{
case IPA_JF_UNKNOWN:
break;
- case IPA_JF_KNOWN_TYPE:
- lto_output_tree (ob, jump_func->value.base_binfo, true);
- break;
case IPA_JF_CONST:
lto_output_tree (ob, jump_func->value.constant, true);
break;
{
case IPA_JF_UNKNOWN:
break;
- case IPA_JF_KNOWN_TYPE:
- jump_func->value.base_binfo = lto_input_tree (ib, data_in);
- break;
case IPA_JF_CONST:
jump_func->value.constant = lto_input_tree (ib, data_in);
break;
}
}
-/* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
- relevant to indirect inlining to OB. */
+/* Stream out a parameter call note. */
static void
-ipa_write_indirect_edge_info (struct output_block *ob,
- struct cgraph_edge *cs)
+ipa_write_param_call_note (struct output_block *ob,
+ struct ipa_param_call_note *note)
{
- struct cgraph_indirect_call_info *ii = cs->indirect_info;
- struct bitpack_d *bp;
-
- lto_output_sleb128_stream (ob->main_stream, ii->param_index);
- lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
- bp = bitpack_create ();
- bp_pack_value (bp, ii->polymorphic, 1);
- lto_output_bitpack (ob->main_stream, bp);
- bitpack_delete (bp);
-
- if (ii->polymorphic)
- {
- lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
- lto_output_tree (ob, ii->otr_type, true);
- }
+ gcc_assert (!note->processed);
+ lto_output_uleb128_stream (ob->main_stream, gimple_uid (note->stmt));
+ lto_output_sleb128_stream (ob->main_stream, note->formal_id);
+ lto_output_sleb128_stream (ob->main_stream, note->count);
+ lto_output_sleb128_stream (ob->main_stream, note->frequency);
+ lto_output_sleb128_stream (ob->main_stream, note->loop_nest);
}
-/* Read in parts of cgraph_indirect_call_info corresponding to CS that are
- relevant to indirect inlining from IB. */
+/* Read in a parameter call note. */
static void
-ipa_read_indirect_edge_info (struct lto_input_block *ib,
- struct data_in *data_in ATTRIBUTE_UNUSED,
- struct cgraph_edge *cs)
+ipa_read_param_call_note (struct lto_input_block *ib,
+ struct ipa_node_params *info)
+
{
- struct cgraph_indirect_call_info *ii = cs->indirect_info;
- struct bitpack_d *bp;
+ struct ipa_param_call_note *note = XCNEW (struct ipa_param_call_note);
- ii->param_index = (int) lto_input_sleb128 (ib);
- ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
- bp = lto_input_bitpack (ib);
- ii->polymorphic = bp_unpack_value (bp, 1);
- bitpack_delete (bp);
- if (ii->polymorphic)
- {
- ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
- ii->otr_type = lto_input_tree (ib, data_in);
- }
+ note->lto_stmt_uid = (unsigned int) lto_input_uleb128 (ib);
+ note->formal_id = (int) lto_input_sleb128 (ib);
+ note->count = (gcov_type) lto_input_sleb128 (ib);
+ note->frequency = (int) lto_input_sleb128 (ib);
+ note->loop_nest = (int) lto_input_sleb128 (ib);
+
+ note->next = info->param_calls;
+ info->param_calls = note;
}
+
/* Stream out NODE info to OB. */
static void
int j;
struct cgraph_edge *e;
struct bitpack_d *bp;
+ int note_count = 0;
+ struct ipa_param_call_note *note;
encoder = ob->decl_state->cgraph_node_encoder;
node_ref = lto_cgraph_encoder_encode (encoder, node);
gcc_assert (!info->node_enqueued);
gcc_assert (!info->ipcp_orig_node);
for (j = 0; j < ipa_get_param_count (info); j++)
- {
- bp_pack_value (bp, info->params[j].modified, 1);
- bp_pack_value (bp, info->params[j].used, 1);
- }
+ bp_pack_value (bp, info->params[j].modified, 1);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
for (e = node->callees; e; e = e->next_callee)
for (j = 0; j < ipa_get_cs_argument_count (args); j++)
ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
}
- for (e = node->indirect_calls; e; e = e->next_callee)
- ipa_write_indirect_edge_info (ob, e);
+
+ for (note = info->param_calls; note; note = note->next)
+ note_count++;
+ lto_output_uleb128_stream (ob->main_stream, note_count);
+ for (note = info->param_calls; note; note = note->next)
+ ipa_write_param_call_note (ob, note);
}
/* Srtream in NODE info from IB. */
int k;
struct cgraph_edge *e;
struct bitpack_d *bp;
+ int i, note_count;
ipa_initialize_node_params (node);
}
info->node_enqueued = false;
for (k = 0; k < ipa_get_param_count (info); k++)
- {
- info->params[k].modified = bp_unpack_value (bp, 1);
- info->params[k].used = bp_unpack_value (bp, 1);
- }
+ info->params[k].modified = bp_unpack_value (bp, 1);
bitpack_delete (bp);
for (e = node->callees; e; e = e->next_callee)
{
for (k = 0; k < ipa_get_cs_argument_count (args); k++)
ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
}
- for (e = node->indirect_calls; e; e = e->next_callee)
- ipa_read_indirect_edge_info (ib, data_in, e);
+
+ note_count = lto_input_uleb128 (ib);
+ for (i = 0; i < note_count; i++)
+ ipa_read_param_call_note (ib, info);
}
/* Write jump functions for nodes in SET. */
index = lto_input_uleb128 (&ib_main);
encoder = file_data->cgraph_node_encoder;
node = lto_cgraph_encoder_deref (encoder, index);
- gcc_assert (node->analyzed);
ipa_read_node_info (&ib_main, node, data_in);
}
lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
}
}
+
+/* Walk param call notes of NODE and set their call statements given the uid
+ stored in each note and STMTS which is an array of statements indexed by the
+ uid. */
+
+void
+lto_ipa_fixup_call_notes (struct cgraph_node *node, gimple *stmts)
+{
+ struct ipa_node_params *info;
+ struct ipa_param_call_note *note;
+
+ ipa_check_create_node_params ();
+ info = IPA_NODE_REF (node);
+ note = info->param_calls;
+ /* If there are no notes or they have already been fixed up (the same fixup
+ is called for both inlining and ipa-cp), there's nothing to do. */
+ if (!note || note->stmt)
+ return;
+
+ do
+ {
+ note->stmt = stmts[note->lto_stmt_uid];
+ note = note->next;
+ }
+ while (note);
+}
OSDN Git Service
