From: jamborm Date: Fri, 9 Apr 2010 20:24:11 +0000 (+0000) Subject: 2010-04-09 Martin Jambor X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=commitdiff_plain;h=cff8b56df15494dbd6a65ea3b0ad43f8bbb39855 2010-04-09 Martin Jambor * ipa-cp.c (ipcp_lats_are_equal): Return true also if the two lattices are addresses of CONST_DECLs with the same initial value. (ipcp_print_all_lattices): Print values of CONST_DECLs. * ipa-prop.c (ipa_print_node_jump_functions): Likewise. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@158176 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index dd63a97edd2..1c57d045fb1 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +2010-04-09 Martin Jambor + + * ipa-cp.c (ipcp_lats_are_equal): Return true also if the two + lattices are addresses of CONST_DECLs with the same initial value. + (ipcp_print_all_lattices): Print values of CONST_DECLs. + * ipa-prop.c (ipa_print_node_jump_functions): Likewise. + 2010-04-09 Eric Botcazou Bernd Schmidt diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c index b3e8cfa61dc..c6d58b1d452 100644 --- a/gcc/ipa-prop.c +++ b/gcc/ipa-prop.c @@ -30,13 +30,10 @@ along with GCC; see the file COPYING3. If not see #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. */ @@ -44,10 +41,6 @@ VEC (ipa_node_params_t, heap) *ipa_node_params_vector; /* 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; @@ -213,29 +206,6 @@ visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED, 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; @@ -254,35 +224,16 @@ ipa_detect_param_modifications (struct cgraph_node *node) 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; } @@ -306,87 +257,16 @@ ipa_count_arguments (struct cgraph_edge *cs) 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) @@ -394,26 +274,60 @@ ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node) 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); - } } @@ -431,60 +345,51 @@ ipa_print_all_jump_functions (FILE *f) } } -/* 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. */ @@ -507,121 +412,6 @@ compute_complex_assign_jump_func (struct ipa_node_params *info, } -/* 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 ; - else - goto ; - - : - iftmp.1_3 = &obj_2(D)->D.1762; - - : - # iftmp.1_1 = PHI - 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 @@ -659,18 +449,8 @@ compute_scalar_jump_functions (struct ipa_node_params *info, } } 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]); } } @@ -883,8 +663,8 @@ compute_cst_member_ptr_arguments (struct ipa_jump_func *functions, 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); @@ -911,34 +691,6 @@ ipa_compute_jump_functions_for_edge (struct cgraph_edge *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 @@ -993,39 +745,39 @@ ipa_is_ssa_with_stmt_def (tree t) 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: : f$__delta_5 = f.__delta; @@ -1065,11 +817,11 @@ ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt, */ 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; @@ -1077,12 +829,16 @@ ipa_analyze_indirect_call_uses (struct cgraph_node *node, 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; } @@ -1179,73 +935,20 @@ ipa_analyze_indirect_call_uses (struct cgraph_node *node, 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. @@ -1270,38 +973,19 @@ ipa_analyze_params_uses (struct cgraph_node *node) 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, @@ -1314,166 +998,52 @@ 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, @@ -1483,74 +1053,84 @@ try_make_edge_direct_virtual_call (struct cgraph_edge *ie, 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 @@ -1564,7 +1144,7 @@ propagate_info_to_inlined_callees (struct cgraph_edge *cs, 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) @@ -1636,6 +1216,13 @@ ipa_free_node_params_substructures (struct ipa_node_params *info) 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)); } @@ -1673,10 +1260,6 @@ ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED) 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)); } @@ -1730,10 +1313,6 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst, 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. */ @@ -1743,6 +1322,7 @@ 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 (); @@ -1756,6 +1336,17 @@ ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst, 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. */ @@ -1792,19 +1383,11 @@ ipa_unregister_cgraph_hooks (void) 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) { @@ -1818,10 +1401,8 @@ ipa_free_all_structures_after_ipa_cp (void) 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 (); @@ -1840,8 +1421,7 @@ ipa_print_node_params (FILE * f, struct cgraph_node *node) 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++) { @@ -1853,8 +1433,6 @@ ipa_print_node_params (FILE * f, struct cgraph_node *node) : "(unnamed)")); if (ipa_is_param_modified (info, i)) fprintf (f, " modified"); - if (ipa_is_param_used (info, i)) - fprintf (f, " used"); fprintf (f, "\n"); } } @@ -2122,7 +1700,7 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt, 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); @@ -2335,9 +1913,6 @@ ipa_write_jump_function (struct output_block *ob, { 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; @@ -2375,9 +1950,6 @@ ipa_read_jump_function (struct lto_input_block *ib, { 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; @@ -2398,53 +1970,40 @@ ipa_read_jump_function (struct lto_input_block *ib, } } -/* 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 @@ -2456,6 +2015,8 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *node) 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); @@ -2469,10 +2030,7 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *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) @@ -2484,8 +2042,12 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *node) 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. */ @@ -2498,6 +2060,7 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node, int k; struct cgraph_edge *e; struct bitpack_d *bp; + int i, note_count; ipa_initialize_node_params (node); @@ -2511,10 +2074,7 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *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) { @@ -2530,8 +2090,10 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node, 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. */ @@ -2600,7 +2162,6 @@ ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data, 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, @@ -2657,3 +2218,29 @@ ipa_update_after_lto_read (void) 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); +}