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 "lto-streamer.h"
40 /* Vector where the parameter infos are actually stored. */
41 VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
42 /* Vector where the parameter infos are actually stored. */
43 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
45 /* Bitmap with all UIDs of call graph edges that have been already processed
46 by indirect inlining. */
47 static bitmap iinlining_processed_edges;
49 /* Holders of ipa cgraph hooks: */
50 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
51 static struct cgraph_node_hook_list *node_removal_hook_holder;
52 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
53 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
55 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
56 it is in one or not. It should almost never be used directly, as opposed to
57 ipa_push_func_to_list. */
60 ipa_push_func_to_list_1 (struct ipa_func_list **wl,
61 struct cgraph_node *node,
62 struct ipa_node_params *info)
64 struct ipa_func_list *temp;
66 info->node_enqueued = 1;
67 temp = XCNEW (struct ipa_func_list);
73 /* Initialize worklist to contain all functions. */
75 struct ipa_func_list *
76 ipa_init_func_list (void)
78 struct cgraph_node *node;
79 struct ipa_func_list * wl;
82 for (node = cgraph_nodes; node; node = node->next)
85 struct ipa_node_params *info = IPA_NODE_REF (node);
86 /* Unreachable nodes should have been eliminated before ipcp and
88 gcc_assert (node->needed || node->reachable);
89 ipa_push_func_to_list_1 (&wl, node, info);
95 /* Remove a function from the worklist WL and return it. */
98 ipa_pop_func_from_list (struct ipa_func_list **wl)
100 struct ipa_node_params *info;
101 struct ipa_func_list *first;
102 struct cgraph_node *node;
109 info = IPA_NODE_REF (node);
110 info->node_enqueued = 0;
114 /* Return index of the formal whose tree is PTREE in function which corresponds
118 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
122 count = ipa_get_param_count (info);
123 for (i = 0; i < count; i++)
124 if (ipa_get_param(info, i) == ptree)
130 /* Populate the param_decl field in parameter descriptors of INFO that
131 corresponds to NODE. */
134 ipa_populate_param_decls (struct cgraph_node *node,
135 struct ipa_node_params *info)
143 fnargs = DECL_ARGUMENTS (fndecl);
145 for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
147 info->params[param_num].decl = parm;
152 /* Return how many formal parameters FNDECL has. */
155 count_formal_params_1 (tree fndecl)
160 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
166 /* Count number of formal parameters in NOTE. Store the result to the
167 appropriate field of INFO. */
170 ipa_count_formal_params (struct cgraph_node *node,
171 struct ipa_node_params *info)
175 param_num = count_formal_params_1 (node->decl);
176 ipa_set_param_count (info, param_num);
179 /* Initialize the ipa_node_params structure associated with NODE by counting
180 the function parameters, creating the descriptors and populating their
184 ipa_initialize_node_params (struct cgraph_node *node)
186 struct ipa_node_params *info = IPA_NODE_REF (node);
190 ipa_count_formal_params (node, info);
191 info->params = XCNEWVEC (struct ipa_param_descriptor,
192 ipa_get_param_count (info));
193 ipa_populate_param_decls (node, info);
197 /* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
198 parameters. If OP is a parameter declaration, mark it as modified in the
199 info structure passed in DATA. */
202 visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
205 struct ipa_node_params *info = (struct ipa_node_params *) data;
207 op = get_base_address (op);
209 && TREE_CODE (op) == PARM_DECL)
211 int index = ipa_get_param_decl_index (info, op);
212 gcc_assert (index >= 0);
213 info->params[index].modified = true;
214 info->params[index].used = true;
220 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
221 If OP is a parameter declaration, mark it as used in the info structure
225 visit_load_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
228 struct ipa_node_params *info = (struct ipa_node_params *) data;
230 op = get_base_address (op);
232 && TREE_CODE (op) == PARM_DECL)
234 int index = ipa_get_param_decl_index (info, op);
235 gcc_assert (index >= 0);
236 info->params[index].used = true;
242 /* Compute which formal parameters of function associated with NODE are locally
243 modified or their address is taken. Note that this does not apply on
244 parameters with SSA names but those can and should be analyzed
248 ipa_detect_param_modifications (struct cgraph_node *node)
250 tree decl = node->decl;
252 struct function *func;
253 gimple_stmt_iterator gsi;
254 struct ipa_node_params *info = IPA_NODE_REF (node);
257 if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
260 for (i = 0; i < ipa_get_param_count (info); i++)
262 tree parm = ipa_get_param (info, i);
263 /* For SSA regs see if parameter is used. For non-SSA we compute
264 the flag during modification analysis. */
265 if (is_gimple_reg (parm)
266 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
267 info->params[i].used = true;
270 func = DECL_STRUCT_FUNCTION (decl);
271 FOR_EACH_BB_FN (bb, func)
272 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
273 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
274 visit_load_for_mod_analysis,
275 visit_store_addr_for_mod_analysis,
276 visit_store_addr_for_mod_analysis);
278 info->modification_analysis_done = 1;
281 /* Count number of arguments callsite CS has and store it in
282 ipa_edge_args structure corresponding to this callsite. */
285 ipa_count_arguments (struct cgraph_edge *cs)
290 stmt = cs->call_stmt;
291 gcc_assert (is_gimple_call (stmt));
292 arg_num = gimple_call_num_args (stmt);
293 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
294 <= (unsigned) cgraph_edge_max_uid)
295 VEC_safe_grow_cleared (ipa_edge_args_t, gc,
296 ipa_edge_args_vector, cgraph_edge_max_uid + 1);
297 ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
300 /* Print the jump functions of all arguments on all call graph edges going from
304 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
307 struct cgraph_edge *cs;
308 struct ipa_jump_func *jump_func;
309 enum jump_func_type type;
311 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
312 for (cs = node->callees; cs; cs = cs->next_callee)
314 if (!ipa_edge_args_info_available_for_edge_p (cs))
317 fprintf (f, " callsite %s ", cgraph_node_name (node));
318 fprintf (f, "-> %s :: \n", cgraph_node_name (cs->callee));
320 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
321 for (i = 0; i < count; i++)
323 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
324 type = jump_func->type;
326 fprintf (f, " param %d: ", i);
327 if (type == IPA_JF_UNKNOWN)
328 fprintf (f, "UNKNOWN\n");
329 else if (type == IPA_JF_KNOWN_TYPE)
331 tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
332 fprintf (f, "KNOWN TYPE, type in binfo is: ");
333 print_generic_expr (f, binfo_type, 0);
334 fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
336 else if (type == IPA_JF_CONST)
338 tree val = jump_func->value.constant;
339 fprintf (f, "CONST: ");
340 print_generic_expr (f, val, 0);
341 if (TREE_CODE (val) == ADDR_EXPR
342 && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
345 print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
350 else if (type == IPA_JF_CONST_MEMBER_PTR)
352 fprintf (f, "CONST MEMBER PTR: ");
353 print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
355 print_generic_expr (f, jump_func->value.member_cst.delta, 0);
358 else if (type == IPA_JF_PASS_THROUGH)
360 fprintf (f, "PASS THROUGH: ");
361 fprintf (f, "%d, op %s ",
362 jump_func->value.pass_through.formal_id,
364 jump_func->value.pass_through.operation]);
365 if (jump_func->value.pass_through.operation != NOP_EXPR)
366 print_generic_expr (dump_file,
367 jump_func->value.pass_through.operand, 0);
368 fprintf (dump_file, "\n");
370 else if (type == IPA_JF_ANCESTOR)
372 fprintf (f, "ANCESTOR: ");
373 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
374 jump_func->value.ancestor.formal_id,
375 jump_func->value.ancestor.offset);
376 print_generic_expr (f, jump_func->value.ancestor.type, 0);
377 fprintf (dump_file, "\n");
383 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
386 ipa_print_all_jump_functions (FILE *f)
388 struct cgraph_node *node;
390 fprintf (f, "\nJump functions:\n");
391 for (node = cgraph_nodes; node; node = node->next)
393 ipa_print_node_jump_functions (f, node);
397 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
398 of an assignment statement STMT, try to find out whether NAME can be
399 described by a (possibly polynomial) pass-through jump-function or an
400 ancestor jump function and if so, write the appropriate function into
404 compute_complex_assign_jump_func (struct ipa_node_params *info,
405 struct ipa_jump_func *jfunc,
406 gimple stmt, tree name)
408 HOST_WIDE_INT offset, size, max_size;
412 op1 = gimple_assign_rhs1 (stmt);
413 op2 = gimple_assign_rhs2 (stmt);
415 if (TREE_CODE (op1) == SSA_NAME
416 && SSA_NAME_IS_DEFAULT_DEF (op1))
418 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
424 if (!is_gimple_ip_invariant (op2)
425 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
426 && !useless_type_conversion_p (TREE_TYPE (name),
430 jfunc->type = IPA_JF_PASS_THROUGH;
431 jfunc->value.pass_through.formal_id = index;
432 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
433 jfunc->value.pass_through.operand = op2;
435 else if (gimple_assign_unary_nop_p (stmt))
437 jfunc->type = IPA_JF_PASS_THROUGH;
438 jfunc->value.pass_through.formal_id = index;
439 jfunc->value.pass_through.operation = NOP_EXPR;
444 if (TREE_CODE (op1) != ADDR_EXPR)
447 op1 = TREE_OPERAND (op1, 0);
448 type = TREE_TYPE (op1);
449 if (TREE_CODE (type) != RECORD_TYPE)
451 op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
452 if (TREE_CODE (op1) != INDIRECT_REF
453 /* If this is a varying address, punt. */
457 op1 = TREE_OPERAND (op1, 0);
458 if (TREE_CODE (op1) != SSA_NAME
459 || !SSA_NAME_IS_DEFAULT_DEF (op1))
462 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
465 jfunc->type = IPA_JF_ANCESTOR;
466 jfunc->value.ancestor.formal_id = index;
467 jfunc->value.ancestor.offset = offset;
468 jfunc->value.ancestor.type = type;
473 /* Given that an actual argument is an SSA_NAME that is a result of a phi
474 statement PHI, try to find out whether NAME is in fact a
475 multiple-inheritance typecast from a descendant into an ancestor of a formal
476 parameter and thus can be described by an ancestor jump function and if so,
477 write the appropriate function into JFUNC.
479 Essentially we want to match the following pattern:
487 iftmp.1_3 = &obj_2(D)->D.1762;
490 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
491 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
495 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
496 struct ipa_jump_func *jfunc,
499 HOST_WIDE_INT offset, size, max_size;
501 basic_block phi_bb, assign_bb, cond_bb;
502 tree tmp, parm, expr;
505 if (gimple_phi_num_args (phi) != 2
506 || !integer_zerop (PHI_ARG_DEF (phi, 1)))
509 tmp = PHI_ARG_DEF (phi, 0);
510 if (TREE_CODE (tmp) != SSA_NAME
511 || SSA_NAME_IS_DEFAULT_DEF (tmp)
512 || !POINTER_TYPE_P (TREE_TYPE (tmp))
513 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
516 assign = SSA_NAME_DEF_STMT (tmp);
517 assign_bb = gimple_bb (assign);
518 if (!single_pred_p (assign_bb)
519 || !gimple_assign_single_p (assign))
521 expr = gimple_assign_rhs1 (assign);
523 if (TREE_CODE (expr) != ADDR_EXPR)
525 expr = TREE_OPERAND (expr, 0);
526 expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
528 if (TREE_CODE (expr) != INDIRECT_REF
529 /* If this is a varying address, punt. */
533 parm = TREE_OPERAND (expr, 0);
534 if (TREE_CODE (parm) != SSA_NAME
535 || !SSA_NAME_IS_DEFAULT_DEF (parm))
538 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
542 cond_bb = single_pred (assign_bb);
543 cond = last_stmt (cond_bb);
544 if (gimple_code (cond) != GIMPLE_COND
545 || gimple_cond_code (cond) != NE_EXPR
546 || gimple_cond_lhs (cond) != parm
547 || !integer_zerop (gimple_cond_rhs (cond)))
551 phi_bb = gimple_bb (phi);
552 for (i = 0; i < 2; i++)
554 basic_block pred = EDGE_PRED (phi_bb, i)->src;
555 if (pred != assign_bb && pred != cond_bb)
559 jfunc->type = IPA_JF_ANCESTOR;
560 jfunc->value.ancestor.formal_id = index;
561 jfunc->value.ancestor.offset = offset;
562 jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
565 /* Given OP whch is passed as an actual argument to a called function,
566 determine if it is possible to construct a KNOWN_TYPE jump function for it
567 and if so, create one and store it to JFUNC. */
570 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
574 if (TREE_CODE (op) != ADDR_EXPR)
577 op = TREE_OPERAND (op, 0);
578 binfo = gimple_get_relevant_ref_binfo (op, NULL_TREE);
581 jfunc->type = IPA_JF_KNOWN_TYPE;
582 jfunc->value.base_binfo = binfo;
587 /* Determine the jump functions of scalar arguments. Scalar means SSA names
588 and constants of a number of selected types. INFO is the ipa_node_params
589 structure associated with the caller, FUNCTIONS is a pointer to an array of
590 jump function structures associated with CALL which is the call statement
594 compute_scalar_jump_functions (struct ipa_node_params *info,
595 struct ipa_jump_func *functions,
601 for (num = 0; num < gimple_call_num_args (call); num++)
603 arg = gimple_call_arg (call, num);
605 if (is_gimple_ip_invariant (arg))
607 functions[num].type = IPA_JF_CONST;
608 functions[num].value.constant = arg;
610 else if (TREE_CODE (arg) == SSA_NAME)
612 if (SSA_NAME_IS_DEFAULT_DEF (arg))
614 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
618 functions[num].type = IPA_JF_PASS_THROUGH;
619 functions[num].value.pass_through.formal_id = index;
620 functions[num].value.pass_through.operation = NOP_EXPR;
625 gimple stmt = SSA_NAME_DEF_STMT (arg);
626 if (is_gimple_assign (stmt))
627 compute_complex_assign_jump_func (info, &functions[num],
629 else if (gimple_code (stmt) == GIMPLE_PHI)
630 compute_complex_ancestor_jump_func (info, &functions[num],
635 compute_known_type_jump_func (arg, &functions[num]);
639 /* Inspect the given TYPE and return true iff it has the same structure (the
640 same number of fields of the same types) as a C++ member pointer. If
641 METHOD_PTR and DELTA are non-NULL, store the trees representing the
642 corresponding fields there. */
645 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
649 if (TREE_CODE (type) != RECORD_TYPE)
652 fld = TYPE_FIELDS (type);
653 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
654 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
660 fld = TREE_CHAIN (fld);
661 if (!fld || INTEGRAL_TYPE_P (fld))
666 if (TREE_CHAIN (fld))
672 /* Go through arguments of the CALL and for every one that looks like a member
673 pointer, check whether it can be safely declared pass-through and if so,
674 mark that to the corresponding item of jump FUNCTIONS. Return true iff
675 there are non-pass-through member pointers within the arguments. INFO
676 describes formal parameters of the caller. */
679 compute_pass_through_member_ptrs (struct ipa_node_params *info,
680 struct ipa_jump_func *functions,
683 bool undecided_members = false;
687 for (num = 0; num < gimple_call_num_args (call); num++)
689 arg = gimple_call_arg (call, num);
691 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
693 if (TREE_CODE (arg) == PARM_DECL)
695 int index = ipa_get_param_decl_index (info, arg);
697 gcc_assert (index >=0);
698 if (!ipa_is_param_modified (info, index))
700 functions[num].type = IPA_JF_PASS_THROUGH;
701 functions[num].value.pass_through.formal_id = index;
702 functions[num].value.pass_through.operation = NOP_EXPR;
705 undecided_members = true;
708 undecided_members = true;
712 return undecided_members;
715 /* Simple function filling in a member pointer constant jump function (with PFN
716 and DELTA as the constant value) into JFUNC. */
719 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
720 tree pfn, tree delta)
722 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
723 jfunc->value.member_cst.pfn = pfn;
724 jfunc->value.member_cst.delta = delta;
727 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
728 return the rhs of its defining statement. */
731 get_ssa_def_if_simple_copy (tree rhs)
733 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
735 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
737 if (gimple_assign_single_p (def_stmt))
738 rhs = gimple_assign_rhs1 (def_stmt);
745 /* Traverse statements from CALL backwards, scanning whether the argument ARG
746 which is a member pointer is filled in with constant values. If it is, fill
747 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
748 fields of the record type of the member pointer. To give an example, we
749 look for a pattern looking like the following:
751 D.2515.__pfn ={v} printStuff;
752 D.2515.__delta ={v} 0;
753 i_1 = doprinting (D.2515); */
756 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
757 tree delta_field, struct ipa_jump_func *jfunc)
759 gimple_stmt_iterator gsi;
760 tree method = NULL_TREE;
761 tree delta = NULL_TREE;
763 gsi = gsi_for_stmt (call);
766 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
768 gimple stmt = gsi_stmt (gsi);
771 if (!gimple_assign_single_p (stmt))
774 lhs = gimple_assign_lhs (stmt);
775 rhs = gimple_assign_rhs1 (stmt);
777 if (TREE_CODE (lhs) != COMPONENT_REF
778 || TREE_OPERAND (lhs, 0) != arg)
781 fld = TREE_OPERAND (lhs, 1);
782 if (!method && fld == method_field)
784 rhs = get_ssa_def_if_simple_copy (rhs);
785 if (TREE_CODE (rhs) == ADDR_EXPR
786 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
787 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
789 method = TREE_OPERAND (rhs, 0);
792 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
800 if (!delta && fld == delta_field)
802 rhs = get_ssa_def_if_simple_copy (rhs);
803 if (TREE_CODE (rhs) == INTEGER_CST)
808 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
820 /* Go through the arguments of the CALL and for every member pointer within
821 tries determine whether it is a constant. If it is, create a corresponding
822 constant jump function in FUNCTIONS which is an array of jump functions
823 associated with the call. */
826 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
830 tree arg, method_field, delta_field;
832 for (num = 0; num < gimple_call_num_args (call); num++)
834 arg = gimple_call_arg (call, num);
836 if (functions[num].type == IPA_JF_UNKNOWN
837 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
839 determine_cst_member_ptr (call, arg, method_field, delta_field,
844 /* Compute jump function for all arguments of callsite CS and insert the
845 information in the jump_functions array in the ipa_edge_args corresponding
849 ipa_compute_jump_functions (struct cgraph_edge *cs)
851 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
852 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
855 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
857 arguments->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
858 ipa_get_cs_argument_count (arguments));
860 call = cs->call_stmt;
861 gcc_assert (is_gimple_call (call));
863 /* We will deal with constants and SSA scalars first: */
864 compute_scalar_jump_functions (info, arguments->jump_functions, call);
866 /* Let's check whether there are any potential member pointers and if so,
867 whether we can determine their functions as pass_through. */
868 if (!compute_pass_through_member_ptrs (info, 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 /* If RHS looks like a rhs of a statement loading pfn from a member
877 pointer formal parameter, return the parameter, otherwise return
878 NULL. If USE_DELTA, then we look for a use of the delta field
879 rather than the pfn. */
882 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
888 if (TREE_CODE (rhs) != COMPONENT_REF)
891 rec = TREE_OPERAND (rhs, 0);
892 if (TREE_CODE (rec) != PARM_DECL
893 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
896 fld = TREE_OPERAND (rhs, 1);
897 if (use_delta ? (fld == delta_field) : (fld == ptr_field))
903 /* If STMT looks like a statement loading a value from a member pointer formal
904 parameter, this function returns that parameter. */
907 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
911 if (!gimple_assign_single_p (stmt))
914 rhs = gimple_assign_rhs1 (stmt);
915 return ipa_get_member_ptr_load_param (rhs, use_delta);
918 /* Returns true iff T is an SSA_NAME defined by a statement. */
921 ipa_is_ssa_with_stmt_def (tree t)
923 if (TREE_CODE (t) == SSA_NAME
924 && !SSA_NAME_IS_DEFAULT_DEF (t))
930 /* Find the indirect call graph edge corresponding to STMT and add to it all
931 information necessary to describe a call to a parameter number PARAM_INDEX.
932 NODE is the caller. POLYMORPHIC should be set to true iff the call is a
936 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
939 struct cgraph_edge *cs;
941 cs = cgraph_edge (node, stmt);
942 cs->indirect_info->param_index = param_index;
943 cs->indirect_info->anc_offset = 0;
944 cs->indirect_info->polymorphic = polymorphic;
947 tree otr = gimple_call_fn (stmt);
948 tree type, token = OBJ_TYPE_REF_TOKEN (otr);
949 cs->indirect_info->otr_token = tree_low_cst (token, 1);
950 type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
951 cs->indirect_info->otr_type = type;
955 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
956 (described by INFO). Currently it checks whether the call calls a pointer
957 that is a formal parameter and if so, the parameter is marked with the
958 called flag and an indirect call graph edge describing the call is created.
959 This is very simple for ordinary pointers represented in SSA but not-so-nice
960 when it comes to member pointers. The ugly part of this function does
961 nothing more than trying to match the pattern of such a call. An example of
962 such a pattern is the gimple dump below, the call is on the last line:
965 f$__delta_5 = f.__delta;
966 f$__pfn_24 = f.__pfn;
967 D.2496_3 = (int) f$__pfn_24;
968 D.2497_4 = D.2496_3 & 1;
975 D.2500_7 = (unsigned int) f$__delta_5;
976 D.2501_8 = &S + D.2500_7;
977 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
978 D.2503_10 = *D.2502_9;
979 D.2504_12 = f$__pfn_24 + -1;
980 D.2505_13 = (unsigned int) D.2504_12;
981 D.2506_14 = D.2503_10 + D.2505_13;
982 D.2507_15 = *D.2506_14;
983 iftmp.11_16 = (String:: *) D.2507_15;
986 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
987 D.2500_19 = (unsigned int) f$__delta_5;
988 D.2508_20 = &S + D.2500_19;
989 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
991 Such patterns are results of simple calls to a member pointer:
993 int doprinting (int (MyString::* f)(int) const)
995 MyString S ("somestring");
1002 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1003 struct ipa_node_params *info,
1004 gimple call, tree target)
1009 tree rec, rec2, cond;
1012 basic_block bb, virt_bb, join;
1014 if (SSA_NAME_IS_DEFAULT_DEF (target))
1016 tree var = SSA_NAME_VAR (target);
1017 index = ipa_get_param_decl_index (info, var);
1019 ipa_note_param_call (node, index, call, false);
1023 /* Now we need to try to match the complex pattern of calling a member
1026 if (!POINTER_TYPE_P (TREE_TYPE (target))
1027 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1030 def = SSA_NAME_DEF_STMT (target);
1031 if (gimple_code (def) != GIMPLE_PHI)
1034 if (gimple_phi_num_args (def) != 2)
1037 /* First, we need to check whether one of these is a load from a member
1038 pointer that is a parameter to this function. */
1039 n1 = PHI_ARG_DEF (def, 0);
1040 n2 = PHI_ARG_DEF (def, 1);
1041 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1043 d1 = SSA_NAME_DEF_STMT (n1);
1044 d2 = SSA_NAME_DEF_STMT (n2);
1046 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1048 if (ipa_get_stmt_member_ptr_load_param (d2, false))
1051 bb = gimple_bb (d1);
1052 virt_bb = gimple_bb (d2);
1054 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1056 bb = gimple_bb (d2);
1057 virt_bb = gimple_bb (d1);
1062 /* Second, we need to check that the basic blocks are laid out in the way
1063 corresponding to the pattern. */
1065 join = gimple_bb (def);
1066 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1067 || single_pred (virt_bb) != bb
1068 || single_succ (virt_bb) != join)
1071 /* Third, let's see that the branching is done depending on the least
1072 significant bit of the pfn. */
1074 branch = last_stmt (bb);
1075 if (gimple_code (branch) != GIMPLE_COND)
1078 if (gimple_cond_code (branch) != NE_EXPR
1079 || !integer_zerop (gimple_cond_rhs (branch)))
1082 cond = gimple_cond_lhs (branch);
1083 if (!ipa_is_ssa_with_stmt_def (cond))
1086 def = SSA_NAME_DEF_STMT (cond);
1087 if (!is_gimple_assign (def)
1088 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1089 || !integer_onep (gimple_assign_rhs2 (def)))
1092 cond = gimple_assign_rhs1 (def);
1093 if (!ipa_is_ssa_with_stmt_def (cond))
1096 def = SSA_NAME_DEF_STMT (cond);
1098 if (is_gimple_assign (def)
1099 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1101 cond = gimple_assign_rhs1 (def);
1102 if (!ipa_is_ssa_with_stmt_def (cond))
1104 def = SSA_NAME_DEF_STMT (cond);
1107 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1108 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1109 == ptrmemfunc_vbit_in_delta));
1114 index = ipa_get_param_decl_index (info, rec);
1115 if (index >= 0 && !ipa_is_param_modified (info, index))
1116 ipa_note_param_call (node, index, call, false);
1121 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1122 object referenced in the expression is a formal parameter of the caller
1123 (described by INFO), create a call note for the statement. */
1126 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1127 struct ipa_node_params *info, gimple call,
1130 tree obj = OBJ_TYPE_REF_OBJECT (target);
1134 if (TREE_CODE (obj) == ADDR_EXPR)
1138 obj = TREE_OPERAND (obj, 0);
1140 while (TREE_CODE (obj) == COMPONENT_REF);
1141 if (TREE_CODE (obj) != INDIRECT_REF)
1143 obj = TREE_OPERAND (obj, 0);
1146 if (TREE_CODE (obj) != SSA_NAME
1147 || !SSA_NAME_IS_DEFAULT_DEF (obj))
1150 var = SSA_NAME_VAR (obj);
1151 index = ipa_get_param_decl_index (info, var);
1154 ipa_note_param_call (node, index, call, true);
1157 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1158 of the caller (described by INFO). */
1161 ipa_analyze_call_uses (struct cgraph_node *node,
1162 struct ipa_node_params *info, gimple call)
1164 tree target = gimple_call_fn (call);
1166 if (TREE_CODE (target) == SSA_NAME)
1167 ipa_analyze_indirect_call_uses (node, info, call, target);
1168 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1169 ipa_analyze_virtual_call_uses (node, info, call, target);
1173 /* Analyze the call statement STMT with respect to formal parameters (described
1174 in INFO) of caller given by NODE. Currently it only checks whether formal
1175 parameters are called. */
1178 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1181 if (is_gimple_call (stmt))
1182 ipa_analyze_call_uses (node, info, stmt);
1185 /* Scan the function body of NODE and inspect the uses of formal parameters.
1186 Store the findings in various structures of the associated ipa_node_params
1187 structure, such as parameter flags, notes etc. */
1190 ipa_analyze_params_uses (struct cgraph_node *node)
1192 tree decl = node->decl;
1194 struct function *func;
1195 gimple_stmt_iterator gsi;
1196 struct ipa_node_params *info = IPA_NODE_REF (node);
1198 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1201 func = DECL_STRUCT_FUNCTION (decl);
1202 FOR_EACH_BB_FN (bb, func)
1204 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1206 gimple stmt = gsi_stmt (gsi);
1207 ipa_analyze_stmt_uses (node, info, stmt);
1211 info->uses_analysis_done = 1;
1214 /* Update the jump function DST when the call graph edge correspondng to SRC is
1215 is being inlined, knowing that DST is of type ancestor and src of known
1219 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1220 struct ipa_jump_func *dst)
1224 new_binfo = get_binfo_at_offset (src->value.base_binfo,
1225 dst->value.ancestor.offset,
1226 dst->value.ancestor.type);
1229 dst->type = IPA_JF_KNOWN_TYPE;
1230 dst->value.base_binfo = new_binfo;
1233 dst->type = IPA_JF_UNKNOWN;
1236 /* Update the jump functions associated with call graph edge E when the call
1237 graph edge CS is being inlined, assuming that E->caller is already (possibly
1238 indirectly) inlined into CS->callee and that E has not been inlined. */
1241 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1242 struct cgraph_edge *e)
1244 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1245 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1246 int count = ipa_get_cs_argument_count (args);
1249 for (i = 0; i < count; i++)
1251 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1253 if (dst->type == IPA_JF_ANCESTOR)
1255 struct ipa_jump_func *src;
1257 /* Variable number of arguments can cause havoc if we try to access
1258 one that does not exist in the inlined edge. So make sure we
1260 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1262 dst->type = IPA_JF_UNKNOWN;
1266 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1267 if (src->type == IPA_JF_KNOWN_TYPE)
1268 combine_known_type_and_ancestor_jfs (src, dst);
1269 else if (src->type == IPA_JF_CONST)
1271 struct ipa_jump_func kt_func;
1273 kt_func.type = IPA_JF_UNKNOWN;
1274 compute_known_type_jump_func (src->value.constant, &kt_func);
1275 if (kt_func.type == IPA_JF_KNOWN_TYPE)
1276 combine_known_type_and_ancestor_jfs (&kt_func, dst);
1278 dst->type = IPA_JF_UNKNOWN;
1280 else if (src->type == IPA_JF_PASS_THROUGH
1281 && src->value.pass_through.operation == NOP_EXPR)
1282 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1283 else if (src->type == IPA_JF_ANCESTOR)
1285 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1286 dst->value.ancestor.offset += src->value.ancestor.offset;
1289 dst->type = IPA_JF_UNKNOWN;
1291 else if (dst->type == IPA_JF_PASS_THROUGH)
1293 struct ipa_jump_func *src;
1294 /* We must check range due to calls with variable number of arguments
1295 and we cannot combine jump functions with operations. */
1296 if (dst->value.pass_through.operation == NOP_EXPR
1297 && (dst->value.pass_through.formal_id
1298 < ipa_get_cs_argument_count (top)))
1300 src = ipa_get_ith_jump_func (top,
1301 dst->value.pass_through.formal_id);
1305 dst->type = IPA_JF_UNKNOWN;
1310 /* If TARGET is an addr_expr of a function declaration, make it the destination
1311 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1313 static struct cgraph_edge *
1314 make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
1316 struct cgraph_node *callee;
1318 if (TREE_CODE (target) != ADDR_EXPR)
1320 target = TREE_OPERAND (target, 0);
1321 if (TREE_CODE (target) != FUNCTION_DECL)
1323 callee = cgraph_node (target);
1327 cgraph_make_edge_direct (ie, callee);
1330 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1331 "(%s/%i -> %s/%i) for stmt ",
1332 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1333 cgraph_node_name (ie->caller), ie->caller->uid,
1334 cgraph_node_name (ie->callee), ie->callee->uid);
1337 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1339 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1344 /* Try to find a destination for indirect edge IE that corresponds to a simple
1345 call or a call of a member function pointer and where the destination is a
1346 pointer formal parameter described by jump function JFUNC. If it can be
1347 determined, return the newly direct edge, otherwise return NULL. */
1349 static struct cgraph_edge *
1350 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1351 struct ipa_jump_func *jfunc)
1355 if (jfunc->type == IPA_JF_CONST)
1356 target = jfunc->value.constant;
1357 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1358 target = jfunc->value.member_cst.pfn;
1362 return make_edge_direct_to_target (ie, target);
1365 /* Try to find a destination for indirect edge IE that corresponds to a
1366 virtuall call based on a formal parameter which is described by jump
1367 function JFUNC and if it can be determined, make it direct and return the
1368 direct edge. Otherwise, return NULL. */
1370 static struct cgraph_edge *
1371 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1372 struct ipa_jump_func *jfunc)
1374 tree binfo, type, target;
1375 HOST_WIDE_INT token;
1377 if (jfunc->type == IPA_JF_KNOWN_TYPE)
1378 binfo = jfunc->value.base_binfo;
1379 else if (jfunc->type == IPA_JF_CONST)
1381 tree cst = jfunc->value.constant;
1382 if (TREE_CODE (cst) == ADDR_EXPR)
1383 binfo = gimple_get_relevant_ref_binfo (TREE_OPERAND (cst, 0),
1394 token = ie->indirect_info->otr_token;
1395 type = ie->indirect_info->otr_type;
1396 binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
1398 target = gimple_fold_obj_type_ref_known_binfo (token, binfo);
1403 return make_edge_direct_to_target (ie, target);
1408 /* Update the param called notes associated with NODE when CS is being inlined,
1409 assuming NODE is (potentially indirectly) inlined into CS->callee.
1410 Moreover, if the callee is discovered to be constant, create a new cgraph
1411 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1412 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1415 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1416 struct cgraph_node *node,
1417 VEC (cgraph_edge_p, heap) **new_edges)
1419 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1420 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1423 ipa_check_create_edge_args ();
1425 for (ie = node->indirect_calls; ie; ie = next_ie)
1427 struct cgraph_indirect_call_info *ici = ie->indirect_info;
1428 struct ipa_jump_func *jfunc;
1430 next_ie = ie->next_callee;
1431 if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
1434 /* If we ever use indirect edges for anything other than indirect
1435 inlining, we will need to skip those with negative param_indices. */
1436 if (ici->param_index == -1)
1439 /* We must check range due to calls with variable number of arguments: */
1440 if (ici->param_index >= ipa_get_cs_argument_count (top))
1442 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1446 jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1447 if (jfunc->type == IPA_JF_PASS_THROUGH
1448 && jfunc->value.pass_through.operation == NOP_EXPR)
1449 ici->param_index = jfunc->value.pass_through.formal_id;
1450 else if (jfunc->type == IPA_JF_ANCESTOR)
1452 ici->param_index = jfunc->value.ancestor.formal_id;
1453 ici->anc_offset += jfunc->value.ancestor.offset;
1456 /* Either we can find a destination for this edge now or never. */
1457 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1459 if (ici->polymorphic)
1460 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1462 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1464 if (new_direct_edge)
1466 new_direct_edge->indirect_inlining_edge = 1;
1469 VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1471 top = IPA_EDGE_REF (cs);
1480 /* Recursively traverse subtree of NODE (including node) made of inlined
1481 cgraph_edges when CS has been inlined and invoke
1482 update_indirect_edges_after_inlining on all nodes and
1483 update_jump_functions_after_inlining on all non-inlined edges that lead out
1484 of this subtree. Newly discovered indirect edges will be added to
1485 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1489 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1490 struct cgraph_node *node,
1491 VEC (cgraph_edge_p, heap) **new_edges)
1493 struct cgraph_edge *e;
1496 res = update_indirect_edges_after_inlining (cs, node, new_edges);
1498 for (e = node->callees; e; e = e->next_callee)
1499 if (!e->inline_failed)
1500 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1502 update_jump_functions_after_inlining (cs, e);
1507 /* Update jump functions and call note functions on inlining the call site CS.
1508 CS is expected to lead to a node already cloned by
1509 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1510 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1514 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1515 VEC (cgraph_edge_p, heap) **new_edges)
1517 /* FIXME lto: We do not stream out indirect call information. */
1521 /* Do nothing if the preparation phase has not been carried out yet
1522 (i.e. during early inlining). */
1523 if (!ipa_node_params_vector)
1525 gcc_assert (ipa_edge_args_vector);
1527 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1530 /* Frees all dynamically allocated structures that the argument info points
1534 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1536 if (args->jump_functions)
1537 ggc_free (args->jump_functions);
1539 memset (args, 0, sizeof (*args));
1542 /* Free all ipa_edge structures. */
1545 ipa_free_all_edge_args (void)
1548 struct ipa_edge_args *args;
1551 VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
1553 ipa_free_edge_args_substructures (args);
1555 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1556 ipa_edge_args_vector = NULL;
1559 /* Frees all dynamically allocated structures that the param info points
1563 ipa_free_node_params_substructures (struct ipa_node_params *info)
1566 free (info->params);
1568 memset (info, 0, sizeof (*info));
1571 /* Free all ipa_node_params structures. */
1574 ipa_free_all_node_params (void)
1577 struct ipa_node_params *info;
1580 VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
1582 ipa_free_node_params_substructures (info);
1584 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1585 ipa_node_params_vector = NULL;
1588 /* Hook that is called by cgraph.c when an edge is removed. */
1591 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1593 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1594 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1595 <= (unsigned)cs->uid)
1597 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1600 /* Hook that is called by cgraph.c when a node is removed. */
1603 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1605 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1606 if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1607 <= (unsigned)node->uid)
1609 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1612 /* Helper function to duplicate an array of size N that is at SRC and store a
1613 pointer to it to DST. Nothing is done if SRC is NULL. */
1616 duplicate_array (void *src, size_t n)
1628 /* Like duplicate_array byt in GGC memory. */
1631 duplicate_ggc_array (void *src, size_t n)
1643 /* Hook that is called by cgraph.c when a node is duplicated. */
1646 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1647 __attribute__((unused)) void *data)
1649 struct ipa_edge_args *old_args, *new_args;
1652 ipa_check_create_edge_args ();
1654 old_args = IPA_EDGE_REF (src);
1655 new_args = IPA_EDGE_REF (dst);
1657 arg_count = ipa_get_cs_argument_count (old_args);
1658 ipa_set_cs_argument_count (new_args, arg_count);
1659 new_args->jump_functions = (struct ipa_jump_func *)
1660 duplicate_ggc_array (old_args->jump_functions,
1661 sizeof (struct ipa_jump_func) * arg_count);
1663 if (iinlining_processed_edges
1664 && bitmap_bit_p (iinlining_processed_edges, src->uid))
1665 bitmap_set_bit (iinlining_processed_edges, dst->uid);
1668 /* Hook that is called by cgraph.c when a node is duplicated. */
1671 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1672 __attribute__((unused)) void *data)
1674 struct ipa_node_params *old_info, *new_info;
1677 ipa_check_create_node_params ();
1678 old_info = IPA_NODE_REF (src);
1679 new_info = IPA_NODE_REF (dst);
1680 param_count = ipa_get_param_count (old_info);
1682 ipa_set_param_count (new_info, param_count);
1683 new_info->params = (struct ipa_param_descriptor *)
1684 duplicate_array (old_info->params,
1685 sizeof (struct ipa_param_descriptor) * param_count);
1686 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1687 new_info->count_scale = old_info->count_scale;
1690 /* Register our cgraph hooks if they are not already there. */
1693 ipa_register_cgraph_hooks (void)
1695 if (!edge_removal_hook_holder)
1696 edge_removal_hook_holder =
1697 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1698 if (!node_removal_hook_holder)
1699 node_removal_hook_holder =
1700 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1701 if (!edge_duplication_hook_holder)
1702 edge_duplication_hook_holder =
1703 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1704 if (!node_duplication_hook_holder)
1705 node_duplication_hook_holder =
1706 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1709 /* Unregister our cgraph hooks if they are not already there. */
1712 ipa_unregister_cgraph_hooks (void)
1714 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1715 edge_removal_hook_holder = NULL;
1716 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1717 node_removal_hook_holder = NULL;
1718 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1719 edge_duplication_hook_holder = NULL;
1720 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1721 node_duplication_hook_holder = NULL;
1724 /* Allocate all necessary data strucutures necessary for indirect inlining. */
1727 ipa_create_all_structures_for_iinln (void)
1729 iinlining_processed_edges = BITMAP_ALLOC (NULL);
1732 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1733 longer needed after ipa-cp. */
1736 ipa_free_all_structures_after_ipa_cp (void)
1738 if (!flag_indirect_inlining)
1740 ipa_free_all_edge_args ();
1741 ipa_free_all_node_params ();
1742 ipa_unregister_cgraph_hooks ();
1746 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1747 longer needed after indirect inlining. */
1750 ipa_free_all_structures_after_iinln (void)
1752 BITMAP_FREE (iinlining_processed_edges);
1754 ipa_free_all_edge_args ();
1755 ipa_free_all_node_params ();
1756 ipa_unregister_cgraph_hooks ();
1759 /* Print ipa_tree_map data structures of all functions in the
1763 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1767 struct ipa_node_params *info;
1769 if (!node->analyzed)
1771 info = IPA_NODE_REF (node);
1772 fprintf (f, " function %s parameter descriptors:\n",
1773 cgraph_node_name (node));
1774 count = ipa_get_param_count (info);
1775 for (i = 0; i < count; i++)
1777 temp = ipa_get_param (info, i);
1778 if (TREE_CODE (temp) == PARM_DECL)
1779 fprintf (f, " param %d : %s", i,
1781 ? (*lang_hooks.decl_printable_name) (temp, 2)
1783 if (ipa_is_param_modified (info, i))
1784 fprintf (f, " modified");
1785 if (ipa_is_param_used (info, i))
1786 fprintf (f, " used");
1791 /* Print ipa_tree_map data structures of all functions in the
1795 ipa_print_all_params (FILE * f)
1797 struct cgraph_node *node;
1799 fprintf (f, "\nFunction parameters:\n");
1800 for (node = cgraph_nodes; node; node = node->next)
1801 ipa_print_node_params (f, node);
1804 /* Return a heap allocated vector containing formal parameters of FNDECL. */
1807 ipa_get_vector_of_formal_parms (tree fndecl)
1809 VEC(tree, heap) *args;
1813 count = count_formal_params_1 (fndecl);
1814 args = VEC_alloc (tree, heap, count);
1815 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
1816 VEC_quick_push (tree, args, parm);
1821 /* Return a heap allocated vector containing types of formal parameters of
1822 function type FNTYPE. */
1824 static inline VEC(tree, heap) *
1825 get_vector_of_formal_parm_types (tree fntype)
1827 VEC(tree, heap) *types;
1831 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1834 types = VEC_alloc (tree, heap, count);
1835 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1836 VEC_quick_push (tree, types, TREE_VALUE (t));
1841 /* Modify the function declaration FNDECL and its type according to the plan in
1842 ADJUSTMENTS. It also sets base fields of individual adjustments structures
1843 to reflect the actual parameters being modified which are determined by the
1844 base_index field. */
1847 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
1848 const char *synth_parm_prefix)
1850 VEC(tree, heap) *oparms, *otypes;
1851 tree orig_type, new_type = NULL;
1852 tree old_arg_types, t, new_arg_types = NULL;
1853 tree parm, *link = &DECL_ARGUMENTS (fndecl);
1854 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
1855 tree new_reversed = NULL;
1856 bool care_for_types, last_parm_void;
1858 if (!synth_parm_prefix)
1859 synth_parm_prefix = "SYNTH";
1861 oparms = ipa_get_vector_of_formal_parms (fndecl);
1862 orig_type = TREE_TYPE (fndecl);
1863 old_arg_types = TYPE_ARG_TYPES (orig_type);
1865 /* The following test is an ugly hack, some functions simply don't have any
1866 arguments in their type. This is probably a bug but well... */
1867 care_for_types = (old_arg_types != NULL_TREE);
1870 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
1872 otypes = get_vector_of_formal_parm_types (orig_type);
1874 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
1876 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
1880 last_parm_void = false;
1884 for (i = 0; i < len; i++)
1886 struct ipa_parm_adjustment *adj;
1889 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
1890 parm = VEC_index (tree, oparms, adj->base_index);
1893 if (adj->copy_param)
1896 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
1900 link = &TREE_CHAIN (parm);
1902 else if (!adj->remove_param)
1908 ptype = build_pointer_type (adj->type);
1913 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
1915 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
1917 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
1919 DECL_ARTIFICIAL (new_parm) = 1;
1920 DECL_ARG_TYPE (new_parm) = ptype;
1921 DECL_CONTEXT (new_parm) = fndecl;
1922 TREE_USED (new_parm) = 1;
1923 DECL_IGNORED_P (new_parm) = 1;
1924 layout_decl (new_parm, 0);
1926 add_referenced_var (new_parm);
1927 mark_sym_for_renaming (new_parm);
1929 adj->reduction = new_parm;
1933 link = &TREE_CHAIN (new_parm);
1941 new_reversed = nreverse (new_arg_types);
1945 TREE_CHAIN (new_arg_types) = void_list_node;
1947 new_reversed = void_list_node;
1951 /* Use copy_node to preserve as much as possible from original type
1952 (debug info, attribute lists etc.)
1953 Exception is METHOD_TYPEs must have THIS argument.
1954 When we are asked to remove it, we need to build new FUNCTION_TYPE
1956 if (TREE_CODE (orig_type) != METHOD_TYPE
1957 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
1958 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
1960 new_type = copy_node (orig_type);
1961 TYPE_ARG_TYPES (new_type) = new_reversed;
1966 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
1968 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
1969 DECL_VINDEX (fndecl) = NULL_TREE;
1972 /* This is a new type, not a copy of an old type. Need to reassociate
1973 variants. We can handle everything except the main variant lazily. */
1974 t = TYPE_MAIN_VARIANT (orig_type);
1977 TYPE_MAIN_VARIANT (new_type) = t;
1978 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
1979 TYPE_NEXT_VARIANT (t) = new_type;
1983 TYPE_MAIN_VARIANT (new_type) = new_type;
1984 TYPE_NEXT_VARIANT (new_type) = NULL;
1987 TREE_TYPE (fndecl) = new_type;
1989 VEC_free (tree, heap, otypes);
1990 VEC_free (tree, heap, oparms);
1993 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
1994 If this is a directly recursive call, CS must be NULL. Otherwise it must
1995 contain the corresponding call graph edge. */
1998 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
1999 ipa_parm_adjustment_vec adjustments)
2001 VEC(tree, heap) *vargs;
2003 gimple_stmt_iterator gsi;
2007 len = VEC_length (ipa_parm_adjustment_t, adjustments);
2008 vargs = VEC_alloc (tree, heap, len);
2010 gsi = gsi_for_stmt (stmt);
2011 for (i = 0; i < len; i++)
2013 struct ipa_parm_adjustment *adj;
2015 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2017 if (adj->copy_param)
2019 tree arg = gimple_call_arg (stmt, adj->base_index);
2021 VEC_quick_push (tree, vargs, arg);
2023 else if (!adj->remove_param)
2025 tree expr, orig_expr;
2026 bool allow_ptr, repl_found;
2028 orig_expr = expr = gimple_call_arg (stmt, adj->base_index);
2029 if (TREE_CODE (expr) == ADDR_EXPR)
2032 expr = TREE_OPERAND (expr, 0);
2037 repl_found = build_ref_for_offset (&expr, TREE_TYPE (expr),
2038 adj->offset, adj->type,
2043 expr = build_fold_addr_expr (expr);
2047 tree ptrtype = build_pointer_type (adj->type);
2049 if (!POINTER_TYPE_P (TREE_TYPE (expr)))
2050 expr = build_fold_addr_expr (expr);
2051 if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr)))
2052 expr = fold_convert (ptrtype, expr);
2053 expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr,
2054 build_int_cst (sizetype,
2055 adj->offset / BITS_PER_UNIT));
2057 expr = fold_build1 (INDIRECT_REF, adj->type, expr);
2059 expr = force_gimple_operand_gsi (&gsi, expr,
2061 || is_gimple_reg_type (adj->type),
2062 NULL, true, GSI_SAME_STMT);
2063 VEC_quick_push (tree, vargs, expr);
2067 if (dump_file && (dump_flags & TDF_DETAILS))
2069 fprintf (dump_file, "replacing stmt:");
2070 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2073 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2074 new_stmt = gimple_build_call_vec (callee_decl, vargs);
2075 VEC_free (tree, heap, vargs);
2076 if (gimple_call_lhs (stmt))
2077 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2079 gimple_set_block (new_stmt, gimple_block (stmt));
2080 if (gimple_has_location (stmt))
2081 gimple_set_location (new_stmt, gimple_location (stmt));
2082 gimple_call_copy_flags (new_stmt, stmt);
2083 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2085 if (dump_file && (dump_flags & TDF_DETAILS))
2087 fprintf (dump_file, "with stmt:");
2088 print_gimple_stmt (dump_file, new_stmt, 0, 0);
2089 fprintf (dump_file, "\n");
2091 gsi_replace (&gsi, new_stmt, true);
2093 cgraph_set_call_stmt (cs, new_stmt);
2094 update_ssa (TODO_update_ssa);
2095 free_dominance_info (CDI_DOMINATORS);
2098 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2101 index_in_adjustments_multiple_times_p (int base_index,
2102 ipa_parm_adjustment_vec adjustments)
2104 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2107 for (i = 0; i < len; i++)
2109 struct ipa_parm_adjustment *adj;
2110 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2112 if (adj->base_index == base_index)
2124 /* Return adjustments that should have the same effect on function parameters
2125 and call arguments as if they were first changed according to adjustments in
2126 INNER and then by adjustments in OUTER. */
2128 ipa_parm_adjustment_vec
2129 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2130 ipa_parm_adjustment_vec outer)
2132 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2133 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2135 ipa_parm_adjustment_vec adjustments, tmp;
2137 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2138 for (i = 0; i < inlen; i++)
2140 struct ipa_parm_adjustment *n;
2141 n = VEC_index (ipa_parm_adjustment_t, inner, i);
2143 if (n->remove_param)
2146 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2149 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2150 for (i = 0; i < outlen; i++)
2152 struct ipa_parm_adjustment *r;
2153 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2155 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2158 gcc_assert (!in->remove_param);
2159 if (out->remove_param)
2161 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2163 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2164 memset (r, 0, sizeof (*r));
2165 r->remove_param = true;
2170 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2171 memset (r, 0, sizeof (*r));
2172 r->base_index = in->base_index;
2173 r->type = out->type;
2175 /* FIXME: Create nonlocal value too. */
2177 if (in->copy_param && out->copy_param)
2178 r->copy_param = true;
2179 else if (in->copy_param)
2180 r->offset = out->offset;
2181 else if (out->copy_param)
2182 r->offset = in->offset;
2184 r->offset = in->offset + out->offset;
2187 for (i = 0; i < inlen; i++)
2189 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2192 if (n->remove_param)
2193 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2196 VEC_free (ipa_parm_adjustment_t, heap, tmp);
2200 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2201 friendly way, assuming they are meant to be applied to FNDECL. */
2204 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2207 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2209 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2211 fprintf (file, "IPA param adjustments: ");
2212 for (i = 0; i < len; i++)
2214 struct ipa_parm_adjustment *adj;
2215 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2218 fprintf (file, " ");
2222 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2223 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2226 fprintf (file, ", base: ");
2227 print_generic_expr (file, adj->base, 0);
2231 fprintf (file, ", reduction: ");
2232 print_generic_expr (file, adj->reduction, 0);
2234 if (adj->new_ssa_base)
2236 fprintf (file, ", new_ssa_base: ");
2237 print_generic_expr (file, adj->new_ssa_base, 0);
2240 if (adj->copy_param)
2241 fprintf (file, ", copy_param");
2242 else if (adj->remove_param)
2243 fprintf (file, ", remove_param");
2245 fprintf (file, ", offset %li", (long) adj->offset);
2247 fprintf (file, ", by_ref");
2248 print_node_brief (file, ", type: ", adj->type, 0);
2249 fprintf (file, "\n");
2251 VEC_free (tree, heap, parms);
2254 /* Stream out jump function JUMP_FUNC to OB. */
2257 ipa_write_jump_function (struct output_block *ob,
2258 struct ipa_jump_func *jump_func)
2260 lto_output_uleb128_stream (ob->main_stream,
2263 switch (jump_func->type)
2265 case IPA_JF_UNKNOWN:
2267 case IPA_JF_KNOWN_TYPE:
2268 lto_output_tree (ob, jump_func->value.base_binfo, true);
2271 lto_output_tree (ob, jump_func->value.constant, true);
2273 case IPA_JF_PASS_THROUGH:
2274 lto_output_tree (ob, jump_func->value.pass_through.operand, true);
2275 lto_output_uleb128_stream (ob->main_stream,
2276 jump_func->value.pass_through.formal_id);
2277 lto_output_uleb128_stream (ob->main_stream,
2278 jump_func->value.pass_through.operation);
2280 case IPA_JF_ANCESTOR:
2281 lto_output_uleb128_stream (ob->main_stream,
2282 jump_func->value.ancestor.offset);
2283 lto_output_tree (ob, jump_func->value.ancestor.type, true);
2284 lto_output_uleb128_stream (ob->main_stream,
2285 jump_func->value.ancestor.formal_id);
2287 case IPA_JF_CONST_MEMBER_PTR:
2288 lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
2289 lto_output_tree (ob, jump_func->value.member_cst.delta, false);
2294 /* Read in jump function JUMP_FUNC from IB. */
2297 ipa_read_jump_function (struct lto_input_block *ib,
2298 struct ipa_jump_func *jump_func,
2299 struct data_in *data_in)
2301 jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
2303 switch (jump_func->type)
2305 case IPA_JF_UNKNOWN:
2307 case IPA_JF_KNOWN_TYPE:
2308 jump_func->value.base_binfo = lto_input_tree (ib, data_in);
2311 jump_func->value.constant = lto_input_tree (ib, data_in);
2313 case IPA_JF_PASS_THROUGH:
2314 jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
2315 jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
2316 jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
2318 case IPA_JF_ANCESTOR:
2319 jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
2320 jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
2321 jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
2323 case IPA_JF_CONST_MEMBER_PTR:
2324 jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
2325 jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
2330 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2331 relevant to indirect inlining to OB. */
2334 ipa_write_indirect_edge_info (struct output_block *ob,
2335 struct cgraph_edge *cs)
2337 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2338 struct bitpack_d *bp;
2340 lto_output_sleb128_stream (ob->main_stream, ii->param_index);
2341 lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
2342 bp = bitpack_create ();
2343 bp_pack_value (bp, ii->polymorphic, 1);
2344 lto_output_bitpack (ob->main_stream, bp);
2345 bitpack_delete (bp);
2347 if (ii->polymorphic)
2349 lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
2350 lto_output_tree (ob, ii->otr_type, true);
2354 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2355 relevant to indirect inlining from IB. */
2358 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2359 struct data_in *data_in ATTRIBUTE_UNUSED,
2360 struct cgraph_edge *cs)
2362 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2363 struct bitpack_d *bp;
2365 ii->param_index = (int) lto_input_sleb128 (ib);
2366 ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2367 bp = lto_input_bitpack (ib);
2368 ii->polymorphic = bp_unpack_value (bp, 1);
2369 bitpack_delete (bp);
2370 if (ii->polymorphic)
2372 ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2373 ii->otr_type = lto_input_tree (ib, data_in);
2377 /* Stream out NODE info to OB. */
2380 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2383 lto_cgraph_encoder_t encoder;
2384 struct ipa_node_params *info = IPA_NODE_REF (node);
2386 struct cgraph_edge *e;
2387 struct bitpack_d *bp;
2389 encoder = ob->decl_state->cgraph_node_encoder;
2390 node_ref = lto_cgraph_encoder_encode (encoder, node);
2391 lto_output_uleb128_stream (ob->main_stream, node_ref);
2393 bp = bitpack_create ();
2394 bp_pack_value (bp, info->called_with_var_arguments, 1);
2395 bp_pack_value (bp, info->uses_analysis_done, 1);
2396 gcc_assert (info->modification_analysis_done
2397 || ipa_get_param_count (info) == 0);
2398 gcc_assert (!info->node_enqueued);
2399 gcc_assert (!info->ipcp_orig_node);
2400 for (j = 0; j < ipa_get_param_count (info); j++)
2402 bp_pack_value (bp, info->params[j].modified, 1);
2403 bp_pack_value (bp, info->params[j].used, 1);
2405 lto_output_bitpack (ob->main_stream, bp);
2406 bitpack_delete (bp);
2407 for (e = node->callees; e; e = e->next_callee)
2409 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2411 lto_output_uleb128_stream (ob->main_stream,
2412 ipa_get_cs_argument_count (args));
2413 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2414 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2416 for (e = node->indirect_calls; e; e = e->next_callee)
2417 ipa_write_indirect_edge_info (ob, e);
2420 /* Srtream in NODE info from IB. */
2423 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2424 struct data_in *data_in)
2426 struct ipa_node_params *info = IPA_NODE_REF (node);
2428 struct cgraph_edge *e;
2429 struct bitpack_d *bp;
2431 ipa_initialize_node_params (node);
2433 bp = lto_input_bitpack (ib);
2434 info->called_with_var_arguments = bp_unpack_value (bp, 1);
2435 info->uses_analysis_done = bp_unpack_value (bp, 1);
2436 if (ipa_get_param_count (info) != 0)
2438 info->modification_analysis_done = true;
2439 info->uses_analysis_done = true;
2441 info->node_enqueued = false;
2442 for (k = 0; k < ipa_get_param_count (info); k++)
2444 info->params[k].modified = bp_unpack_value (bp, 1);
2445 info->params[k].used = bp_unpack_value (bp, 1);
2447 bitpack_delete (bp);
2448 for (e = node->callees; e; e = e->next_callee)
2450 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2451 int count = lto_input_uleb128 (ib);
2453 ipa_set_cs_argument_count (args, count);
2457 args->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
2458 ipa_get_cs_argument_count (args));
2459 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2460 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2462 for (e = node->indirect_calls; e; e = e->next_callee)
2463 ipa_read_indirect_edge_info (ib, data_in, e);
2466 /* Write jump functions for nodes in SET. */
2469 ipa_prop_write_jump_functions (cgraph_node_set set)
2471 struct cgraph_node *node;
2472 struct output_block *ob = create_output_block (LTO_section_jump_functions);
2473 unsigned int count = 0;
2474 cgraph_node_set_iterator csi;
2476 ob->cgraph_node = NULL;
2478 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2480 node = csi_node (csi);
2481 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2485 lto_output_uleb128_stream (ob->main_stream, count);
2487 /* Process all of the functions. */
2488 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2490 node = csi_node (csi);
2491 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2492 ipa_write_node_info (ob, node);
2494 lto_output_1_stream (ob->main_stream, 0);
2495 produce_asm (ob, NULL);
2496 destroy_output_block (ob);
2499 /* Read section in file FILE_DATA of length LEN with data DATA. */
2502 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2505 const struct lto_function_header *header =
2506 (const struct lto_function_header *) data;
2507 const int32_t cfg_offset = sizeof (struct lto_function_header);
2508 const int32_t main_offset = cfg_offset + header->cfg_size;
2509 const int32_t string_offset = main_offset + header->main_size;
2510 struct data_in *data_in;
2511 struct lto_input_block ib_main;
2515 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2519 lto_data_in_create (file_data, (const char *) data + string_offset,
2520 header->string_size, NULL);
2521 count = lto_input_uleb128 (&ib_main);
2523 for (i = 0; i < count; i++)
2526 struct cgraph_node *node;
2527 lto_cgraph_encoder_t encoder;
2529 index = lto_input_uleb128 (&ib_main);
2530 encoder = file_data->cgraph_node_encoder;
2531 node = lto_cgraph_encoder_deref (encoder, index);
2532 gcc_assert (node->analyzed);
2533 ipa_read_node_info (&ib_main, node, data_in);
2535 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2537 lto_data_in_delete (data_in);
2540 /* Read ipcp jump functions. */
2543 ipa_prop_read_jump_functions (void)
2545 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2546 struct lto_file_decl_data *file_data;
2549 ipa_check_create_node_params ();
2550 ipa_check_create_edge_args ();
2551 ipa_register_cgraph_hooks ();
2553 while ((file_data = file_data_vec[j++]))
2556 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2559 ipa_prop_read_section (file_data, data, len);
2563 /* After merging units, we can get mismatch in argument counts.
2564 Also decl merging might've rendered parameter lists obsolette.
2565 Also compute called_with_variable_arg info. */
2568 ipa_update_after_lto_read (void)
2570 struct cgraph_node *node;
2571 struct cgraph_edge *cs;
2573 ipa_check_create_node_params ();
2574 ipa_check_create_edge_args ();
2576 for (node = cgraph_nodes; node; node = node->next)
2578 ipa_initialize_node_params (node);
2580 for (node = cgraph_nodes; node; node = node->next)
2582 for (cs = node->callees; cs; cs = cs->next_callee)
2584 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2585 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2586 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));