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 = DECL_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 = DECL_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;
365 tree op1, op2, base, type;
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 base = get_ref_base_and_extent (op1, &offset, &size, &max_size);
408 if (TREE_CODE (base) != MEM_REF
409 /* If this is a varying address, punt. */
413 offset += mem_ref_offset (base).low * BITS_PER_UNIT;
414 base = TREE_OPERAND (base, 0);
415 if (TREE_CODE (base) != SSA_NAME
416 || !SSA_NAME_IS_DEFAULT_DEF (base)
420 /* Dynamic types are changed only in constructors and destructors and */
421 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (base));
424 jfunc->type = IPA_JF_ANCESTOR;
425 jfunc->value.ancestor.formal_id = index;
426 jfunc->value.ancestor.offset = offset;
427 jfunc->value.ancestor.type = type;
432 /* Given that an actual argument is an SSA_NAME that is a result of a phi
433 statement PHI, try to find out whether NAME is in fact a
434 multiple-inheritance typecast from a descendant into an ancestor of a formal
435 parameter and thus can be described by an ancestor jump function and if so,
436 write the appropriate function into JFUNC.
438 Essentially we want to match the following pattern:
446 iftmp.1_3 = &obj_2(D)->D.1762;
449 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
450 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
454 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
455 struct ipa_jump_func *jfunc,
458 HOST_WIDE_INT offset, size, max_size;
460 basic_block phi_bb, assign_bb, cond_bb;
461 tree tmp, parm, expr;
464 if (gimple_phi_num_args (phi) != 2)
467 if (integer_zerop (PHI_ARG_DEF (phi, 1)))
468 tmp = PHI_ARG_DEF (phi, 0);
469 else if (integer_zerop (PHI_ARG_DEF (phi, 0)))
470 tmp = PHI_ARG_DEF (phi, 1);
473 if (TREE_CODE (tmp) != SSA_NAME
474 || SSA_NAME_IS_DEFAULT_DEF (tmp)
475 || !POINTER_TYPE_P (TREE_TYPE (tmp))
476 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
479 assign = SSA_NAME_DEF_STMT (tmp);
480 assign_bb = gimple_bb (assign);
481 if (!single_pred_p (assign_bb)
482 || !gimple_assign_single_p (assign))
484 expr = gimple_assign_rhs1 (assign);
486 if (TREE_CODE (expr) != ADDR_EXPR)
488 expr = TREE_OPERAND (expr, 0);
489 expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
491 if (TREE_CODE (expr) != MEM_REF
492 /* If this is a varying address, punt. */
496 offset += mem_ref_offset (expr).low * BITS_PER_UNIT;
497 parm = TREE_OPERAND (expr, 0);
498 if (TREE_CODE (parm) != SSA_NAME
499 || !SSA_NAME_IS_DEFAULT_DEF (parm)
503 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
507 cond_bb = single_pred (assign_bb);
508 cond = last_stmt (cond_bb);
510 || gimple_code (cond) != GIMPLE_COND
511 || gimple_cond_code (cond) != NE_EXPR
512 || gimple_cond_lhs (cond) != parm
513 || !integer_zerop (gimple_cond_rhs (cond)))
517 phi_bb = gimple_bb (phi);
518 for (i = 0; i < 2; i++)
520 basic_block pred = EDGE_PRED (phi_bb, i)->src;
521 if (pred != assign_bb && pred != cond_bb)
525 jfunc->type = IPA_JF_ANCESTOR;
526 jfunc->value.ancestor.formal_id = index;
527 jfunc->value.ancestor.offset = offset;
528 jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
531 /* Given OP whch is passed as an actual argument to a called function,
532 determine if it is possible to construct a KNOWN_TYPE jump function for it
533 and if so, create one and store it to JFUNC. */
536 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
538 HOST_WIDE_INT offset, size, max_size;
541 if (TREE_CODE (op) != ADDR_EXPR
542 || TREE_CODE (TREE_TYPE (TREE_TYPE (op))) != RECORD_TYPE)
545 op = TREE_OPERAND (op, 0);
546 base = get_ref_base_and_extent (op, &offset, &size, &max_size);
550 || TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE
551 || is_global_var (base))
554 binfo = TYPE_BINFO (TREE_TYPE (base));
557 binfo = get_binfo_at_offset (binfo, offset, TREE_TYPE (op));
560 jfunc->type = IPA_JF_KNOWN_TYPE;
561 jfunc->value.base_binfo = binfo;
566 /* Determine the jump functions of scalar arguments. Scalar means SSA names
567 and constants of a number of selected types. INFO is the ipa_node_params
568 structure associated with the caller, FUNCTIONS is a pointer to an array of
569 jump function structures associated with CALL which is the call statement
573 compute_scalar_jump_functions (struct ipa_node_params *info,
574 struct ipa_jump_func *functions,
580 for (num = 0; num < gimple_call_num_args (call); num++)
582 arg = gimple_call_arg (call, num);
584 if (is_gimple_ip_invariant (arg))
586 functions[num].type = IPA_JF_CONST;
587 functions[num].value.constant = arg;
589 else if (TREE_CODE (arg) == SSA_NAME)
591 if (SSA_NAME_IS_DEFAULT_DEF (arg))
593 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
597 functions[num].type = IPA_JF_PASS_THROUGH;
598 functions[num].value.pass_through.formal_id = index;
599 functions[num].value.pass_through.operation = NOP_EXPR;
604 gimple stmt = SSA_NAME_DEF_STMT (arg);
605 if (is_gimple_assign (stmt))
606 compute_complex_assign_jump_func (info, &functions[num],
608 else if (gimple_code (stmt) == GIMPLE_PHI)
609 compute_complex_ancestor_jump_func (info, &functions[num],
614 compute_known_type_jump_func (arg, &functions[num]);
618 /* Inspect the given TYPE and return true iff it has the same structure (the
619 same number of fields of the same types) as a C++ member pointer. If
620 METHOD_PTR and DELTA are non-NULL, store the trees representing the
621 corresponding fields there. */
624 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
628 if (TREE_CODE (type) != RECORD_TYPE)
631 fld = TYPE_FIELDS (type);
632 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
633 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
639 fld = DECL_CHAIN (fld);
640 if (!fld || INTEGRAL_TYPE_P (fld))
645 if (DECL_CHAIN (fld))
651 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
652 boolean variable pointed to by DATA. */
655 mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
658 bool *b = (bool *) data;
663 /* Return true if the formal parameter PARM might have been modified in this
664 function before reaching the statement CALL. PARM_INFO is a pointer to a
665 structure containing intermediate information about PARM. */
668 is_parm_modified_before_call (struct param_analysis_info *parm_info,
669 gimple call, tree parm)
671 bool modified = false;
674 if (parm_info->modified)
677 ao_ref_init (&refd, parm);
678 walk_aliased_vdefs (&refd, gimple_vuse (call), mark_modified,
679 &modified, &parm_info->visited_statements);
682 parm_info->modified = true;
688 /* Go through arguments of the CALL and for every one that looks like a member
689 pointer, check whether it can be safely declared pass-through and if so,
690 mark that to the corresponding item of jump FUNCTIONS. Return true iff
691 there are non-pass-through member pointers within the arguments. INFO
692 describes formal parameters of the caller. PARMS_INFO is a pointer to a
693 vector containing intermediate information about each formal parameter. */
696 compute_pass_through_member_ptrs (struct ipa_node_params *info,
697 struct param_analysis_info *parms_info,
698 struct ipa_jump_func *functions,
701 bool undecided_members = false;
705 for (num = 0; num < gimple_call_num_args (call); num++)
707 arg = gimple_call_arg (call, num);
709 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
711 if (TREE_CODE (arg) == PARM_DECL)
713 int index = ipa_get_param_decl_index (info, arg);
715 gcc_assert (index >=0);
716 if (!is_parm_modified_before_call (&parms_info[index], call, arg))
718 functions[num].type = IPA_JF_PASS_THROUGH;
719 functions[num].value.pass_through.formal_id = index;
720 functions[num].value.pass_through.operation = NOP_EXPR;
723 undecided_members = true;
726 undecided_members = true;
730 return undecided_members;
733 /* Simple function filling in a member pointer constant jump function (with PFN
734 and DELTA as the constant value) into JFUNC. */
737 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
738 tree pfn, tree delta)
740 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
741 jfunc->value.member_cst.pfn = pfn;
742 jfunc->value.member_cst.delta = delta;
745 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
746 return the rhs of its defining statement. */
749 get_ssa_def_if_simple_copy (tree rhs)
751 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
753 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
755 if (gimple_assign_single_p (def_stmt))
756 rhs = gimple_assign_rhs1 (def_stmt);
763 /* Traverse statements from CALL backwards, scanning whether the argument ARG
764 which is a member pointer is filled in with constant values. If it is, fill
765 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
766 fields of the record type of the member pointer. To give an example, we
767 look for a pattern looking like the following:
769 D.2515.__pfn ={v} printStuff;
770 D.2515.__delta ={v} 0;
771 i_1 = doprinting (D.2515); */
774 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
775 tree delta_field, struct ipa_jump_func *jfunc)
777 gimple_stmt_iterator gsi;
778 tree method = NULL_TREE;
779 tree delta = NULL_TREE;
781 gsi = gsi_for_stmt (call);
784 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
786 gimple stmt = gsi_stmt (gsi);
789 if (!stmt_may_clobber_ref_p (stmt, arg))
791 if (!gimple_assign_single_p (stmt))
794 lhs = gimple_assign_lhs (stmt);
795 rhs = gimple_assign_rhs1 (stmt);
797 if (TREE_CODE (lhs) != COMPONENT_REF
798 || TREE_OPERAND (lhs, 0) != arg)
801 fld = TREE_OPERAND (lhs, 1);
802 if (!method && fld == method_field)
804 rhs = get_ssa_def_if_simple_copy (rhs);
805 if (TREE_CODE (rhs) == ADDR_EXPR
806 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
807 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
809 method = TREE_OPERAND (rhs, 0);
812 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
820 if (!delta && fld == delta_field)
822 rhs = get_ssa_def_if_simple_copy (rhs);
823 if (TREE_CODE (rhs) == INTEGER_CST)
828 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
840 /* Go through the arguments of the CALL and for every member pointer within
841 tries determine whether it is a constant. If it is, create a corresponding
842 constant jump function in FUNCTIONS which is an array of jump functions
843 associated with the call. */
846 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
850 tree arg, method_field, delta_field;
852 for (num = 0; num < gimple_call_num_args (call); num++)
854 arg = gimple_call_arg (call, num);
856 if (functions[num].type == IPA_JF_UNKNOWN
857 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
859 determine_cst_member_ptr (call, arg, method_field, delta_field,
864 /* Compute jump function for all arguments of callsite CS and insert the
865 information in the jump_functions array in the ipa_edge_args corresponding
869 ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_info,
870 struct cgraph_edge *cs)
872 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
873 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
876 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
878 arguments->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
879 (ipa_get_cs_argument_count (arguments));
881 call = cs->call_stmt;
882 gcc_assert (is_gimple_call (call));
884 /* We will deal with constants and SSA scalars first: */
885 compute_scalar_jump_functions (info, arguments->jump_functions, call);
887 /* Let's check whether there are any potential member pointers and if so,
888 whether we can determine their functions as pass_through. */
889 if (!compute_pass_through_member_ptrs (info, parms_info,
890 arguments->jump_functions, call))
893 /* Finally, let's check whether we actually pass a new constant member
895 compute_cst_member_ptr_arguments (arguments->jump_functions, call);
898 /* Compute jump functions for all edges - both direct and indirect - outgoing
899 from NODE. Also count the actual arguments in the process. */
902 ipa_compute_jump_functions (struct cgraph_node *node,
903 struct param_analysis_info *parms_info)
905 struct cgraph_edge *cs;
907 for (cs = node->callees; cs; cs = cs->next_callee)
909 /* We do not need to bother analyzing calls to unknown
910 functions unless they may become known during lto/whopr. */
911 if (!cs->callee->analyzed && !flag_lto)
913 ipa_count_arguments (cs);
914 /* If the descriptor of the callee is not initialized yet, we have to do
916 if (cs->callee->analyzed)
917 ipa_initialize_node_params (cs->callee);
918 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
919 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
920 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
921 ipa_compute_jump_functions_for_edge (parms_info, cs);
924 for (cs = node->indirect_calls; cs; cs = cs->next_callee)
926 ipa_count_arguments (cs);
927 ipa_compute_jump_functions_for_edge (parms_info, cs);
931 /* If RHS looks like a rhs of a statement loading pfn from a member
932 pointer formal parameter, return the parameter, otherwise return
933 NULL. If USE_DELTA, then we look for a use of the delta field
934 rather than the pfn. */
937 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
939 tree rec, ref_field, ref_offset, fld, fld_offset, ptr_field, delta_field;
941 if (TREE_CODE (rhs) == COMPONENT_REF)
943 ref_field = TREE_OPERAND (rhs, 1);
944 rhs = TREE_OPERAND (rhs, 0);
947 ref_field = NULL_TREE;
948 if (TREE_CODE (rhs) != MEM_REF)
950 rec = TREE_OPERAND (rhs, 0);
951 if (TREE_CODE (rec) != ADDR_EXPR)
953 rec = TREE_OPERAND (rec, 0);
954 if (TREE_CODE (rec) != PARM_DECL
955 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
958 ref_offset = TREE_OPERAND (rhs, 1);
962 if (integer_nonzerop (ref_offset))
970 return ref_field == fld ? rec : NULL_TREE;
974 fld_offset = byte_position (delta_field);
976 fld_offset = byte_position (ptr_field);
978 return tree_int_cst_equal (ref_offset, fld_offset) ? rec : NULL_TREE;
981 /* If STMT looks like a statement loading a value from a member pointer formal
982 parameter, this function returns that parameter. */
985 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
989 if (!gimple_assign_single_p (stmt))
992 rhs = gimple_assign_rhs1 (stmt);
993 return ipa_get_member_ptr_load_param (rhs, use_delta);
996 /* Returns true iff T is an SSA_NAME defined by a statement. */
999 ipa_is_ssa_with_stmt_def (tree t)
1001 if (TREE_CODE (t) == SSA_NAME
1002 && !SSA_NAME_IS_DEFAULT_DEF (t))
1008 /* Find the indirect call graph edge corresponding to STMT and add to it all
1009 information necessary to describe a call to a parameter number PARAM_INDEX.
1010 NODE is the caller. POLYMORPHIC should be set to true iff the call is a
1014 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
1017 struct cgraph_edge *cs;
1019 cs = cgraph_edge (node, stmt);
1020 cs->indirect_info->param_index = param_index;
1021 cs->indirect_info->anc_offset = 0;
1022 cs->indirect_info->polymorphic = polymorphic;
1025 tree otr = gimple_call_fn (stmt);
1026 tree type, token = OBJ_TYPE_REF_TOKEN (otr);
1027 cs->indirect_info->otr_token = tree_low_cst (token, 1);
1028 type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
1029 cs->indirect_info->otr_type = type;
1033 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1034 (described by INFO). PARMS_INFO is a pointer to a vector containing
1035 intermediate information about each formal parameter. Currently it checks
1036 whether the call calls a pointer that is a formal parameter and if so, the
1037 parameter is marked with the called flag and an indirect call graph edge
1038 describing the call is created. This is very simple for ordinary pointers
1039 represented in SSA but not-so-nice when it comes to member pointers. The
1040 ugly part of this function does nothing more than trying to match the
1041 pattern of such a call. An example of such a pattern is the gimple dump
1042 below, the call is on the last line:
1045 f$__delta_5 = f.__delta;
1046 f$__pfn_24 = f.__pfn;
1050 f$__delta_5 = MEM[(struct *)&f];
1051 f$__pfn_24 = MEM[(struct *)&f + 4B];
1053 and a few lines below:
1056 D.2496_3 = (int) f$__pfn_24;
1057 D.2497_4 = D.2496_3 & 1;
1064 D.2500_7 = (unsigned int) f$__delta_5;
1065 D.2501_8 = &S + D.2500_7;
1066 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1067 D.2503_10 = *D.2502_9;
1068 D.2504_12 = f$__pfn_24 + -1;
1069 D.2505_13 = (unsigned int) D.2504_12;
1070 D.2506_14 = D.2503_10 + D.2505_13;
1071 D.2507_15 = *D.2506_14;
1072 iftmp.11_16 = (String:: *) D.2507_15;
1075 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1076 D.2500_19 = (unsigned int) f$__delta_5;
1077 D.2508_20 = &S + D.2500_19;
1078 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1080 Such patterns are results of simple calls to a member pointer:
1082 int doprinting (int (MyString::* f)(int) const)
1084 MyString S ("somestring");
1091 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1092 struct ipa_node_params *info,
1093 struct param_analysis_info *parms_info,
1094 gimple call, tree target)
1099 tree rec, rec2, cond;
1102 basic_block bb, virt_bb, join;
1104 if (SSA_NAME_IS_DEFAULT_DEF (target))
1106 tree var = SSA_NAME_VAR (target);
1107 index = ipa_get_param_decl_index (info, var);
1109 ipa_note_param_call (node, index, call, false);
1113 /* Now we need to try to match the complex pattern of calling a member
1116 if (!POINTER_TYPE_P (TREE_TYPE (target))
1117 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1120 def = SSA_NAME_DEF_STMT (target);
1121 if (gimple_code (def) != GIMPLE_PHI)
1124 if (gimple_phi_num_args (def) != 2)
1127 /* First, we need to check whether one of these is a load from a member
1128 pointer that is a parameter to this function. */
1129 n1 = PHI_ARG_DEF (def, 0);
1130 n2 = PHI_ARG_DEF (def, 1);
1131 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1133 d1 = SSA_NAME_DEF_STMT (n1);
1134 d2 = SSA_NAME_DEF_STMT (n2);
1136 join = gimple_bb (def);
1137 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1139 if (ipa_get_stmt_member_ptr_load_param (d2, false))
1142 bb = EDGE_PRED (join, 0)->src;
1143 virt_bb = gimple_bb (d2);
1145 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1147 bb = EDGE_PRED (join, 1)->src;
1148 virt_bb = gimple_bb (d1);
1153 /* Second, we need to check that the basic blocks are laid out in the way
1154 corresponding to the pattern. */
1156 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1157 || single_pred (virt_bb) != bb
1158 || single_succ (virt_bb) != join)
1161 /* Third, let's see that the branching is done depending on the least
1162 significant bit of the pfn. */
1164 branch = last_stmt (bb);
1165 if (!branch || gimple_code (branch) != GIMPLE_COND)
1168 if (gimple_cond_code (branch) != NE_EXPR
1169 || !integer_zerop (gimple_cond_rhs (branch)))
1172 cond = gimple_cond_lhs (branch);
1173 if (!ipa_is_ssa_with_stmt_def (cond))
1176 def = SSA_NAME_DEF_STMT (cond);
1177 if (!is_gimple_assign (def)
1178 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1179 || !integer_onep (gimple_assign_rhs2 (def)))
1182 cond = gimple_assign_rhs1 (def);
1183 if (!ipa_is_ssa_with_stmt_def (cond))
1186 def = SSA_NAME_DEF_STMT (cond);
1188 if (is_gimple_assign (def)
1189 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1191 cond = gimple_assign_rhs1 (def);
1192 if (!ipa_is_ssa_with_stmt_def (cond))
1194 def = SSA_NAME_DEF_STMT (cond);
1197 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1198 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1199 == ptrmemfunc_vbit_in_delta));
1204 index = ipa_get_param_decl_index (info, rec);
1205 if (index >= 0 && !is_parm_modified_before_call (&parms_info[index],
1207 ipa_note_param_call (node, index, call, false);
1212 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1213 object referenced in the expression is a formal parameter of the caller
1214 (described by INFO), create a call note for the statement. */
1217 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1218 struct ipa_node_params *info, gimple call,
1221 tree obj = OBJ_TYPE_REF_OBJECT (target);
1225 if (TREE_CODE (obj) == ADDR_EXPR)
1229 obj = TREE_OPERAND (obj, 0);
1231 while (TREE_CODE (obj) == COMPONENT_REF);
1232 if (TREE_CODE (obj) != MEM_REF)
1234 obj = TREE_OPERAND (obj, 0);
1237 if (TREE_CODE (obj) != SSA_NAME
1238 || !SSA_NAME_IS_DEFAULT_DEF (obj))
1241 var = SSA_NAME_VAR (obj);
1242 index = ipa_get_param_decl_index (info, var);
1245 ipa_note_param_call (node, index, call, true);
1248 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1249 of the caller (described by INFO). PARMS_INFO is a pointer to a vector
1250 containing intermediate information about each formal parameter. */
1253 ipa_analyze_call_uses (struct cgraph_node *node,
1254 struct ipa_node_params *info,
1255 struct param_analysis_info *parms_info, gimple call)
1257 tree target = gimple_call_fn (call);
1259 if (TREE_CODE (target) == SSA_NAME)
1260 ipa_analyze_indirect_call_uses (node, info, parms_info, call, target);
1261 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1262 ipa_analyze_virtual_call_uses (node, info, call, target);
1266 /* Analyze the call statement STMT with respect to formal parameters (described
1267 in INFO) of caller given by NODE. Currently it only checks whether formal
1268 parameters are called. PARMS_INFO is a pointer to a vector containing
1269 intermediate information about each formal parameter. */
1272 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1273 struct param_analysis_info *parms_info, gimple stmt)
1275 if (is_gimple_call (stmt))
1276 ipa_analyze_call_uses (node, info, parms_info, stmt);
1279 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1280 If OP is a parameter declaration, mark it as used in the info structure
1284 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
1285 tree op, void *data)
1287 struct ipa_node_params *info = (struct ipa_node_params *) data;
1289 op = get_base_address (op);
1291 && TREE_CODE (op) == PARM_DECL)
1293 int index = ipa_get_param_decl_index (info, op);
1294 gcc_assert (index >= 0);
1295 info->params[index].used = true;
1301 /* Scan the function body of NODE and inspect the uses of formal parameters.
1302 Store the findings in various structures of the associated ipa_node_params
1303 structure, such as parameter flags, notes etc. PARMS_INFO is a pointer to a
1304 vector containing intermediate information about each formal parameter. */
1307 ipa_analyze_params_uses (struct cgraph_node *node,
1308 struct param_analysis_info *parms_info)
1310 tree decl = node->decl;
1312 struct function *func;
1313 gimple_stmt_iterator gsi;
1314 struct ipa_node_params *info = IPA_NODE_REF (node);
1317 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1320 for (i = 0; i < ipa_get_param_count (info); i++)
1322 tree parm = ipa_get_param (info, i);
1323 /* For SSA regs see if parameter is used. For non-SSA we compute
1324 the flag during modification analysis. */
1325 if (is_gimple_reg (parm)
1326 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
1327 info->params[i].used = true;
1330 func = DECL_STRUCT_FUNCTION (decl);
1331 FOR_EACH_BB_FN (bb, func)
1333 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1335 gimple stmt = gsi_stmt (gsi);
1337 if (is_gimple_debug (stmt))
1340 ipa_analyze_stmt_uses (node, info, parms_info, stmt);
1341 walk_stmt_load_store_addr_ops (stmt, info,
1342 visit_ref_for_mod_analysis,
1343 visit_ref_for_mod_analysis,
1344 visit_ref_for_mod_analysis);
1346 for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
1347 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
1348 visit_ref_for_mod_analysis,
1349 visit_ref_for_mod_analysis,
1350 visit_ref_for_mod_analysis);
1353 info->uses_analysis_done = 1;
1356 /* Initialize the array describing properties of of formal parameters of NODE,
1357 analyze their uses and and compute jump functions associated witu actual
1358 arguments of calls from within NODE. */
1361 ipa_analyze_node (struct cgraph_node *node)
1363 struct ipa_node_params *info = IPA_NODE_REF (node);
1364 struct param_analysis_info *parms_info;
1367 ipa_initialize_node_params (node);
1369 param_count = ipa_get_param_count (info);
1370 parms_info = XALLOCAVEC (struct param_analysis_info, param_count);
1371 memset (parms_info, 0, sizeof (struct param_analysis_info) * param_count);
1373 ipa_analyze_params_uses (node, parms_info);
1374 ipa_compute_jump_functions (node, parms_info);
1376 for (i = 0; i < param_count; i++)
1377 if (parms_info[i].visited_statements)
1378 BITMAP_FREE (parms_info[i].visited_statements);
1382 /* Update the jump function DST when the call graph edge correspondng to SRC is
1383 is being inlined, knowing that DST is of type ancestor and src of known
1387 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1388 struct ipa_jump_func *dst)
1392 new_binfo = get_binfo_at_offset (src->value.base_binfo,
1393 dst->value.ancestor.offset,
1394 dst->value.ancestor.type);
1397 dst->type = IPA_JF_KNOWN_TYPE;
1398 dst->value.base_binfo = new_binfo;
1401 dst->type = IPA_JF_UNKNOWN;
1404 /* Update the jump functions associated with call graph edge E when the call
1405 graph edge CS is being inlined, assuming that E->caller is already (possibly
1406 indirectly) inlined into CS->callee and that E has not been inlined. */
1409 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1410 struct cgraph_edge *e)
1412 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1413 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1414 int count = ipa_get_cs_argument_count (args);
1417 for (i = 0; i < count; i++)
1419 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1421 if (dst->type == IPA_JF_ANCESTOR)
1423 struct ipa_jump_func *src;
1425 /* Variable number of arguments can cause havoc if we try to access
1426 one that does not exist in the inlined edge. So make sure we
1428 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1430 dst->type = IPA_JF_UNKNOWN;
1434 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1435 if (src->type == IPA_JF_KNOWN_TYPE)
1436 combine_known_type_and_ancestor_jfs (src, dst);
1437 else if (src->type == IPA_JF_PASS_THROUGH
1438 && src->value.pass_through.operation == NOP_EXPR)
1439 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1440 else if (src->type == IPA_JF_ANCESTOR)
1442 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1443 dst->value.ancestor.offset += src->value.ancestor.offset;
1446 dst->type = IPA_JF_UNKNOWN;
1448 else if (dst->type == IPA_JF_PASS_THROUGH)
1450 struct ipa_jump_func *src;
1451 /* We must check range due to calls with variable number of arguments
1452 and we cannot combine jump functions with operations. */
1453 if (dst->value.pass_through.operation == NOP_EXPR
1454 && (dst->value.pass_through.formal_id
1455 < ipa_get_cs_argument_count (top)))
1457 src = ipa_get_ith_jump_func (top,
1458 dst->value.pass_through.formal_id);
1462 dst->type = IPA_JF_UNKNOWN;
1467 /* If TARGET is an addr_expr of a function declaration, make it the destination
1468 of an indirect edge IE and return the edge. Otherwise, return NULL. Delta,
1469 if non-NULL, is an integer constant that must be added to this pointer
1470 (first parameter). */
1472 struct cgraph_edge *
1473 ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target, tree delta)
1475 struct cgraph_node *callee;
1477 if (TREE_CODE (target) == ADDR_EXPR)
1478 target = TREE_OPERAND (target, 0);
1479 if (TREE_CODE (target) != FUNCTION_DECL)
1481 callee = cgraph_node (target);
1484 ipa_check_create_node_params ();
1486 cgraph_make_edge_direct (ie, callee, delta ? tree_low_cst (delta, 0) : 0);
1489 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1490 "(%s/%i -> %s/%i), for stmt ",
1491 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1492 cgraph_node_name (ie->caller), ie->caller->uid,
1493 cgraph_node_name (ie->callee), ie->callee->uid);
1495 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1497 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1501 fprintf (dump_file, " Thunk delta is ");
1502 print_generic_expr (dump_file, delta, 0);
1503 fprintf (dump_file, "\n");
1507 if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie))
1508 != ipa_get_param_count (IPA_NODE_REF (callee)))
1509 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee));
1514 /* Try to find a destination for indirect edge IE that corresponds to a simple
1515 call or a call of a member function pointer and where the destination is a
1516 pointer formal parameter described by jump function JFUNC. If it can be
1517 determined, return the newly direct edge, otherwise return NULL. */
1519 static struct cgraph_edge *
1520 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1521 struct ipa_jump_func *jfunc)
1525 if (jfunc->type == IPA_JF_CONST)
1526 target = jfunc->value.constant;
1527 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1528 target = jfunc->value.member_cst.pfn;
1532 return ipa_make_edge_direct_to_target (ie, target, NULL_TREE);
1535 /* Try to find a destination for indirect edge IE that corresponds to a
1536 virtuall call based on a formal parameter which is described by jump
1537 function JFUNC and if it can be determined, make it direct and return the
1538 direct edge. Otherwise, return NULL. */
1540 static struct cgraph_edge *
1541 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1542 struct ipa_jump_func *jfunc)
1544 tree binfo, type, target, delta;
1545 HOST_WIDE_INT token;
1547 if (jfunc->type == IPA_JF_KNOWN_TYPE)
1548 binfo = jfunc->value.base_binfo;
1555 token = ie->indirect_info->otr_token;
1556 type = ie->indirect_info->otr_type;
1557 binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
1559 target = gimple_get_virt_mehtod_for_binfo (token, binfo, &delta, true);
1564 return ipa_make_edge_direct_to_target (ie, target, delta);
1569 /* Update the param called notes associated with NODE when CS is being inlined,
1570 assuming NODE is (potentially indirectly) inlined into CS->callee.
1571 Moreover, if the callee is discovered to be constant, create a new cgraph
1572 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1573 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1576 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1577 struct cgraph_node *node,
1578 VEC (cgraph_edge_p, heap) **new_edges)
1580 struct ipa_edge_args *top;
1581 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1584 ipa_check_create_edge_args ();
1585 top = IPA_EDGE_REF (cs);
1587 for (ie = node->indirect_calls; ie; ie = next_ie)
1589 struct cgraph_indirect_call_info *ici = ie->indirect_info;
1590 struct ipa_jump_func *jfunc;
1592 next_ie = ie->next_callee;
1593 if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
1596 /* If we ever use indirect edges for anything other than indirect
1597 inlining, we will need to skip those with negative param_indices. */
1598 if (ici->param_index == -1)
1601 /* We must check range due to calls with variable number of arguments: */
1602 if (ici->param_index >= ipa_get_cs_argument_count (top))
1604 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1608 jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1609 if (jfunc->type == IPA_JF_PASS_THROUGH
1610 && jfunc->value.pass_through.operation == NOP_EXPR)
1611 ici->param_index = jfunc->value.pass_through.formal_id;
1612 else if (jfunc->type == IPA_JF_ANCESTOR)
1614 ici->param_index = jfunc->value.ancestor.formal_id;
1615 ici->anc_offset += jfunc->value.ancestor.offset;
1618 /* Either we can find a destination for this edge now or never. */
1619 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1621 if (ici->polymorphic)
1622 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1624 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1626 if (new_direct_edge)
1628 new_direct_edge->indirect_inlining_edge = 1;
1631 VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1633 top = IPA_EDGE_REF (cs);
1642 /* Recursively traverse subtree of NODE (including node) made of inlined
1643 cgraph_edges when CS has been inlined and invoke
1644 update_indirect_edges_after_inlining on all nodes and
1645 update_jump_functions_after_inlining on all non-inlined edges that lead out
1646 of this subtree. Newly discovered indirect edges will be added to
1647 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1651 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1652 struct cgraph_node *node,
1653 VEC (cgraph_edge_p, heap) **new_edges)
1655 struct cgraph_edge *e;
1658 res = update_indirect_edges_after_inlining (cs, node, new_edges);
1660 for (e = node->callees; e; e = e->next_callee)
1661 if (!e->inline_failed)
1662 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1664 update_jump_functions_after_inlining (cs, e);
1669 /* Update jump functions and call note functions on inlining the call site CS.
1670 CS is expected to lead to a node already cloned by
1671 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1672 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1676 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1677 VEC (cgraph_edge_p, heap) **new_edges)
1679 /* FIXME lto: We do not stream out indirect call information. */
1683 /* Do nothing if the preparation phase has not been carried out yet
1684 (i.e. during early inlining). */
1685 if (!ipa_node_params_vector)
1687 gcc_assert (ipa_edge_args_vector);
1689 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1692 /* Frees all dynamically allocated structures that the argument info points
1696 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1698 if (args->jump_functions)
1699 ggc_free (args->jump_functions);
1701 memset (args, 0, sizeof (*args));
1704 /* Free all ipa_edge structures. */
1707 ipa_free_all_edge_args (void)
1710 struct ipa_edge_args *args;
1712 FOR_EACH_VEC_ELT (ipa_edge_args_t, ipa_edge_args_vector, i, args)
1713 ipa_free_edge_args_substructures (args);
1715 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1716 ipa_edge_args_vector = NULL;
1719 /* Frees all dynamically allocated structures that the param info points
1723 ipa_free_node_params_substructures (struct ipa_node_params *info)
1726 free (info->params);
1728 memset (info, 0, sizeof (*info));
1731 /* Free all ipa_node_params structures. */
1734 ipa_free_all_node_params (void)
1737 struct ipa_node_params *info;
1739 FOR_EACH_VEC_ELT (ipa_node_params_t, ipa_node_params_vector, i, info)
1740 ipa_free_node_params_substructures (info);
1742 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1743 ipa_node_params_vector = NULL;
1746 /* Hook that is called by cgraph.c when an edge is removed. */
1749 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1751 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1752 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1753 <= (unsigned)cs->uid)
1755 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1758 /* Hook that is called by cgraph.c when a node is removed. */
1761 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1763 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1764 if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1765 <= (unsigned)node->uid)
1767 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1770 /* Helper function to duplicate an array of size N that is at SRC and store a
1771 pointer to it to DST. Nothing is done if SRC is NULL. */
1774 duplicate_array (void *src, size_t n)
1786 static struct ipa_jump_func *
1787 duplicate_ipa_jump_func_array (const struct ipa_jump_func * src, size_t n)
1789 struct ipa_jump_func *p;
1794 p = ggc_alloc_vec_ipa_jump_func (n);
1795 memcpy (p, src, n * sizeof (struct ipa_jump_func));
1799 /* Hook that is called by cgraph.c when a node is duplicated. */
1802 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1803 __attribute__((unused)) void *data)
1805 struct ipa_edge_args *old_args, *new_args;
1808 ipa_check_create_edge_args ();
1810 old_args = IPA_EDGE_REF (src);
1811 new_args = IPA_EDGE_REF (dst);
1813 arg_count = ipa_get_cs_argument_count (old_args);
1814 ipa_set_cs_argument_count (new_args, arg_count);
1815 new_args->jump_functions =
1816 duplicate_ipa_jump_func_array (old_args->jump_functions, arg_count);
1818 if (iinlining_processed_edges
1819 && bitmap_bit_p (iinlining_processed_edges, src->uid))
1820 bitmap_set_bit (iinlining_processed_edges, dst->uid);
1823 /* Hook that is called by cgraph.c when a node is duplicated. */
1826 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1827 __attribute__((unused)) void *data)
1829 struct ipa_node_params *old_info, *new_info;
1832 ipa_check_create_node_params ();
1833 old_info = IPA_NODE_REF (src);
1834 new_info = IPA_NODE_REF (dst);
1835 param_count = ipa_get_param_count (old_info);
1837 ipa_set_param_count (new_info, param_count);
1838 new_info->params = (struct ipa_param_descriptor *)
1839 duplicate_array (old_info->params,
1840 sizeof (struct ipa_param_descriptor) * param_count);
1841 for (i = 0; i < param_count; i++)
1842 new_info->params[i].types = VEC_copy (tree, heap,
1843 old_info->params[i].types);
1844 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1845 new_info->count_scale = old_info->count_scale;
1847 new_info->called_with_var_arguments = old_info->called_with_var_arguments;
1848 new_info->uses_analysis_done = old_info->uses_analysis_done;
1849 new_info->node_enqueued = old_info->node_enqueued;
1852 /* Register our cgraph hooks if they are not already there. */
1855 ipa_register_cgraph_hooks (void)
1857 if (!edge_removal_hook_holder)
1858 edge_removal_hook_holder =
1859 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1860 if (!node_removal_hook_holder)
1861 node_removal_hook_holder =
1862 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1863 if (!edge_duplication_hook_holder)
1864 edge_duplication_hook_holder =
1865 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1866 if (!node_duplication_hook_holder)
1867 node_duplication_hook_holder =
1868 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1871 /* Unregister our cgraph hooks if they are not already there. */
1874 ipa_unregister_cgraph_hooks (void)
1876 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1877 edge_removal_hook_holder = NULL;
1878 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1879 node_removal_hook_holder = NULL;
1880 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1881 edge_duplication_hook_holder = NULL;
1882 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1883 node_duplication_hook_holder = NULL;
1886 /* Allocate all necessary data strucutures necessary for indirect inlining. */
1889 ipa_create_all_structures_for_iinln (void)
1891 iinlining_processed_edges = BITMAP_ALLOC (NULL);
1894 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1895 longer needed after ipa-cp. */
1898 ipa_free_all_structures_after_ipa_cp (void)
1900 if (!flag_indirect_inlining)
1902 ipa_free_all_edge_args ();
1903 ipa_free_all_node_params ();
1904 ipa_unregister_cgraph_hooks ();
1908 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1909 longer needed after indirect inlining. */
1912 ipa_free_all_structures_after_iinln (void)
1914 BITMAP_FREE (iinlining_processed_edges);
1916 ipa_free_all_edge_args ();
1917 ipa_free_all_node_params ();
1918 ipa_unregister_cgraph_hooks ();
1921 /* Print ipa_tree_map data structures of all functions in the
1925 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1929 struct ipa_node_params *info;
1931 if (!node->analyzed)
1933 info = IPA_NODE_REF (node);
1934 fprintf (f, " function %s parameter descriptors:\n",
1935 cgraph_node_name (node));
1936 count = ipa_get_param_count (info);
1937 for (i = 0; i < count; i++)
1939 temp = ipa_get_param (info, i);
1940 if (TREE_CODE (temp) == PARM_DECL)
1941 fprintf (f, " param %d : %s", i,
1943 ? (*lang_hooks.decl_printable_name) (temp, 2)
1945 if (ipa_is_param_used (info, i))
1946 fprintf (f, " used");
1951 /* Print ipa_tree_map data structures of all functions in the
1955 ipa_print_all_params (FILE * f)
1957 struct cgraph_node *node;
1959 fprintf (f, "\nFunction parameters:\n");
1960 for (node = cgraph_nodes; node; node = node->next)
1961 ipa_print_node_params (f, node);
1964 /* Return a heap allocated vector containing formal parameters of FNDECL. */
1967 ipa_get_vector_of_formal_parms (tree fndecl)
1969 VEC(tree, heap) *args;
1973 count = count_formal_params_1 (fndecl);
1974 args = VEC_alloc (tree, heap, count);
1975 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
1976 VEC_quick_push (tree, args, parm);
1981 /* Return a heap allocated vector containing types of formal parameters of
1982 function type FNTYPE. */
1984 static inline VEC(tree, heap) *
1985 get_vector_of_formal_parm_types (tree fntype)
1987 VEC(tree, heap) *types;
1991 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1994 types = VEC_alloc (tree, heap, count);
1995 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1996 VEC_quick_push (tree, types, TREE_VALUE (t));
2001 /* Modify the function declaration FNDECL and its type according to the plan in
2002 ADJUSTMENTS. It also sets base fields of individual adjustments structures
2003 to reflect the actual parameters being modified which are determined by the
2004 base_index field. */
2007 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
2008 const char *synth_parm_prefix)
2010 VEC(tree, heap) *oparms, *otypes;
2011 tree orig_type, new_type = NULL;
2012 tree old_arg_types, t, new_arg_types = NULL;
2013 tree parm, *link = &DECL_ARGUMENTS (fndecl);
2014 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2015 tree new_reversed = NULL;
2016 bool care_for_types, last_parm_void;
2018 if (!synth_parm_prefix)
2019 synth_parm_prefix = "SYNTH";
2021 oparms = ipa_get_vector_of_formal_parms (fndecl);
2022 orig_type = TREE_TYPE (fndecl);
2023 old_arg_types = TYPE_ARG_TYPES (orig_type);
2025 /* The following test is an ugly hack, some functions simply don't have any
2026 arguments in their type. This is probably a bug but well... */
2027 care_for_types = (old_arg_types != NULL_TREE);
2030 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
2032 otypes = get_vector_of_formal_parm_types (orig_type);
2034 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
2036 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
2040 last_parm_void = false;
2044 for (i = 0; i < len; i++)
2046 struct ipa_parm_adjustment *adj;
2049 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2050 parm = VEC_index (tree, oparms, adj->base_index);
2053 if (adj->copy_param)
2056 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
2060 link = &DECL_CHAIN (parm);
2062 else if (!adj->remove_param)
2068 ptype = build_pointer_type (adj->type);
2073 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
2075 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
2077 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
2079 DECL_ARTIFICIAL (new_parm) = 1;
2080 DECL_ARG_TYPE (new_parm) = ptype;
2081 DECL_CONTEXT (new_parm) = fndecl;
2082 TREE_USED (new_parm) = 1;
2083 DECL_IGNORED_P (new_parm) = 1;
2084 layout_decl (new_parm, 0);
2086 add_referenced_var (new_parm);
2087 mark_sym_for_renaming (new_parm);
2089 adj->reduction = new_parm;
2093 link = &DECL_CHAIN (new_parm);
2101 new_reversed = nreverse (new_arg_types);
2105 TREE_CHAIN (new_arg_types) = void_list_node;
2107 new_reversed = void_list_node;
2111 /* Use copy_node to preserve as much as possible from original type
2112 (debug info, attribute lists etc.)
2113 Exception is METHOD_TYPEs must have THIS argument.
2114 When we are asked to remove it, we need to build new FUNCTION_TYPE
2116 if (TREE_CODE (orig_type) != METHOD_TYPE
2117 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
2118 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
2120 new_type = build_distinct_type_copy (orig_type);
2121 TYPE_ARG_TYPES (new_type) = new_reversed;
2126 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
2128 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
2129 DECL_VINDEX (fndecl) = NULL_TREE;
2132 /* When signature changes, we need to clear builtin info. */
2133 if (DECL_BUILT_IN (fndecl))
2135 DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
2136 DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
2139 /* This is a new type, not a copy of an old type. Need to reassociate
2140 variants. We can handle everything except the main variant lazily. */
2141 t = TYPE_MAIN_VARIANT (orig_type);
2144 TYPE_MAIN_VARIANT (new_type) = t;
2145 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
2146 TYPE_NEXT_VARIANT (t) = new_type;
2150 TYPE_MAIN_VARIANT (new_type) = new_type;
2151 TYPE_NEXT_VARIANT (new_type) = NULL;
2154 TREE_TYPE (fndecl) = new_type;
2155 DECL_VIRTUAL_P (fndecl) = 0;
2157 VEC_free (tree, heap, otypes);
2158 VEC_free (tree, heap, oparms);
2161 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2162 If this is a directly recursive call, CS must be NULL. Otherwise it must
2163 contain the corresponding call graph edge. */
2166 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2167 ipa_parm_adjustment_vec adjustments)
2169 VEC(tree, heap) *vargs;
2171 gimple_stmt_iterator gsi;
2175 len = VEC_length (ipa_parm_adjustment_t, adjustments);
2176 vargs = VEC_alloc (tree, heap, len);
2178 gsi = gsi_for_stmt (stmt);
2179 for (i = 0; i < len; i++)
2181 struct ipa_parm_adjustment *adj;
2183 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2185 if (adj->copy_param)
2187 tree arg = gimple_call_arg (stmt, adj->base_index);
2189 VEC_quick_push (tree, vargs, arg);
2191 else if (!adj->remove_param)
2193 tree expr, base, off;
2196 /* We create a new parameter out of the value of the old one, we can
2197 do the following kind of transformations:
2199 - A scalar passed by reference is converted to a scalar passed by
2200 value. (adj->by_ref is false and the type of the original
2201 actual argument is a pointer to a scalar).
2203 - A part of an aggregate is passed instead of the whole aggregate.
2204 The part can be passed either by value or by reference, this is
2205 determined by value of adj->by_ref. Moreover, the code below
2206 handles both situations when the original aggregate is passed by
2207 value (its type is not a pointer) and when it is passed by
2208 reference (it is a pointer to an aggregate).
2210 When the new argument is passed by reference (adj->by_ref is true)
2211 it must be a part of an aggregate and therefore we form it by
2212 simply taking the address of a reference inside the original
2215 gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0);
2216 base = gimple_call_arg (stmt, adj->base_index);
2217 loc = EXPR_LOCATION (base);
2219 if (TREE_CODE (base) != ADDR_EXPR
2220 && POINTER_TYPE_P (TREE_TYPE (base)))
2221 off = build_int_cst (adj->alias_ptr_type,
2222 adj->offset / BITS_PER_UNIT);
2225 HOST_WIDE_INT base_offset;
2228 if (TREE_CODE (base) == ADDR_EXPR)
2229 base = TREE_OPERAND (base, 0);
2231 base = get_addr_base_and_unit_offset (base, &base_offset);
2232 /* Aggregate arguments can have non-invariant addresses. */
2235 base = build_fold_addr_expr (prev_base);
2236 off = build_int_cst (adj->alias_ptr_type,
2237 adj->offset / BITS_PER_UNIT);
2239 else if (TREE_CODE (base) == MEM_REF)
2241 off = build_int_cst (adj->alias_ptr_type,
2243 + adj->offset / BITS_PER_UNIT);
2244 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1),
2246 base = TREE_OPERAND (base, 0);
2250 off = build_int_cst (adj->alias_ptr_type,
2252 + adj->offset / BITS_PER_UNIT);
2253 base = build_fold_addr_expr (base);
2257 expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off);
2259 expr = build_fold_addr_expr (expr);
2261 expr = force_gimple_operand_gsi (&gsi, expr,
2263 || is_gimple_reg_type (adj->type),
2264 NULL, true, GSI_SAME_STMT);
2265 VEC_quick_push (tree, vargs, expr);
2269 if (dump_file && (dump_flags & TDF_DETAILS))
2271 fprintf (dump_file, "replacing stmt:");
2272 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2275 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2276 new_stmt = gimple_build_call_vec (callee_decl, vargs);
2277 VEC_free (tree, heap, vargs);
2278 if (gimple_call_lhs (stmt))
2279 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2281 gimple_set_block (new_stmt, gimple_block (stmt));
2282 if (gimple_has_location (stmt))
2283 gimple_set_location (new_stmt, gimple_location (stmt));
2284 gimple_call_copy_flags (new_stmt, stmt);
2285 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2287 if (dump_file && (dump_flags & TDF_DETAILS))
2289 fprintf (dump_file, "with stmt:");
2290 print_gimple_stmt (dump_file, new_stmt, 0, 0);
2291 fprintf (dump_file, "\n");
2293 gsi_replace (&gsi, new_stmt, true);
2295 cgraph_set_call_stmt (cs, new_stmt);
2296 update_ssa (TODO_update_ssa);
2297 free_dominance_info (CDI_DOMINATORS);
2300 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2303 index_in_adjustments_multiple_times_p (int base_index,
2304 ipa_parm_adjustment_vec adjustments)
2306 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2309 for (i = 0; i < len; i++)
2311 struct ipa_parm_adjustment *adj;
2312 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2314 if (adj->base_index == base_index)
2326 /* Return adjustments that should have the same effect on function parameters
2327 and call arguments as if they were first changed according to adjustments in
2328 INNER and then by adjustments in OUTER. */
2330 ipa_parm_adjustment_vec
2331 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2332 ipa_parm_adjustment_vec outer)
2334 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2335 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2337 ipa_parm_adjustment_vec adjustments, tmp;
2339 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2340 for (i = 0; i < inlen; i++)
2342 struct ipa_parm_adjustment *n;
2343 n = VEC_index (ipa_parm_adjustment_t, inner, i);
2345 if (n->remove_param)
2348 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2351 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2352 for (i = 0; i < outlen; i++)
2354 struct ipa_parm_adjustment *r;
2355 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2357 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2360 gcc_assert (!in->remove_param);
2361 if (out->remove_param)
2363 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2365 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2366 memset (r, 0, sizeof (*r));
2367 r->remove_param = true;
2372 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2373 memset (r, 0, sizeof (*r));
2374 r->base_index = in->base_index;
2375 r->type = out->type;
2377 /* FIXME: Create nonlocal value too. */
2379 if (in->copy_param && out->copy_param)
2380 r->copy_param = true;
2381 else if (in->copy_param)
2382 r->offset = out->offset;
2383 else if (out->copy_param)
2384 r->offset = in->offset;
2386 r->offset = in->offset + out->offset;
2389 for (i = 0; i < inlen; i++)
2391 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2394 if (n->remove_param)
2395 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2398 VEC_free (ipa_parm_adjustment_t, heap, tmp);
2402 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2403 friendly way, assuming they are meant to be applied to FNDECL. */
2406 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2409 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2411 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2413 fprintf (file, "IPA param adjustments: ");
2414 for (i = 0; i < len; i++)
2416 struct ipa_parm_adjustment *adj;
2417 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2420 fprintf (file, " ");
2424 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2425 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2428 fprintf (file, ", base: ");
2429 print_generic_expr (file, adj->base, 0);
2433 fprintf (file, ", reduction: ");
2434 print_generic_expr (file, adj->reduction, 0);
2436 if (adj->new_ssa_base)
2438 fprintf (file, ", new_ssa_base: ");
2439 print_generic_expr (file, adj->new_ssa_base, 0);
2442 if (adj->copy_param)
2443 fprintf (file, ", copy_param");
2444 else if (adj->remove_param)
2445 fprintf (file, ", remove_param");
2447 fprintf (file, ", offset %li", (long) adj->offset);
2449 fprintf (file, ", by_ref");
2450 print_node_brief (file, ", type: ", adj->type, 0);
2451 fprintf (file, "\n");
2453 VEC_free (tree, heap, parms);
2456 /* Stream out jump function JUMP_FUNC to OB. */
2459 ipa_write_jump_function (struct output_block *ob,
2460 struct ipa_jump_func *jump_func)
2462 lto_output_uleb128_stream (ob->main_stream,
2465 switch (jump_func->type)
2467 case IPA_JF_UNKNOWN:
2469 case IPA_JF_KNOWN_TYPE:
2470 lto_output_tree (ob, jump_func->value.base_binfo, true);
2473 lto_output_tree (ob, jump_func->value.constant, true);
2475 case IPA_JF_PASS_THROUGH:
2476 lto_output_tree (ob, jump_func->value.pass_through.operand, true);
2477 lto_output_uleb128_stream (ob->main_stream,
2478 jump_func->value.pass_through.formal_id);
2479 lto_output_uleb128_stream (ob->main_stream,
2480 jump_func->value.pass_through.operation);
2482 case IPA_JF_ANCESTOR:
2483 lto_output_uleb128_stream (ob->main_stream,
2484 jump_func->value.ancestor.offset);
2485 lto_output_tree (ob, jump_func->value.ancestor.type, true);
2486 lto_output_uleb128_stream (ob->main_stream,
2487 jump_func->value.ancestor.formal_id);
2489 case IPA_JF_CONST_MEMBER_PTR:
2490 lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
2491 lto_output_tree (ob, jump_func->value.member_cst.delta, false);
2496 /* Read in jump function JUMP_FUNC from IB. */
2499 ipa_read_jump_function (struct lto_input_block *ib,
2500 struct ipa_jump_func *jump_func,
2501 struct data_in *data_in)
2503 jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
2505 switch (jump_func->type)
2507 case IPA_JF_UNKNOWN:
2509 case IPA_JF_KNOWN_TYPE:
2510 jump_func->value.base_binfo = lto_input_tree (ib, data_in);
2513 jump_func->value.constant = lto_input_tree (ib, data_in);
2515 case IPA_JF_PASS_THROUGH:
2516 jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
2517 jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
2518 jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
2520 case IPA_JF_ANCESTOR:
2521 jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
2522 jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
2523 jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
2525 case IPA_JF_CONST_MEMBER_PTR:
2526 jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
2527 jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
2532 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2533 relevant to indirect inlining to OB. */
2536 ipa_write_indirect_edge_info (struct output_block *ob,
2537 struct cgraph_edge *cs)
2539 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2540 struct bitpack_d bp;
2542 lto_output_sleb128_stream (ob->main_stream, ii->param_index);
2543 lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
2544 bp = bitpack_create (ob->main_stream);
2545 bp_pack_value (&bp, ii->polymorphic, 1);
2546 lto_output_bitpack (&bp);
2548 if (ii->polymorphic)
2550 lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
2551 lto_output_tree (ob, ii->otr_type, true);
2555 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2556 relevant to indirect inlining from IB. */
2559 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2560 struct data_in *data_in ATTRIBUTE_UNUSED,
2561 struct cgraph_edge *cs)
2563 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2564 struct bitpack_d bp;
2566 ii->param_index = (int) lto_input_sleb128 (ib);
2567 ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2568 bp = lto_input_bitpack (ib);
2569 ii->polymorphic = bp_unpack_value (&bp, 1);
2570 if (ii->polymorphic)
2572 ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2573 ii->otr_type = lto_input_tree (ib, data_in);
2577 /* Stream out NODE info to OB. */
2580 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2583 lto_cgraph_encoder_t encoder;
2584 struct ipa_node_params *info = IPA_NODE_REF (node);
2586 struct cgraph_edge *e;
2587 struct bitpack_d bp;
2589 encoder = ob->decl_state->cgraph_node_encoder;
2590 node_ref = lto_cgraph_encoder_encode (encoder, node);
2591 lto_output_uleb128_stream (ob->main_stream, node_ref);
2593 bp = bitpack_create (ob->main_stream);
2594 bp_pack_value (&bp, info->called_with_var_arguments, 1);
2595 gcc_assert (info->uses_analysis_done
2596 || ipa_get_param_count (info) == 0);
2597 gcc_assert (!info->node_enqueued);
2598 gcc_assert (!info->ipcp_orig_node);
2599 for (j = 0; j < ipa_get_param_count (info); j++)
2600 bp_pack_value (&bp, info->params[j].used, 1);
2601 lto_output_bitpack (&bp);
2602 for (e = node->callees; e; e = e->next_callee)
2604 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2606 lto_output_uleb128_stream (ob->main_stream,
2607 ipa_get_cs_argument_count (args));
2608 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2609 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2611 for (e = node->indirect_calls; e; e = e->next_callee)
2612 ipa_write_indirect_edge_info (ob, e);
2615 /* Srtream in NODE info from IB. */
2618 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2619 struct data_in *data_in)
2621 struct ipa_node_params *info = IPA_NODE_REF (node);
2623 struct cgraph_edge *e;
2624 struct bitpack_d bp;
2626 ipa_initialize_node_params (node);
2628 bp = lto_input_bitpack (ib);
2629 info->called_with_var_arguments = bp_unpack_value (&bp, 1);
2630 if (ipa_get_param_count (info) != 0)
2631 info->uses_analysis_done = true;
2632 info->node_enqueued = false;
2633 for (k = 0; k < ipa_get_param_count (info); k++)
2634 info->params[k].used = bp_unpack_value (&bp, 1);
2635 for (e = node->callees; e; e = e->next_callee)
2637 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2638 int count = lto_input_uleb128 (ib);
2640 ipa_set_cs_argument_count (args, count);
2644 args->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
2645 (ipa_get_cs_argument_count (args));
2646 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2647 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2649 for (e = node->indirect_calls; e; e = e->next_callee)
2650 ipa_read_indirect_edge_info (ib, data_in, e);
2653 /* Write jump functions for nodes in SET. */
2656 ipa_prop_write_jump_functions (cgraph_node_set set)
2658 struct cgraph_node *node;
2659 struct output_block *ob = create_output_block (LTO_section_jump_functions);
2660 unsigned int count = 0;
2661 cgraph_node_set_iterator csi;
2663 ob->cgraph_node = NULL;
2665 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2667 node = csi_node (csi);
2668 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2672 lto_output_uleb128_stream (ob->main_stream, count);
2674 /* Process all of the functions. */
2675 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2677 node = csi_node (csi);
2678 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2679 ipa_write_node_info (ob, node);
2681 lto_output_1_stream (ob->main_stream, 0);
2682 produce_asm (ob, NULL);
2683 destroy_output_block (ob);
2686 /* Read section in file FILE_DATA of length LEN with data DATA. */
2689 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2692 const struct lto_function_header *header =
2693 (const struct lto_function_header *) data;
2694 const int32_t cfg_offset = sizeof (struct lto_function_header);
2695 const int32_t main_offset = cfg_offset + header->cfg_size;
2696 const int32_t string_offset = main_offset + header->main_size;
2697 struct data_in *data_in;
2698 struct lto_input_block ib_main;
2702 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2706 lto_data_in_create (file_data, (const char *) data + string_offset,
2707 header->string_size, NULL);
2708 count = lto_input_uleb128 (&ib_main);
2710 for (i = 0; i < count; i++)
2713 struct cgraph_node *node;
2714 lto_cgraph_encoder_t encoder;
2716 index = lto_input_uleb128 (&ib_main);
2717 encoder = file_data->cgraph_node_encoder;
2718 node = lto_cgraph_encoder_deref (encoder, index);
2719 gcc_assert (node->analyzed);
2720 ipa_read_node_info (&ib_main, node, data_in);
2722 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2724 lto_data_in_delete (data_in);
2727 /* Read ipcp jump functions. */
2730 ipa_prop_read_jump_functions (void)
2732 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2733 struct lto_file_decl_data *file_data;
2736 ipa_check_create_node_params ();
2737 ipa_check_create_edge_args ();
2738 ipa_register_cgraph_hooks ();
2740 while ((file_data = file_data_vec[j++]))
2743 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2746 ipa_prop_read_section (file_data, data, len);
2750 /* After merging units, we can get mismatch in argument counts.
2751 Also decl merging might've rendered parameter lists obsolette.
2752 Also compute called_with_variable_arg info. */
2755 ipa_update_after_lto_read (void)
2757 struct cgraph_node *node;
2758 struct cgraph_edge *cs;
2760 ipa_check_create_node_params ();
2761 ipa_check_create_edge_args ();
2763 for (node = cgraph_nodes; node; node = node->next)
2765 ipa_initialize_node_params (node);
2767 for (node = cgraph_nodes; node; node = node->next)
2769 for (cs = node->callees; cs; cs = cs->next_callee)
2771 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2772 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2773 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));