1 /* Interprocedural analyses.
2 Copyright (C) 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "langhooks.h"
30 #include "tree-flow.h"
31 #include "tree-pass.h"
32 #include "tree-inline.h"
37 #include "diagnostic.h"
38 #include "tree-pretty-print.h"
39 #include "gimple-pretty-print.h"
40 #include "lto-streamer.h"
43 /* Intermediate information about a parameter that is only useful during the
44 run of ipa_analyze_node and is not kept afterwards. */
46 struct param_analysis_info
49 bitmap visited_statements;
52 /* Vector where the parameter infos are actually stored. */
53 VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
54 /* Vector where the parameter infos are actually stored. */
55 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
57 /* Bitmap with all UIDs of call graph edges that have been already processed
58 by indirect inlining. */
59 static bitmap iinlining_processed_edges;
61 /* Holders of ipa cgraph hooks: */
62 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
63 static struct cgraph_node_hook_list *node_removal_hook_holder;
64 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
65 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
67 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
68 it is in one or not. It should almost never be used directly, as opposed to
69 ipa_push_func_to_list. */
72 ipa_push_func_to_list_1 (struct ipa_func_list **wl,
73 struct cgraph_node *node,
74 struct ipa_node_params *info)
76 struct ipa_func_list *temp;
78 info->node_enqueued = 1;
79 temp = XCNEW (struct ipa_func_list);
85 /* Initialize worklist to contain all functions. */
87 struct ipa_func_list *
88 ipa_init_func_list (void)
90 struct cgraph_node *node;
91 struct ipa_func_list * wl;
94 for (node = cgraph_nodes; node; node = node->next)
97 struct ipa_node_params *info = IPA_NODE_REF (node);
98 /* Unreachable nodes should have been eliminated before ipcp and
100 gcc_assert (node->needed || node->reachable);
101 ipa_push_func_to_list_1 (&wl, node, info);
107 /* Remove a function from the worklist WL and return it. */
110 ipa_pop_func_from_list (struct ipa_func_list **wl)
112 struct ipa_node_params *info;
113 struct ipa_func_list *first;
114 struct cgraph_node *node;
121 info = IPA_NODE_REF (node);
122 info->node_enqueued = 0;
126 /* Return index of the formal whose tree is PTREE in function which corresponds
130 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
134 count = ipa_get_param_count (info);
135 for (i = 0; i < count; i++)
136 if (ipa_get_param(info, i) == ptree)
142 /* Populate the param_decl field in parameter descriptors of INFO that
143 corresponds to NODE. */
146 ipa_populate_param_decls (struct cgraph_node *node,
147 struct ipa_node_params *info)
155 fnargs = DECL_ARGUMENTS (fndecl);
157 for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
159 info->params[param_num].decl = parm;
164 /* Return how many formal parameters FNDECL has. */
167 count_formal_params_1 (tree fndecl)
172 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
178 /* Count number of formal parameters in NOTE. Store the result to the
179 appropriate field of INFO. */
182 ipa_count_formal_params (struct cgraph_node *node,
183 struct ipa_node_params *info)
187 param_num = count_formal_params_1 (node->decl);
188 ipa_set_param_count (info, param_num);
191 /* Initialize the ipa_node_params structure associated with NODE by counting
192 the function parameters, creating the descriptors and populating their
196 ipa_initialize_node_params (struct cgraph_node *node)
198 struct ipa_node_params *info = IPA_NODE_REF (node);
202 ipa_count_formal_params (node, info);
203 info->params = XCNEWVEC (struct ipa_param_descriptor,
204 ipa_get_param_count (info));
205 ipa_populate_param_decls (node, info);
209 /* Count number of arguments callsite CS has and store it in
210 ipa_edge_args structure corresponding to this callsite. */
213 ipa_count_arguments (struct cgraph_edge *cs)
218 stmt = cs->call_stmt;
219 gcc_assert (is_gimple_call (stmt));
220 arg_num = gimple_call_num_args (stmt);
221 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
222 <= (unsigned) cgraph_edge_max_uid)
223 VEC_safe_grow_cleared (ipa_edge_args_t, gc,
224 ipa_edge_args_vector, cgraph_edge_max_uid + 1);
225 ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
228 /* Print the jump functions associated with call graph edge CS to file F. */
231 ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
235 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
236 for (i = 0; i < count; i++)
238 struct ipa_jump_func *jump_func;
239 enum jump_func_type type;
241 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
242 type = jump_func->type;
244 fprintf (f, " param %d: ", i);
245 if (type == IPA_JF_UNKNOWN)
246 fprintf (f, "UNKNOWN\n");
247 else if (type == IPA_JF_KNOWN_TYPE)
249 tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
250 fprintf (f, "KNOWN TYPE, type in binfo is: ");
251 print_generic_expr (f, binfo_type, 0);
252 fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
254 else if (type == IPA_JF_CONST)
256 tree val = jump_func->value.constant;
257 fprintf (f, "CONST: ");
258 print_generic_expr (f, val, 0);
259 if (TREE_CODE (val) == ADDR_EXPR
260 && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
263 print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
268 else if (type == IPA_JF_CONST_MEMBER_PTR)
270 fprintf (f, "CONST MEMBER PTR: ");
271 print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
273 print_generic_expr (f, jump_func->value.member_cst.delta, 0);
276 else if (type == IPA_JF_PASS_THROUGH)
278 fprintf (f, "PASS THROUGH: ");
279 fprintf (f, "%d, op %s ",
280 jump_func->value.pass_through.formal_id,
282 jump_func->value.pass_through.operation]);
283 if (jump_func->value.pass_through.operation != NOP_EXPR)
284 print_generic_expr (dump_file,
285 jump_func->value.pass_through.operand, 0);
286 fprintf (dump_file, "\n");
288 else if (type == IPA_JF_ANCESTOR)
290 fprintf (f, "ANCESTOR: ");
291 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
292 jump_func->value.ancestor.formal_id,
293 jump_func->value.ancestor.offset);
294 print_generic_expr (f, jump_func->value.ancestor.type, 0);
295 fprintf (dump_file, "\n");
301 /* Print the jump functions of all arguments on all call graph edges going from
305 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
307 struct cgraph_edge *cs;
310 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
311 for (cs = node->callees; cs; cs = cs->next_callee)
313 if (!ipa_edge_args_info_available_for_edge_p (cs))
316 fprintf (f, " callsite %s/%i -> %s/%i : \n",
317 cgraph_node_name (node), node->uid,
318 cgraph_node_name (cs->callee), cs->callee->uid);
319 ipa_print_node_jump_functions_for_edge (f, cs);
322 for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++)
324 if (!ipa_edge_args_info_available_for_edge_p (cs))
329 fprintf (f, " indirect callsite %d for stmt ", i);
330 print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
333 fprintf (f, " indirect callsite %d :\n", i);
334 ipa_print_node_jump_functions_for_edge (f, cs);
339 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
342 ipa_print_all_jump_functions (FILE *f)
344 struct cgraph_node *node;
346 fprintf (f, "\nJump functions:\n");
347 for (node = cgraph_nodes; node; node = node->next)
349 ipa_print_node_jump_functions (f, node);
353 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
354 of an assignment statement STMT, try to find out whether NAME can be
355 described by a (possibly polynomial) pass-through jump-function or an
356 ancestor jump function and if so, write the appropriate function into
360 compute_complex_assign_jump_func (struct ipa_node_params *info,
361 struct ipa_jump_func *jfunc,
362 gimple stmt, tree name)
364 HOST_WIDE_INT offset, size, max_size;
368 op1 = gimple_assign_rhs1 (stmt);
369 op2 = gimple_assign_rhs2 (stmt);
371 if (TREE_CODE (op1) == SSA_NAME
372 && SSA_NAME_IS_DEFAULT_DEF (op1))
374 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
380 if (!is_gimple_ip_invariant (op2)
381 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
382 && !useless_type_conversion_p (TREE_TYPE (name),
386 jfunc->type = IPA_JF_PASS_THROUGH;
387 jfunc->value.pass_through.formal_id = index;
388 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
389 jfunc->value.pass_through.operand = op2;
391 else if (gimple_assign_unary_nop_p (stmt))
393 jfunc->type = IPA_JF_PASS_THROUGH;
394 jfunc->value.pass_through.formal_id = index;
395 jfunc->value.pass_through.operation = NOP_EXPR;
400 if (TREE_CODE (op1) != ADDR_EXPR)
403 op1 = TREE_OPERAND (op1, 0);
404 type = TREE_TYPE (op1);
405 if (TREE_CODE (type) != RECORD_TYPE)
407 op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
408 if (TREE_CODE (op1) != INDIRECT_REF
409 /* If this is a varying address, punt. */
413 op1 = TREE_OPERAND (op1, 0);
414 if (TREE_CODE (op1) != SSA_NAME
415 || !SSA_NAME_IS_DEFAULT_DEF (op1))
418 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
421 jfunc->type = IPA_JF_ANCESTOR;
422 jfunc->value.ancestor.formal_id = index;
423 jfunc->value.ancestor.offset = offset;
424 jfunc->value.ancestor.type = type;
429 /* Given that an actual argument is an SSA_NAME that is a result of a phi
430 statement PHI, try to find out whether NAME is in fact a
431 multiple-inheritance typecast from a descendant into an ancestor of a formal
432 parameter and thus can be described by an ancestor jump function and if so,
433 write the appropriate function into JFUNC.
435 Essentially we want to match the following pattern:
443 iftmp.1_3 = &obj_2(D)->D.1762;
446 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
447 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
451 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
452 struct ipa_jump_func *jfunc,
455 HOST_WIDE_INT offset, size, max_size;
457 basic_block phi_bb, assign_bb, cond_bb;
458 tree tmp, parm, expr;
461 if (gimple_phi_num_args (phi) != 2
462 || !integer_zerop (PHI_ARG_DEF (phi, 1)))
465 tmp = PHI_ARG_DEF (phi, 0);
466 if (TREE_CODE (tmp) != SSA_NAME
467 || SSA_NAME_IS_DEFAULT_DEF (tmp)
468 || !POINTER_TYPE_P (TREE_TYPE (tmp))
469 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
472 assign = SSA_NAME_DEF_STMT (tmp);
473 assign_bb = gimple_bb (assign);
474 if (!single_pred_p (assign_bb)
475 || !gimple_assign_single_p (assign))
477 expr = gimple_assign_rhs1 (assign);
479 if (TREE_CODE (expr) != ADDR_EXPR)
481 expr = TREE_OPERAND (expr, 0);
482 expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
484 if (TREE_CODE (expr) != INDIRECT_REF
485 /* If this is a varying address, punt. */
489 parm = TREE_OPERAND (expr, 0);
490 if (TREE_CODE (parm) != SSA_NAME
491 || !SSA_NAME_IS_DEFAULT_DEF (parm))
494 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
498 cond_bb = single_pred (assign_bb);
499 cond = last_stmt (cond_bb);
501 || gimple_code (cond) != GIMPLE_COND
502 || gimple_cond_code (cond) != NE_EXPR
503 || gimple_cond_lhs (cond) != parm
504 || !integer_zerop (gimple_cond_rhs (cond)))
508 phi_bb = gimple_bb (phi);
509 for (i = 0; i < 2; i++)
511 basic_block pred = EDGE_PRED (phi_bb, i)->src;
512 if (pred != assign_bb && pred != cond_bb)
516 jfunc->type = IPA_JF_ANCESTOR;
517 jfunc->value.ancestor.formal_id = index;
518 jfunc->value.ancestor.offset = offset;
519 jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
522 /* Given OP whch is passed as an actual argument to a called function,
523 determine if it is possible to construct a KNOWN_TYPE jump function for it
524 and if so, create one and store it to JFUNC. */
527 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
531 if (TREE_CODE (op) != ADDR_EXPR)
534 op = TREE_OPERAND (op, 0);
535 binfo = gimple_get_relevant_ref_binfo (op, NULL_TREE);
538 jfunc->type = IPA_JF_KNOWN_TYPE;
539 jfunc->value.base_binfo = binfo;
544 /* Determine the jump functions of scalar arguments. Scalar means SSA names
545 and constants of a number of selected types. INFO is the ipa_node_params
546 structure associated with the caller, FUNCTIONS is a pointer to an array of
547 jump function structures associated with CALL which is the call statement
551 compute_scalar_jump_functions (struct ipa_node_params *info,
552 struct ipa_jump_func *functions,
558 for (num = 0; num < gimple_call_num_args (call); num++)
560 arg = gimple_call_arg (call, num);
562 if (is_gimple_ip_invariant (arg))
564 functions[num].type = IPA_JF_CONST;
565 functions[num].value.constant = arg;
567 else if (TREE_CODE (arg) == SSA_NAME)
569 if (SSA_NAME_IS_DEFAULT_DEF (arg))
571 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
575 functions[num].type = IPA_JF_PASS_THROUGH;
576 functions[num].value.pass_through.formal_id = index;
577 functions[num].value.pass_through.operation = NOP_EXPR;
582 gimple stmt = SSA_NAME_DEF_STMT (arg);
583 if (is_gimple_assign (stmt))
584 compute_complex_assign_jump_func (info, &functions[num],
586 else if (gimple_code (stmt) == GIMPLE_PHI)
587 compute_complex_ancestor_jump_func (info, &functions[num],
592 compute_known_type_jump_func (arg, &functions[num]);
596 /* Inspect the given TYPE and return true iff it has the same structure (the
597 same number of fields of the same types) as a C++ member pointer. If
598 METHOD_PTR and DELTA are non-NULL, store the trees representing the
599 corresponding fields there. */
602 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
606 if (TREE_CODE (type) != RECORD_TYPE)
609 fld = TYPE_FIELDS (type);
610 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
611 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
617 fld = TREE_CHAIN (fld);
618 if (!fld || INTEGRAL_TYPE_P (fld))
623 if (TREE_CHAIN (fld))
629 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
630 boolean variable pointed to by DATA. */
633 mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
636 bool *b = (bool *) data;
641 /* Return true if the formal parameter PARM might have been modified in this
642 function before reaching the statement CALL. PARM_INFO is a pointer to a
643 structure containing intermediate information about PARM. */
646 is_parm_modified_before_call (struct param_analysis_info *parm_info,
647 gimple call, tree parm)
649 bool modified = false;
652 if (parm_info->modified)
655 ao_ref_init (&refd, parm);
656 walk_aliased_vdefs (&refd, gimple_vuse (call), mark_modified,
657 &modified, &parm_info->visited_statements);
660 parm_info->modified = true;
666 /* Go through arguments of the CALL and for every one that looks like a member
667 pointer, check whether it can be safely declared pass-through and if so,
668 mark that to the corresponding item of jump FUNCTIONS. Return true iff
669 there are non-pass-through member pointers within the arguments. INFO
670 describes formal parameters of the caller. PARMS_INFO is a pointer to a
671 vector containing intermediate information about each formal parameter. */
674 compute_pass_through_member_ptrs (struct ipa_node_params *info,
675 struct param_analysis_info *parms_info,
676 struct ipa_jump_func *functions,
679 bool undecided_members = false;
683 for (num = 0; num < gimple_call_num_args (call); num++)
685 arg = gimple_call_arg (call, num);
687 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
689 if (TREE_CODE (arg) == PARM_DECL)
691 int index = ipa_get_param_decl_index (info, arg);
693 gcc_assert (index >=0);
694 if (!is_parm_modified_before_call (&parms_info[index], call, arg))
696 functions[num].type = IPA_JF_PASS_THROUGH;
697 functions[num].value.pass_through.formal_id = index;
698 functions[num].value.pass_through.operation = NOP_EXPR;
701 undecided_members = true;
704 undecided_members = true;
708 return undecided_members;
711 /* Simple function filling in a member pointer constant jump function (with PFN
712 and DELTA as the constant value) into JFUNC. */
715 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
716 tree pfn, tree delta)
718 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
719 jfunc->value.member_cst.pfn = pfn;
720 jfunc->value.member_cst.delta = delta;
723 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
724 return the rhs of its defining statement. */
727 get_ssa_def_if_simple_copy (tree rhs)
729 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
731 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
733 if (gimple_assign_single_p (def_stmt))
734 rhs = gimple_assign_rhs1 (def_stmt);
741 /* Traverse statements from CALL backwards, scanning whether the argument ARG
742 which is a member pointer is filled in with constant values. If it is, fill
743 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
744 fields of the record type of the member pointer. To give an example, we
745 look for a pattern looking like the following:
747 D.2515.__pfn ={v} printStuff;
748 D.2515.__delta ={v} 0;
749 i_1 = doprinting (D.2515); */
752 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
753 tree delta_field, struct ipa_jump_func *jfunc)
755 gimple_stmt_iterator gsi;
756 tree method = NULL_TREE;
757 tree delta = NULL_TREE;
759 gsi = gsi_for_stmt (call);
762 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
764 gimple stmt = gsi_stmt (gsi);
767 if (!stmt_may_clobber_ref_p (stmt, arg))
769 if (!gimple_assign_single_p (stmt))
772 lhs = gimple_assign_lhs (stmt);
773 rhs = gimple_assign_rhs1 (stmt);
775 if (TREE_CODE (lhs) != COMPONENT_REF
776 || TREE_OPERAND (lhs, 0) != arg)
779 fld = TREE_OPERAND (lhs, 1);
780 if (!method && fld == method_field)
782 rhs = get_ssa_def_if_simple_copy (rhs);
783 if (TREE_CODE (rhs) == ADDR_EXPR
784 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
785 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
787 method = TREE_OPERAND (rhs, 0);
790 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
798 if (!delta && fld == delta_field)
800 rhs = get_ssa_def_if_simple_copy (rhs);
801 if (TREE_CODE (rhs) == INTEGER_CST)
806 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
818 /* Go through the arguments of the CALL and for every member pointer within
819 tries determine whether it is a constant. If it is, create a corresponding
820 constant jump function in FUNCTIONS which is an array of jump functions
821 associated with the call. */
824 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
828 tree arg, method_field, delta_field;
830 for (num = 0; num < gimple_call_num_args (call); num++)
832 arg = gimple_call_arg (call, num);
834 if (functions[num].type == IPA_JF_UNKNOWN
835 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
837 determine_cst_member_ptr (call, arg, method_field, delta_field,
842 /* Compute jump function for all arguments of callsite CS and insert the
843 information in the jump_functions array in the ipa_edge_args corresponding
847 ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_info,
848 struct cgraph_edge *cs)
850 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
851 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
854 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
856 arguments->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
857 (ipa_get_cs_argument_count (arguments));
859 call = cs->call_stmt;
860 gcc_assert (is_gimple_call (call));
862 /* We will deal with constants and SSA scalars first: */
863 compute_scalar_jump_functions (info, arguments->jump_functions, call);
865 /* Let's check whether there are any potential member pointers and if so,
866 whether we can determine their functions as pass_through. */
867 if (!compute_pass_through_member_ptrs (info, parms_info,
868 arguments->jump_functions, call))
871 /* Finally, let's check whether we actually pass a new constant member
873 compute_cst_member_ptr_arguments (arguments->jump_functions, call);
876 /* Compute jump functions for all edges - both direct and indirect - outgoing
877 from NODE. Also count the actual arguments in the process. */
880 ipa_compute_jump_functions (struct cgraph_node *node,
881 struct param_analysis_info *parms_info)
883 struct cgraph_edge *cs;
885 for (cs = node->callees; cs; cs = cs->next_callee)
887 /* We do not need to bother analyzing calls to unknown
888 functions unless they may become known during lto/whopr. */
889 if (!cs->callee->analyzed && !flag_lto && !flag_whopr)
891 ipa_count_arguments (cs);
892 /* If the descriptor of the callee is not initialized yet, we have to do
894 if (cs->callee->analyzed)
895 ipa_initialize_node_params (cs->callee);
896 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
897 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
898 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
899 ipa_compute_jump_functions_for_edge (parms_info, cs);
902 for (cs = node->indirect_calls; cs; cs = cs->next_callee)
904 ipa_count_arguments (cs);
905 ipa_compute_jump_functions_for_edge (parms_info, cs);
909 /* If RHS looks like a rhs of a statement loading pfn from a member
910 pointer formal parameter, return the parameter, otherwise return
911 NULL. If USE_DELTA, then we look for a use of the delta field
912 rather than the pfn. */
915 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
921 if (TREE_CODE (rhs) != COMPONENT_REF)
924 rec = TREE_OPERAND (rhs, 0);
925 if (TREE_CODE (rec) != PARM_DECL
926 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
929 fld = TREE_OPERAND (rhs, 1);
930 if (use_delta ? (fld == delta_field) : (fld == ptr_field))
936 /* If STMT looks like a statement loading a value from a member pointer formal
937 parameter, this function returns that parameter. */
940 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
944 if (!gimple_assign_single_p (stmt))
947 rhs = gimple_assign_rhs1 (stmt);
948 return ipa_get_member_ptr_load_param (rhs, use_delta);
951 /* Returns true iff T is an SSA_NAME defined by a statement. */
954 ipa_is_ssa_with_stmt_def (tree t)
956 if (TREE_CODE (t) == SSA_NAME
957 && !SSA_NAME_IS_DEFAULT_DEF (t))
963 /* Find the indirect call graph edge corresponding to STMT and add to it all
964 information necessary to describe a call to a parameter number PARAM_INDEX.
965 NODE is the caller. POLYMORPHIC should be set to true iff the call is a
969 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
972 struct cgraph_edge *cs;
974 cs = cgraph_edge (node, stmt);
975 cs->indirect_info->param_index = param_index;
976 cs->indirect_info->anc_offset = 0;
977 cs->indirect_info->polymorphic = polymorphic;
980 tree otr = gimple_call_fn (stmt);
981 tree type, token = OBJ_TYPE_REF_TOKEN (otr);
982 cs->indirect_info->otr_token = tree_low_cst (token, 1);
983 type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
984 cs->indirect_info->otr_type = type;
988 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
989 (described by INFO). PARMS_INFO is a pointer to a vector containing
990 intermediate information about each formal parameter. Currently it checks
991 whether the call calls a pointer that is a formal parameter and if so, the
992 parameter is marked with the called flag and an indirect call graph edge
993 describing the call is created. This is very simple for ordinary pointers
994 represented in SSA but not-so-nice when it comes to member pointers. The
995 ugly part of this function does nothing more than trying to match the
996 pattern of such a call. An example of such a pattern is the gimple dump
997 below, the call is on the last line:
1000 f$__delta_5 = f.__delta;
1001 f$__pfn_24 = f.__pfn;
1006 D.2496_3 = (int) f$__pfn_24;
1007 D.2497_4 = D.2496_3 & 1;
1014 D.2500_7 = (unsigned int) f$__delta_5;
1015 D.2501_8 = &S + D.2500_7;
1016 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1017 D.2503_10 = *D.2502_9;
1018 D.2504_12 = f$__pfn_24 + -1;
1019 D.2505_13 = (unsigned int) D.2504_12;
1020 D.2506_14 = D.2503_10 + D.2505_13;
1021 D.2507_15 = *D.2506_14;
1022 iftmp.11_16 = (String:: *) D.2507_15;
1025 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1026 D.2500_19 = (unsigned int) f$__delta_5;
1027 D.2508_20 = &S + D.2500_19;
1028 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1030 Such patterns are results of simple calls to a member pointer:
1032 int doprinting (int (MyString::* f)(int) const)
1034 MyString S ("somestring");
1041 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1042 struct ipa_node_params *info,
1043 struct param_analysis_info *parms_info,
1044 gimple call, tree target)
1049 tree rec, rec2, cond;
1052 basic_block bb, virt_bb, join;
1054 if (SSA_NAME_IS_DEFAULT_DEF (target))
1056 tree var = SSA_NAME_VAR (target);
1057 index = ipa_get_param_decl_index (info, var);
1059 ipa_note_param_call (node, index, call, false);
1063 /* Now we need to try to match the complex pattern of calling a member
1066 if (!POINTER_TYPE_P (TREE_TYPE (target))
1067 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1070 def = SSA_NAME_DEF_STMT (target);
1071 if (gimple_code (def) != GIMPLE_PHI)
1074 if (gimple_phi_num_args (def) != 2)
1077 /* First, we need to check whether one of these is a load from a member
1078 pointer that is a parameter to this function. */
1079 n1 = PHI_ARG_DEF (def, 0);
1080 n2 = PHI_ARG_DEF (def, 1);
1081 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1083 d1 = SSA_NAME_DEF_STMT (n1);
1084 d2 = SSA_NAME_DEF_STMT (n2);
1086 join = gimple_bb (def);
1087 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1089 if (ipa_get_stmt_member_ptr_load_param (d2, false))
1092 bb = EDGE_PRED (join, 0)->src;
1093 virt_bb = gimple_bb (d2);
1095 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1097 bb = EDGE_PRED (join, 1)->src;
1098 virt_bb = gimple_bb (d1);
1103 /* Second, we need to check that the basic blocks are laid out in the way
1104 corresponding to the pattern. */
1106 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1107 || single_pred (virt_bb) != bb
1108 || single_succ (virt_bb) != join)
1111 /* Third, let's see that the branching is done depending on the least
1112 significant bit of the pfn. */
1114 branch = last_stmt (bb);
1115 if (!branch || gimple_code (branch) != GIMPLE_COND)
1118 if (gimple_cond_code (branch) != NE_EXPR
1119 || !integer_zerop (gimple_cond_rhs (branch)))
1122 cond = gimple_cond_lhs (branch);
1123 if (!ipa_is_ssa_with_stmt_def (cond))
1126 def = SSA_NAME_DEF_STMT (cond);
1127 if (!is_gimple_assign (def)
1128 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1129 || !integer_onep (gimple_assign_rhs2 (def)))
1132 cond = gimple_assign_rhs1 (def);
1133 if (!ipa_is_ssa_with_stmt_def (cond))
1136 def = SSA_NAME_DEF_STMT (cond);
1138 if (is_gimple_assign (def)
1139 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1141 cond = gimple_assign_rhs1 (def);
1142 if (!ipa_is_ssa_with_stmt_def (cond))
1144 def = SSA_NAME_DEF_STMT (cond);
1147 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1148 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1149 == ptrmemfunc_vbit_in_delta));
1154 index = ipa_get_param_decl_index (info, rec);
1155 if (index >= 0 && !is_parm_modified_before_call (&parms_info[index],
1157 ipa_note_param_call (node, index, call, false);
1162 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1163 object referenced in the expression is a formal parameter of the caller
1164 (described by INFO), create a call note for the statement. */
1167 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1168 struct ipa_node_params *info, gimple call,
1171 tree obj = OBJ_TYPE_REF_OBJECT (target);
1175 if (TREE_CODE (obj) == ADDR_EXPR)
1179 obj = TREE_OPERAND (obj, 0);
1181 while (TREE_CODE (obj) == COMPONENT_REF);
1182 if (TREE_CODE (obj) != INDIRECT_REF)
1184 obj = TREE_OPERAND (obj, 0);
1187 if (TREE_CODE (obj) != SSA_NAME
1188 || !SSA_NAME_IS_DEFAULT_DEF (obj))
1191 var = SSA_NAME_VAR (obj);
1192 index = ipa_get_param_decl_index (info, var);
1195 ipa_note_param_call (node, index, call, true);
1198 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1199 of the caller (described by INFO). PARMS_INFO is a pointer to a vector
1200 containing intermediate information about each formal parameter. */
1203 ipa_analyze_call_uses (struct cgraph_node *node,
1204 struct ipa_node_params *info,
1205 struct param_analysis_info *parms_info, gimple call)
1207 tree target = gimple_call_fn (call);
1209 if (TREE_CODE (target) == SSA_NAME)
1210 ipa_analyze_indirect_call_uses (node, info, parms_info, call, target);
1211 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1212 ipa_analyze_virtual_call_uses (node, info, call, target);
1216 /* Analyze the call statement STMT with respect to formal parameters (described
1217 in INFO) of caller given by NODE. Currently it only checks whether formal
1218 parameters are called. PARMS_INFO is a pointer to a vector containing
1219 intermediate information about each formal parameter. */
1222 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1223 struct param_analysis_info *parms_info, gimple stmt)
1225 if (is_gimple_call (stmt))
1226 ipa_analyze_call_uses (node, info, parms_info, stmt);
1229 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1230 If OP is a parameter declaration, mark it as used in the info structure
1234 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
1235 tree op, void *data)
1237 struct ipa_node_params *info = (struct ipa_node_params *) data;
1239 op = get_base_address (op);
1241 && TREE_CODE (op) == PARM_DECL)
1243 int index = ipa_get_param_decl_index (info, op);
1244 gcc_assert (index >= 0);
1245 info->params[index].used = true;
1251 /* Scan the function body of NODE and inspect the uses of formal parameters.
1252 Store the findings in various structures of the associated ipa_node_params
1253 structure, such as parameter flags, notes etc. PARMS_INFO is a pointer to a
1254 vector containing intermediate information about each formal parameter. */
1257 ipa_analyze_params_uses (struct cgraph_node *node,
1258 struct param_analysis_info *parms_info)
1260 tree decl = node->decl;
1262 struct function *func;
1263 gimple_stmt_iterator gsi;
1264 struct ipa_node_params *info = IPA_NODE_REF (node);
1267 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1270 for (i = 0; i < ipa_get_param_count (info); i++)
1272 tree parm = ipa_get_param (info, i);
1273 /* For SSA regs see if parameter is used. For non-SSA we compute
1274 the flag during modification analysis. */
1275 if (is_gimple_reg (parm)
1276 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
1277 info->params[i].used = true;
1280 func = DECL_STRUCT_FUNCTION (decl);
1281 FOR_EACH_BB_FN (bb, func)
1283 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1285 gimple stmt = gsi_stmt (gsi);
1287 if (is_gimple_debug (stmt))
1290 ipa_analyze_stmt_uses (node, info, parms_info, stmt);
1291 walk_stmt_load_store_addr_ops (stmt, info,
1292 visit_ref_for_mod_analysis,
1293 visit_ref_for_mod_analysis,
1294 visit_ref_for_mod_analysis);
1296 for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
1297 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
1298 visit_ref_for_mod_analysis,
1299 visit_ref_for_mod_analysis,
1300 visit_ref_for_mod_analysis);
1303 info->uses_analysis_done = 1;
1306 /* Initialize the array describing properties of of formal parameters of NODE,
1307 analyze their uses and and compute jump functions associated witu actual
1308 arguments of calls from within NODE. */
1311 ipa_analyze_node (struct cgraph_node *node)
1313 struct ipa_node_params *info = IPA_NODE_REF (node);
1314 struct param_analysis_info *parms_info;
1317 ipa_initialize_node_params (node);
1319 param_count = ipa_get_param_count (info);
1320 parms_info = XALLOCAVEC (struct param_analysis_info, param_count);
1321 memset (parms_info, 0, sizeof (struct param_analysis_info) * param_count);
1323 ipa_analyze_params_uses (node, parms_info);
1324 ipa_compute_jump_functions (node, parms_info);
1326 for (i = 0; i < param_count; i++)
1327 if (parms_info[i].visited_statements)
1328 BITMAP_FREE (parms_info[i].visited_statements);
1332 /* Update the jump function DST when the call graph edge correspondng to SRC is
1333 is being inlined, knowing that DST is of type ancestor and src of known
1337 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1338 struct ipa_jump_func *dst)
1342 new_binfo = get_binfo_at_offset (src->value.base_binfo,
1343 dst->value.ancestor.offset,
1344 dst->value.ancestor.type);
1347 dst->type = IPA_JF_KNOWN_TYPE;
1348 dst->value.base_binfo = new_binfo;
1351 dst->type = IPA_JF_UNKNOWN;
1354 /* Update the jump functions associated with call graph edge E when the call
1355 graph edge CS is being inlined, assuming that E->caller is already (possibly
1356 indirectly) inlined into CS->callee and that E has not been inlined. */
1359 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1360 struct cgraph_edge *e)
1362 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1363 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1364 int count = ipa_get_cs_argument_count (args);
1367 for (i = 0; i < count; i++)
1369 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1371 if (dst->type == IPA_JF_ANCESTOR)
1373 struct ipa_jump_func *src;
1375 /* Variable number of arguments can cause havoc if we try to access
1376 one that does not exist in the inlined edge. So make sure we
1378 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1380 dst->type = IPA_JF_UNKNOWN;
1384 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1385 if (src->type == IPA_JF_KNOWN_TYPE)
1386 combine_known_type_and_ancestor_jfs (src, dst);
1387 else if (src->type == IPA_JF_CONST)
1389 struct ipa_jump_func kt_func;
1391 kt_func.type = IPA_JF_UNKNOWN;
1392 compute_known_type_jump_func (src->value.constant, &kt_func);
1393 if (kt_func.type == IPA_JF_KNOWN_TYPE)
1394 combine_known_type_and_ancestor_jfs (&kt_func, dst);
1396 dst->type = IPA_JF_UNKNOWN;
1398 else if (src->type == IPA_JF_PASS_THROUGH
1399 && src->value.pass_through.operation == NOP_EXPR)
1400 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1401 else if (src->type == IPA_JF_ANCESTOR)
1403 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1404 dst->value.ancestor.offset += src->value.ancestor.offset;
1407 dst->type = IPA_JF_UNKNOWN;
1409 else if (dst->type == IPA_JF_PASS_THROUGH)
1411 struct ipa_jump_func *src;
1412 /* We must check range due to calls with variable number of arguments
1413 and we cannot combine jump functions with operations. */
1414 if (dst->value.pass_through.operation == NOP_EXPR
1415 && (dst->value.pass_through.formal_id
1416 < ipa_get_cs_argument_count (top)))
1418 src = ipa_get_ith_jump_func (top,
1419 dst->value.pass_through.formal_id);
1423 dst->type = IPA_JF_UNKNOWN;
1428 /* If TARGET is an addr_expr of a function declaration, make it the destination
1429 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1431 static struct cgraph_edge *
1432 make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
1434 struct cgraph_node *callee;
1436 if (TREE_CODE (target) != ADDR_EXPR)
1438 target = TREE_OPERAND (target, 0);
1439 if (TREE_CODE (target) != FUNCTION_DECL)
1441 callee = cgraph_node (target);
1445 cgraph_make_edge_direct (ie, callee);
1448 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1449 "(%s/%i -> %s/%i) for stmt ",
1450 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1451 cgraph_node_name (ie->caller), ie->caller->uid,
1452 cgraph_node_name (ie->callee), ie->callee->uid);
1455 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1457 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1460 if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie))
1461 != ipa_get_param_count (IPA_NODE_REF (callee)))
1462 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee));
1467 /* Try to find a destination for indirect edge IE that corresponds to a simple
1468 call or a call of a member function pointer and where the destination is a
1469 pointer formal parameter described by jump function JFUNC. If it can be
1470 determined, return the newly direct edge, otherwise return NULL. */
1472 static struct cgraph_edge *
1473 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1474 struct ipa_jump_func *jfunc)
1478 if (jfunc->type == IPA_JF_CONST)
1479 target = jfunc->value.constant;
1480 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1481 target = jfunc->value.member_cst.pfn;
1485 return make_edge_direct_to_target (ie, target);
1488 /* Try to find a destination for indirect edge IE that corresponds to a
1489 virtuall call based on a formal parameter which is described by jump
1490 function JFUNC and if it can be determined, make it direct and return the
1491 direct edge. Otherwise, return NULL. */
1493 static struct cgraph_edge *
1494 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1495 struct ipa_jump_func *jfunc)
1497 tree binfo, type, target;
1498 HOST_WIDE_INT token;
1500 if (jfunc->type == IPA_JF_KNOWN_TYPE)
1501 binfo = jfunc->value.base_binfo;
1502 else if (jfunc->type == IPA_JF_CONST)
1504 tree cst = jfunc->value.constant;
1505 if (TREE_CODE (cst) == ADDR_EXPR)
1506 binfo = gimple_get_relevant_ref_binfo (TREE_OPERAND (cst, 0),
1517 token = ie->indirect_info->otr_token;
1518 type = ie->indirect_info->otr_type;
1519 binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
1521 target = gimple_fold_obj_type_ref_known_binfo (token, binfo);
1526 return make_edge_direct_to_target (ie, target);
1531 /* Update the param called notes associated with NODE when CS is being inlined,
1532 assuming NODE is (potentially indirectly) inlined into CS->callee.
1533 Moreover, if the callee is discovered to be constant, create a new cgraph
1534 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1535 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1538 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1539 struct cgraph_node *node,
1540 VEC (cgraph_edge_p, heap) **new_edges)
1542 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1543 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1546 ipa_check_create_edge_args ();
1548 for (ie = node->indirect_calls; ie; ie = next_ie)
1550 struct cgraph_indirect_call_info *ici = ie->indirect_info;
1551 struct ipa_jump_func *jfunc;
1553 next_ie = ie->next_callee;
1554 if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
1557 /* If we ever use indirect edges for anything other than indirect
1558 inlining, we will need to skip those with negative param_indices. */
1559 if (ici->param_index == -1)
1562 /* We must check range due to calls with variable number of arguments: */
1563 if (ici->param_index >= ipa_get_cs_argument_count (top))
1565 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1569 jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1570 if (jfunc->type == IPA_JF_PASS_THROUGH
1571 && jfunc->value.pass_through.operation == NOP_EXPR)
1572 ici->param_index = jfunc->value.pass_through.formal_id;
1573 else if (jfunc->type == IPA_JF_ANCESTOR)
1575 ici->param_index = jfunc->value.ancestor.formal_id;
1576 ici->anc_offset += jfunc->value.ancestor.offset;
1579 /* Either we can find a destination for this edge now or never. */
1580 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1582 if (ici->polymorphic)
1583 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1585 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1587 if (new_direct_edge)
1589 new_direct_edge->indirect_inlining_edge = 1;
1592 VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1594 top = IPA_EDGE_REF (cs);
1603 /* Recursively traverse subtree of NODE (including node) made of inlined
1604 cgraph_edges when CS has been inlined and invoke
1605 update_indirect_edges_after_inlining on all nodes and
1606 update_jump_functions_after_inlining on all non-inlined edges that lead out
1607 of this subtree. Newly discovered indirect edges will be added to
1608 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1612 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1613 struct cgraph_node *node,
1614 VEC (cgraph_edge_p, heap) **new_edges)
1616 struct cgraph_edge *e;
1619 res = update_indirect_edges_after_inlining (cs, node, new_edges);
1621 for (e = node->callees; e; e = e->next_callee)
1622 if (!e->inline_failed)
1623 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1625 update_jump_functions_after_inlining (cs, e);
1630 /* Update jump functions and call note functions on inlining the call site CS.
1631 CS is expected to lead to a node already cloned by
1632 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1633 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1637 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1638 VEC (cgraph_edge_p, heap) **new_edges)
1640 /* FIXME lto: We do not stream out indirect call information. */
1644 /* Do nothing if the preparation phase has not been carried out yet
1645 (i.e. during early inlining). */
1646 if (!ipa_node_params_vector)
1648 gcc_assert (ipa_edge_args_vector);
1650 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1653 /* Frees all dynamically allocated structures that the argument info points
1657 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1659 if (args->jump_functions)
1660 ggc_free (args->jump_functions);
1662 memset (args, 0, sizeof (*args));
1665 /* Free all ipa_edge structures. */
1668 ipa_free_all_edge_args (void)
1671 struct ipa_edge_args *args;
1674 VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
1676 ipa_free_edge_args_substructures (args);
1678 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1679 ipa_edge_args_vector = NULL;
1682 /* Frees all dynamically allocated structures that the param info points
1686 ipa_free_node_params_substructures (struct ipa_node_params *info)
1689 free (info->params);
1691 memset (info, 0, sizeof (*info));
1694 /* Free all ipa_node_params structures. */
1697 ipa_free_all_node_params (void)
1700 struct ipa_node_params *info;
1703 VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
1705 ipa_free_node_params_substructures (info);
1707 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1708 ipa_node_params_vector = NULL;
1711 /* Hook that is called by cgraph.c when an edge is removed. */
1714 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1716 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1717 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1718 <= (unsigned)cs->uid)
1720 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1723 /* Hook that is called by cgraph.c when a node is removed. */
1726 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1728 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1729 if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1730 <= (unsigned)node->uid)
1732 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1735 /* Helper function to duplicate an array of size N that is at SRC and store a
1736 pointer to it to DST. Nothing is done if SRC is NULL. */
1739 duplicate_array (void *src, size_t n)
1751 static struct ipa_jump_func *
1752 duplicate_ipa_jump_func_array (const struct ipa_jump_func * src, size_t n)
1754 struct ipa_jump_func *p;
1759 p = ggc_alloc_vec_ipa_jump_func (n);
1760 memcpy (p, src, n * sizeof (struct ipa_jump_func));
1764 /* Hook that is called by cgraph.c when a node is duplicated. */
1767 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1768 __attribute__((unused)) void *data)
1770 struct ipa_edge_args *old_args, *new_args;
1773 ipa_check_create_edge_args ();
1775 old_args = IPA_EDGE_REF (src);
1776 new_args = IPA_EDGE_REF (dst);
1778 arg_count = ipa_get_cs_argument_count (old_args);
1779 ipa_set_cs_argument_count (new_args, arg_count);
1780 new_args->jump_functions =
1781 duplicate_ipa_jump_func_array (old_args->jump_functions, arg_count);
1783 if (iinlining_processed_edges
1784 && bitmap_bit_p (iinlining_processed_edges, src->uid))
1785 bitmap_set_bit (iinlining_processed_edges, dst->uid);
1788 /* Hook that is called by cgraph.c when a node is duplicated. */
1791 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1792 __attribute__((unused)) void *data)
1794 struct ipa_node_params *old_info, *new_info;
1797 ipa_check_create_node_params ();
1798 old_info = IPA_NODE_REF (src);
1799 new_info = IPA_NODE_REF (dst);
1800 param_count = ipa_get_param_count (old_info);
1802 ipa_set_param_count (new_info, param_count);
1803 new_info->params = (struct ipa_param_descriptor *)
1804 duplicate_array (old_info->params,
1805 sizeof (struct ipa_param_descriptor) * param_count);
1806 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1807 new_info->count_scale = old_info->count_scale;
1810 /* Register our cgraph hooks if they are not already there. */
1813 ipa_register_cgraph_hooks (void)
1815 if (!edge_removal_hook_holder)
1816 edge_removal_hook_holder =
1817 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1818 if (!node_removal_hook_holder)
1819 node_removal_hook_holder =
1820 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1821 if (!edge_duplication_hook_holder)
1822 edge_duplication_hook_holder =
1823 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1824 if (!node_duplication_hook_holder)
1825 node_duplication_hook_holder =
1826 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1829 /* Unregister our cgraph hooks if they are not already there. */
1832 ipa_unregister_cgraph_hooks (void)
1834 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1835 edge_removal_hook_holder = NULL;
1836 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1837 node_removal_hook_holder = NULL;
1838 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1839 edge_duplication_hook_holder = NULL;
1840 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1841 node_duplication_hook_holder = NULL;
1844 /* Allocate all necessary data strucutures necessary for indirect inlining. */
1847 ipa_create_all_structures_for_iinln (void)
1849 iinlining_processed_edges = BITMAP_ALLOC (NULL);
1852 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1853 longer needed after ipa-cp. */
1856 ipa_free_all_structures_after_ipa_cp (void)
1858 if (!flag_indirect_inlining)
1860 ipa_free_all_edge_args ();
1861 ipa_free_all_node_params ();
1862 ipa_unregister_cgraph_hooks ();
1866 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1867 longer needed after indirect inlining. */
1870 ipa_free_all_structures_after_iinln (void)
1872 BITMAP_FREE (iinlining_processed_edges);
1874 ipa_free_all_edge_args ();
1875 ipa_free_all_node_params ();
1876 ipa_unregister_cgraph_hooks ();
1879 /* Print ipa_tree_map data structures of all functions in the
1883 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1887 struct ipa_node_params *info;
1889 if (!node->analyzed)
1891 info = IPA_NODE_REF (node);
1892 fprintf (f, " function %s parameter descriptors:\n",
1893 cgraph_node_name (node));
1894 count = ipa_get_param_count (info);
1895 for (i = 0; i < count; i++)
1897 temp = ipa_get_param (info, i);
1898 if (TREE_CODE (temp) == PARM_DECL)
1899 fprintf (f, " param %d : %s", i,
1901 ? (*lang_hooks.decl_printable_name) (temp, 2)
1903 if (ipa_is_param_used (info, i))
1904 fprintf (f, " used");
1909 /* Print ipa_tree_map data structures of all functions in the
1913 ipa_print_all_params (FILE * f)
1915 struct cgraph_node *node;
1917 fprintf (f, "\nFunction parameters:\n");
1918 for (node = cgraph_nodes; node; node = node->next)
1919 ipa_print_node_params (f, node);
1922 /* Return a heap allocated vector containing formal parameters of FNDECL. */
1925 ipa_get_vector_of_formal_parms (tree fndecl)
1927 VEC(tree, heap) *args;
1931 count = count_formal_params_1 (fndecl);
1932 args = VEC_alloc (tree, heap, count);
1933 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
1934 VEC_quick_push (tree, args, parm);
1939 /* Return a heap allocated vector containing types of formal parameters of
1940 function type FNTYPE. */
1942 static inline VEC(tree, heap) *
1943 get_vector_of_formal_parm_types (tree fntype)
1945 VEC(tree, heap) *types;
1949 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1952 types = VEC_alloc (tree, heap, count);
1953 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1954 VEC_quick_push (tree, types, TREE_VALUE (t));
1959 /* Modify the function declaration FNDECL and its type according to the plan in
1960 ADJUSTMENTS. It also sets base fields of individual adjustments structures
1961 to reflect the actual parameters being modified which are determined by the
1962 base_index field. */
1965 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
1966 const char *synth_parm_prefix)
1968 VEC(tree, heap) *oparms, *otypes;
1969 tree orig_type, new_type = NULL;
1970 tree old_arg_types, t, new_arg_types = NULL;
1971 tree parm, *link = &DECL_ARGUMENTS (fndecl);
1972 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
1973 tree new_reversed = NULL;
1974 bool care_for_types, last_parm_void;
1976 if (!synth_parm_prefix)
1977 synth_parm_prefix = "SYNTH";
1979 oparms = ipa_get_vector_of_formal_parms (fndecl);
1980 orig_type = TREE_TYPE (fndecl);
1981 old_arg_types = TYPE_ARG_TYPES (orig_type);
1983 /* The following test is an ugly hack, some functions simply don't have any
1984 arguments in their type. This is probably a bug but well... */
1985 care_for_types = (old_arg_types != NULL_TREE);
1988 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
1990 otypes = get_vector_of_formal_parm_types (orig_type);
1992 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
1994 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
1998 last_parm_void = false;
2002 for (i = 0; i < len; i++)
2004 struct ipa_parm_adjustment *adj;
2007 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2008 parm = VEC_index (tree, oparms, adj->base_index);
2011 if (adj->copy_param)
2014 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
2018 link = &TREE_CHAIN (parm);
2020 else if (!adj->remove_param)
2026 ptype = build_pointer_type (adj->type);
2031 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
2033 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
2035 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
2037 DECL_ARTIFICIAL (new_parm) = 1;
2038 DECL_ARG_TYPE (new_parm) = ptype;
2039 DECL_CONTEXT (new_parm) = fndecl;
2040 TREE_USED (new_parm) = 1;
2041 DECL_IGNORED_P (new_parm) = 1;
2042 layout_decl (new_parm, 0);
2044 add_referenced_var (new_parm);
2045 mark_sym_for_renaming (new_parm);
2047 adj->reduction = new_parm;
2051 link = &TREE_CHAIN (new_parm);
2059 new_reversed = nreverse (new_arg_types);
2063 TREE_CHAIN (new_arg_types) = void_list_node;
2065 new_reversed = void_list_node;
2069 /* Use copy_node to preserve as much as possible from original type
2070 (debug info, attribute lists etc.)
2071 Exception is METHOD_TYPEs must have THIS argument.
2072 When we are asked to remove it, we need to build new FUNCTION_TYPE
2074 if (TREE_CODE (orig_type) != METHOD_TYPE
2075 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
2076 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
2078 new_type = copy_node (orig_type);
2079 TYPE_ARG_TYPES (new_type) = new_reversed;
2084 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
2086 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
2087 DECL_VINDEX (fndecl) = NULL_TREE;
2090 /* When signature changes, we need to clear builtin info. */
2091 if (DECL_BUILT_IN (fndecl))
2093 DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
2094 DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
2097 /* This is a new type, not a copy of an old type. Need to reassociate
2098 variants. We can handle everything except the main variant lazily. */
2099 t = TYPE_MAIN_VARIANT (orig_type);
2102 TYPE_MAIN_VARIANT (new_type) = t;
2103 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
2104 TYPE_NEXT_VARIANT (t) = new_type;
2108 TYPE_MAIN_VARIANT (new_type) = new_type;
2109 TYPE_NEXT_VARIANT (new_type) = NULL;
2112 TREE_TYPE (fndecl) = new_type;
2114 VEC_free (tree, heap, otypes);
2115 VEC_free (tree, heap, oparms);
2118 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2119 If this is a directly recursive call, CS must be NULL. Otherwise it must
2120 contain the corresponding call graph edge. */
2123 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2124 ipa_parm_adjustment_vec adjustments)
2126 VEC(tree, heap) *vargs;
2128 gimple_stmt_iterator gsi;
2132 len = VEC_length (ipa_parm_adjustment_t, adjustments);
2133 vargs = VEC_alloc (tree, heap, len);
2135 gsi = gsi_for_stmt (stmt);
2136 for (i = 0; i < len; i++)
2138 struct ipa_parm_adjustment *adj;
2140 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2142 if (adj->copy_param)
2144 tree arg = gimple_call_arg (stmt, adj->base_index);
2146 VEC_quick_push (tree, vargs, arg);
2148 else if (!adj->remove_param)
2150 tree expr, orig_expr;
2151 bool allow_ptr, repl_found;
2153 orig_expr = expr = gimple_call_arg (stmt, adj->base_index);
2154 if (TREE_CODE (expr) == ADDR_EXPR)
2157 expr = TREE_OPERAND (expr, 0);
2162 repl_found = build_ref_for_offset (&expr, TREE_TYPE (expr),
2163 adj->offset, adj->type,
2168 expr = build_fold_addr_expr (expr);
2172 tree ptrtype = build_pointer_type (adj->type);
2174 if (!POINTER_TYPE_P (TREE_TYPE (expr)))
2175 expr = build_fold_addr_expr (expr);
2176 if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr)))
2177 expr = fold_convert (ptrtype, expr);
2178 expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr,
2179 build_int_cst (sizetype,
2180 adj->offset / BITS_PER_UNIT));
2182 expr = fold_build1 (INDIRECT_REF, adj->type, expr);
2184 expr = force_gimple_operand_gsi (&gsi, expr,
2186 || is_gimple_reg_type (adj->type),
2187 NULL, true, GSI_SAME_STMT);
2188 VEC_quick_push (tree, vargs, expr);
2192 if (dump_file && (dump_flags & TDF_DETAILS))
2194 fprintf (dump_file, "replacing stmt:");
2195 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2198 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2199 new_stmt = gimple_build_call_vec (callee_decl, vargs);
2200 VEC_free (tree, heap, vargs);
2201 if (gimple_call_lhs (stmt))
2202 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2204 gimple_set_block (new_stmt, gimple_block (stmt));
2205 if (gimple_has_location (stmt))
2206 gimple_set_location (new_stmt, gimple_location (stmt));
2207 gimple_call_copy_flags (new_stmt, stmt);
2208 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2210 if (dump_file && (dump_flags & TDF_DETAILS))
2212 fprintf (dump_file, "with stmt:");
2213 print_gimple_stmt (dump_file, new_stmt, 0, 0);
2214 fprintf (dump_file, "\n");
2216 gsi_replace (&gsi, new_stmt, true);
2218 cgraph_set_call_stmt (cs, new_stmt);
2219 update_ssa (TODO_update_ssa);
2220 free_dominance_info (CDI_DOMINATORS);
2223 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2226 index_in_adjustments_multiple_times_p (int base_index,
2227 ipa_parm_adjustment_vec adjustments)
2229 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2232 for (i = 0; i < len; i++)
2234 struct ipa_parm_adjustment *adj;
2235 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2237 if (adj->base_index == base_index)
2249 /* Return adjustments that should have the same effect on function parameters
2250 and call arguments as if they were first changed according to adjustments in
2251 INNER and then by adjustments in OUTER. */
2253 ipa_parm_adjustment_vec
2254 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2255 ipa_parm_adjustment_vec outer)
2257 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2258 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2260 ipa_parm_adjustment_vec adjustments, tmp;
2262 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2263 for (i = 0; i < inlen; i++)
2265 struct ipa_parm_adjustment *n;
2266 n = VEC_index (ipa_parm_adjustment_t, inner, i);
2268 if (n->remove_param)
2271 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2274 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2275 for (i = 0; i < outlen; i++)
2277 struct ipa_parm_adjustment *r;
2278 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2280 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2283 gcc_assert (!in->remove_param);
2284 if (out->remove_param)
2286 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2288 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2289 memset (r, 0, sizeof (*r));
2290 r->remove_param = true;
2295 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2296 memset (r, 0, sizeof (*r));
2297 r->base_index = in->base_index;
2298 r->type = out->type;
2300 /* FIXME: Create nonlocal value too. */
2302 if (in->copy_param && out->copy_param)
2303 r->copy_param = true;
2304 else if (in->copy_param)
2305 r->offset = out->offset;
2306 else if (out->copy_param)
2307 r->offset = in->offset;
2309 r->offset = in->offset + out->offset;
2312 for (i = 0; i < inlen; i++)
2314 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2317 if (n->remove_param)
2318 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2321 VEC_free (ipa_parm_adjustment_t, heap, tmp);
2325 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2326 friendly way, assuming they are meant to be applied to FNDECL. */
2329 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2332 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2334 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2336 fprintf (file, "IPA param adjustments: ");
2337 for (i = 0; i < len; i++)
2339 struct ipa_parm_adjustment *adj;
2340 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2343 fprintf (file, " ");
2347 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2348 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2351 fprintf (file, ", base: ");
2352 print_generic_expr (file, adj->base, 0);
2356 fprintf (file, ", reduction: ");
2357 print_generic_expr (file, adj->reduction, 0);
2359 if (adj->new_ssa_base)
2361 fprintf (file, ", new_ssa_base: ");
2362 print_generic_expr (file, adj->new_ssa_base, 0);
2365 if (adj->copy_param)
2366 fprintf (file, ", copy_param");
2367 else if (adj->remove_param)
2368 fprintf (file, ", remove_param");
2370 fprintf (file, ", offset %li", (long) adj->offset);
2372 fprintf (file, ", by_ref");
2373 print_node_brief (file, ", type: ", adj->type, 0);
2374 fprintf (file, "\n");
2376 VEC_free (tree, heap, parms);
2379 /* Stream out jump function JUMP_FUNC to OB. */
2382 ipa_write_jump_function (struct output_block *ob,
2383 struct ipa_jump_func *jump_func)
2385 lto_output_uleb128_stream (ob->main_stream,
2388 switch (jump_func->type)
2390 case IPA_JF_UNKNOWN:
2392 case IPA_JF_KNOWN_TYPE:
2393 lto_output_tree (ob, jump_func->value.base_binfo, true);
2396 lto_output_tree (ob, jump_func->value.constant, true);
2398 case IPA_JF_PASS_THROUGH:
2399 lto_output_tree (ob, jump_func->value.pass_through.operand, true);
2400 lto_output_uleb128_stream (ob->main_stream,
2401 jump_func->value.pass_through.formal_id);
2402 lto_output_uleb128_stream (ob->main_stream,
2403 jump_func->value.pass_through.operation);
2405 case IPA_JF_ANCESTOR:
2406 lto_output_uleb128_stream (ob->main_stream,
2407 jump_func->value.ancestor.offset);
2408 lto_output_tree (ob, jump_func->value.ancestor.type, true);
2409 lto_output_uleb128_stream (ob->main_stream,
2410 jump_func->value.ancestor.formal_id);
2412 case IPA_JF_CONST_MEMBER_PTR:
2413 lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
2414 lto_output_tree (ob, jump_func->value.member_cst.delta, false);
2419 /* Read in jump function JUMP_FUNC from IB. */
2422 ipa_read_jump_function (struct lto_input_block *ib,
2423 struct ipa_jump_func *jump_func,
2424 struct data_in *data_in)
2426 jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
2428 switch (jump_func->type)
2430 case IPA_JF_UNKNOWN:
2432 case IPA_JF_KNOWN_TYPE:
2433 jump_func->value.base_binfo = lto_input_tree (ib, data_in);
2436 jump_func->value.constant = lto_input_tree (ib, data_in);
2438 case IPA_JF_PASS_THROUGH:
2439 jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
2440 jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
2441 jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
2443 case IPA_JF_ANCESTOR:
2444 jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
2445 jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
2446 jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
2448 case IPA_JF_CONST_MEMBER_PTR:
2449 jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
2450 jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
2455 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2456 relevant to indirect inlining to OB. */
2459 ipa_write_indirect_edge_info (struct output_block *ob,
2460 struct cgraph_edge *cs)
2462 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2463 struct bitpack_d bp;
2465 lto_output_sleb128_stream (ob->main_stream, ii->param_index);
2466 lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
2467 bp = bitpack_create (ob->main_stream);
2468 bp_pack_value (&bp, ii->polymorphic, 1);
2469 lto_output_bitpack (&bp);
2471 if (ii->polymorphic)
2473 lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
2474 lto_output_tree (ob, ii->otr_type, true);
2478 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2479 relevant to indirect inlining from IB. */
2482 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2483 struct data_in *data_in ATTRIBUTE_UNUSED,
2484 struct cgraph_edge *cs)
2486 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2487 struct bitpack_d bp;
2489 ii->param_index = (int) lto_input_sleb128 (ib);
2490 ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2491 bp = lto_input_bitpack (ib);
2492 ii->polymorphic = bp_unpack_value (&bp, 1);
2493 if (ii->polymorphic)
2495 ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2496 ii->otr_type = lto_input_tree (ib, data_in);
2500 /* Stream out NODE info to OB. */
2503 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2506 lto_cgraph_encoder_t encoder;
2507 struct ipa_node_params *info = IPA_NODE_REF (node);
2509 struct cgraph_edge *e;
2510 struct bitpack_d bp;
2512 encoder = ob->decl_state->cgraph_node_encoder;
2513 node_ref = lto_cgraph_encoder_encode (encoder, node);
2514 lto_output_uleb128_stream (ob->main_stream, node_ref);
2516 bp = bitpack_create (ob->main_stream);
2517 bp_pack_value (&bp, info->called_with_var_arguments, 1);
2518 gcc_assert (info->uses_analysis_done
2519 || ipa_get_param_count (info) == 0);
2520 gcc_assert (!info->node_enqueued);
2521 gcc_assert (!info->ipcp_orig_node);
2522 for (j = 0; j < ipa_get_param_count (info); j++)
2523 bp_pack_value (&bp, info->params[j].used, 1);
2524 lto_output_bitpack (&bp);
2525 for (e = node->callees; e; e = e->next_callee)
2527 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2529 lto_output_uleb128_stream (ob->main_stream,
2530 ipa_get_cs_argument_count (args));
2531 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2532 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2534 for (e = node->indirect_calls; e; e = e->next_callee)
2535 ipa_write_indirect_edge_info (ob, e);
2538 /* Srtream in NODE info from IB. */
2541 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2542 struct data_in *data_in)
2544 struct ipa_node_params *info = IPA_NODE_REF (node);
2546 struct cgraph_edge *e;
2547 struct bitpack_d bp;
2549 ipa_initialize_node_params (node);
2551 bp = lto_input_bitpack (ib);
2552 info->called_with_var_arguments = bp_unpack_value (&bp, 1);
2553 if (ipa_get_param_count (info) != 0)
2554 info->uses_analysis_done = true;
2555 info->node_enqueued = false;
2556 for (k = 0; k < ipa_get_param_count (info); k++)
2557 info->params[k].used = bp_unpack_value (&bp, 1);
2558 for (e = node->callees; e; e = e->next_callee)
2560 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2561 int count = lto_input_uleb128 (ib);
2563 ipa_set_cs_argument_count (args, count);
2567 args->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
2568 (ipa_get_cs_argument_count (args));
2569 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2570 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2572 for (e = node->indirect_calls; e; e = e->next_callee)
2573 ipa_read_indirect_edge_info (ib, data_in, e);
2576 /* Write jump functions for nodes in SET. */
2579 ipa_prop_write_jump_functions (cgraph_node_set set)
2581 struct cgraph_node *node;
2582 struct output_block *ob = create_output_block (LTO_section_jump_functions);
2583 unsigned int count = 0;
2584 cgraph_node_set_iterator csi;
2586 ob->cgraph_node = NULL;
2588 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2590 node = csi_node (csi);
2591 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2595 lto_output_uleb128_stream (ob->main_stream, count);
2597 /* Process all of the functions. */
2598 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2600 node = csi_node (csi);
2601 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2602 ipa_write_node_info (ob, node);
2604 lto_output_1_stream (ob->main_stream, 0);
2605 produce_asm (ob, NULL);
2606 destroy_output_block (ob);
2609 /* Read section in file FILE_DATA of length LEN with data DATA. */
2612 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2615 const struct lto_function_header *header =
2616 (const struct lto_function_header *) data;
2617 const int32_t cfg_offset = sizeof (struct lto_function_header);
2618 const int32_t main_offset = cfg_offset + header->cfg_size;
2619 const int32_t string_offset = main_offset + header->main_size;
2620 struct data_in *data_in;
2621 struct lto_input_block ib_main;
2625 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2629 lto_data_in_create (file_data, (const char *) data + string_offset,
2630 header->string_size, NULL);
2631 count = lto_input_uleb128 (&ib_main);
2633 for (i = 0; i < count; i++)
2636 struct cgraph_node *node;
2637 lto_cgraph_encoder_t encoder;
2639 index = lto_input_uleb128 (&ib_main);
2640 encoder = file_data->cgraph_node_encoder;
2641 node = lto_cgraph_encoder_deref (encoder, index);
2642 gcc_assert (node->analyzed);
2643 ipa_read_node_info (&ib_main, node, data_in);
2645 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2647 lto_data_in_delete (data_in);
2650 /* Read ipcp jump functions. */
2653 ipa_prop_read_jump_functions (void)
2655 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2656 struct lto_file_decl_data *file_data;
2659 ipa_check_create_node_params ();
2660 ipa_check_create_edge_args ();
2661 ipa_register_cgraph_hooks ();
2663 while ((file_data = file_data_vec[j++]))
2666 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2669 ipa_prop_read_section (file_data, data, len);
2673 /* After merging units, we can get mismatch in argument counts.
2674 Also decl merging might've rendered parameter lists obsolette.
2675 Also compute called_with_variable_arg info. */
2678 ipa_update_after_lto_read (void)
2680 struct cgraph_node *node;
2681 struct cgraph_edge *cs;
2683 ipa_check_create_node_params ();
2684 ipa_check_create_edge_args ();
2686 for (node = cgraph_nodes; node; node = node->next)
2688 ipa_initialize_node_params (node);
2690 for (node = cgraph_nodes; node; node = node->next)
2692 for (cs = node->callees; cs; cs = cs->next_callee)
2694 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2695 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2696 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));