1 /* Interprocedural analyses.
2 Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "langhooks.h"
29 #include "tree-flow.h"
30 #include "tree-pass.h"
31 #include "tree-inline.h"
35 #include "diagnostic.h"
36 #include "lto-streamer.h"
38 /* Vector where the parameter infos are actually stored. */
39 VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
40 /* Vector where the parameter infos are actually stored. */
41 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
43 /* Holders of ipa cgraph hooks: */
44 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
45 static struct cgraph_node_hook_list *node_removal_hook_holder;
46 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
47 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
49 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
50 it is in one or not. It should almost never be used directly, as opposed to
51 ipa_push_func_to_list. */
54 ipa_push_func_to_list_1 (struct ipa_func_list **wl,
55 struct cgraph_node *node,
56 struct ipa_node_params *info)
58 struct ipa_func_list *temp;
60 info->node_enqueued = 1;
61 temp = XCNEW (struct ipa_func_list);
67 /* Initialize worklist to contain all functions. */
69 struct ipa_func_list *
70 ipa_init_func_list (void)
72 struct cgraph_node *node;
73 struct ipa_func_list * wl;
76 for (node = cgraph_nodes; node; node = node->next)
79 struct ipa_node_params *info = IPA_NODE_REF (node);
80 /* Unreachable nodes should have been eliminated before ipcp and
82 gcc_assert (node->needed || node->reachable);
83 ipa_push_func_to_list_1 (&wl, node, info);
89 /* Remove a function from the worklist WL and return it. */
92 ipa_pop_func_from_list (struct ipa_func_list **wl)
94 struct ipa_node_params *info;
95 struct ipa_func_list *first;
96 struct cgraph_node *node;
103 info = IPA_NODE_REF (node);
104 info->node_enqueued = 0;
108 /* Return index of the formal whose tree is PTREE in function which corresponds
112 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
116 count = ipa_get_param_count (info);
117 for (i = 0; i < count; i++)
118 if (ipa_get_param(info, i) == ptree)
124 /* Populate the param_decl field in parameter descriptors of INFO that
125 corresponds to NODE. */
128 ipa_populate_param_decls (struct cgraph_node *node,
129 struct ipa_node_params *info)
137 fnargs = DECL_ARGUMENTS (fndecl);
139 for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
141 info->params[param_num].decl = parm;
146 /* Return how many formal parameters FNDECL has. */
149 count_formal_params_1 (tree fndecl)
154 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
160 /* Count number of formal parameters in NOTE. Store the result to the
161 appropriate field of INFO. */
164 ipa_count_formal_params (struct cgraph_node *node,
165 struct ipa_node_params *info)
169 param_num = count_formal_params_1 (node->decl);
170 ipa_set_param_count (info, param_num);
173 /* Initialize the ipa_node_params structure associated with NODE by counting
174 the function parameters, creating the descriptors and populating their
178 ipa_initialize_node_params (struct cgraph_node *node)
180 struct ipa_node_params *info = IPA_NODE_REF (node);
184 ipa_count_formal_params (node, info);
185 info->params = XCNEWVEC (struct ipa_param_descriptor,
186 ipa_get_param_count (info));
187 ipa_populate_param_decls (node, info);
191 /* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
192 parameters. If OP is a parameter declaration, mark it as modified in the
193 info structure passed in DATA. */
196 visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
199 struct ipa_node_params *info = (struct ipa_node_params *) data;
201 if (TREE_CODE (op) == PARM_DECL)
203 int index = ipa_get_param_decl_index (info, op);
204 gcc_assert (index >= 0);
205 info->params[index].modified = true;
211 /* Compute which formal parameters of function associated with NODE are locally
212 modified or their address is taken. Note that this does not apply on
213 parameters with SSA names but those can and should be analyzed
217 ipa_detect_param_modifications (struct cgraph_node *node)
219 tree decl = node->decl;
221 struct function *func;
222 gimple_stmt_iterator gsi;
223 struct ipa_node_params *info = IPA_NODE_REF (node);
225 if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
228 func = DECL_STRUCT_FUNCTION (decl);
229 FOR_EACH_BB_FN (bb, func)
230 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
231 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info, NULL,
232 visit_store_addr_for_mod_analysis,
233 visit_store_addr_for_mod_analysis);
235 info->modification_analysis_done = 1;
238 /* Count number of arguments callsite CS has and store it in
239 ipa_edge_args structure corresponding to this callsite. */
242 ipa_count_arguments (struct cgraph_edge *cs)
247 stmt = cs->call_stmt;
248 gcc_assert (is_gimple_call (stmt));
249 arg_num = gimple_call_num_args (stmt);
250 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
251 <= (unsigned) cgraph_edge_max_uid)
252 VEC_safe_grow_cleared (ipa_edge_args_t, gc,
253 ipa_edge_args_vector, cgraph_edge_max_uid + 1);
254 ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
257 /* Print the jump functions of all arguments on all call graph edges going from
261 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
264 struct cgraph_edge *cs;
265 struct ipa_jump_func *jump_func;
266 enum jump_func_type type;
268 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
269 for (cs = node->callees; cs; cs = cs->next_callee)
271 if (!ipa_edge_args_info_available_for_edge_p (cs))
274 fprintf (f, " callsite %s ", cgraph_node_name (node));
275 fprintf (f, "-> %s :: \n", cgraph_node_name (cs->callee));
277 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
278 for (i = 0; i < count; i++)
280 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
281 type = jump_func->type;
283 fprintf (f, " param %d: ", i);
284 if (type == IPA_JF_UNKNOWN)
285 fprintf (f, "UNKNOWN\n");
286 else if (type == IPA_JF_CONST)
288 tree val = jump_func->value.constant;
289 fprintf (f, "CONST: ");
290 print_generic_expr (f, val, 0);
293 else if (type == IPA_JF_CONST_MEMBER_PTR)
295 fprintf (f, "CONST MEMBER PTR: ");
296 print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
298 print_generic_expr (f, jump_func->value.member_cst.delta, 0);
301 else if (type == IPA_JF_PASS_THROUGH)
303 fprintf (f, "PASS THROUGH: ");
304 fprintf (f, "%d, op %s ",
305 jump_func->value.pass_through.formal_id,
307 jump_func->value.pass_through.operation]);
308 if (jump_func->value.pass_through.operation != NOP_EXPR)
309 print_generic_expr (dump_file,
310 jump_func->value.pass_through.operand, 0);
311 fprintf (dump_file, "\n");
313 else if (type == IPA_JF_ANCESTOR)
315 fprintf (f, "ANCESTOR: ");
316 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC"\n",
317 jump_func->value.ancestor.formal_id,
318 jump_func->value.ancestor.offset);
324 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
327 ipa_print_all_jump_functions (FILE *f)
329 struct cgraph_node *node;
331 fprintf (f, "\nJump functions:\n");
332 for (node = cgraph_nodes; node; node = node->next)
334 ipa_print_node_jump_functions (f, node);
338 /* Determine whether passing ssa name NAME constitutes a polynomial
339 pass-through function or getting an address of an acestor and if so, write
340 such a jump function to JFUNC. INFO describes the caller. */
343 compute_complex_pass_through (struct ipa_node_params *info,
344 struct ipa_jump_func *jfunc,
347 HOST_WIDE_INT offset, size, max_size;
350 gimple stmt = SSA_NAME_DEF_STMT (name);
352 if (!is_gimple_assign (stmt))
354 op1 = gimple_assign_rhs1 (stmt);
355 op2 = gimple_assign_rhs2 (stmt);
359 if (TREE_CODE (op1) != SSA_NAME
360 || !SSA_NAME_IS_DEFAULT_DEF (op1)
361 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
362 && !useless_type_conversion_p (TREE_TYPE (name),
364 || !is_gimple_ip_invariant (op2))
367 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
370 jfunc->type = IPA_JF_PASS_THROUGH;
371 jfunc->value.pass_through.formal_id = index;
372 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
373 jfunc->value.pass_through.operand = op2;
378 if (TREE_CODE (op1) != ADDR_EXPR)
380 op1 = TREE_OPERAND (op1, 0);
381 type = TREE_TYPE (op1);
383 op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
384 if (TREE_CODE (op1) != INDIRECT_REF
385 /* If this is a varying address, punt. */
389 op1 = TREE_OPERAND (op1, 0);
390 if (TREE_CODE (op1) != SSA_NAME
391 || !SSA_NAME_IS_DEFAULT_DEF (op1))
394 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
397 jfunc->type = IPA_JF_ANCESTOR;
398 jfunc->value.ancestor.formal_id = index;
399 jfunc->value.ancestor.offset = offset;
400 jfunc->value.ancestor.type = type;
405 /* Determine the jump functions of scalar arguments. Scalar means SSA names
406 and constants of a number of selected types. INFO is the ipa_node_params
407 structure associated with the caller, FUNCTIONS is a pointer to an array of
408 jump function structures associated with CALL which is the call statement
412 compute_scalar_jump_functions (struct ipa_node_params *info,
413 struct ipa_jump_func *functions,
419 for (num = 0; num < gimple_call_num_args (call); num++)
421 arg = gimple_call_arg (call, num);
423 if (is_gimple_ip_invariant (arg))
425 functions[num].type = IPA_JF_CONST;
426 functions[num].value.constant = arg;
428 else if (TREE_CODE (arg) == SSA_NAME)
430 if (SSA_NAME_IS_DEFAULT_DEF (arg))
432 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
436 functions[num].type = IPA_JF_PASS_THROUGH;
437 functions[num].value.pass_through.formal_id = index;
438 functions[num].value.pass_through.operation = NOP_EXPR;
442 compute_complex_pass_through (info, &functions[num], arg);
447 /* Inspect the given TYPE and return true iff it has the same structure (the
448 same number of fields of the same types) as a C++ member pointer. If
449 METHOD_PTR and DELTA are non-NULL, store the trees representing the
450 corresponding fields there. */
453 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
457 if (TREE_CODE (type) != RECORD_TYPE)
460 fld = TYPE_FIELDS (type);
461 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
462 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
468 fld = TREE_CHAIN (fld);
469 if (!fld || INTEGRAL_TYPE_P (fld))
474 if (TREE_CHAIN (fld))
480 /* Go through arguments of the CALL and for every one that looks like a member
481 pointer, check whether it can be safely declared pass-through and if so,
482 mark that to the corresponding item of jump FUNCTIONS. Return true iff
483 there are non-pass-through member pointers within the arguments. INFO
484 describes formal parameters of the caller. */
487 compute_pass_through_member_ptrs (struct ipa_node_params *info,
488 struct ipa_jump_func *functions,
491 bool undecided_members = false;
495 for (num = 0; num < gimple_call_num_args (call); num++)
497 arg = gimple_call_arg (call, num);
499 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
501 if (TREE_CODE (arg) == PARM_DECL)
503 int index = ipa_get_param_decl_index (info, arg);
505 gcc_assert (index >=0);
506 if (!ipa_is_param_modified (info, index))
508 functions[num].type = IPA_JF_PASS_THROUGH;
509 functions[num].value.pass_through.formal_id = index;
510 functions[num].value.pass_through.operation = NOP_EXPR;
513 undecided_members = true;
516 undecided_members = true;
520 return undecided_members;
523 /* Simple function filling in a member pointer constant jump function (with PFN
524 and DELTA as the constant value) into JFUNC. */
527 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
528 tree pfn, tree delta)
530 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
531 jfunc->value.member_cst.pfn = pfn;
532 jfunc->value.member_cst.delta = delta;
535 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
536 return the rhs of its defining statement. */
539 get_ssa_def_if_simple_copy (tree rhs)
541 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
543 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
545 if (gimple_assign_single_p (def_stmt))
546 rhs = gimple_assign_rhs1 (def_stmt);
553 /* Traverse statements from CALL backwards, scanning whether the argument ARG
554 which is a member pointer is filled in with constant values. If it is, fill
555 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
556 fields of the record type of the member pointer. To give an example, we
557 look for a pattern looking like the following:
559 D.2515.__pfn ={v} printStuff;
560 D.2515.__delta ={v} 0;
561 i_1 = doprinting (D.2515); */
564 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
565 tree delta_field, struct ipa_jump_func *jfunc)
567 gimple_stmt_iterator gsi;
568 tree method = NULL_TREE;
569 tree delta = NULL_TREE;
571 gsi = gsi_for_stmt (call);
574 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
576 gimple stmt = gsi_stmt (gsi);
579 if (!gimple_assign_single_p (stmt))
582 lhs = gimple_assign_lhs (stmt);
583 rhs = gimple_assign_rhs1 (stmt);
585 if (TREE_CODE (lhs) != COMPONENT_REF
586 || TREE_OPERAND (lhs, 0) != arg)
589 fld = TREE_OPERAND (lhs, 1);
590 if (!method && fld == method_field)
592 rhs = get_ssa_def_if_simple_copy (rhs);
593 if (TREE_CODE (rhs) == ADDR_EXPR
594 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
595 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
597 method = TREE_OPERAND (rhs, 0);
600 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
608 if (!delta && fld == delta_field)
610 rhs = get_ssa_def_if_simple_copy (rhs);
611 if (TREE_CODE (rhs) == INTEGER_CST)
616 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
628 /* Go through the arguments of the CALL and for every member pointer within
629 tries determine whether it is a constant. If it is, create a corresponding
630 constant jump function in FUNCTIONS which is an array of jump functions
631 associated with the call. */
634 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
638 tree arg, method_field, delta_field;
640 for (num = 0; num < gimple_call_num_args (call); num++)
642 arg = gimple_call_arg (call, num);
644 if (functions[num].type == IPA_JF_UNKNOWN
645 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
647 determine_cst_member_ptr (call, arg, method_field, delta_field,
652 /* Compute jump function for all arguments of callsite CS and insert the
653 information in the jump_functions array in the ipa_edge_args corresponding
657 ipa_compute_jump_functions (struct cgraph_edge *cs)
659 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
660 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
663 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
665 arguments->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
666 ipa_get_cs_argument_count (arguments));
668 call = cs->call_stmt;
669 gcc_assert (is_gimple_call (call));
671 /* We will deal with constants and SSA scalars first: */
672 compute_scalar_jump_functions (info, arguments->jump_functions, call);
674 /* Let's check whether there are any potential member pointers and if so,
675 whether we can determine their functions as pass_through. */
676 if (!compute_pass_through_member_ptrs (info, arguments->jump_functions, call))
679 /* Finally, let's check whether we actually pass a new constant member
681 compute_cst_member_ptr_arguments (arguments->jump_functions, call);
684 /* If RHS looks like a rhs of a statement loading pfn from a member
685 pointer formal parameter, return the parameter, otherwise return
686 NULL. If USE_DELTA, then we look for a use of the delta field
687 rather than the pfn. */
690 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
696 if (TREE_CODE (rhs) != COMPONENT_REF)
699 rec = TREE_OPERAND (rhs, 0);
700 if (TREE_CODE (rec) != PARM_DECL
701 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
704 fld = TREE_OPERAND (rhs, 1);
705 if (use_delta ? (fld == delta_field) : (fld == ptr_field))
711 /* If STMT looks like a statement loading a value from a member pointer formal
712 parameter, this function returns that parameter. */
715 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
719 if (!gimple_assign_single_p (stmt))
722 rhs = gimple_assign_rhs1 (stmt);
723 return ipa_get_member_ptr_load_param (rhs, use_delta);
726 /* Returns true iff T is an SSA_NAME defined by a statement. */
729 ipa_is_ssa_with_stmt_def (tree t)
731 if (TREE_CODE (t) == SSA_NAME
732 && !SSA_NAME_IS_DEFAULT_DEF (t))
738 /* Creates a new note describing a call to a parameter number FORMAL_ID and
739 attaches it to the linked list of INFO. It also sets the called flag of the
740 parameter. STMT is the corresponding call statement. */
743 ipa_note_param_call (struct ipa_node_params *info, int formal_id,
746 struct ipa_param_call_note *note;
747 basic_block bb = gimple_bb (stmt);
749 info->params[formal_id].called = 1;
751 note = XCNEW (struct ipa_param_call_note);
752 note->formal_id = formal_id;
754 note->count = bb->count;
755 note->frequency = compute_call_stmt_bb_frequency (current_function_decl, bb);
757 note->next = info->param_calls;
758 info->param_calls = note;
763 /* Analyze the CALL and examine uses of formal parameters of the caller
764 (described by INFO). Currently it checks whether the call calls a pointer
765 that is a formal parameter and if so, the parameter is marked with the
766 called flag and a note describing the call is created. This is very simple
767 for ordinary pointers represented in SSA but not-so-nice when it comes to
768 member pointers. The ugly part of this function does nothing more than
769 tries to match the pattern of such a call. An example of such a pattern is
770 the gimple dump below, the call is on the last line:
773 f$__delta_5 = f.__delta;
774 f$__pfn_24 = f.__pfn;
775 D.2496_3 = (int) f$__pfn_24;
776 D.2497_4 = D.2496_3 & 1;
783 D.2500_7 = (unsigned int) f$__delta_5;
784 D.2501_8 = &S + D.2500_7;
785 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
786 D.2503_10 = *D.2502_9;
787 D.2504_12 = f$__pfn_24 + -1;
788 D.2505_13 = (unsigned int) D.2504_12;
789 D.2506_14 = D.2503_10 + D.2505_13;
790 D.2507_15 = *D.2506_14;
791 iftmp.11_16 = (String:: *) D.2507_15;
794 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
795 D.2500_19 = (unsigned int) f$__delta_5;
796 D.2508_20 = &S + D.2500_19;
797 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
799 Such patterns are results of simple calls to a member pointer:
801 int doprinting (int (MyString::* f)(int) const)
803 MyString S ("somestring");
810 ipa_analyze_call_uses (struct ipa_node_params *info, gimple call)
812 tree target = gimple_call_fn (call);
817 tree rec, rec2, cond;
820 basic_block bb, virt_bb, join;
822 if (TREE_CODE (target) != SSA_NAME)
825 var = SSA_NAME_VAR (target);
826 if (SSA_NAME_IS_DEFAULT_DEF (target))
828 /* assuming TREE_CODE (var) == PARM_DECL */
829 index = ipa_get_param_decl_index (info, var);
831 ipa_note_param_call (info, index, call);
835 /* Now we need to try to match the complex pattern of calling a member
838 if (!POINTER_TYPE_P (TREE_TYPE (target))
839 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
842 def = SSA_NAME_DEF_STMT (target);
843 if (gimple_code (def) != GIMPLE_PHI)
846 if (gimple_phi_num_args (def) != 2)
849 /* First, we need to check whether one of these is a load from a member
850 pointer that is a parameter to this function. */
851 n1 = PHI_ARG_DEF (def, 0);
852 n2 = PHI_ARG_DEF (def, 1);
853 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
855 d1 = SSA_NAME_DEF_STMT (n1);
856 d2 = SSA_NAME_DEF_STMT (n2);
858 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
860 if (ipa_get_stmt_member_ptr_load_param (d2, false))
864 virt_bb = gimple_bb (d2);
866 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
869 virt_bb = gimple_bb (d1);
874 /* Second, we need to check that the basic blocks are laid out in the way
875 corresponding to the pattern. */
877 join = gimple_bb (def);
878 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
879 || single_pred (virt_bb) != bb
880 || single_succ (virt_bb) != join)
883 /* Third, let's see that the branching is done depending on the least
884 significant bit of the pfn. */
886 branch = last_stmt (bb);
887 if (gimple_code (branch) != GIMPLE_COND)
890 if (gimple_cond_code (branch) != NE_EXPR
891 || !integer_zerop (gimple_cond_rhs (branch)))
894 cond = gimple_cond_lhs (branch);
895 if (!ipa_is_ssa_with_stmt_def (cond))
898 def = SSA_NAME_DEF_STMT (cond);
899 if (!is_gimple_assign (def)
900 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
901 || !integer_onep (gimple_assign_rhs2 (def)))
904 cond = gimple_assign_rhs1 (def);
905 if (!ipa_is_ssa_with_stmt_def (cond))
908 def = SSA_NAME_DEF_STMT (cond);
910 if (is_gimple_assign (def)
911 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
913 cond = gimple_assign_rhs1 (def);
914 if (!ipa_is_ssa_with_stmt_def (cond))
916 def = SSA_NAME_DEF_STMT (cond);
919 rec2 = ipa_get_stmt_member_ptr_load_param (def,
920 (TARGET_PTRMEMFUNC_VBIT_LOCATION
921 == ptrmemfunc_vbit_in_delta));
926 index = ipa_get_param_decl_index (info, rec);
927 if (index >= 0 && !ipa_is_param_modified (info, index))
928 ipa_note_param_call (info, index, call);
933 /* Analyze the statement STMT with respect to formal parameters (described in
934 INFO) and their uses. Currently it only checks whether formal parameters
938 ipa_analyze_stmt_uses (struct ipa_node_params *info, gimple stmt)
940 if (is_gimple_call (stmt))
941 ipa_analyze_call_uses (info, stmt);
944 /* Scan the function body of NODE and inspect the uses of formal parameters.
945 Store the findings in various structures of the associated ipa_node_params
946 structure, such as parameter flags, notes etc. */
949 ipa_analyze_params_uses (struct cgraph_node *node)
951 tree decl = node->decl;
953 struct function *func;
954 gimple_stmt_iterator gsi;
955 struct ipa_node_params *info = IPA_NODE_REF (node);
957 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
960 func = DECL_STRUCT_FUNCTION (decl);
961 FOR_EACH_BB_FN (bb, func)
963 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
965 gimple stmt = gsi_stmt (gsi);
966 ipa_analyze_stmt_uses (info, stmt);
970 info->uses_analysis_done = 1;
973 /* Update the jump functions associated with call graph edge E when the call
974 graph edge CS is being inlined, assuming that E->caller is already (possibly
975 indirectly) inlined into CS->callee and that E has not been inlined.
977 We keep pass through functions only if they do not contain any operation.
978 This is sufficient for inlining and greately simplifies things. */
981 update_jump_functions_after_inlining (struct cgraph_edge *cs,
982 struct cgraph_edge *e)
984 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
985 struct ipa_edge_args *args = IPA_EDGE_REF (e);
986 int count = ipa_get_cs_argument_count (args);
989 for (i = 0; i < count; i++)
991 struct ipa_jump_func *src, *dst = ipa_get_ith_jump_func (args, i);
993 if (dst->type == IPA_JF_ANCESTOR)
995 dst->type = IPA_JF_UNKNOWN;
999 if (dst->type != IPA_JF_PASS_THROUGH)
1002 /* We must check range due to calls with variable number of arguments and
1003 we cannot combine jump functions with operations. */
1004 if (dst->value.pass_through.operation != NOP_EXPR
1005 || (dst->value.pass_through.formal_id
1006 >= ipa_get_cs_argument_count (top)))
1008 dst->type = IPA_JF_UNKNOWN;
1012 src = ipa_get_ith_jump_func (top, dst->value.pass_through.formal_id);
1017 /* Print out a debug message to file F that we have discovered that an indirect
1018 call described by NT is in fact a call of a known constant function described
1019 by JFUNC. NODE is the node where the call is. */
1022 print_edge_addition_message (FILE *f, struct ipa_param_call_note *nt,
1023 struct ipa_jump_func *jfunc,
1024 struct cgraph_node *node)
1026 fprintf (f, "ipa-prop: Discovered an indirect call to a known target (");
1027 if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1029 print_node_brief (f, "", jfunc->value.member_cst.pfn, 0);
1030 print_node_brief (f, ", ", jfunc->value.member_cst.delta, 0);
1033 print_node_brief(f, "", jfunc->value.constant, 0);
1035 fprintf (f, ") in %s: ", cgraph_node_name (node));
1036 print_gimple_stmt (f, nt->stmt, 2, TDF_SLIM);
1039 /* Update the param called notes associated with NODE when CS is being inlined,
1040 assuming NODE is (potentially indirectly) inlined into CS->callee.
1041 Moreover, if the callee is discovered to be constant, create a new cgraph
1042 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1043 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1046 update_call_notes_after_inlining (struct cgraph_edge *cs,
1047 struct cgraph_node *node,
1048 VEC (cgraph_edge_p, heap) **new_edges)
1050 struct ipa_node_params *info = IPA_NODE_REF (node);
1051 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1052 struct ipa_param_call_note *nt;
1055 for (nt = info->param_calls; nt; nt = nt->next)
1057 struct ipa_jump_func *jfunc;
1062 /* We must check range due to calls with variable number of arguments: */
1063 if (nt->formal_id >= ipa_get_cs_argument_count (top))
1065 nt->processed = true;
1069 jfunc = ipa_get_ith_jump_func (top, nt->formal_id);
1070 if (jfunc->type == IPA_JF_PASS_THROUGH
1071 && jfunc->value.pass_through.operation == NOP_EXPR)
1072 nt->formal_id = jfunc->value.pass_through.formal_id;
1073 else if (jfunc->type == IPA_JF_CONST
1074 || jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1076 struct cgraph_node *callee;
1077 struct cgraph_edge *new_indirect_edge;
1080 nt->processed = true;
1081 if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1082 decl = jfunc->value.member_cst.pfn;
1084 decl = jfunc->value.constant;
1086 if (TREE_CODE (decl) != ADDR_EXPR)
1088 decl = TREE_OPERAND (decl, 0);
1090 if (TREE_CODE (decl) != FUNCTION_DECL)
1092 callee = cgraph_node (decl);
1093 if (!callee || !callee->local.inlinable)
1098 print_edge_addition_message (dump_file, nt, jfunc, node);
1100 new_indirect_edge = cgraph_create_edge (node, callee, nt->stmt,
1101 nt->count, nt->frequency,
1103 new_indirect_edge->indirect_call = 1;
1104 ipa_check_create_edge_args ();
1106 VEC_safe_push (cgraph_edge_p, heap, *new_edges, new_indirect_edge);
1107 top = IPA_EDGE_REF (cs);
1111 /* Ancestor jum functions and pass theoughs with operations should
1112 not be used on parameters that then get called. */
1113 gcc_assert (jfunc->type == IPA_JF_UNKNOWN);
1114 nt->processed = true;
1120 /* Recursively traverse subtree of NODE (including node) made of inlined
1121 cgraph_edges when CS has been inlined and invoke
1122 update_call_notes_after_inlining on all nodes and
1123 update_jump_functions_after_inlining on all non-inlined edges that lead out
1124 of this subtree. Newly discovered indirect edges will be added to
1125 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1129 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1130 struct cgraph_node *node,
1131 VEC (cgraph_edge_p, heap) **new_edges)
1133 struct cgraph_edge *e;
1136 res = update_call_notes_after_inlining (cs, node, new_edges);
1138 for (e = node->callees; e; e = e->next_callee)
1139 if (!e->inline_failed)
1140 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1142 update_jump_functions_after_inlining (cs, e);
1147 /* Update jump functions and call note functions on inlining the call site CS.
1148 CS is expected to lead to a node already cloned by
1149 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1150 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1154 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1155 VEC (cgraph_edge_p, heap) **new_edges)
1157 /* FIXME lto: We do not stream out indirect call information. */
1161 /* Do nothing if the preparation phase has not been carried out yet
1162 (i.e. during early inlining). */
1163 if (!ipa_node_params_vector)
1165 gcc_assert (ipa_edge_args_vector);
1167 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1170 /* Frees all dynamically allocated structures that the argument info points
1174 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1176 if (args->jump_functions)
1177 ggc_free (args->jump_functions);
1179 memset (args, 0, sizeof (*args));
1182 /* Free all ipa_edge structures. */
1185 ipa_free_all_edge_args (void)
1188 struct ipa_edge_args *args;
1191 VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
1193 ipa_free_edge_args_substructures (args);
1195 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1196 ipa_edge_args_vector = NULL;
1199 /* Frees all dynamically allocated structures that the param info points
1203 ipa_free_node_params_substructures (struct ipa_node_params *info)
1206 free (info->params);
1208 while (info->param_calls)
1210 struct ipa_param_call_note *note = info->param_calls;
1211 info->param_calls = note->next;
1215 memset (info, 0, sizeof (*info));
1218 /* Free all ipa_node_params structures. */
1221 ipa_free_all_node_params (void)
1224 struct ipa_node_params *info;
1227 VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
1229 ipa_free_node_params_substructures (info);
1231 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1232 ipa_node_params_vector = NULL;
1235 /* Hook that is called by cgraph.c when an edge is removed. */
1238 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1240 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1241 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1242 <= (unsigned)cs->uid)
1244 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1247 /* Hook that is called by cgraph.c when a node is removed. */
1250 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1252 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1255 /* Helper function to duplicate an array of size N that is at SRC and store a
1256 pointer to it to DST. Nothing is done if SRC is NULL. */
1259 duplicate_array (void *src, size_t n)
1271 /* Like duplicate_array byt in GGC memory. */
1274 duplicate_ggc_array (void *src, size_t n)
1286 /* Hook that is called by cgraph.c when a node is duplicated. */
1289 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1290 __attribute__((unused)) void *data)
1292 struct ipa_edge_args *old_args, *new_args;
1295 ipa_check_create_edge_args ();
1297 old_args = IPA_EDGE_REF (src);
1298 new_args = IPA_EDGE_REF (dst);
1300 arg_count = ipa_get_cs_argument_count (old_args);
1301 ipa_set_cs_argument_count (new_args, arg_count);
1302 new_args->jump_functions = (struct ipa_jump_func *)
1303 duplicate_ggc_array (old_args->jump_functions,
1304 sizeof (struct ipa_jump_func) * arg_count);
1307 /* Hook that is called by cgraph.c when a node is duplicated. */
1310 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1311 __attribute__((unused)) void *data)
1313 struct ipa_node_params *old_info, *new_info;
1314 struct ipa_param_call_note *note;
1317 ipa_check_create_node_params ();
1318 old_info = IPA_NODE_REF (src);
1319 new_info = IPA_NODE_REF (dst);
1320 param_count = ipa_get_param_count (old_info);
1322 ipa_set_param_count (new_info, param_count);
1323 new_info->params = (struct ipa_param_descriptor *)
1324 duplicate_array (old_info->params,
1325 sizeof (struct ipa_param_descriptor) * param_count);
1326 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1327 new_info->count_scale = old_info->count_scale;
1329 for (note = old_info->param_calls; note; note = note->next)
1331 struct ipa_param_call_note *nn;
1333 nn = (struct ipa_param_call_note *)
1334 xcalloc (1, sizeof (struct ipa_param_call_note));
1335 memcpy (nn, note, sizeof (struct ipa_param_call_note));
1336 nn->next = new_info->param_calls;
1337 new_info->param_calls = nn;
1341 /* Register our cgraph hooks if they are not already there. */
1344 ipa_register_cgraph_hooks (void)
1346 if (!edge_removal_hook_holder)
1347 edge_removal_hook_holder =
1348 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1349 if (!node_removal_hook_holder)
1350 node_removal_hook_holder =
1351 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1352 if (!edge_duplication_hook_holder)
1353 edge_duplication_hook_holder =
1354 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1355 if (!node_duplication_hook_holder)
1356 node_duplication_hook_holder =
1357 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1360 /* Unregister our cgraph hooks if they are not already there. */
1363 ipa_unregister_cgraph_hooks (void)
1365 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1366 edge_removal_hook_holder = NULL;
1367 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1368 node_removal_hook_holder = NULL;
1369 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1370 edge_duplication_hook_holder = NULL;
1371 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1372 node_duplication_hook_holder = NULL;
1375 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1376 longer needed after ipa-cp. */
1379 free_all_ipa_structures_after_ipa_cp (void)
1381 if (!flag_indirect_inlining)
1383 ipa_free_all_edge_args ();
1384 ipa_free_all_node_params ();
1385 ipa_unregister_cgraph_hooks ();
1389 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1390 longer needed after indirect inlining. */
1393 free_all_ipa_structures_after_iinln (void)
1395 ipa_free_all_edge_args ();
1396 ipa_free_all_node_params ();
1397 ipa_unregister_cgraph_hooks ();
1400 /* Print ipa_tree_map data structures of all functions in the
1404 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1408 struct ipa_node_params *info;
1410 if (!node->analyzed)
1412 info = IPA_NODE_REF (node);
1413 fprintf (f, " function %s Trees :: \n", cgraph_node_name (node));
1414 count = ipa_get_param_count (info);
1415 for (i = 0; i < count; i++)
1417 temp = ipa_get_param (info, i);
1418 if (TREE_CODE (temp) == PARM_DECL)
1419 fprintf (f, " param %d : %s", i,
1421 ? (*lang_hooks.decl_printable_name) (temp, 2)
1423 if (ipa_is_param_modified (info, i))
1424 fprintf (f, " modified");
1425 if (ipa_is_param_called (info, i))
1426 fprintf (f, " called");
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 NODE info to OB. */
1967 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
1970 lto_cgraph_encoder_t encoder;
1971 struct ipa_node_params *info = IPA_NODE_REF (node);
1973 struct cgraph_edge *e;
1974 struct bitpack_d *bp;
1976 encoder = ob->decl_state->cgraph_node_encoder;
1977 node_ref = lto_cgraph_encoder_encode (encoder, node);
1978 lto_output_uleb128_stream (ob->main_stream, node_ref);
1980 /* Note that flags will need to be read in the opposite
1981 order as we are pushing the bitflags into FLAGS. */
1982 bp = bitpack_create ();
1983 bp_pack_value (bp, info->called_with_var_arguments, 1);
1984 gcc_assert (info->modification_analysis_done || ipa_get_param_count (info) == 0);
1985 gcc_assert (info->uses_analysis_done || ipa_get_param_count (info) == 0);
1986 gcc_assert (!info->node_enqueued);
1987 gcc_assert (!info->ipcp_orig_node);
1988 for (j = 0; j < ipa_get_param_count (info); j++)
1990 bp_pack_value (bp, info->params[j].modified, 1);
1991 bp_pack_value (bp, info->params[j].called, 1);
1993 lto_output_bitpack (ob->main_stream, bp);
1994 bitpack_delete (bp);
1995 for (e = node->callees; e; e = e->next_callee)
1997 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1999 lto_output_uleb128_stream (ob->main_stream, ipa_get_cs_argument_count (args));
2000 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2001 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2005 /* Srtream in NODE info from IB. */
2008 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2009 struct data_in *data_in)
2011 struct ipa_node_params *info = IPA_NODE_REF (node);
2013 struct cgraph_edge *e;
2014 struct bitpack_d *bp;
2016 ipa_initialize_node_params (node);
2018 /* Note that the flags must be read in the opposite
2019 order in which they were written (the bitflags were
2020 pushed into FLAGS). */
2021 bp = lto_input_bitpack (ib);
2022 info->called_with_var_arguments = bp_unpack_value (bp, 1);
2023 if (ipa_get_param_count (info) != 0)
2025 info->modification_analysis_done = true;
2026 info->uses_analysis_done = true;
2028 info->node_enqueued = false;
2029 for (k = 0; k < ipa_get_param_count (info); k++)
2031 info->params[k].modified = bp_unpack_value (bp, 1);
2032 info->params[k].called = bp_unpack_value (bp, 1);
2034 bitpack_delete (bp);
2035 for (e = node->callees; e; e = e->next_callee)
2037 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2038 int count = lto_input_uleb128 (ib);
2040 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
2041 <= (unsigned) cgraph_edge_max_uid)
2042 VEC_safe_grow_cleared (ipa_edge_args_t, gc,
2043 ipa_edge_args_vector, cgraph_edge_max_uid + 1);
2044 ipa_set_cs_argument_count (args, count);
2048 args->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
2049 ipa_get_cs_argument_count (args));
2050 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2051 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2055 /* Write jump functions for nodes in SET. */
2058 ipa_prop_write_jump_functions (cgraph_node_set set)
2060 struct cgraph_node *node;
2061 struct output_block *ob = create_output_block (LTO_section_jump_functions);
2062 unsigned int count = 0;
2063 cgraph_node_set_iterator csi;
2065 ob->cgraph_node = NULL;
2067 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2069 node = csi_node (csi);
2070 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2074 lto_output_uleb128_stream (ob->main_stream, count);
2076 /* Process all of the functions. */
2077 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2079 node = csi_node (csi);
2080 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2081 ipa_write_node_info (ob, node);
2083 lto_output_1_stream (ob->main_stream, 0);
2084 produce_asm (ob, NULL);
2085 destroy_output_block (ob);
2088 /* Read section in file FILE_DATA of length LEN with data DATA. */
2091 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2094 const struct lto_function_header *header =
2095 (const struct lto_function_header *) data;
2096 const int32_t cfg_offset = sizeof (struct lto_function_header);
2097 const int32_t main_offset = cfg_offset + header->cfg_size;
2098 const int32_t string_offset = main_offset + header->main_size;
2099 struct data_in *data_in;
2100 struct lto_input_block ib_main;
2104 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2108 lto_data_in_create (file_data, (const char *) data + string_offset,
2109 header->string_size, NULL);
2110 count = lto_input_uleb128 (&ib_main);
2112 for (i = 0; i < count; i++)
2115 struct cgraph_node *node;
2116 lto_cgraph_encoder_t encoder;
2118 index = lto_input_uleb128 (&ib_main);
2119 encoder = file_data->cgraph_node_encoder;
2120 node = lto_cgraph_encoder_deref (encoder, index);
2121 ipa_read_node_info (&ib_main, node, data_in);
2123 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2125 lto_data_in_delete (data_in);
2128 /* Read ipcp jump functions. */
2131 ipa_prop_read_jump_functions (void)
2133 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2134 struct lto_file_decl_data *file_data;
2137 ipa_check_create_node_params ();
2138 ipa_check_create_edge_args ();
2139 ipa_register_cgraph_hooks ();
2141 while ((file_data = file_data_vec[j++]))
2144 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2147 ipa_prop_read_section (file_data, data, len);
2151 /* After merging units, we can get mismatch in argument counts.
2152 Also decl merging might've rendered parameter lists obsolette.
2153 Also compute called_with_variable_arg info. */
2156 ipa_update_after_lto_read (void)
2158 struct cgraph_node *node;
2159 struct cgraph_edge *cs;
2161 ipa_check_create_node_params ();
2162 ipa_check_create_edge_args ();
2164 for (node = cgraph_nodes; node; node = node->next)
2166 if (!node->analyzed)
2168 ipa_initialize_node_params (node);
2169 for (cs = node->callees; cs; cs = cs->next_callee)
2171 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2172 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2173 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));