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;
368 op1 = gimple_assign_rhs1 (stmt);
369 op2 = gimple_assign_rhs2 (stmt);
371 if (TREE_CODE (op1) == SSA_NAME
372 && SSA_NAME_IS_DEFAULT_DEF (op1))
374 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
380 if (!is_gimple_ip_invariant (op2)
381 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
382 && !useless_type_conversion_p (TREE_TYPE (name),
386 jfunc->type = IPA_JF_PASS_THROUGH;
387 jfunc->value.pass_through.formal_id = index;
388 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
389 jfunc->value.pass_through.operand = op2;
391 else if (gimple_assign_unary_nop_p (stmt))
393 jfunc->type = IPA_JF_PASS_THROUGH;
394 jfunc->value.pass_through.formal_id = index;
395 jfunc->value.pass_through.operation = NOP_EXPR;
400 if (TREE_CODE (op1) != ADDR_EXPR)
403 op1 = TREE_OPERAND (op1, 0);
404 type = TREE_TYPE (op1);
405 if (TREE_CODE (type) != RECORD_TYPE)
407 op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
408 if (TREE_CODE (op1) != MEM_REF
409 /* If this is a varying address, punt. */
413 offset += mem_ref_offset (op1).low * BITS_PER_UNIT;
414 op1 = TREE_OPERAND (op1, 0);
415 if (TREE_CODE (op1) != SSA_NAME
416 || !SSA_NAME_IS_DEFAULT_DEF (op1)
420 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
423 jfunc->type = IPA_JF_ANCESTOR;
424 jfunc->value.ancestor.formal_id = index;
425 jfunc->value.ancestor.offset = offset;
426 jfunc->value.ancestor.type = type;
431 /* Given that an actual argument is an SSA_NAME that is a result of a phi
432 statement PHI, try to find out whether NAME is in fact a
433 multiple-inheritance typecast from a descendant into an ancestor of a formal
434 parameter and thus can be described by an ancestor jump function and if so,
435 write the appropriate function into JFUNC.
437 Essentially we want to match the following pattern:
445 iftmp.1_3 = &obj_2(D)->D.1762;
448 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
449 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
453 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
454 struct ipa_jump_func *jfunc,
457 HOST_WIDE_INT offset, size, max_size;
459 basic_block phi_bb, assign_bb, cond_bb;
460 tree tmp, parm, expr;
463 if (gimple_phi_num_args (phi) != 2
464 || !integer_zerop (PHI_ARG_DEF (phi, 1)))
467 tmp = PHI_ARG_DEF (phi, 0);
468 if (TREE_CODE (tmp) != SSA_NAME
469 || SSA_NAME_IS_DEFAULT_DEF (tmp)
470 || !POINTER_TYPE_P (TREE_TYPE (tmp))
471 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
474 assign = SSA_NAME_DEF_STMT (tmp);
475 assign_bb = gimple_bb (assign);
476 if (!single_pred_p (assign_bb)
477 || !gimple_assign_single_p (assign))
479 expr = gimple_assign_rhs1 (assign);
481 if (TREE_CODE (expr) != ADDR_EXPR)
483 expr = TREE_OPERAND (expr, 0);
484 expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
486 if (TREE_CODE (expr) != MEM_REF
487 /* If this is a varying address, punt. */
491 offset += mem_ref_offset (expr).low * BITS_PER_UNIT;
492 parm = TREE_OPERAND (expr, 0);
493 if (TREE_CODE (parm) != SSA_NAME
494 || !SSA_NAME_IS_DEFAULT_DEF (parm)
498 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
502 cond_bb = single_pred (assign_bb);
503 cond = last_stmt (cond_bb);
505 || gimple_code (cond) != GIMPLE_COND
506 || gimple_cond_code (cond) != NE_EXPR
507 || gimple_cond_lhs (cond) != parm
508 || !integer_zerop (gimple_cond_rhs (cond)))
512 phi_bb = gimple_bb (phi);
513 for (i = 0; i < 2; i++)
515 basic_block pred = EDGE_PRED (phi_bb, i)->src;
516 if (pred != assign_bb && pred != cond_bb)
520 jfunc->type = IPA_JF_ANCESTOR;
521 jfunc->value.ancestor.formal_id = index;
522 jfunc->value.ancestor.offset = offset;
523 jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
526 /* Given OP whch is passed as an actual argument to a called function,
527 determine if it is possible to construct a KNOWN_TYPE jump function for it
528 and if so, create one and store it to JFUNC. */
531 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
535 if (TREE_CODE (op) != ADDR_EXPR)
538 op = TREE_OPERAND (op, 0);
539 binfo = gimple_get_relevant_ref_binfo (op, NULL_TREE);
542 jfunc->type = IPA_JF_KNOWN_TYPE;
543 jfunc->value.base_binfo = binfo;
548 /* Determine the jump functions of scalar arguments. Scalar means SSA names
549 and constants of a number of selected types. INFO is the ipa_node_params
550 structure associated with the caller, FUNCTIONS is a pointer to an array of
551 jump function structures associated with CALL which is the call statement
555 compute_scalar_jump_functions (struct ipa_node_params *info,
556 struct ipa_jump_func *functions,
562 for (num = 0; num < gimple_call_num_args (call); num++)
564 arg = gimple_call_arg (call, num);
566 if (is_gimple_ip_invariant (arg))
568 functions[num].type = IPA_JF_CONST;
569 functions[num].value.constant = arg;
571 else if (TREE_CODE (arg) == SSA_NAME)
573 if (SSA_NAME_IS_DEFAULT_DEF (arg))
575 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
579 functions[num].type = IPA_JF_PASS_THROUGH;
580 functions[num].value.pass_through.formal_id = index;
581 functions[num].value.pass_through.operation = NOP_EXPR;
586 gimple stmt = SSA_NAME_DEF_STMT (arg);
587 if (is_gimple_assign (stmt))
588 compute_complex_assign_jump_func (info, &functions[num],
590 else if (gimple_code (stmt) == GIMPLE_PHI)
591 compute_complex_ancestor_jump_func (info, &functions[num],
596 compute_known_type_jump_func (arg, &functions[num]);
600 /* Inspect the given TYPE and return true iff it has the same structure (the
601 same number of fields of the same types) as a C++ member pointer. If
602 METHOD_PTR and DELTA are non-NULL, store the trees representing the
603 corresponding fields there. */
606 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
610 if (TREE_CODE (type) != RECORD_TYPE)
613 fld = TYPE_FIELDS (type);
614 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
615 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
621 fld = DECL_CHAIN (fld);
622 if (!fld || INTEGRAL_TYPE_P (fld))
627 if (DECL_CHAIN (fld))
633 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
634 boolean variable pointed to by DATA. */
637 mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
640 bool *b = (bool *) data;
645 /* Return true if the formal parameter PARM might have been modified in this
646 function before reaching the statement CALL. PARM_INFO is a pointer to a
647 structure containing intermediate information about PARM. */
650 is_parm_modified_before_call (struct param_analysis_info *parm_info,
651 gimple call, tree parm)
653 bool modified = false;
656 if (parm_info->modified)
659 ao_ref_init (&refd, parm);
660 walk_aliased_vdefs (&refd, gimple_vuse (call), mark_modified,
661 &modified, &parm_info->visited_statements);
664 parm_info->modified = true;
670 /* Go through arguments of the CALL and for every one that looks like a member
671 pointer, check whether it can be safely declared pass-through and if so,
672 mark that to the corresponding item of jump FUNCTIONS. Return true iff
673 there are non-pass-through member pointers within the arguments. INFO
674 describes formal parameters of the caller. PARMS_INFO is a pointer to a
675 vector containing intermediate information about each formal parameter. */
678 compute_pass_through_member_ptrs (struct ipa_node_params *info,
679 struct param_analysis_info *parms_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 (!is_parm_modified_before_call (&parms_info[index], call, arg))
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 (!stmt_may_clobber_ref_p (stmt, arg))
773 if (!gimple_assign_single_p (stmt))
776 lhs = gimple_assign_lhs (stmt);
777 rhs = gimple_assign_rhs1 (stmt);
779 if (TREE_CODE (lhs) != COMPONENT_REF
780 || TREE_OPERAND (lhs, 0) != arg)
783 fld = TREE_OPERAND (lhs, 1);
784 if (!method && fld == method_field)
786 rhs = get_ssa_def_if_simple_copy (rhs);
787 if (TREE_CODE (rhs) == ADDR_EXPR
788 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
789 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
791 method = TREE_OPERAND (rhs, 0);
794 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
802 if (!delta && fld == delta_field)
804 rhs = get_ssa_def_if_simple_copy (rhs);
805 if (TREE_CODE (rhs) == INTEGER_CST)
810 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
822 /* Go through the arguments of the CALL and for every member pointer within
823 tries determine whether it is a constant. If it is, create a corresponding
824 constant jump function in FUNCTIONS which is an array of jump functions
825 associated with the call. */
828 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
832 tree arg, method_field, delta_field;
834 for (num = 0; num < gimple_call_num_args (call); num++)
836 arg = gimple_call_arg (call, num);
838 if (functions[num].type == IPA_JF_UNKNOWN
839 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
841 determine_cst_member_ptr (call, arg, method_field, delta_field,
846 /* Compute jump function for all arguments of callsite CS and insert the
847 information in the jump_functions array in the ipa_edge_args corresponding
851 ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_info,
852 struct cgraph_edge *cs)
854 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
855 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
858 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
860 arguments->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
861 (ipa_get_cs_argument_count (arguments));
863 call = cs->call_stmt;
864 gcc_assert (is_gimple_call (call));
866 /* We will deal with constants and SSA scalars first: */
867 compute_scalar_jump_functions (info, arguments->jump_functions, call);
869 /* Let's check whether there are any potential member pointers and if so,
870 whether we can determine their functions as pass_through. */
871 if (!compute_pass_through_member_ptrs (info, parms_info,
872 arguments->jump_functions, call))
875 /* Finally, let's check whether we actually pass a new constant member
877 compute_cst_member_ptr_arguments (arguments->jump_functions, call);
880 /* Compute jump functions for all edges - both direct and indirect - outgoing
881 from NODE. Also count the actual arguments in the process. */
884 ipa_compute_jump_functions (struct cgraph_node *node,
885 struct param_analysis_info *parms_info)
887 struct cgraph_edge *cs;
889 for (cs = node->callees; cs; cs = cs->next_callee)
891 /* We do not need to bother analyzing calls to unknown
892 functions unless they may become known during lto/whopr. */
893 if (!cs->callee->analyzed && !flag_lto)
895 ipa_count_arguments (cs);
896 /* If the descriptor of the callee is not initialized yet, we have to do
898 if (cs->callee->analyzed)
899 ipa_initialize_node_params (cs->callee);
900 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
901 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
902 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
903 ipa_compute_jump_functions_for_edge (parms_info, cs);
906 for (cs = node->indirect_calls; cs; cs = cs->next_callee)
908 ipa_count_arguments (cs);
909 ipa_compute_jump_functions_for_edge (parms_info, cs);
913 /* If RHS looks like a rhs of a statement loading pfn from a member
914 pointer formal parameter, return the parameter, otherwise return
915 NULL. If USE_DELTA, then we look for a use of the delta field
916 rather than the pfn. */
919 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
921 tree rec, ref_field, ref_offset, fld, fld_offset, ptr_field, delta_field;
923 if (TREE_CODE (rhs) == COMPONENT_REF)
925 ref_field = TREE_OPERAND (rhs, 1);
926 rhs = TREE_OPERAND (rhs, 0);
929 ref_field = NULL_TREE;
930 if (TREE_CODE (rhs) != MEM_REF)
932 rec = TREE_OPERAND (rhs, 0);
933 if (TREE_CODE (rec) != ADDR_EXPR)
935 rec = TREE_OPERAND (rec, 0);
936 if (TREE_CODE (rec) != PARM_DECL
937 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
940 ref_offset = TREE_OPERAND (rhs, 1);
944 if (integer_nonzerop (ref_offset))
952 return ref_field == fld ? rec : NULL_TREE;
956 fld_offset = byte_position (delta_field);
958 fld_offset = byte_position (ptr_field);
960 return tree_int_cst_equal (ref_offset, fld_offset) ? rec : NULL_TREE;
963 /* If STMT looks like a statement loading a value from a member pointer formal
964 parameter, this function returns that parameter. */
967 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
971 if (!gimple_assign_single_p (stmt))
974 rhs = gimple_assign_rhs1 (stmt);
975 return ipa_get_member_ptr_load_param (rhs, use_delta);
978 /* Returns true iff T is an SSA_NAME defined by a statement. */
981 ipa_is_ssa_with_stmt_def (tree t)
983 if (TREE_CODE (t) == SSA_NAME
984 && !SSA_NAME_IS_DEFAULT_DEF (t))
990 /* Find the indirect call graph edge corresponding to STMT and add to it all
991 information necessary to describe a call to a parameter number PARAM_INDEX.
992 NODE is the caller. POLYMORPHIC should be set to true iff the call is a
996 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
999 struct cgraph_edge *cs;
1001 cs = cgraph_edge (node, stmt);
1002 cs->indirect_info->param_index = param_index;
1003 cs->indirect_info->anc_offset = 0;
1004 cs->indirect_info->polymorphic = polymorphic;
1007 tree otr = gimple_call_fn (stmt);
1008 tree type, token = OBJ_TYPE_REF_TOKEN (otr);
1009 cs->indirect_info->otr_token = tree_low_cst (token, 1);
1010 type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
1011 cs->indirect_info->otr_type = type;
1015 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1016 (described by INFO). PARMS_INFO is a pointer to a vector containing
1017 intermediate information about each formal parameter. Currently it checks
1018 whether the call calls a pointer that is a formal parameter and if so, the
1019 parameter is marked with the called flag and an indirect call graph edge
1020 describing the call is created. This is very simple for ordinary pointers
1021 represented in SSA but not-so-nice when it comes to member pointers. The
1022 ugly part of this function does nothing more than trying to match the
1023 pattern of such a call. An example of such a pattern is the gimple dump
1024 below, the call is on the last line:
1027 f$__delta_5 = f.__delta;
1028 f$__pfn_24 = f.__pfn;
1032 f$__delta_5 = MEM[(struct *)&f];
1033 f$__pfn_24 = MEM[(struct *)&f + 4B];
1035 and a few lines below:
1038 D.2496_3 = (int) f$__pfn_24;
1039 D.2497_4 = D.2496_3 & 1;
1046 D.2500_7 = (unsigned int) f$__delta_5;
1047 D.2501_8 = &S + D.2500_7;
1048 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1049 D.2503_10 = *D.2502_9;
1050 D.2504_12 = f$__pfn_24 + -1;
1051 D.2505_13 = (unsigned int) D.2504_12;
1052 D.2506_14 = D.2503_10 + D.2505_13;
1053 D.2507_15 = *D.2506_14;
1054 iftmp.11_16 = (String:: *) D.2507_15;
1057 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1058 D.2500_19 = (unsigned int) f$__delta_5;
1059 D.2508_20 = &S + D.2500_19;
1060 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1062 Such patterns are results of simple calls to a member pointer:
1064 int doprinting (int (MyString::* f)(int) const)
1066 MyString S ("somestring");
1073 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1074 struct ipa_node_params *info,
1075 struct param_analysis_info *parms_info,
1076 gimple call, tree target)
1081 tree rec, rec2, cond;
1084 basic_block bb, virt_bb, join;
1086 if (SSA_NAME_IS_DEFAULT_DEF (target))
1088 tree var = SSA_NAME_VAR (target);
1089 index = ipa_get_param_decl_index (info, var);
1091 ipa_note_param_call (node, index, call, false);
1095 /* Now we need to try to match the complex pattern of calling a member
1098 if (!POINTER_TYPE_P (TREE_TYPE (target))
1099 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1102 def = SSA_NAME_DEF_STMT (target);
1103 if (gimple_code (def) != GIMPLE_PHI)
1106 if (gimple_phi_num_args (def) != 2)
1109 /* First, we need to check whether one of these is a load from a member
1110 pointer that is a parameter to this function. */
1111 n1 = PHI_ARG_DEF (def, 0);
1112 n2 = PHI_ARG_DEF (def, 1);
1113 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1115 d1 = SSA_NAME_DEF_STMT (n1);
1116 d2 = SSA_NAME_DEF_STMT (n2);
1118 join = gimple_bb (def);
1119 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1121 if (ipa_get_stmt_member_ptr_load_param (d2, false))
1124 bb = EDGE_PRED (join, 0)->src;
1125 virt_bb = gimple_bb (d2);
1127 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1129 bb = EDGE_PRED (join, 1)->src;
1130 virt_bb = gimple_bb (d1);
1135 /* Second, we need to check that the basic blocks are laid out in the way
1136 corresponding to the pattern. */
1138 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1139 || single_pred (virt_bb) != bb
1140 || single_succ (virt_bb) != join)
1143 /* Third, let's see that the branching is done depending on the least
1144 significant bit of the pfn. */
1146 branch = last_stmt (bb);
1147 if (!branch || gimple_code (branch) != GIMPLE_COND)
1150 if (gimple_cond_code (branch) != NE_EXPR
1151 || !integer_zerop (gimple_cond_rhs (branch)))
1154 cond = gimple_cond_lhs (branch);
1155 if (!ipa_is_ssa_with_stmt_def (cond))
1158 def = SSA_NAME_DEF_STMT (cond);
1159 if (!is_gimple_assign (def)
1160 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1161 || !integer_onep (gimple_assign_rhs2 (def)))
1164 cond = gimple_assign_rhs1 (def);
1165 if (!ipa_is_ssa_with_stmt_def (cond))
1168 def = SSA_NAME_DEF_STMT (cond);
1170 if (is_gimple_assign (def)
1171 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1173 cond = gimple_assign_rhs1 (def);
1174 if (!ipa_is_ssa_with_stmt_def (cond))
1176 def = SSA_NAME_DEF_STMT (cond);
1179 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1180 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1181 == ptrmemfunc_vbit_in_delta));
1186 index = ipa_get_param_decl_index (info, rec);
1187 if (index >= 0 && !is_parm_modified_before_call (&parms_info[index],
1189 ipa_note_param_call (node, index, call, false);
1194 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1195 object referenced in the expression is a formal parameter of the caller
1196 (described by INFO), create a call note for the statement. */
1199 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1200 struct ipa_node_params *info, gimple call,
1203 tree obj = OBJ_TYPE_REF_OBJECT (target);
1207 if (TREE_CODE (obj) == ADDR_EXPR)
1211 obj = TREE_OPERAND (obj, 0);
1213 while (TREE_CODE (obj) == COMPONENT_REF);
1214 if (TREE_CODE (obj) != MEM_REF)
1216 obj = TREE_OPERAND (obj, 0);
1219 if (TREE_CODE (obj) != SSA_NAME
1220 || !SSA_NAME_IS_DEFAULT_DEF (obj))
1223 var = SSA_NAME_VAR (obj);
1224 index = ipa_get_param_decl_index (info, var);
1227 ipa_note_param_call (node, index, call, true);
1230 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1231 of the caller (described by INFO). PARMS_INFO is a pointer to a vector
1232 containing intermediate information about each formal parameter. */
1235 ipa_analyze_call_uses (struct cgraph_node *node,
1236 struct ipa_node_params *info,
1237 struct param_analysis_info *parms_info, gimple call)
1239 tree target = gimple_call_fn (call);
1241 if (TREE_CODE (target) == SSA_NAME)
1242 ipa_analyze_indirect_call_uses (node, info, parms_info, call, target);
1243 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1244 ipa_analyze_virtual_call_uses (node, info, call, target);
1248 /* Analyze the call statement STMT with respect to formal parameters (described
1249 in INFO) of caller given by NODE. Currently it only checks whether formal
1250 parameters are called. PARMS_INFO is a pointer to a vector containing
1251 intermediate information about each formal parameter. */
1254 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1255 struct param_analysis_info *parms_info, gimple stmt)
1257 if (is_gimple_call (stmt))
1258 ipa_analyze_call_uses (node, info, parms_info, stmt);
1261 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1262 If OP is a parameter declaration, mark it as used in the info structure
1266 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
1267 tree op, void *data)
1269 struct ipa_node_params *info = (struct ipa_node_params *) data;
1271 op = get_base_address (op);
1273 && TREE_CODE (op) == PARM_DECL)
1275 int index = ipa_get_param_decl_index (info, op);
1276 gcc_assert (index >= 0);
1277 info->params[index].used = true;
1283 /* Scan the function body of NODE and inspect the uses of formal parameters.
1284 Store the findings in various structures of the associated ipa_node_params
1285 structure, such as parameter flags, notes etc. PARMS_INFO is a pointer to a
1286 vector containing intermediate information about each formal parameter. */
1289 ipa_analyze_params_uses (struct cgraph_node *node,
1290 struct param_analysis_info *parms_info)
1292 tree decl = node->decl;
1294 struct function *func;
1295 gimple_stmt_iterator gsi;
1296 struct ipa_node_params *info = IPA_NODE_REF (node);
1299 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1302 for (i = 0; i < ipa_get_param_count (info); i++)
1304 tree parm = ipa_get_param (info, i);
1305 /* For SSA regs see if parameter is used. For non-SSA we compute
1306 the flag during modification analysis. */
1307 if (is_gimple_reg (parm)
1308 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
1309 info->params[i].used = true;
1312 func = DECL_STRUCT_FUNCTION (decl);
1313 FOR_EACH_BB_FN (bb, func)
1315 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1317 gimple stmt = gsi_stmt (gsi);
1319 if (is_gimple_debug (stmt))
1322 ipa_analyze_stmt_uses (node, info, parms_info, stmt);
1323 walk_stmt_load_store_addr_ops (stmt, info,
1324 visit_ref_for_mod_analysis,
1325 visit_ref_for_mod_analysis,
1326 visit_ref_for_mod_analysis);
1328 for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
1329 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
1330 visit_ref_for_mod_analysis,
1331 visit_ref_for_mod_analysis,
1332 visit_ref_for_mod_analysis);
1335 info->uses_analysis_done = 1;
1338 /* Initialize the array describing properties of of formal parameters of NODE,
1339 analyze their uses and and compute jump functions associated witu actual
1340 arguments of calls from within NODE. */
1343 ipa_analyze_node (struct cgraph_node *node)
1345 struct ipa_node_params *info = IPA_NODE_REF (node);
1346 struct param_analysis_info *parms_info;
1349 ipa_initialize_node_params (node);
1351 param_count = ipa_get_param_count (info);
1352 parms_info = XALLOCAVEC (struct param_analysis_info, param_count);
1353 memset (parms_info, 0, sizeof (struct param_analysis_info) * param_count);
1355 ipa_analyze_params_uses (node, parms_info);
1356 ipa_compute_jump_functions (node, parms_info);
1358 for (i = 0; i < param_count; i++)
1359 if (parms_info[i].visited_statements)
1360 BITMAP_FREE (parms_info[i].visited_statements);
1364 /* Update the jump function DST when the call graph edge correspondng to SRC is
1365 is being inlined, knowing that DST is of type ancestor and src of known
1369 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1370 struct ipa_jump_func *dst)
1374 new_binfo = get_binfo_at_offset (src->value.base_binfo,
1375 dst->value.ancestor.offset,
1376 dst->value.ancestor.type);
1379 dst->type = IPA_JF_KNOWN_TYPE;
1380 dst->value.base_binfo = new_binfo;
1383 dst->type = IPA_JF_UNKNOWN;
1386 /* Update the jump functions associated with call graph edge E when the call
1387 graph edge CS is being inlined, assuming that E->caller is already (possibly
1388 indirectly) inlined into CS->callee and that E has not been inlined. */
1391 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1392 struct cgraph_edge *e)
1394 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1395 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1396 int count = ipa_get_cs_argument_count (args);
1399 for (i = 0; i < count; i++)
1401 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1403 if (dst->type == IPA_JF_ANCESTOR)
1405 struct ipa_jump_func *src;
1407 /* Variable number of arguments can cause havoc if we try to access
1408 one that does not exist in the inlined edge. So make sure we
1410 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1412 dst->type = IPA_JF_UNKNOWN;
1416 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1417 if (src->type == IPA_JF_KNOWN_TYPE)
1418 combine_known_type_and_ancestor_jfs (src, dst);
1419 else if (src->type == IPA_JF_CONST)
1421 struct ipa_jump_func kt_func;
1423 kt_func.type = IPA_JF_UNKNOWN;
1424 compute_known_type_jump_func (src->value.constant, &kt_func);
1425 if (kt_func.type == IPA_JF_KNOWN_TYPE)
1426 combine_known_type_and_ancestor_jfs (&kt_func, dst);
1428 dst->type = IPA_JF_UNKNOWN;
1430 else if (src->type == IPA_JF_PASS_THROUGH
1431 && src->value.pass_through.operation == NOP_EXPR)
1432 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1433 else if (src->type == IPA_JF_ANCESTOR)
1435 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1436 dst->value.ancestor.offset += src->value.ancestor.offset;
1439 dst->type = IPA_JF_UNKNOWN;
1441 else if (dst->type == IPA_JF_PASS_THROUGH)
1443 struct ipa_jump_func *src;
1444 /* We must check range due to calls with variable number of arguments
1445 and we cannot combine jump functions with operations. */
1446 if (dst->value.pass_through.operation == NOP_EXPR
1447 && (dst->value.pass_through.formal_id
1448 < ipa_get_cs_argument_count (top)))
1450 src = ipa_get_ith_jump_func (top,
1451 dst->value.pass_through.formal_id);
1455 dst->type = IPA_JF_UNKNOWN;
1460 /* If TARGET is an addr_expr of a function declaration, make it the destination
1461 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1463 struct cgraph_edge *
1464 ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
1466 struct cgraph_node *callee;
1468 if (TREE_CODE (target) != ADDR_EXPR)
1470 target = TREE_OPERAND (target, 0);
1471 if (TREE_CODE (target) != FUNCTION_DECL)
1473 callee = cgraph_node (target);
1476 ipa_check_create_node_params ();
1477 cgraph_make_edge_direct (ie, callee);
1480 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1481 "(%s/%i -> %s/%i) for stmt ",
1482 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1483 cgraph_node_name (ie->caller), ie->caller->uid,
1484 cgraph_node_name (ie->callee), ie->callee->uid);
1487 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1489 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1492 if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie))
1493 != ipa_get_param_count (IPA_NODE_REF (callee)))
1494 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee));
1499 /* Try to find a destination for indirect edge IE that corresponds to a simple
1500 call or a call of a member function pointer and where the destination is a
1501 pointer formal parameter described by jump function JFUNC. If it can be
1502 determined, return the newly direct edge, otherwise return NULL. */
1504 static struct cgraph_edge *
1505 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1506 struct ipa_jump_func *jfunc)
1510 if (jfunc->type == IPA_JF_CONST)
1511 target = jfunc->value.constant;
1512 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1513 target = jfunc->value.member_cst.pfn;
1517 return ipa_make_edge_direct_to_target (ie, target);
1520 /* Try to find a destination for indirect edge IE that corresponds to a
1521 virtuall call based on a formal parameter which is described by jump
1522 function JFUNC and if it can be determined, make it direct and return the
1523 direct edge. Otherwise, return NULL. */
1525 static struct cgraph_edge *
1526 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1527 struct ipa_jump_func *jfunc)
1529 tree binfo, type, target;
1530 HOST_WIDE_INT token;
1532 if (jfunc->type == IPA_JF_KNOWN_TYPE)
1533 binfo = jfunc->value.base_binfo;
1534 else if (jfunc->type == IPA_JF_CONST)
1536 tree cst = jfunc->value.constant;
1537 if (TREE_CODE (cst) == ADDR_EXPR)
1538 binfo = gimple_get_relevant_ref_binfo (TREE_OPERAND (cst, 0),
1549 token = ie->indirect_info->otr_token;
1550 type = ie->indirect_info->otr_type;
1551 binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
1553 target = gimple_fold_obj_type_ref_known_binfo (token, binfo);
1558 return ipa_make_edge_direct_to_target (ie, target);
1563 /* Update the param called notes associated with NODE when CS is being inlined,
1564 assuming NODE is (potentially indirectly) inlined into CS->callee.
1565 Moreover, if the callee is discovered to be constant, create a new cgraph
1566 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1567 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1570 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1571 struct cgraph_node *node,
1572 VEC (cgraph_edge_p, heap) **new_edges)
1574 struct ipa_edge_args *top;
1575 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1578 ipa_check_create_edge_args ();
1579 top = IPA_EDGE_REF (cs);
1581 for (ie = node->indirect_calls; ie; ie = next_ie)
1583 struct cgraph_indirect_call_info *ici = ie->indirect_info;
1584 struct ipa_jump_func *jfunc;
1586 next_ie = ie->next_callee;
1587 if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
1590 /* If we ever use indirect edges for anything other than indirect
1591 inlining, we will need to skip those with negative param_indices. */
1592 if (ici->param_index == -1)
1595 /* We must check range due to calls with variable number of arguments: */
1596 if (ici->param_index >= ipa_get_cs_argument_count (top))
1598 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1602 jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1603 if (jfunc->type == IPA_JF_PASS_THROUGH
1604 && jfunc->value.pass_through.operation == NOP_EXPR)
1605 ici->param_index = jfunc->value.pass_through.formal_id;
1606 else if (jfunc->type == IPA_JF_ANCESTOR)
1608 ici->param_index = jfunc->value.ancestor.formal_id;
1609 ici->anc_offset += jfunc->value.ancestor.offset;
1612 /* Either we can find a destination for this edge now or never. */
1613 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1615 if (ici->polymorphic)
1616 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1618 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1620 if (new_direct_edge)
1622 new_direct_edge->indirect_inlining_edge = 1;
1625 VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1627 top = IPA_EDGE_REF (cs);
1636 /* Recursively traverse subtree of NODE (including node) made of inlined
1637 cgraph_edges when CS has been inlined and invoke
1638 update_indirect_edges_after_inlining on all nodes and
1639 update_jump_functions_after_inlining on all non-inlined edges that lead out
1640 of this subtree. Newly discovered indirect edges will be added to
1641 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1645 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1646 struct cgraph_node *node,
1647 VEC (cgraph_edge_p, heap) **new_edges)
1649 struct cgraph_edge *e;
1652 res = update_indirect_edges_after_inlining (cs, node, new_edges);
1654 for (e = node->callees; e; e = e->next_callee)
1655 if (!e->inline_failed)
1656 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1658 update_jump_functions_after_inlining (cs, e);
1663 /* Update jump functions and call note functions on inlining the call site CS.
1664 CS is expected to lead to a node already cloned by
1665 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1666 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1670 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1671 VEC (cgraph_edge_p, heap) **new_edges)
1673 /* FIXME lto: We do not stream out indirect call information. */
1677 /* Do nothing if the preparation phase has not been carried out yet
1678 (i.e. during early inlining). */
1679 if (!ipa_node_params_vector)
1681 gcc_assert (ipa_edge_args_vector);
1683 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1686 /* Frees all dynamically allocated structures that the argument info points
1690 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1692 if (args->jump_functions)
1693 ggc_free (args->jump_functions);
1695 memset (args, 0, sizeof (*args));
1698 /* Free all ipa_edge structures. */
1701 ipa_free_all_edge_args (void)
1704 struct ipa_edge_args *args;
1706 FOR_EACH_VEC_ELT (ipa_edge_args_t, ipa_edge_args_vector, i, args)
1707 ipa_free_edge_args_substructures (args);
1709 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1710 ipa_edge_args_vector = NULL;
1713 /* Frees all dynamically allocated structures that the param info points
1717 ipa_free_node_params_substructures (struct ipa_node_params *info)
1720 free (info->params);
1722 memset (info, 0, sizeof (*info));
1725 /* Free all ipa_node_params structures. */
1728 ipa_free_all_node_params (void)
1731 struct ipa_node_params *info;
1733 FOR_EACH_VEC_ELT (ipa_node_params_t, ipa_node_params_vector, i, info)
1734 ipa_free_node_params_substructures (info);
1736 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1737 ipa_node_params_vector = NULL;
1740 /* Hook that is called by cgraph.c when an edge is removed. */
1743 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1745 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1746 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1747 <= (unsigned)cs->uid)
1749 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1752 /* Hook that is called by cgraph.c when a node is removed. */
1755 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1757 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1758 if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1759 <= (unsigned)node->uid)
1761 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1764 /* Helper function to duplicate an array of size N that is at SRC and store a
1765 pointer to it to DST. Nothing is done if SRC is NULL. */
1768 duplicate_array (void *src, size_t n)
1780 static struct ipa_jump_func *
1781 duplicate_ipa_jump_func_array (const struct ipa_jump_func * src, size_t n)
1783 struct ipa_jump_func *p;
1788 p = ggc_alloc_vec_ipa_jump_func (n);
1789 memcpy (p, src, n * sizeof (struct ipa_jump_func));
1793 /* Hook that is called by cgraph.c when a node is duplicated. */
1796 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1797 __attribute__((unused)) void *data)
1799 struct ipa_edge_args *old_args, *new_args;
1802 ipa_check_create_edge_args ();
1804 old_args = IPA_EDGE_REF (src);
1805 new_args = IPA_EDGE_REF (dst);
1807 arg_count = ipa_get_cs_argument_count (old_args);
1808 ipa_set_cs_argument_count (new_args, arg_count);
1809 new_args->jump_functions =
1810 duplicate_ipa_jump_func_array (old_args->jump_functions, arg_count);
1812 if (iinlining_processed_edges
1813 && bitmap_bit_p (iinlining_processed_edges, src->uid))
1814 bitmap_set_bit (iinlining_processed_edges, dst->uid);
1817 /* Hook that is called by cgraph.c when a node is duplicated. */
1820 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1821 __attribute__((unused)) void *data)
1823 struct ipa_node_params *old_info, *new_info;
1826 ipa_check_create_node_params ();
1827 old_info = IPA_NODE_REF (src);
1828 new_info = IPA_NODE_REF (dst);
1829 param_count = ipa_get_param_count (old_info);
1831 ipa_set_param_count (new_info, param_count);
1832 new_info->params = (struct ipa_param_descriptor *)
1833 duplicate_array (old_info->params,
1834 sizeof (struct ipa_param_descriptor) * param_count);
1835 for (i = 0; i < param_count; i++)
1836 new_info->params[i].types = VEC_copy (tree, heap,
1837 old_info->params[i].types);
1838 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1839 new_info->count_scale = old_info->count_scale;
1841 new_info->called_with_var_arguments = old_info->called_with_var_arguments;
1842 new_info->uses_analysis_done = old_info->uses_analysis_done;
1843 new_info->node_enqueued = old_info->node_enqueued;
1846 /* Register our cgraph hooks if they are not already there. */
1849 ipa_register_cgraph_hooks (void)
1851 if (!edge_removal_hook_holder)
1852 edge_removal_hook_holder =
1853 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1854 if (!node_removal_hook_holder)
1855 node_removal_hook_holder =
1856 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1857 if (!edge_duplication_hook_holder)
1858 edge_duplication_hook_holder =
1859 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1860 if (!node_duplication_hook_holder)
1861 node_duplication_hook_holder =
1862 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1865 /* Unregister our cgraph hooks if they are not already there. */
1868 ipa_unregister_cgraph_hooks (void)
1870 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1871 edge_removal_hook_holder = NULL;
1872 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1873 node_removal_hook_holder = NULL;
1874 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1875 edge_duplication_hook_holder = NULL;
1876 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1877 node_duplication_hook_holder = NULL;
1880 /* Allocate all necessary data strucutures necessary for indirect inlining. */
1883 ipa_create_all_structures_for_iinln (void)
1885 iinlining_processed_edges = BITMAP_ALLOC (NULL);
1888 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1889 longer needed after ipa-cp. */
1892 ipa_free_all_structures_after_ipa_cp (void)
1894 if (!flag_indirect_inlining)
1896 ipa_free_all_edge_args ();
1897 ipa_free_all_node_params ();
1898 ipa_unregister_cgraph_hooks ();
1902 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1903 longer needed after indirect inlining. */
1906 ipa_free_all_structures_after_iinln (void)
1908 BITMAP_FREE (iinlining_processed_edges);
1910 ipa_free_all_edge_args ();
1911 ipa_free_all_node_params ();
1912 ipa_unregister_cgraph_hooks ();
1915 /* Print ipa_tree_map data structures of all functions in the
1919 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1923 struct ipa_node_params *info;
1925 if (!node->analyzed)
1927 info = IPA_NODE_REF (node);
1928 fprintf (f, " function %s parameter descriptors:\n",
1929 cgraph_node_name (node));
1930 count = ipa_get_param_count (info);
1931 for (i = 0; i < count; i++)
1933 temp = ipa_get_param (info, i);
1934 if (TREE_CODE (temp) == PARM_DECL)
1935 fprintf (f, " param %d : %s", i,
1937 ? (*lang_hooks.decl_printable_name) (temp, 2)
1939 if (ipa_is_param_used (info, i))
1940 fprintf (f, " used");
1945 /* Print ipa_tree_map data structures of all functions in the
1949 ipa_print_all_params (FILE * f)
1951 struct cgraph_node *node;
1953 fprintf (f, "\nFunction parameters:\n");
1954 for (node = cgraph_nodes; node; node = node->next)
1955 ipa_print_node_params (f, node);
1958 /* Return a heap allocated vector containing formal parameters of FNDECL. */
1961 ipa_get_vector_of_formal_parms (tree fndecl)
1963 VEC(tree, heap) *args;
1967 count = count_formal_params_1 (fndecl);
1968 args = VEC_alloc (tree, heap, count);
1969 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
1970 VEC_quick_push (tree, args, parm);
1975 /* Return a heap allocated vector containing types of formal parameters of
1976 function type FNTYPE. */
1978 static inline VEC(tree, heap) *
1979 get_vector_of_formal_parm_types (tree fntype)
1981 VEC(tree, heap) *types;
1985 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1988 types = VEC_alloc (tree, heap, count);
1989 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1990 VEC_quick_push (tree, types, TREE_VALUE (t));
1995 /* Modify the function declaration FNDECL and its type according to the plan in
1996 ADJUSTMENTS. It also sets base fields of individual adjustments structures
1997 to reflect the actual parameters being modified which are determined by the
1998 base_index field. */
2001 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
2002 const char *synth_parm_prefix)
2004 VEC(tree, heap) *oparms, *otypes;
2005 tree orig_type, new_type = NULL;
2006 tree old_arg_types, t, new_arg_types = NULL;
2007 tree parm, *link = &DECL_ARGUMENTS (fndecl);
2008 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2009 tree new_reversed = NULL;
2010 bool care_for_types, last_parm_void;
2012 if (!synth_parm_prefix)
2013 synth_parm_prefix = "SYNTH";
2015 oparms = ipa_get_vector_of_formal_parms (fndecl);
2016 orig_type = TREE_TYPE (fndecl);
2017 old_arg_types = TYPE_ARG_TYPES (orig_type);
2019 /* The following test is an ugly hack, some functions simply don't have any
2020 arguments in their type. This is probably a bug but well... */
2021 care_for_types = (old_arg_types != NULL_TREE);
2024 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
2026 otypes = get_vector_of_formal_parm_types (orig_type);
2028 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
2030 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
2034 last_parm_void = false;
2038 for (i = 0; i < len; i++)
2040 struct ipa_parm_adjustment *adj;
2043 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2044 parm = VEC_index (tree, oparms, adj->base_index);
2047 if (adj->copy_param)
2050 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
2054 link = &DECL_CHAIN (parm);
2056 else if (!adj->remove_param)
2062 ptype = build_pointer_type (adj->type);
2067 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
2069 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
2071 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
2073 DECL_ARTIFICIAL (new_parm) = 1;
2074 DECL_ARG_TYPE (new_parm) = ptype;
2075 DECL_CONTEXT (new_parm) = fndecl;
2076 TREE_USED (new_parm) = 1;
2077 DECL_IGNORED_P (new_parm) = 1;
2078 layout_decl (new_parm, 0);
2080 add_referenced_var (new_parm);
2081 mark_sym_for_renaming (new_parm);
2083 adj->reduction = new_parm;
2087 link = &DECL_CHAIN (new_parm);
2095 new_reversed = nreverse (new_arg_types);
2099 TREE_CHAIN (new_arg_types) = void_list_node;
2101 new_reversed = void_list_node;
2105 /* Use copy_node to preserve as much as possible from original type
2106 (debug info, attribute lists etc.)
2107 Exception is METHOD_TYPEs must have THIS argument.
2108 When we are asked to remove it, we need to build new FUNCTION_TYPE
2110 if (TREE_CODE (orig_type) != METHOD_TYPE
2111 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
2112 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
2114 new_type = build_distinct_type_copy (orig_type);
2115 TYPE_ARG_TYPES (new_type) = new_reversed;
2120 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
2122 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
2123 DECL_VINDEX (fndecl) = NULL_TREE;
2126 /* When signature changes, we need to clear builtin info. */
2127 if (DECL_BUILT_IN (fndecl))
2129 DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
2130 DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
2133 /* This is a new type, not a copy of an old type. Need to reassociate
2134 variants. We can handle everything except the main variant lazily. */
2135 t = TYPE_MAIN_VARIANT (orig_type);
2138 TYPE_MAIN_VARIANT (new_type) = t;
2139 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
2140 TYPE_NEXT_VARIANT (t) = new_type;
2144 TYPE_MAIN_VARIANT (new_type) = new_type;
2145 TYPE_NEXT_VARIANT (new_type) = NULL;
2148 TREE_TYPE (fndecl) = new_type;
2149 DECL_VIRTUAL_P (fndecl) = 0;
2151 VEC_free (tree, heap, otypes);
2152 VEC_free (tree, heap, oparms);
2155 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2156 If this is a directly recursive call, CS must be NULL. Otherwise it must
2157 contain the corresponding call graph edge. */
2160 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2161 ipa_parm_adjustment_vec adjustments)
2163 VEC(tree, heap) *vargs;
2165 gimple_stmt_iterator gsi;
2169 len = VEC_length (ipa_parm_adjustment_t, adjustments);
2170 vargs = VEC_alloc (tree, heap, len);
2172 gsi = gsi_for_stmt (stmt);
2173 for (i = 0; i < len; i++)
2175 struct ipa_parm_adjustment *adj;
2177 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2179 if (adj->copy_param)
2181 tree arg = gimple_call_arg (stmt, adj->base_index);
2183 VEC_quick_push (tree, vargs, arg);
2185 else if (!adj->remove_param)
2187 tree expr, base, off;
2190 /* We create a new parameter out of the value of the old one, we can
2191 do the following kind of transformations:
2193 - A scalar passed by reference is converted to a scalar passed by
2194 value. (adj->by_ref is false and the type of the original
2195 actual argument is a pointer to a scalar).
2197 - A part of an aggregate is passed instead of the whole aggregate.
2198 The part can be passed either by value or by reference, this is
2199 determined by value of adj->by_ref. Moreover, the code below
2200 handles both situations when the original aggregate is passed by
2201 value (its type is not a pointer) and when it is passed by
2202 reference (it is a pointer to an aggregate).
2204 When the new argument is passed by reference (adj->by_ref is true)
2205 it must be a part of an aggregate and therefore we form it by
2206 simply taking the address of a reference inside the original
2209 gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0);
2210 base = gimple_call_arg (stmt, adj->base_index);
2211 loc = EXPR_LOCATION (base);
2213 if (TREE_CODE (base) != ADDR_EXPR
2214 && POINTER_TYPE_P (TREE_TYPE (base)))
2215 off = build_int_cst (adj->alias_ptr_type,
2216 adj->offset / BITS_PER_UNIT);
2219 HOST_WIDE_INT base_offset;
2222 if (TREE_CODE (base) == ADDR_EXPR)
2223 base = TREE_OPERAND (base, 0);
2225 base = get_addr_base_and_unit_offset (base, &base_offset);
2226 /* Aggregate arguments can have non-invariant addresses. */
2229 base = build_fold_addr_expr (prev_base);
2230 off = build_int_cst (adj->alias_ptr_type,
2231 adj->offset / BITS_PER_UNIT);
2233 else if (TREE_CODE (base) == MEM_REF)
2235 off = build_int_cst (adj->alias_ptr_type,
2237 + adj->offset / BITS_PER_UNIT);
2238 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1),
2240 base = TREE_OPERAND (base, 0);
2244 off = build_int_cst (adj->alias_ptr_type,
2246 + adj->offset / BITS_PER_UNIT);
2247 base = build_fold_addr_expr (base);
2251 expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off);
2253 expr = build_fold_addr_expr (expr);
2255 expr = force_gimple_operand_gsi (&gsi, expr,
2257 || is_gimple_reg_type (adj->type),
2258 NULL, true, GSI_SAME_STMT);
2259 VEC_quick_push (tree, vargs, expr);
2263 if (dump_file && (dump_flags & TDF_DETAILS))
2265 fprintf (dump_file, "replacing stmt:");
2266 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2269 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2270 new_stmt = gimple_build_call_vec (callee_decl, vargs);
2271 VEC_free (tree, heap, vargs);
2272 if (gimple_call_lhs (stmt))
2273 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2275 gimple_set_block (new_stmt, gimple_block (stmt));
2276 if (gimple_has_location (stmt))
2277 gimple_set_location (new_stmt, gimple_location (stmt));
2278 gimple_call_copy_flags (new_stmt, stmt);
2279 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2281 if (dump_file && (dump_flags & TDF_DETAILS))
2283 fprintf (dump_file, "with stmt:");
2284 print_gimple_stmt (dump_file, new_stmt, 0, 0);
2285 fprintf (dump_file, "\n");
2287 gsi_replace (&gsi, new_stmt, true);
2289 cgraph_set_call_stmt (cs, new_stmt);
2290 update_ssa (TODO_update_ssa);
2291 free_dominance_info (CDI_DOMINATORS);
2294 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2297 index_in_adjustments_multiple_times_p (int base_index,
2298 ipa_parm_adjustment_vec adjustments)
2300 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2303 for (i = 0; i < len; i++)
2305 struct ipa_parm_adjustment *adj;
2306 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2308 if (adj->base_index == base_index)
2320 /* Return adjustments that should have the same effect on function parameters
2321 and call arguments as if they were first changed according to adjustments in
2322 INNER and then by adjustments in OUTER. */
2324 ipa_parm_adjustment_vec
2325 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2326 ipa_parm_adjustment_vec outer)
2328 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2329 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2331 ipa_parm_adjustment_vec adjustments, tmp;
2333 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2334 for (i = 0; i < inlen; i++)
2336 struct ipa_parm_adjustment *n;
2337 n = VEC_index (ipa_parm_adjustment_t, inner, i);
2339 if (n->remove_param)
2342 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2345 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2346 for (i = 0; i < outlen; i++)
2348 struct ipa_parm_adjustment *r;
2349 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2351 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2354 gcc_assert (!in->remove_param);
2355 if (out->remove_param)
2357 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2359 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2360 memset (r, 0, sizeof (*r));
2361 r->remove_param = true;
2366 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2367 memset (r, 0, sizeof (*r));
2368 r->base_index = in->base_index;
2369 r->type = out->type;
2371 /* FIXME: Create nonlocal value too. */
2373 if (in->copy_param && out->copy_param)
2374 r->copy_param = true;
2375 else if (in->copy_param)
2376 r->offset = out->offset;
2377 else if (out->copy_param)
2378 r->offset = in->offset;
2380 r->offset = in->offset + out->offset;
2383 for (i = 0; i < inlen; i++)
2385 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2388 if (n->remove_param)
2389 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2392 VEC_free (ipa_parm_adjustment_t, heap, tmp);
2396 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2397 friendly way, assuming they are meant to be applied to FNDECL. */
2400 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2403 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2405 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2407 fprintf (file, "IPA param adjustments: ");
2408 for (i = 0; i < len; i++)
2410 struct ipa_parm_adjustment *adj;
2411 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2414 fprintf (file, " ");
2418 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2419 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2422 fprintf (file, ", base: ");
2423 print_generic_expr (file, adj->base, 0);
2427 fprintf (file, ", reduction: ");
2428 print_generic_expr (file, adj->reduction, 0);
2430 if (adj->new_ssa_base)
2432 fprintf (file, ", new_ssa_base: ");
2433 print_generic_expr (file, adj->new_ssa_base, 0);
2436 if (adj->copy_param)
2437 fprintf (file, ", copy_param");
2438 else if (adj->remove_param)
2439 fprintf (file, ", remove_param");
2441 fprintf (file, ", offset %li", (long) adj->offset);
2443 fprintf (file, ", by_ref");
2444 print_node_brief (file, ", type: ", adj->type, 0);
2445 fprintf (file, "\n");
2447 VEC_free (tree, heap, parms);
2450 /* Stream out jump function JUMP_FUNC to OB. */
2453 ipa_write_jump_function (struct output_block *ob,
2454 struct ipa_jump_func *jump_func)
2456 lto_output_uleb128_stream (ob->main_stream,
2459 switch (jump_func->type)
2461 case IPA_JF_UNKNOWN:
2463 case IPA_JF_KNOWN_TYPE:
2464 lto_output_tree (ob, jump_func->value.base_binfo, true);
2467 lto_output_tree (ob, jump_func->value.constant, true);
2469 case IPA_JF_PASS_THROUGH:
2470 lto_output_tree (ob, jump_func->value.pass_through.operand, true);
2471 lto_output_uleb128_stream (ob->main_stream,
2472 jump_func->value.pass_through.formal_id);
2473 lto_output_uleb128_stream (ob->main_stream,
2474 jump_func->value.pass_through.operation);
2476 case IPA_JF_ANCESTOR:
2477 lto_output_uleb128_stream (ob->main_stream,
2478 jump_func->value.ancestor.offset);
2479 lto_output_tree (ob, jump_func->value.ancestor.type, true);
2480 lto_output_uleb128_stream (ob->main_stream,
2481 jump_func->value.ancestor.formal_id);
2483 case IPA_JF_CONST_MEMBER_PTR:
2484 lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
2485 lto_output_tree (ob, jump_func->value.member_cst.delta, false);
2490 /* Read in jump function JUMP_FUNC from IB. */
2493 ipa_read_jump_function (struct lto_input_block *ib,
2494 struct ipa_jump_func *jump_func,
2495 struct data_in *data_in)
2497 jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
2499 switch (jump_func->type)
2501 case IPA_JF_UNKNOWN:
2503 case IPA_JF_KNOWN_TYPE:
2504 jump_func->value.base_binfo = lto_input_tree (ib, data_in);
2507 jump_func->value.constant = lto_input_tree (ib, data_in);
2509 case IPA_JF_PASS_THROUGH:
2510 jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
2511 jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
2512 jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
2514 case IPA_JF_ANCESTOR:
2515 jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
2516 jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
2517 jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
2519 case IPA_JF_CONST_MEMBER_PTR:
2520 jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
2521 jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
2526 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2527 relevant to indirect inlining to OB. */
2530 ipa_write_indirect_edge_info (struct output_block *ob,
2531 struct cgraph_edge *cs)
2533 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2534 struct bitpack_d bp;
2536 lto_output_sleb128_stream (ob->main_stream, ii->param_index);
2537 lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
2538 bp = bitpack_create (ob->main_stream);
2539 bp_pack_value (&bp, ii->polymorphic, 1);
2540 lto_output_bitpack (&bp);
2542 if (ii->polymorphic)
2544 lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
2545 lto_output_tree (ob, ii->otr_type, true);
2549 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2550 relevant to indirect inlining from IB. */
2553 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2554 struct data_in *data_in ATTRIBUTE_UNUSED,
2555 struct cgraph_edge *cs)
2557 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2558 struct bitpack_d bp;
2560 ii->param_index = (int) lto_input_sleb128 (ib);
2561 ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2562 bp = lto_input_bitpack (ib);
2563 ii->polymorphic = bp_unpack_value (&bp, 1);
2564 if (ii->polymorphic)
2566 ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2567 ii->otr_type = lto_input_tree (ib, data_in);
2571 /* Stream out NODE info to OB. */
2574 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2577 lto_cgraph_encoder_t encoder;
2578 struct ipa_node_params *info = IPA_NODE_REF (node);
2580 struct cgraph_edge *e;
2581 struct bitpack_d bp;
2583 encoder = ob->decl_state->cgraph_node_encoder;
2584 node_ref = lto_cgraph_encoder_encode (encoder, node);
2585 lto_output_uleb128_stream (ob->main_stream, node_ref);
2587 bp = bitpack_create (ob->main_stream);
2588 bp_pack_value (&bp, info->called_with_var_arguments, 1);
2589 gcc_assert (info->uses_analysis_done
2590 || ipa_get_param_count (info) == 0);
2591 gcc_assert (!info->node_enqueued);
2592 gcc_assert (!info->ipcp_orig_node);
2593 for (j = 0; j < ipa_get_param_count (info); j++)
2594 bp_pack_value (&bp, info->params[j].used, 1);
2595 lto_output_bitpack (&bp);
2596 for (e = node->callees; e; e = e->next_callee)
2598 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2600 lto_output_uleb128_stream (ob->main_stream,
2601 ipa_get_cs_argument_count (args));
2602 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2603 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2605 for (e = node->indirect_calls; e; e = e->next_callee)
2606 ipa_write_indirect_edge_info (ob, e);
2609 /* Srtream in NODE info from IB. */
2612 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2613 struct data_in *data_in)
2615 struct ipa_node_params *info = IPA_NODE_REF (node);
2617 struct cgraph_edge *e;
2618 struct bitpack_d bp;
2620 ipa_initialize_node_params (node);
2622 bp = lto_input_bitpack (ib);
2623 info->called_with_var_arguments = bp_unpack_value (&bp, 1);
2624 if (ipa_get_param_count (info) != 0)
2625 info->uses_analysis_done = true;
2626 info->node_enqueued = false;
2627 for (k = 0; k < ipa_get_param_count (info); k++)
2628 info->params[k].used = bp_unpack_value (&bp, 1);
2629 for (e = node->callees; e; e = e->next_callee)
2631 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2632 int count = lto_input_uleb128 (ib);
2634 ipa_set_cs_argument_count (args, count);
2638 args->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
2639 (ipa_get_cs_argument_count (args));
2640 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2641 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2643 for (e = node->indirect_calls; e; e = e->next_callee)
2644 ipa_read_indirect_edge_info (ib, data_in, e);
2647 /* Write jump functions for nodes in SET. */
2650 ipa_prop_write_jump_functions (cgraph_node_set set)
2652 struct cgraph_node *node;
2653 struct output_block *ob = create_output_block (LTO_section_jump_functions);
2654 unsigned int count = 0;
2655 cgraph_node_set_iterator csi;
2657 ob->cgraph_node = NULL;
2659 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2661 node = csi_node (csi);
2662 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2666 lto_output_uleb128_stream (ob->main_stream, count);
2668 /* Process all of the functions. */
2669 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2671 node = csi_node (csi);
2672 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2673 ipa_write_node_info (ob, node);
2675 lto_output_1_stream (ob->main_stream, 0);
2676 produce_asm (ob, NULL);
2677 destroy_output_block (ob);
2680 /* Read section in file FILE_DATA of length LEN with data DATA. */
2683 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2686 const struct lto_function_header *header =
2687 (const struct lto_function_header *) data;
2688 const int32_t cfg_offset = sizeof (struct lto_function_header);
2689 const int32_t main_offset = cfg_offset + header->cfg_size;
2690 const int32_t string_offset = main_offset + header->main_size;
2691 struct data_in *data_in;
2692 struct lto_input_block ib_main;
2696 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2700 lto_data_in_create (file_data, (const char *) data + string_offset,
2701 header->string_size, NULL);
2702 count = lto_input_uleb128 (&ib_main);
2704 for (i = 0; i < count; i++)
2707 struct cgraph_node *node;
2708 lto_cgraph_encoder_t encoder;
2710 index = lto_input_uleb128 (&ib_main);
2711 encoder = file_data->cgraph_node_encoder;
2712 node = lto_cgraph_encoder_deref (encoder, index);
2713 gcc_assert (node->analyzed);
2714 ipa_read_node_info (&ib_main, node, data_in);
2716 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2718 lto_data_in_delete (data_in);
2721 /* Read ipcp jump functions. */
2724 ipa_prop_read_jump_functions (void)
2726 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2727 struct lto_file_decl_data *file_data;
2730 ipa_check_create_node_params ();
2731 ipa_check_create_edge_args ();
2732 ipa_register_cgraph_hooks ();
2734 while ((file_data = file_data_vec[j++]))
2737 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2740 ipa_prop_read_section (file_data, data, len);
2744 /* After merging units, we can get mismatch in argument counts.
2745 Also decl merging might've rendered parameter lists obsolette.
2746 Also compute called_with_variable_arg info. */
2749 ipa_update_after_lto_read (void)
2751 struct cgraph_node *node;
2752 struct cgraph_edge *cs;
2754 ipa_check_create_node_params ();
2755 ipa_check_create_edge_args ();
2757 for (node = cgraph_nodes; node; node = node->next)
2759 ipa_initialize_node_params (node);
2761 for (node = cgraph_nodes; node; node = node->next)
2763 for (cs = node->callees; cs; cs = cs->next_callee)
2765 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2766 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2767 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));