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"
36 #include "diagnostic.h"
37 #include "lto-streamer.h"
39 /* Vector where the parameter infos are actually stored. */
40 VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
41 /* Vector where the parameter infos are actually stored. */
42 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
44 /* Holders of ipa cgraph hooks: */
45 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
46 static struct cgraph_node_hook_list *node_removal_hook_holder;
47 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
48 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
50 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
51 it is in one or not. It should almost never be used directly, as opposed to
52 ipa_push_func_to_list. */
55 ipa_push_func_to_list_1 (struct ipa_func_list **wl,
56 struct cgraph_node *node,
57 struct ipa_node_params *info)
59 struct ipa_func_list *temp;
61 info->node_enqueued = 1;
62 temp = XCNEW (struct ipa_func_list);
68 /* Initialize worklist to contain all functions. */
70 struct ipa_func_list *
71 ipa_init_func_list (void)
73 struct cgraph_node *node;
74 struct ipa_func_list * wl;
77 for (node = cgraph_nodes; node; node = node->next)
80 struct ipa_node_params *info = IPA_NODE_REF (node);
81 /* Unreachable nodes should have been eliminated before ipcp and
83 gcc_assert (node->needed || node->reachable);
84 ipa_push_func_to_list_1 (&wl, node, info);
90 /* Remove a function from the worklist WL and return it. */
93 ipa_pop_func_from_list (struct ipa_func_list **wl)
95 struct ipa_node_params *info;
96 struct ipa_func_list *first;
97 struct cgraph_node *node;
104 info = IPA_NODE_REF (node);
105 info->node_enqueued = 0;
109 /* Return index of the formal whose tree is PTREE in function which corresponds
113 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
117 count = ipa_get_param_count (info);
118 for (i = 0; i < count; i++)
119 if (ipa_get_param(info, i) == ptree)
125 /* Populate the param_decl field in parameter descriptors of INFO that
126 corresponds to NODE. */
129 ipa_populate_param_decls (struct cgraph_node *node,
130 struct ipa_node_params *info)
138 fnargs = DECL_ARGUMENTS (fndecl);
140 for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
142 info->params[param_num].decl = parm;
147 /* Return how many formal parameters FNDECL has. */
150 count_formal_params_1 (tree fndecl)
155 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
161 /* Count number of formal parameters in NOTE. Store the result to the
162 appropriate field of INFO. */
165 ipa_count_formal_params (struct cgraph_node *node,
166 struct ipa_node_params *info)
170 param_num = count_formal_params_1 (node->decl);
171 ipa_set_param_count (info, param_num);
174 /* Initialize the ipa_node_params structure associated with NODE by counting
175 the function parameters, creating the descriptors and populating their
179 ipa_initialize_node_params (struct cgraph_node *node)
181 struct ipa_node_params *info = IPA_NODE_REF (node);
185 ipa_count_formal_params (node, info);
186 info->params = XCNEWVEC (struct ipa_param_descriptor,
187 ipa_get_param_count (info));
188 ipa_populate_param_decls (node, info);
192 /* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
193 parameters. If OP is a parameter declaration, mark it as modified in the
194 info structure passed in DATA. */
197 visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
200 struct ipa_node_params *info = (struct ipa_node_params *) data;
202 if (TREE_CODE (op) == PARM_DECL)
204 int index = ipa_get_param_decl_index (info, op);
205 gcc_assert (index >= 0);
206 info->params[index].modified = true;
212 /* Compute which formal parameters of function associated with NODE are locally
213 modified or their address is taken. Note that this does not apply on
214 parameters with SSA names but those can and should be analyzed
218 ipa_detect_param_modifications (struct cgraph_node *node)
220 tree decl = node->decl;
222 struct function *func;
223 gimple_stmt_iterator gsi;
224 struct ipa_node_params *info = IPA_NODE_REF (node);
226 if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
229 func = DECL_STRUCT_FUNCTION (decl);
230 FOR_EACH_BB_FN (bb, func)
231 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
232 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info, NULL,
233 visit_store_addr_for_mod_analysis,
234 visit_store_addr_for_mod_analysis);
236 info->modification_analysis_done = 1;
239 /* Count number of arguments callsite CS has and store it in
240 ipa_edge_args structure corresponding to this callsite. */
243 ipa_count_arguments (struct cgraph_edge *cs)
248 stmt = cs->call_stmt;
249 gcc_assert (is_gimple_call (stmt));
250 arg_num = gimple_call_num_args (stmt);
251 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
252 <= (unsigned) cgraph_edge_max_uid)
253 VEC_safe_grow_cleared (ipa_edge_args_t, gc,
254 ipa_edge_args_vector, cgraph_edge_max_uid + 1);
255 ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
258 /* Print the jump functions of all arguments on all call graph edges going from
262 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
265 struct cgraph_edge *cs;
266 struct ipa_jump_func *jump_func;
267 enum jump_func_type type;
269 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
270 for (cs = node->callees; cs; cs = cs->next_callee)
272 if (!ipa_edge_args_info_available_for_edge_p (cs))
275 fprintf (f, " callsite %s ", cgraph_node_name (node));
276 fprintf (f, "-> %s :: \n", cgraph_node_name (cs->callee));
278 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
279 for (i = 0; i < count; i++)
281 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
282 type = jump_func->type;
284 fprintf (f, " param %d: ", i);
285 if (type == IPA_JF_UNKNOWN)
286 fprintf (f, "UNKNOWN\n");
287 else if (type == IPA_JF_CONST)
289 tree val = jump_func->value.constant;
290 fprintf (f, "CONST: ");
291 print_generic_expr (f, val, 0);
294 else if (type == IPA_JF_CONST_MEMBER_PTR)
296 fprintf (f, "CONST MEMBER PTR: ");
297 print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
299 print_generic_expr (f, jump_func->value.member_cst.delta, 0);
302 else if (type == IPA_JF_PASS_THROUGH)
304 fprintf (f, "PASS THROUGH: ");
305 fprintf (f, "%d, op %s ",
306 jump_func->value.pass_through.formal_id,
308 jump_func->value.pass_through.operation]);
309 if (jump_func->value.pass_through.operation != NOP_EXPR)
310 print_generic_expr (dump_file,
311 jump_func->value.pass_through.operand, 0);
312 fprintf (dump_file, "\n");
314 else if (type == IPA_JF_ANCESTOR)
316 fprintf (f, "ANCESTOR: ");
317 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC"\n",
318 jump_func->value.ancestor.formal_id,
319 jump_func->value.ancestor.offset);
325 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
328 ipa_print_all_jump_functions (FILE *f)
330 struct cgraph_node *node;
332 fprintf (f, "\nJump functions:\n");
333 for (node = cgraph_nodes; node; node = node->next)
335 ipa_print_node_jump_functions (f, node);
339 /* Determine whether passing ssa name NAME constitutes a polynomial
340 pass-through function or getting an address of an acestor and if so, write
341 such a jump function to JFUNC. INFO describes the caller. */
344 compute_complex_pass_through (struct ipa_node_params *info,
345 struct ipa_jump_func *jfunc,
348 HOST_WIDE_INT offset, size, max_size;
351 gimple stmt = SSA_NAME_DEF_STMT (name);
353 if (!is_gimple_assign (stmt))
355 op1 = gimple_assign_rhs1 (stmt);
356 op2 = gimple_assign_rhs2 (stmt);
360 if (TREE_CODE (op1) != SSA_NAME
361 || !SSA_NAME_IS_DEFAULT_DEF (op1)
362 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
363 && !useless_type_conversion_p (TREE_TYPE (name),
365 || !is_gimple_ip_invariant (op2))
368 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
371 jfunc->type = IPA_JF_PASS_THROUGH;
372 jfunc->value.pass_through.formal_id = index;
373 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
374 jfunc->value.pass_through.operand = op2;
379 if (TREE_CODE (op1) != ADDR_EXPR)
381 op1 = TREE_OPERAND (op1, 0);
382 type = TREE_TYPE (op1);
384 op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
385 if (TREE_CODE (op1) != INDIRECT_REF
386 /* If this is a varying address, punt. */
390 op1 = TREE_OPERAND (op1, 0);
391 if (TREE_CODE (op1) != SSA_NAME
392 || !SSA_NAME_IS_DEFAULT_DEF (op1))
395 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
398 jfunc->type = IPA_JF_ANCESTOR;
399 jfunc->value.ancestor.formal_id = index;
400 jfunc->value.ancestor.offset = offset;
401 jfunc->value.ancestor.type = type;
406 /* Determine the jump functions of scalar arguments. Scalar means SSA names
407 and constants of a number of selected types. INFO is the ipa_node_params
408 structure associated with the caller, FUNCTIONS is a pointer to an array of
409 jump function structures associated with CALL which is the call statement
413 compute_scalar_jump_functions (struct ipa_node_params *info,
414 struct ipa_jump_func *functions,
420 for (num = 0; num < gimple_call_num_args (call); num++)
422 arg = gimple_call_arg (call, num);
424 if (is_gimple_ip_invariant (arg))
426 functions[num].type = IPA_JF_CONST;
427 functions[num].value.constant = arg;
429 else if (TREE_CODE (arg) == SSA_NAME)
431 if (SSA_NAME_IS_DEFAULT_DEF (arg))
433 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
437 functions[num].type = IPA_JF_PASS_THROUGH;
438 functions[num].value.pass_through.formal_id = index;
439 functions[num].value.pass_through.operation = NOP_EXPR;
443 compute_complex_pass_through (info, &functions[num], arg);
448 /* Inspect the given TYPE and return true iff it has the same structure (the
449 same number of fields of the same types) as a C++ member pointer. If
450 METHOD_PTR and DELTA are non-NULL, store the trees representing the
451 corresponding fields there. */
454 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
458 if (TREE_CODE (type) != RECORD_TYPE)
461 fld = TYPE_FIELDS (type);
462 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
463 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
469 fld = TREE_CHAIN (fld);
470 if (!fld || INTEGRAL_TYPE_P (fld))
475 if (TREE_CHAIN (fld))
481 /* Go through arguments of the CALL and for every one that looks like a member
482 pointer, check whether it can be safely declared pass-through and if so,
483 mark that to the corresponding item of jump FUNCTIONS. Return true iff
484 there are non-pass-through member pointers within the arguments. INFO
485 describes formal parameters of the caller. */
488 compute_pass_through_member_ptrs (struct ipa_node_params *info,
489 struct ipa_jump_func *functions,
492 bool undecided_members = false;
496 for (num = 0; num < gimple_call_num_args (call); num++)
498 arg = gimple_call_arg (call, num);
500 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
502 if (TREE_CODE (arg) == PARM_DECL)
504 int index = ipa_get_param_decl_index (info, arg);
506 gcc_assert (index >=0);
507 if (!ipa_is_param_modified (info, index))
509 functions[num].type = IPA_JF_PASS_THROUGH;
510 functions[num].value.pass_through.formal_id = index;
511 functions[num].value.pass_through.operation = NOP_EXPR;
514 undecided_members = true;
517 undecided_members = true;
521 return undecided_members;
524 /* Simple function filling in a member pointer constant jump function (with PFN
525 and DELTA as the constant value) into JFUNC. */
528 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
529 tree pfn, tree delta)
531 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
532 jfunc->value.member_cst.pfn = pfn;
533 jfunc->value.member_cst.delta = delta;
536 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
537 return the rhs of its defining statement. */
540 get_ssa_def_if_simple_copy (tree rhs)
542 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
544 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
546 if (gimple_assign_single_p (def_stmt))
547 rhs = gimple_assign_rhs1 (def_stmt);
554 /* Traverse statements from CALL backwards, scanning whether the argument ARG
555 which is a member pointer is filled in with constant values. If it is, fill
556 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
557 fields of the record type of the member pointer. To give an example, we
558 look for a pattern looking like the following:
560 D.2515.__pfn ={v} printStuff;
561 D.2515.__delta ={v} 0;
562 i_1 = doprinting (D.2515); */
565 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
566 tree delta_field, struct ipa_jump_func *jfunc)
568 gimple_stmt_iterator gsi;
569 tree method = NULL_TREE;
570 tree delta = NULL_TREE;
572 gsi = gsi_for_stmt (call);
575 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
577 gimple stmt = gsi_stmt (gsi);
580 if (!gimple_assign_single_p (stmt))
583 lhs = gimple_assign_lhs (stmt);
584 rhs = gimple_assign_rhs1 (stmt);
586 if (TREE_CODE (lhs) != COMPONENT_REF
587 || TREE_OPERAND (lhs, 0) != arg)
590 fld = TREE_OPERAND (lhs, 1);
591 if (!method && fld == method_field)
593 rhs = get_ssa_def_if_simple_copy (rhs);
594 if (TREE_CODE (rhs) == ADDR_EXPR
595 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
596 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
598 method = TREE_OPERAND (rhs, 0);
601 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
609 if (!delta && fld == delta_field)
611 rhs = get_ssa_def_if_simple_copy (rhs);
612 if (TREE_CODE (rhs) == INTEGER_CST)
617 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
629 /* Go through the arguments of the CALL and for every member pointer within
630 tries determine whether it is a constant. If it is, create a corresponding
631 constant jump function in FUNCTIONS which is an array of jump functions
632 associated with the call. */
635 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
639 tree arg, method_field, delta_field;
641 for (num = 0; num < gimple_call_num_args (call); num++)
643 arg = gimple_call_arg (call, num);
645 if (functions[num].type == IPA_JF_UNKNOWN
646 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
648 determine_cst_member_ptr (call, arg, method_field, delta_field,
653 /* Compute jump function for all arguments of callsite CS and insert the
654 information in the jump_functions array in the ipa_edge_args corresponding
658 ipa_compute_jump_functions (struct cgraph_edge *cs)
660 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
661 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
664 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
666 arguments->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
667 ipa_get_cs_argument_count (arguments));
669 call = cs->call_stmt;
670 gcc_assert (is_gimple_call (call));
672 /* We will deal with constants and SSA scalars first: */
673 compute_scalar_jump_functions (info, arguments->jump_functions, call);
675 /* Let's check whether there are any potential member pointers and if so,
676 whether we can determine their functions as pass_through. */
677 if (!compute_pass_through_member_ptrs (info, arguments->jump_functions, call))
680 /* Finally, let's check whether we actually pass a new constant member
682 compute_cst_member_ptr_arguments (arguments->jump_functions, call);
685 /* If RHS looks like a rhs of a statement loading pfn from a member
686 pointer formal parameter, return the parameter, otherwise return
687 NULL. If USE_DELTA, then we look for a use of the delta field
688 rather than the pfn. */
691 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
697 if (TREE_CODE (rhs) != COMPONENT_REF)
700 rec = TREE_OPERAND (rhs, 0);
701 if (TREE_CODE (rec) != PARM_DECL
702 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
705 fld = TREE_OPERAND (rhs, 1);
706 if (use_delta ? (fld == delta_field) : (fld == ptr_field))
712 /* If STMT looks like a statement loading a value from a member pointer formal
713 parameter, this function returns that parameter. */
716 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
720 if (!gimple_assign_single_p (stmt))
723 rhs = gimple_assign_rhs1 (stmt);
724 return ipa_get_member_ptr_load_param (rhs, use_delta);
727 /* Returns true iff T is an SSA_NAME defined by a statement. */
730 ipa_is_ssa_with_stmt_def (tree t)
732 if (TREE_CODE (t) == SSA_NAME
733 && !SSA_NAME_IS_DEFAULT_DEF (t))
739 /* Creates a new note describing a call to a parameter number FORMAL_ID and
740 attaches it to the linked list of INFO. It also sets the called flag of the
741 parameter. STMT is the corresponding call statement. */
744 ipa_note_param_call (struct ipa_node_params *info, int formal_id,
747 struct ipa_param_call_note *note;
748 basic_block bb = gimple_bb (stmt);
750 note = XCNEW (struct ipa_param_call_note);
751 note->formal_id = formal_id;
753 note->lto_stmt_uid = gimple_uid (stmt);
754 note->count = bb->count;
755 note->frequency = compute_call_stmt_bb_frequency (current_function_decl, bb);
756 note->loop_nest = bb->loop_depth;
758 note->next = info->param_calls;
759 info->param_calls = note;
764 /* Analyze the CALL and examine uses of formal parameters of the caller
765 (described by INFO). Currently it checks whether the call calls a pointer
766 that is a formal parameter and if so, the parameter is marked with the
767 called flag and a note describing the call is created. This is very simple
768 for ordinary pointers represented in SSA but not-so-nice when it comes to
769 member pointers. The ugly part of this function does nothing more than
770 tries to match the pattern of such a call. An example of such a pattern is
771 the gimple dump below, the call is on the last line:
774 f$__delta_5 = f.__delta;
775 f$__pfn_24 = f.__pfn;
776 D.2496_3 = (int) f$__pfn_24;
777 D.2497_4 = D.2496_3 & 1;
784 D.2500_7 = (unsigned int) f$__delta_5;
785 D.2501_8 = &S + D.2500_7;
786 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
787 D.2503_10 = *D.2502_9;
788 D.2504_12 = f$__pfn_24 + -1;
789 D.2505_13 = (unsigned int) D.2504_12;
790 D.2506_14 = D.2503_10 + D.2505_13;
791 D.2507_15 = *D.2506_14;
792 iftmp.11_16 = (String:: *) D.2507_15;
795 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
796 D.2500_19 = (unsigned int) f$__delta_5;
797 D.2508_20 = &S + D.2500_19;
798 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
800 Such patterns are results of simple calls to a member pointer:
802 int doprinting (int (MyString::* f)(int) const)
804 MyString S ("somestring");
811 ipa_analyze_call_uses (struct ipa_node_params *info, gimple call)
813 tree target = gimple_call_fn (call);
818 tree rec, rec2, cond;
821 basic_block bb, virt_bb, join;
823 if (TREE_CODE (target) != SSA_NAME)
826 var = SSA_NAME_VAR (target);
827 if (SSA_NAME_IS_DEFAULT_DEF (target))
829 /* assuming TREE_CODE (var) == PARM_DECL */
830 index = ipa_get_param_decl_index (info, var);
832 ipa_note_param_call (info, index, call);
836 /* Now we need to try to match the complex pattern of calling a member
839 if (!POINTER_TYPE_P (TREE_TYPE (target))
840 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
843 def = SSA_NAME_DEF_STMT (target);
844 if (gimple_code (def) != GIMPLE_PHI)
847 if (gimple_phi_num_args (def) != 2)
850 /* First, we need to check whether one of these is a load from a member
851 pointer that is a parameter to this function. */
852 n1 = PHI_ARG_DEF (def, 0);
853 n2 = PHI_ARG_DEF (def, 1);
854 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
856 d1 = SSA_NAME_DEF_STMT (n1);
857 d2 = SSA_NAME_DEF_STMT (n2);
859 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
861 if (ipa_get_stmt_member_ptr_load_param (d2, false))
865 virt_bb = gimple_bb (d2);
867 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
870 virt_bb = gimple_bb (d1);
875 /* Second, we need to check that the basic blocks are laid out in the way
876 corresponding to the pattern. */
878 join = gimple_bb (def);
879 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
880 || single_pred (virt_bb) != bb
881 || single_succ (virt_bb) != join)
884 /* Third, let's see that the branching is done depending on the least
885 significant bit of the pfn. */
887 branch = last_stmt (bb);
888 if (gimple_code (branch) != GIMPLE_COND)
891 if (gimple_cond_code (branch) != NE_EXPR
892 || !integer_zerop (gimple_cond_rhs (branch)))
895 cond = gimple_cond_lhs (branch);
896 if (!ipa_is_ssa_with_stmt_def (cond))
899 def = SSA_NAME_DEF_STMT (cond);
900 if (!is_gimple_assign (def)
901 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
902 || !integer_onep (gimple_assign_rhs2 (def)))
905 cond = gimple_assign_rhs1 (def);
906 if (!ipa_is_ssa_with_stmt_def (cond))
909 def = SSA_NAME_DEF_STMT (cond);
911 if (is_gimple_assign (def)
912 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
914 cond = gimple_assign_rhs1 (def);
915 if (!ipa_is_ssa_with_stmt_def (cond))
917 def = SSA_NAME_DEF_STMT (cond);
920 rec2 = ipa_get_stmt_member_ptr_load_param (def,
921 (TARGET_PTRMEMFUNC_VBIT_LOCATION
922 == ptrmemfunc_vbit_in_delta));
927 index = ipa_get_param_decl_index (info, rec);
928 if (index >= 0 && !ipa_is_param_modified (info, index))
929 ipa_note_param_call (info, index, call);
934 /* Analyze the statement STMT with respect to formal parameters (described in
935 INFO) and their uses. Currently it only checks whether formal parameters
939 ipa_analyze_stmt_uses (struct ipa_node_params *info, gimple stmt)
941 if (is_gimple_call (stmt))
942 ipa_analyze_call_uses (info, stmt);
945 /* Scan the function body of NODE and inspect the uses of formal parameters.
946 Store the findings in various structures of the associated ipa_node_params
947 structure, such as parameter flags, notes etc. */
950 ipa_analyze_params_uses (struct cgraph_node *node)
952 tree decl = node->decl;
954 struct function *func;
955 gimple_stmt_iterator gsi;
956 struct ipa_node_params *info = IPA_NODE_REF (node);
958 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
961 func = DECL_STRUCT_FUNCTION (decl);
962 FOR_EACH_BB_FN (bb, func)
964 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
966 gimple stmt = gsi_stmt (gsi);
967 ipa_analyze_stmt_uses (info, stmt);
971 info->uses_analysis_done = 1;
974 /* Update the jump functions associated with call graph edge E when the call
975 graph edge CS is being inlined, assuming that E->caller is already (possibly
976 indirectly) inlined into CS->callee and that E has not been inlined.
978 We keep pass through functions only if they do not contain any operation.
979 This is sufficient for inlining and greately simplifies things. */
982 update_jump_functions_after_inlining (struct cgraph_edge *cs,
983 struct cgraph_edge *e)
985 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
986 struct ipa_edge_args *args = IPA_EDGE_REF (e);
987 int count = ipa_get_cs_argument_count (args);
990 for (i = 0; i < count; i++)
992 struct ipa_jump_func *src, *dst = ipa_get_ith_jump_func (args, i);
994 if (dst->type == IPA_JF_ANCESTOR)
996 dst->type = IPA_JF_UNKNOWN;
1000 if (dst->type != IPA_JF_PASS_THROUGH)
1003 /* We must check range due to calls with variable number of arguments and
1004 we cannot combine jump functions with operations. */
1005 if (dst->value.pass_through.operation != NOP_EXPR
1006 || (dst->value.pass_through.formal_id
1007 >= ipa_get_cs_argument_count (top)))
1009 dst->type = IPA_JF_UNKNOWN;
1013 src = ipa_get_ith_jump_func (top, dst->value.pass_through.formal_id);
1018 /* Print out a debug message to file F that we have discovered that an indirect
1019 call described by NT is in fact a call of a known constant function described
1020 by JFUNC. NODE is the node where the call is. */
1023 print_edge_addition_message (FILE *f, struct ipa_param_call_note *nt,
1024 struct ipa_jump_func *jfunc,
1025 struct cgraph_node *node)
1027 fprintf (f, "ipa-prop: Discovered an indirect call to a known target (");
1028 if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1030 print_node_brief (f, "", jfunc->value.member_cst.pfn, 0);
1031 print_node_brief (f, ", ", jfunc->value.member_cst.delta, 0);
1034 print_node_brief(f, "", jfunc->value.constant, 0);
1036 fprintf (f, ") in %s: ", cgraph_node_name (node));
1037 print_gimple_stmt (f, nt->stmt, 2, TDF_SLIM);
1040 /* Update the param called notes associated with NODE when CS is being inlined,
1041 assuming NODE is (potentially indirectly) inlined into CS->callee.
1042 Moreover, if the callee is discovered to be constant, create a new cgraph
1043 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1044 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1047 update_call_notes_after_inlining (struct cgraph_edge *cs,
1048 struct cgraph_node *node,
1049 VEC (cgraph_edge_p, heap) **new_edges)
1051 struct ipa_node_params *info = IPA_NODE_REF (node);
1052 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1053 struct ipa_param_call_note *nt;
1056 for (nt = info->param_calls; nt; nt = nt->next)
1058 struct ipa_jump_func *jfunc;
1063 /* We must check range due to calls with variable number of arguments: */
1064 if (nt->formal_id >= ipa_get_cs_argument_count (top))
1066 nt->processed = true;
1070 jfunc = ipa_get_ith_jump_func (top, nt->formal_id);
1071 if (jfunc->type == IPA_JF_PASS_THROUGH
1072 && jfunc->value.pass_through.operation == NOP_EXPR)
1073 nt->formal_id = jfunc->value.pass_through.formal_id;
1074 else if (jfunc->type == IPA_JF_CONST
1075 || jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1077 struct cgraph_node *callee;
1078 struct cgraph_edge *new_indirect_edge;
1081 nt->processed = true;
1082 if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1083 decl = jfunc->value.member_cst.pfn;
1085 decl = jfunc->value.constant;
1087 if (TREE_CODE (decl) != ADDR_EXPR)
1089 decl = TREE_OPERAND (decl, 0);
1091 if (TREE_CODE (decl) != FUNCTION_DECL)
1093 callee = cgraph_node (decl);
1094 if (!callee || !callee->local.inlinable)
1099 print_edge_addition_message (dump_file, nt, jfunc, node);
1101 new_indirect_edge = cgraph_create_edge (node, callee, nt->stmt,
1102 nt->count, nt->frequency,
1104 new_indirect_edge->lto_stmt_uid = nt->lto_stmt_uid;
1105 new_indirect_edge->indirect_call = 1;
1106 ipa_check_create_edge_args ();
1108 VEC_safe_push (cgraph_edge_p, heap, *new_edges, new_indirect_edge);
1109 top = IPA_EDGE_REF (cs);
1113 /* Ancestor jum functions and pass theoughs with operations should
1114 not be used on parameters that then get called. */
1115 gcc_assert (jfunc->type == IPA_JF_UNKNOWN);
1116 nt->processed = true;
1122 /* Recursively traverse subtree of NODE (including node) made of inlined
1123 cgraph_edges when CS has been inlined and invoke
1124 update_call_notes_after_inlining on all nodes and
1125 update_jump_functions_after_inlining on all non-inlined edges that lead out
1126 of this subtree. Newly discovered indirect edges will be added to
1127 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1131 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1132 struct cgraph_node *node,
1133 VEC (cgraph_edge_p, heap) **new_edges)
1135 struct cgraph_edge *e;
1138 res = update_call_notes_after_inlining (cs, node, new_edges);
1140 for (e = node->callees; e; e = e->next_callee)
1141 if (!e->inline_failed)
1142 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1144 update_jump_functions_after_inlining (cs, e);
1149 /* Update jump functions and call note functions on inlining the call site CS.
1150 CS is expected to lead to a node already cloned by
1151 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1152 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1156 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1157 VEC (cgraph_edge_p, heap) **new_edges)
1159 /* FIXME lto: We do not stream out indirect call information. */
1163 /* Do nothing if the preparation phase has not been carried out yet
1164 (i.e. during early inlining). */
1165 if (!ipa_node_params_vector)
1167 gcc_assert (ipa_edge_args_vector);
1169 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1172 /* Frees all dynamically allocated structures that the argument info points
1176 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1178 if (args->jump_functions)
1179 ggc_free (args->jump_functions);
1181 memset (args, 0, sizeof (*args));
1184 /* Free all ipa_edge structures. */
1187 ipa_free_all_edge_args (void)
1190 struct ipa_edge_args *args;
1193 VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
1195 ipa_free_edge_args_substructures (args);
1197 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1198 ipa_edge_args_vector = NULL;
1201 /* Frees all dynamically allocated structures that the param info points
1205 ipa_free_node_params_substructures (struct ipa_node_params *info)
1208 free (info->params);
1210 while (info->param_calls)
1212 struct ipa_param_call_note *note = info->param_calls;
1213 info->param_calls = note->next;
1217 memset (info, 0, sizeof (*info));
1220 /* Free all ipa_node_params structures. */
1223 ipa_free_all_node_params (void)
1226 struct ipa_node_params *info;
1229 VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
1231 ipa_free_node_params_substructures (info);
1233 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1234 ipa_node_params_vector = NULL;
1237 /* Hook that is called by cgraph.c when an edge is removed. */
1240 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1242 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1243 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1244 <= (unsigned)cs->uid)
1246 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1249 /* Hook that is called by cgraph.c when a node is removed. */
1252 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1254 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1257 /* Helper function to duplicate an array of size N that is at SRC and store a
1258 pointer to it to DST. Nothing is done if SRC is NULL. */
1261 duplicate_array (void *src, size_t n)
1273 /* Like duplicate_array byt in GGC memory. */
1276 duplicate_ggc_array (void *src, size_t n)
1288 /* Hook that is called by cgraph.c when a node is duplicated. */
1291 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1292 __attribute__((unused)) void *data)
1294 struct ipa_edge_args *old_args, *new_args;
1297 ipa_check_create_edge_args ();
1299 old_args = IPA_EDGE_REF (src);
1300 new_args = IPA_EDGE_REF (dst);
1302 arg_count = ipa_get_cs_argument_count (old_args);
1303 ipa_set_cs_argument_count (new_args, arg_count);
1304 new_args->jump_functions = (struct ipa_jump_func *)
1305 duplicate_ggc_array (old_args->jump_functions,
1306 sizeof (struct ipa_jump_func) * arg_count);
1309 /* Hook that is called by cgraph.c when a node is duplicated. */
1312 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1313 __attribute__((unused)) void *data)
1315 struct ipa_node_params *old_info, *new_info;
1316 struct ipa_param_call_note *note;
1319 ipa_check_create_node_params ();
1320 old_info = IPA_NODE_REF (src);
1321 new_info = IPA_NODE_REF (dst);
1322 param_count = ipa_get_param_count (old_info);
1324 ipa_set_param_count (new_info, param_count);
1325 new_info->params = (struct ipa_param_descriptor *)
1326 duplicate_array (old_info->params,
1327 sizeof (struct ipa_param_descriptor) * param_count);
1328 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1329 new_info->count_scale = old_info->count_scale;
1331 for (note = old_info->param_calls; note; note = note->next)
1333 struct ipa_param_call_note *nn;
1335 nn = (struct ipa_param_call_note *)
1336 xcalloc (1, sizeof (struct ipa_param_call_note));
1337 memcpy (nn, note, sizeof (struct ipa_param_call_note));
1338 nn->next = new_info->param_calls;
1339 new_info->param_calls = nn;
1343 /* Register our cgraph hooks if they are not already there. */
1346 ipa_register_cgraph_hooks (void)
1348 if (!edge_removal_hook_holder)
1349 edge_removal_hook_holder =
1350 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1351 if (!node_removal_hook_holder)
1352 node_removal_hook_holder =
1353 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1354 if (!edge_duplication_hook_holder)
1355 edge_duplication_hook_holder =
1356 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1357 if (!node_duplication_hook_holder)
1358 node_duplication_hook_holder =
1359 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1362 /* Unregister our cgraph hooks if they are not already there. */
1365 ipa_unregister_cgraph_hooks (void)
1367 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1368 edge_removal_hook_holder = NULL;
1369 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1370 node_removal_hook_holder = NULL;
1371 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1372 edge_duplication_hook_holder = NULL;
1373 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1374 node_duplication_hook_holder = NULL;
1377 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1378 longer needed after ipa-cp. */
1381 free_all_ipa_structures_after_ipa_cp (void)
1383 if (!flag_indirect_inlining)
1385 ipa_free_all_edge_args ();
1386 ipa_free_all_node_params ();
1387 ipa_unregister_cgraph_hooks ();
1391 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1392 longer needed after indirect inlining. */
1395 free_all_ipa_structures_after_iinln (void)
1397 ipa_free_all_edge_args ();
1398 ipa_free_all_node_params ();
1399 ipa_unregister_cgraph_hooks ();
1402 /* Print ipa_tree_map data structures of all functions in the
1406 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1410 struct ipa_node_params *info;
1412 if (!node->analyzed)
1414 info = IPA_NODE_REF (node);
1415 fprintf (f, " function %s Trees :: \n", cgraph_node_name (node));
1416 count = ipa_get_param_count (info);
1417 for (i = 0; i < count; i++)
1419 temp = ipa_get_param (info, i);
1420 if (TREE_CODE (temp) == PARM_DECL)
1421 fprintf (f, " param %d : %s", i,
1423 ? (*lang_hooks.decl_printable_name) (temp, 2)
1425 if (ipa_is_param_modified (info, i))
1426 fprintf (f, " modified");
1431 /* Print ipa_tree_map data structures of all functions in the
1435 ipa_print_all_params (FILE * f)
1437 struct cgraph_node *node;
1439 fprintf (f, "\nFunction parameters:\n");
1440 for (node = cgraph_nodes; node; node = node->next)
1441 ipa_print_node_params (f, node);
1444 /* Return a heap allocated vector containing formal parameters of FNDECL. */
1447 ipa_get_vector_of_formal_parms (tree fndecl)
1449 VEC(tree, heap) *args;
1453 count = count_formal_params_1 (fndecl);
1454 args = VEC_alloc (tree, heap, count);
1455 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
1456 VEC_quick_push (tree, args, parm);
1461 /* Return a heap allocated vector containing types of formal parameters of
1462 function type FNTYPE. */
1464 static inline VEC(tree, heap) *
1465 get_vector_of_formal_parm_types (tree fntype)
1467 VEC(tree, heap) *types;
1471 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1474 types = VEC_alloc (tree, heap, count);
1475 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1476 VEC_quick_push (tree, types, TREE_VALUE (t));
1481 /* Modify the function declaration FNDECL and its type according to the plan in
1482 ADJUSTMENTS. It also sets base fields of individual adjustments structures
1483 to reflect the actual parameters being modified which are determined by the
1484 base_index field. */
1487 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
1488 const char *synth_parm_prefix)
1490 VEC(tree, heap) *oparms, *otypes;
1491 tree orig_type, new_type = NULL;
1492 tree old_arg_types, t, new_arg_types = NULL;
1493 tree parm, *link = &DECL_ARGUMENTS (fndecl);
1494 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
1495 tree new_reversed = NULL;
1496 bool care_for_types, last_parm_void;
1498 if (!synth_parm_prefix)
1499 synth_parm_prefix = "SYNTH";
1501 oparms = ipa_get_vector_of_formal_parms (fndecl);
1502 orig_type = TREE_TYPE (fndecl);
1503 old_arg_types = TYPE_ARG_TYPES (orig_type);
1505 /* The following test is an ugly hack, some functions simply don't have any
1506 arguments in their type. This is probably a bug but well... */
1507 care_for_types = (old_arg_types != NULL_TREE);
1510 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
1512 otypes = get_vector_of_formal_parm_types (orig_type);
1514 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
1516 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
1520 last_parm_void = false;
1524 for (i = 0; i < len; i++)
1526 struct ipa_parm_adjustment *adj;
1529 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
1530 parm = VEC_index (tree, oparms, adj->base_index);
1533 if (adj->copy_param)
1536 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
1540 link = &TREE_CHAIN (parm);
1542 else if (!adj->remove_param)
1548 ptype = build_pointer_type (adj->type);
1553 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
1555 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
1557 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
1559 DECL_ARTIFICIAL (new_parm) = 1;
1560 DECL_ARG_TYPE (new_parm) = ptype;
1561 DECL_CONTEXT (new_parm) = fndecl;
1562 TREE_USED (new_parm) = 1;
1563 DECL_IGNORED_P (new_parm) = 1;
1564 layout_decl (new_parm, 0);
1566 add_referenced_var (new_parm);
1567 mark_sym_for_renaming (new_parm);
1569 adj->reduction = new_parm;
1573 link = &TREE_CHAIN (new_parm);
1581 new_reversed = nreverse (new_arg_types);
1585 TREE_CHAIN (new_arg_types) = void_list_node;
1587 new_reversed = void_list_node;
1591 /* Use copy_node to preserve as much as possible from original type
1592 (debug info, attribute lists etc.)
1593 Exception is METHOD_TYPEs must have THIS argument.
1594 When we are asked to remove it, we need to build new FUNCTION_TYPE
1596 if (TREE_CODE (orig_type) != METHOD_TYPE
1597 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
1598 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
1600 new_type = copy_node (orig_type);
1601 TYPE_ARG_TYPES (new_type) = new_reversed;
1606 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
1608 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
1609 DECL_VINDEX (fndecl) = NULL_TREE;
1612 /* This is a new type, not a copy of an old type. Need to reassociate
1613 variants. We can handle everything except the main variant lazily. */
1614 t = TYPE_MAIN_VARIANT (orig_type);
1617 TYPE_MAIN_VARIANT (new_type) = t;
1618 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
1619 TYPE_NEXT_VARIANT (t) = new_type;
1623 TYPE_MAIN_VARIANT (new_type) = new_type;
1624 TYPE_NEXT_VARIANT (new_type) = NULL;
1627 TREE_TYPE (fndecl) = new_type;
1629 VEC_free (tree, heap, otypes);
1630 VEC_free (tree, heap, oparms);
1633 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
1634 If this is a directly recursive call, CS must be NULL. Otherwise it must
1635 contain the corresponding call graph edge. */
1638 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
1639 ipa_parm_adjustment_vec adjustments)
1641 VEC(tree, heap) *vargs;
1643 gimple_stmt_iterator gsi;
1647 len = VEC_length (ipa_parm_adjustment_t, adjustments);
1648 vargs = VEC_alloc (tree, heap, len);
1650 gsi = gsi_for_stmt (stmt);
1651 for (i = 0; i < len; i++)
1653 struct ipa_parm_adjustment *adj;
1655 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
1657 if (adj->copy_param)
1659 tree arg = gimple_call_arg (stmt, adj->base_index);
1661 VEC_quick_push (tree, vargs, arg);
1663 else if (!adj->remove_param)
1665 tree expr, orig_expr;
1666 bool allow_ptr, repl_found;
1668 orig_expr = expr = gimple_call_arg (stmt, adj->base_index);
1669 if (TREE_CODE (expr) == ADDR_EXPR)
1672 expr = TREE_OPERAND (expr, 0);
1677 repl_found = build_ref_for_offset (&expr, TREE_TYPE (expr),
1678 adj->offset, adj->type,
1683 expr = build_fold_addr_expr (expr);
1687 tree ptrtype = build_pointer_type (adj->type);
1689 if (!POINTER_TYPE_P (TREE_TYPE (expr)))
1690 expr = build_fold_addr_expr (expr);
1691 if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr)))
1692 expr = fold_convert (ptrtype, expr);
1693 expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr,
1694 build_int_cst (size_type_node,
1695 adj->offset / BITS_PER_UNIT));
1697 expr = fold_build1 (INDIRECT_REF, adj->type, expr);
1699 expr = force_gimple_operand_gsi (&gsi, expr,
1701 || is_gimple_reg_type (adj->type),
1702 NULL, true, GSI_SAME_STMT);
1703 VEC_quick_push (tree, vargs, expr);
1707 if (dump_file && (dump_flags & TDF_DETAILS))
1709 fprintf (dump_file, "replacing stmt:");
1710 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
1713 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
1714 new_stmt = gimple_build_call_vec (callee_decl, vargs);
1715 VEC_free (tree, heap, vargs);
1716 if (gimple_call_lhs (stmt))
1717 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
1719 gimple_set_block (new_stmt, gimple_block (stmt));
1720 if (gimple_has_location (stmt))
1721 gimple_set_location (new_stmt, gimple_location (stmt));
1722 gimple_call_copy_flags (new_stmt, stmt);
1723 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
1725 if (dump_file && (dump_flags & TDF_DETAILS))
1727 fprintf (dump_file, "with stmt:");
1728 print_gimple_stmt (dump_file, new_stmt, 0, 0);
1729 fprintf (dump_file, "\n");
1731 gsi_replace (&gsi, new_stmt, true);
1733 cgraph_set_call_stmt (cs, new_stmt);
1734 update_ssa (TODO_update_ssa);
1735 free_dominance_info (CDI_DOMINATORS);
1738 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
1741 index_in_adjustments_multiple_times_p (int base_index,
1742 ipa_parm_adjustment_vec adjustments)
1744 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
1747 for (i = 0; i < len; i++)
1749 struct ipa_parm_adjustment *adj;
1750 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
1752 if (adj->base_index == base_index)
1764 /* Return adjustments that should have the same effect on function parameters
1765 and call arguments as if they were first changed according to adjustments in
1766 INNER and then by adjustments in OUTER. */
1768 ipa_parm_adjustment_vec
1769 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
1770 ipa_parm_adjustment_vec outer)
1772 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
1773 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
1775 ipa_parm_adjustment_vec adjustments, tmp;
1777 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
1778 for (i = 0; i < inlen; i++)
1780 struct ipa_parm_adjustment *n;
1781 n = VEC_index (ipa_parm_adjustment_t, inner, i);
1783 if (n->remove_param)
1786 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
1789 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
1790 for (i = 0; i < outlen; i++)
1792 struct ipa_parm_adjustment *r;
1793 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
1795 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
1798 gcc_assert (!in->remove_param);
1799 if (out->remove_param)
1801 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
1803 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
1804 memset (r, 0, sizeof (*r));
1805 r->remove_param = true;
1810 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
1811 memset (r, 0, sizeof (*r));
1812 r->base_index = in->base_index;
1813 r->type = out->type;
1815 /* FIXME: Create nonlocal value too. */
1817 if (in->copy_param && out->copy_param)
1818 r->copy_param = true;
1819 else if (in->copy_param)
1820 r->offset = out->offset;
1821 else if (out->copy_param)
1822 r->offset = in->offset;
1824 r->offset = in->offset + out->offset;
1827 for (i = 0; i < inlen; i++)
1829 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
1832 if (n->remove_param)
1833 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
1836 VEC_free (ipa_parm_adjustment_t, heap, tmp);
1840 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
1841 friendly way, assuming they are meant to be applied to FNDECL. */
1844 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
1847 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
1849 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
1851 fprintf (file, "IPA param adjustments: ");
1852 for (i = 0; i < len; i++)
1854 struct ipa_parm_adjustment *adj;
1855 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
1858 fprintf (file, " ");
1862 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
1863 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
1866 fprintf (file, ", base: ");
1867 print_generic_expr (file, adj->base, 0);
1871 fprintf (file, ", reduction: ");
1872 print_generic_expr (file, adj->reduction, 0);
1874 if (adj->new_ssa_base)
1876 fprintf (file, ", new_ssa_base: ");
1877 print_generic_expr (file, adj->new_ssa_base, 0);
1880 if (adj->copy_param)
1881 fprintf (file, ", copy_param");
1882 else if (adj->remove_param)
1883 fprintf (file, ", remove_param");
1885 fprintf (file, ", offset %li", (long) adj->offset);
1887 fprintf (file, ", by_ref");
1888 print_node_brief (file, ", type: ", adj->type, 0);
1889 fprintf (file, "\n");
1891 VEC_free (tree, heap, parms);
1894 /* Stream out jump function JUMP_FUNC to OB. */
1897 ipa_write_jump_function (struct output_block *ob,
1898 struct ipa_jump_func *jump_func)
1900 lto_output_uleb128_stream (ob->main_stream,
1903 switch (jump_func->type)
1905 case IPA_JF_UNKNOWN:
1908 lto_output_tree (ob, jump_func->value.constant, true);
1910 case IPA_JF_PASS_THROUGH:
1911 lto_output_tree (ob, jump_func->value.pass_through.operand, true);
1912 lto_output_uleb128_stream (ob->main_stream,
1913 jump_func->value.pass_through.formal_id);
1914 lto_output_uleb128_stream (ob->main_stream,
1915 jump_func->value.pass_through.operation);
1917 case IPA_JF_ANCESTOR:
1918 lto_output_uleb128_stream (ob->main_stream,
1919 jump_func->value.ancestor.offset);
1920 lto_output_tree (ob, jump_func->value.ancestor.type, true);
1921 lto_output_uleb128_stream (ob->main_stream,
1922 jump_func->value.ancestor.formal_id);
1924 case IPA_JF_CONST_MEMBER_PTR:
1925 lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
1926 lto_output_tree (ob, jump_func->value.member_cst.delta, false);
1931 /* Read in jump function JUMP_FUNC from IB. */
1934 ipa_read_jump_function (struct lto_input_block *ib,
1935 struct ipa_jump_func *jump_func,
1936 struct data_in *data_in)
1938 jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
1940 switch (jump_func->type)
1942 case IPA_JF_UNKNOWN:
1945 jump_func->value.constant = lto_input_tree (ib, data_in);
1947 case IPA_JF_PASS_THROUGH:
1948 jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
1949 jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
1950 jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
1952 case IPA_JF_ANCESTOR:
1953 jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
1954 jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
1955 jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
1957 case IPA_JF_CONST_MEMBER_PTR:
1958 jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
1959 jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
1964 /* Stream out a parameter call note. */
1967 ipa_write_param_call_note (struct output_block *ob,
1968 struct ipa_param_call_note *note)
1970 gcc_assert (!note->processed);
1971 lto_output_uleb128_stream (ob->main_stream, gimple_uid (note->stmt));
1972 lto_output_sleb128_stream (ob->main_stream, note->formal_id);
1973 lto_output_sleb128_stream (ob->main_stream, note->count);
1974 lto_output_sleb128_stream (ob->main_stream, note->frequency);
1975 lto_output_sleb128_stream (ob->main_stream, note->loop_nest);
1978 /* Read in a parameter call note. */
1981 ipa_read_param_call_note (struct lto_input_block *ib,
1982 struct ipa_node_params *info)
1985 struct ipa_param_call_note *note = XCNEW (struct ipa_param_call_note);
1987 note->lto_stmt_uid = (unsigned int) lto_input_uleb128 (ib);
1988 note->formal_id = (int) lto_input_sleb128 (ib);
1989 note->count = (gcov_type) lto_input_sleb128 (ib);
1990 note->frequency = (int) lto_input_sleb128 (ib);
1991 note->loop_nest = (int) lto_input_sleb128 (ib);
1993 note->next = info->param_calls;
1994 info->param_calls = note;
1998 /* Stream out NODE info to OB. */
2001 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2004 lto_cgraph_encoder_t encoder;
2005 struct ipa_node_params *info = IPA_NODE_REF (node);
2007 struct cgraph_edge *e;
2008 struct bitpack_d *bp;
2010 struct ipa_param_call_note *note;
2012 encoder = ob->decl_state->cgraph_node_encoder;
2013 node_ref = lto_cgraph_encoder_encode (encoder, node);
2014 lto_output_uleb128_stream (ob->main_stream, node_ref);
2016 bp = bitpack_create ();
2017 bp_pack_value (bp, info->called_with_var_arguments, 1);
2018 bp_pack_value (bp, info->uses_analysis_done, 1);
2019 gcc_assert (info->modification_analysis_done
2020 || ipa_get_param_count (info) == 0);
2021 gcc_assert (!info->node_enqueued);
2022 gcc_assert (!info->ipcp_orig_node);
2023 for (j = 0; j < ipa_get_param_count (info); j++)
2024 bp_pack_value (bp, info->params[j].modified, 1);
2025 lto_output_bitpack (ob->main_stream, bp);
2026 bitpack_delete (bp);
2027 for (e = node->callees; e; e = e->next_callee)
2029 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2031 lto_output_uleb128_stream (ob->main_stream,
2032 ipa_get_cs_argument_count (args));
2033 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2034 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2037 for (note = info->param_calls; note; note = note->next)
2039 lto_output_uleb128_stream (ob->main_stream, note_count);
2040 for (note = info->param_calls; note; note = note->next)
2041 ipa_write_param_call_note (ob, note);
2044 /* Srtream in NODE info from IB. */
2047 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2048 struct data_in *data_in)
2050 struct ipa_node_params *info = IPA_NODE_REF (node);
2052 struct cgraph_edge *e;
2053 struct bitpack_d *bp;
2056 ipa_initialize_node_params (node);
2058 bp = lto_input_bitpack (ib);
2059 info->called_with_var_arguments = bp_unpack_value (bp, 1);
2060 info->uses_analysis_done = bp_unpack_value (bp, 1);
2061 if (ipa_get_param_count (info) != 0)
2063 info->modification_analysis_done = true;
2064 info->uses_analysis_done = true;
2066 info->node_enqueued = false;
2067 for (k = 0; k < ipa_get_param_count (info); k++)
2068 info->params[k].modified = bp_unpack_value (bp, 1);
2069 bitpack_delete (bp);
2070 for (e = node->callees; e; e = e->next_callee)
2072 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2073 int count = lto_input_uleb128 (ib);
2075 ipa_set_cs_argument_count (args, count);
2079 args->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
2080 ipa_get_cs_argument_count (args));
2081 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2082 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2085 note_count = lto_input_uleb128 (ib);
2086 for (i = 0; i < note_count; i++)
2087 ipa_read_param_call_note (ib, info);
2090 /* Write jump functions for nodes in SET. */
2093 ipa_prop_write_jump_functions (cgraph_node_set set)
2095 struct cgraph_node *node;
2096 struct output_block *ob = create_output_block (LTO_section_jump_functions);
2097 unsigned int count = 0;
2098 cgraph_node_set_iterator csi;
2100 ob->cgraph_node = NULL;
2102 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2104 node = csi_node (csi);
2105 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2109 lto_output_uleb128_stream (ob->main_stream, count);
2111 /* Process all of the functions. */
2112 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2114 node = csi_node (csi);
2115 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2116 ipa_write_node_info (ob, node);
2118 lto_output_1_stream (ob->main_stream, 0);
2119 produce_asm (ob, NULL);
2120 destroy_output_block (ob);
2123 /* Read section in file FILE_DATA of length LEN with data DATA. */
2126 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2129 const struct lto_function_header *header =
2130 (const struct lto_function_header *) data;
2131 const int32_t cfg_offset = sizeof (struct lto_function_header);
2132 const int32_t main_offset = cfg_offset + header->cfg_size;
2133 const int32_t string_offset = main_offset + header->main_size;
2134 struct data_in *data_in;
2135 struct lto_input_block ib_main;
2139 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2143 lto_data_in_create (file_data, (const char *) data + string_offset,
2144 header->string_size, NULL);
2145 count = lto_input_uleb128 (&ib_main);
2147 for (i = 0; i < count; i++)
2150 struct cgraph_node *node;
2151 lto_cgraph_encoder_t encoder;
2153 index = lto_input_uleb128 (&ib_main);
2154 encoder = file_data->cgraph_node_encoder;
2155 node = lto_cgraph_encoder_deref (encoder, index);
2156 ipa_read_node_info (&ib_main, node, data_in);
2158 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2160 lto_data_in_delete (data_in);
2163 /* Read ipcp jump functions. */
2166 ipa_prop_read_jump_functions (void)
2168 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2169 struct lto_file_decl_data *file_data;
2172 ipa_check_create_node_params ();
2173 ipa_check_create_edge_args ();
2174 ipa_register_cgraph_hooks ();
2176 while ((file_data = file_data_vec[j++]))
2179 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2182 ipa_prop_read_section (file_data, data, len);
2186 /* After merging units, we can get mismatch in argument counts.
2187 Also decl merging might've rendered parameter lists obsolette.
2188 Also compute called_with_variable_arg info. */
2191 ipa_update_after_lto_read (void)
2193 struct cgraph_node *node;
2194 struct cgraph_edge *cs;
2196 ipa_check_create_node_params ();
2197 ipa_check_create_edge_args ();
2199 for (node = cgraph_nodes; node; node = node->next)
2201 ipa_initialize_node_params (node);
2203 for (node = cgraph_nodes; node; node = node->next)
2205 for (cs = node->callees; cs; cs = cs->next_callee)
2207 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2208 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2209 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
2213 /* Walk param call notes of NODE and set their call statements given the uid
2214 stored in each note and STMTS which is an array of statements indexed by the
2218 lto_ipa_fixup_call_notes (struct cgraph_node *node, gimple *stmts)
2220 struct ipa_node_params *info;
2221 struct ipa_param_call_note *note;
2223 ipa_check_create_node_params ();
2224 info = IPA_NODE_REF (node);
2225 note = info->param_calls;
2226 /* If there are no notes or they have already been fixed up (the same fixup
2227 is called for both inlining and ipa-cp), there's nothing to do. */
2228 if (!note || note->stmt)
2233 note->stmt = stmts[note->lto_stmt_uid];