1 /* Interprocedural analyses.
2 Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "langhooks.h"
30 #include "tree-flow.h"
31 #include "tree-pass.h"
32 #include "tree-inline.h"
37 #include "diagnostic.h"
38 #include "tree-pretty-print.h"
39 #include "gimple-pretty-print.h"
40 #include "lto-streamer.h"
41 #include "data-streamer.h"
42 #include "tree-streamer.h"
45 /* Intermediate information about a parameter that is only useful during the
46 run of ipa_analyze_node and is not kept afterwards. */
48 struct param_analysis_info
51 bitmap visited_statements;
54 /* Vector where the parameter infos are actually stored. */
55 VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
56 /* Vector where the parameter infos are actually stored. */
57 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
59 /* Holders of ipa cgraph hooks: */
60 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
61 static struct cgraph_node_hook_list *node_removal_hook_holder;
62 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
63 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
64 static struct cgraph_node_hook_list *function_insertion_hook_holder;
66 /* Return index of the formal whose tree is PTREE in function which corresponds
70 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
74 count = ipa_get_param_count (info);
75 for (i = 0; i < count; i++)
76 if (ipa_get_param (info, i) == ptree)
82 /* Populate the param_decl field in parameter descriptors of INFO that
83 corresponds to NODE. */
86 ipa_populate_param_decls (struct cgraph_node *node,
87 struct ipa_node_params *info)
95 fnargs = DECL_ARGUMENTS (fndecl);
97 for (parm = fnargs; parm; parm = DECL_CHAIN (parm))
99 VEC_index (ipa_param_descriptor_t,
100 info->descriptors, param_num)->decl = parm;
105 /* Return how many formal parameters FNDECL has. */
108 count_formal_params (tree fndecl)
113 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
119 /* Initialize the ipa_node_params structure associated with NODE by counting
120 the function parameters, creating the descriptors and populating their
124 ipa_initialize_node_params (struct cgraph_node *node)
126 struct ipa_node_params *info = IPA_NODE_REF (node);
128 if (!info->descriptors)
132 param_count = count_formal_params (node->decl);
135 VEC_safe_grow_cleared (ipa_param_descriptor_t, heap,
136 info->descriptors, param_count);
137 ipa_populate_param_decls (node, info);
142 /* Print the jump functions associated with call graph edge CS to file F. */
145 ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
149 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
150 for (i = 0; i < count; i++)
152 struct ipa_jump_func *jump_func;
153 enum jump_func_type type;
155 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
156 type = jump_func->type;
158 fprintf (f, " param %d: ", i);
159 if (type == IPA_JF_UNKNOWN)
160 fprintf (f, "UNKNOWN\n");
161 else if (type == IPA_JF_KNOWN_TYPE)
163 fprintf (f, "KNOWN TYPE: base ");
164 print_generic_expr (f, jump_func->value.known_type.base_type, 0);
165 fprintf (f, ", offset "HOST_WIDE_INT_PRINT_DEC", component ",
166 jump_func->value.known_type.offset);
167 print_generic_expr (f, jump_func->value.known_type.component_type, 0);
170 else if (type == IPA_JF_CONST)
172 tree val = jump_func->value.constant;
173 fprintf (f, "CONST: ");
174 print_generic_expr (f, val, 0);
175 if (TREE_CODE (val) == ADDR_EXPR
176 && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
179 print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
184 else if (type == IPA_JF_CONST_MEMBER_PTR)
186 fprintf (f, "CONST MEMBER PTR: ");
187 print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
189 print_generic_expr (f, jump_func->value.member_cst.delta, 0);
192 else if (type == IPA_JF_PASS_THROUGH)
194 fprintf (f, "PASS THROUGH: ");
195 fprintf (f, "%d, op %s ",
196 jump_func->value.pass_through.formal_id,
198 jump_func->value.pass_through.operation]);
199 if (jump_func->value.pass_through.operation != NOP_EXPR)
200 print_generic_expr (f,
201 jump_func->value.pass_through.operand, 0);
204 else if (type == IPA_JF_ANCESTOR)
206 fprintf (f, "ANCESTOR: ");
207 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
208 jump_func->value.ancestor.formal_id,
209 jump_func->value.ancestor.offset);
210 print_generic_expr (f, jump_func->value.ancestor.type, 0);
217 /* Print the jump functions of all arguments on all call graph edges going from
221 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
223 struct cgraph_edge *cs;
226 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
227 for (cs = node->callees; cs; cs = cs->next_callee)
229 if (!ipa_edge_args_info_available_for_edge_p (cs))
232 fprintf (f, " callsite %s/%i -> %s/%i : \n",
233 cgraph_node_name (node), node->uid,
234 cgraph_node_name (cs->callee), cs->callee->uid);
235 ipa_print_node_jump_functions_for_edge (f, cs);
238 for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++)
240 if (!ipa_edge_args_info_available_for_edge_p (cs))
245 fprintf (f, " indirect callsite %d for stmt ", i);
246 print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
249 fprintf (f, " indirect callsite %d :\n", i);
250 ipa_print_node_jump_functions_for_edge (f, cs);
255 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
258 ipa_print_all_jump_functions (FILE *f)
260 struct cgraph_node *node;
262 fprintf (f, "\nJump functions:\n");
263 for (node = cgraph_nodes; node; node = node->next)
265 ipa_print_node_jump_functions (f, node);
269 /* Structure to be passed in between detect_type_change and
270 check_stmt_for_type_change. */
272 struct type_change_info
274 /* Set to true if dynamic type change has been detected. */
275 bool type_maybe_changed;
278 /* Return true if STMT can modify a virtual method table pointer.
280 This function makes special assumptions about both constructors and
281 destructors which are all the functions that are allowed to alter the VMT
282 pointers. It assumes that destructors begin with assignment into all VMT
283 pointers and that constructors essentially look in the following way:
285 1) The very first thing they do is that they call constructors of ancestor
286 sub-objects that have them.
288 2) Then VMT pointers of this and all its ancestors is set to new values
289 corresponding to the type corresponding to the constructor.
291 3) Only afterwards, other stuff such as constructor of member sub-objects
292 and the code written by the user is run. Only this may include calling
293 virtual functions, directly or indirectly.
295 There is no way to call a constructor of an ancestor sub-object in any
298 This means that we do not have to care whether constructors get the correct
299 type information because they will always change it (in fact, if we define
300 the type to be given by the VMT pointer, it is undefined).
302 The most important fact to derive from the above is that if, for some
303 statement in the section 3, we try to detect whether the dynamic type has
304 changed, we can safely ignore all calls as we examine the function body
305 backwards until we reach statements in section 2 because these calls cannot
306 be ancestor constructors or destructors (if the input is not bogus) and so
307 do not change the dynamic type (this holds true only for automatically
308 allocated objects but at the moment we devirtualize only these). We then
309 must detect that statements in section 2 change the dynamic type and can try
310 to derive the new type. That is enough and we can stop, we will never see
311 the calls into constructors of sub-objects in this code. Therefore we can
312 safely ignore all call statements that we traverse.
316 stmt_may_be_vtbl_ptr_store (gimple stmt)
318 if (is_gimple_call (stmt))
320 else if (is_gimple_assign (stmt))
322 tree lhs = gimple_assign_lhs (stmt);
324 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs)))
326 if (flag_strict_aliasing
327 && !POINTER_TYPE_P (TREE_TYPE (lhs)))
330 if (TREE_CODE (lhs) == COMPONENT_REF
331 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1)))
333 /* In the future we might want to use get_base_ref_and_offset to find
334 if there is a field corresponding to the offset and if so, proceed
335 almost like if it was a component ref. */
341 /* Callback of walk_aliased_vdefs and a helper function for
342 detect_type_change to check whether a particular statement may modify
343 the virtual table pointer, and if possible also determine the new type of
344 the (sub-)object. It stores its result into DATA, which points to a
345 type_change_info structure. */
348 check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
350 gimple stmt = SSA_NAME_DEF_STMT (vdef);
351 struct type_change_info *tci = (struct type_change_info *) data;
353 if (stmt_may_be_vtbl_ptr_store (stmt))
355 tci->type_maybe_changed = true;
362 /* Detect whether the dynamic type of ARG has changed (before callsite CALL) by
363 looking for assignments to its virtual table pointer. If it is, return true
364 and fill in the jump function JFUNC with relevant type information or set it
365 to unknown. ARG is the object itself (not a pointer to it, unless
366 dereferenced). BASE is the base of the memory access as returned by
367 get_ref_base_and_extent, as is the offset. */
370 detect_type_change (tree arg, tree base, gimple call,
371 struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
373 struct type_change_info tci;
376 gcc_checking_assert (DECL_P (arg)
377 || TREE_CODE (arg) == MEM_REF
378 || handled_component_p (arg));
379 /* Const calls cannot call virtual methods through VMT and so type changes do
381 if (!flag_devirtualize || !gimple_vuse (call))
384 tci.type_maybe_changed = false;
389 ao.size = POINTER_SIZE;
390 ao.max_size = ao.size;
391 ao.ref_alias_set = -1;
392 ao.base_alias_set = -1;
394 walk_aliased_vdefs (&ao, gimple_vuse (call), check_stmt_for_type_change,
396 if (!tci.type_maybe_changed)
399 jfunc->type = IPA_JF_UNKNOWN;
403 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
404 SSA name (its dereference will become the base and the offset is assumed to
408 detect_type_change_ssa (tree arg, gimple call, struct ipa_jump_func *jfunc)
410 gcc_checking_assert (TREE_CODE (arg) == SSA_NAME);
411 if (!flag_devirtualize
412 || !POINTER_TYPE_P (TREE_TYPE (arg))
413 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != RECORD_TYPE)
416 arg = build2 (MEM_REF, ptr_type_node, arg,
417 build_int_cst (ptr_type_node, 0));
419 return detect_type_change (arg, arg, call, jfunc, 0);
423 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
424 of an assignment statement STMT, try to find out whether NAME can be
425 described by a (possibly polynomial) pass-through jump-function or an
426 ancestor jump function and if so, write the appropriate function into
430 compute_complex_assign_jump_func (struct ipa_node_params *info,
431 struct ipa_jump_func *jfunc,
432 gimple call, gimple stmt, tree name)
434 HOST_WIDE_INT offset, size, max_size;
435 tree op1, op2, base, ssa;
438 op1 = gimple_assign_rhs1 (stmt);
439 op2 = gimple_assign_rhs2 (stmt);
441 if (TREE_CODE (op1) == SSA_NAME
442 && SSA_NAME_IS_DEFAULT_DEF (op1))
444 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
450 if (!is_gimple_ip_invariant (op2)
451 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
452 && !useless_type_conversion_p (TREE_TYPE (name),
456 jfunc->type = IPA_JF_PASS_THROUGH;
457 jfunc->value.pass_through.formal_id = index;
458 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
459 jfunc->value.pass_through.operand = op2;
461 else if (gimple_assign_unary_nop_p (stmt)
462 && !detect_type_change_ssa (op1, call, jfunc))
464 jfunc->type = IPA_JF_PASS_THROUGH;
465 jfunc->value.pass_through.formal_id = index;
466 jfunc->value.pass_through.operation = NOP_EXPR;
471 if (TREE_CODE (op1) != ADDR_EXPR)
473 op1 = TREE_OPERAND (op1, 0);
474 if (TREE_CODE (TREE_TYPE (op1)) != RECORD_TYPE)
476 base = get_ref_base_and_extent (op1, &offset, &size, &max_size);
477 if (TREE_CODE (base) != MEM_REF
478 /* If this is a varying address, punt. */
482 offset += mem_ref_offset (base).low * BITS_PER_UNIT;
483 ssa = TREE_OPERAND (base, 0);
484 if (TREE_CODE (ssa) != SSA_NAME
485 || !SSA_NAME_IS_DEFAULT_DEF (ssa)
489 /* Dynamic types are changed only in constructors and destructors and */
490 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (ssa));
492 && !detect_type_change (op1, base, call, jfunc, offset))
494 jfunc->type = IPA_JF_ANCESTOR;
495 jfunc->value.ancestor.formal_id = index;
496 jfunc->value.ancestor.offset = offset;
497 jfunc->value.ancestor.type = TREE_TYPE (op1);
501 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
504 iftmp.1_3 = &obj_2(D)->D.1762;
506 The base of the MEM_REF must be a default definition SSA NAME of a
507 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
508 whole MEM_REF expression is returned and the offset calculated from any
509 handled components and the MEM_REF itself is stored into *OFFSET. The whole
510 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
513 get_ancestor_addr_info (gimple assign, tree *obj_p, HOST_WIDE_INT *offset)
515 HOST_WIDE_INT size, max_size;
516 tree expr, parm, obj;
518 if (!gimple_assign_single_p (assign))
520 expr = gimple_assign_rhs1 (assign);
522 if (TREE_CODE (expr) != ADDR_EXPR)
524 expr = TREE_OPERAND (expr, 0);
526 expr = get_ref_base_and_extent (expr, offset, &size, &max_size);
528 if (TREE_CODE (expr) != MEM_REF
529 /* If this is a varying address, punt. */
534 parm = TREE_OPERAND (expr, 0);
535 if (TREE_CODE (parm) != SSA_NAME
536 || !SSA_NAME_IS_DEFAULT_DEF (parm)
537 || TREE_CODE (SSA_NAME_VAR (parm)) != PARM_DECL)
540 *offset += mem_ref_offset (expr).low * BITS_PER_UNIT;
546 /* Given that an actual argument is an SSA_NAME that is a result of a phi
547 statement PHI, try to find out whether NAME is in fact a
548 multiple-inheritance typecast from a descendant into an ancestor of a formal
549 parameter and thus can be described by an ancestor jump function and if so,
550 write the appropriate function into JFUNC.
552 Essentially we want to match the following pattern:
560 iftmp.1_3 = &obj_2(D)->D.1762;
563 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
564 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
568 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
569 struct ipa_jump_func *jfunc,
570 gimple call, gimple phi)
572 HOST_WIDE_INT offset;
574 basic_block phi_bb, assign_bb, cond_bb;
575 tree tmp, parm, expr, obj;
578 if (gimple_phi_num_args (phi) != 2)
581 if (integer_zerop (PHI_ARG_DEF (phi, 1)))
582 tmp = PHI_ARG_DEF (phi, 0);
583 else if (integer_zerop (PHI_ARG_DEF (phi, 0)))
584 tmp = PHI_ARG_DEF (phi, 1);
587 if (TREE_CODE (tmp) != SSA_NAME
588 || SSA_NAME_IS_DEFAULT_DEF (tmp)
589 || !POINTER_TYPE_P (TREE_TYPE (tmp))
590 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
593 assign = SSA_NAME_DEF_STMT (tmp);
594 assign_bb = gimple_bb (assign);
595 if (!single_pred_p (assign_bb))
597 expr = get_ancestor_addr_info (assign, &obj, &offset);
600 parm = TREE_OPERAND (expr, 0);
601 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
602 gcc_assert (index >= 0);
604 cond_bb = single_pred (assign_bb);
605 cond = last_stmt (cond_bb);
607 || gimple_code (cond) != GIMPLE_COND
608 || gimple_cond_code (cond) != NE_EXPR
609 || gimple_cond_lhs (cond) != parm
610 || !integer_zerop (gimple_cond_rhs (cond)))
613 phi_bb = gimple_bb (phi);
614 for (i = 0; i < 2; i++)
616 basic_block pred = EDGE_PRED (phi_bb, i)->src;
617 if (pred != assign_bb && pred != cond_bb)
621 if (!detect_type_change (obj, expr, call, jfunc, offset))
623 jfunc->type = IPA_JF_ANCESTOR;
624 jfunc->value.ancestor.formal_id = index;
625 jfunc->value.ancestor.offset = offset;
626 jfunc->value.ancestor.type = TREE_TYPE (obj);
630 /* Given OP which is passed as an actual argument to a called function,
631 determine if it is possible to construct a KNOWN_TYPE jump function for it
632 and if so, create one and store it to JFUNC. */
635 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc,
638 HOST_WIDE_INT offset, size, max_size;
641 if (!flag_devirtualize
642 || TREE_CODE (op) != ADDR_EXPR
643 || TREE_CODE (TREE_TYPE (TREE_TYPE (op))) != RECORD_TYPE)
646 op = TREE_OPERAND (op, 0);
647 base = get_ref_base_and_extent (op, &offset, &size, &max_size);
651 || TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE
652 || is_global_var (base))
655 if (detect_type_change (op, base, call, jfunc, offset)
656 || !TYPE_BINFO (TREE_TYPE (base)))
659 jfunc->type = IPA_JF_KNOWN_TYPE;
660 jfunc->value.known_type.base_type = TREE_TYPE (base);
661 jfunc->value.known_type.offset = offset;
662 jfunc->value.known_type.component_type = TREE_TYPE (op);
666 /* Determine the jump functions of scalar arguments. Scalar means SSA names
667 and constants of a number of selected types. INFO is the ipa_node_params
668 structure associated with the caller, FUNCTIONS is a pointer to an array of
669 jump function structures associated with CALL which is the call statement
673 compute_scalar_jump_functions (struct ipa_node_params *info,
674 struct ipa_edge_args *args,
680 for (num = 0; num < gimple_call_num_args (call); num++)
682 struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, num);
683 arg = gimple_call_arg (call, num);
685 if (is_gimple_ip_invariant (arg))
687 jfunc->type = IPA_JF_CONST;
688 jfunc->value.constant = arg;
690 else if (TREE_CODE (arg) == SSA_NAME)
692 if (SSA_NAME_IS_DEFAULT_DEF (arg))
694 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
697 && !detect_type_change_ssa (arg, call, jfunc))
699 jfunc->type = IPA_JF_PASS_THROUGH;
700 jfunc->value.pass_through.formal_id = index;
701 jfunc->value.pass_through.operation = NOP_EXPR;
706 gimple stmt = SSA_NAME_DEF_STMT (arg);
707 if (is_gimple_assign (stmt))
708 compute_complex_assign_jump_func (info, jfunc, call, stmt, arg);
709 else if (gimple_code (stmt) == GIMPLE_PHI)
710 compute_complex_ancestor_jump_func (info, jfunc, call, stmt);
714 compute_known_type_jump_func (arg, jfunc, call);
718 /* Inspect the given TYPE and return true iff it has the same structure (the
719 same number of fields of the same types) as a C++ member pointer. If
720 METHOD_PTR and DELTA are non-NULL, store the trees representing the
721 corresponding fields there. */
724 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
728 if (TREE_CODE (type) != RECORD_TYPE)
731 fld = TYPE_FIELDS (type);
732 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
733 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
739 fld = DECL_CHAIN (fld);
740 if (!fld || INTEGRAL_TYPE_P (fld))
745 if (DECL_CHAIN (fld))
751 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
752 boolean variable pointed to by DATA. */
755 mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
758 bool *b = (bool *) data;
763 /* Return true if the formal parameter PARM might have been modified in this
764 function before reaching the statement CALL. PARM_INFO is a pointer to a
765 structure containing intermediate information about PARM. */
768 is_parm_modified_before_call (struct param_analysis_info *parm_info,
769 gimple call, tree parm)
771 bool modified = false;
774 if (parm_info->modified)
777 ao_ref_init (&refd, parm);
778 walk_aliased_vdefs (&refd, gimple_vuse (call), mark_modified,
779 &modified, &parm_info->visited_statements);
782 parm_info->modified = true;
788 /* Go through arguments of the CALL and for every one that looks like a member
789 pointer, check whether it can be safely declared pass-through and if so,
790 mark that to the corresponding item of jump FUNCTIONS. Return true iff
791 there are non-pass-through member pointers within the arguments. INFO
792 describes formal parameters of the caller. PARMS_INFO is a pointer to a
793 vector containing intermediate information about each formal parameter. */
796 compute_pass_through_member_ptrs (struct ipa_node_params *info,
797 struct param_analysis_info *parms_info,
798 struct ipa_edge_args *args,
801 bool undecided_members = false;
805 for (num = 0; num < gimple_call_num_args (call); num++)
807 arg = gimple_call_arg (call, num);
809 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
811 if (TREE_CODE (arg) == PARM_DECL)
813 int index = ipa_get_param_decl_index (info, arg);
815 gcc_assert (index >=0);
816 if (!is_parm_modified_before_call (&parms_info[index], call, arg))
818 struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args,
820 jfunc->type = IPA_JF_PASS_THROUGH;
821 jfunc->value.pass_through.formal_id = index;
822 jfunc->value.pass_through.operation = NOP_EXPR;
825 undecided_members = true;
828 undecided_members = true;
832 return undecided_members;
835 /* Simple function filling in a member pointer constant jump function (with PFN
836 and DELTA as the constant value) into JFUNC. */
839 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
840 tree pfn, tree delta)
842 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
843 jfunc->value.member_cst.pfn = pfn;
844 jfunc->value.member_cst.delta = delta;
847 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
848 return the rhs of its defining statement. */
851 get_ssa_def_if_simple_copy (tree rhs)
853 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
855 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
857 if (gimple_assign_single_p (def_stmt))
858 rhs = gimple_assign_rhs1 (def_stmt);
865 /* Traverse statements from CALL backwards, scanning whether the argument ARG
866 which is a member pointer is filled in with constant values. If it is, fill
867 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
868 fields of the record type of the member pointer. To give an example, we
869 look for a pattern looking like the following:
871 D.2515.__pfn ={v} printStuff;
872 D.2515.__delta ={v} 0;
873 i_1 = doprinting (D.2515); */
876 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
877 tree delta_field, struct ipa_jump_func *jfunc)
879 gimple_stmt_iterator gsi;
880 tree method = NULL_TREE;
881 tree delta = NULL_TREE;
883 gsi = gsi_for_stmt (call);
886 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
888 gimple stmt = gsi_stmt (gsi);
891 if (!stmt_may_clobber_ref_p (stmt, arg))
893 if (!gimple_assign_single_p (stmt))
896 lhs = gimple_assign_lhs (stmt);
897 rhs = gimple_assign_rhs1 (stmt);
899 if (TREE_CODE (lhs) != COMPONENT_REF
900 || TREE_OPERAND (lhs, 0) != arg)
903 fld = TREE_OPERAND (lhs, 1);
904 if (!method && fld == method_field)
906 rhs = get_ssa_def_if_simple_copy (rhs);
907 if (TREE_CODE (rhs) == ADDR_EXPR
908 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
909 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
911 method = TREE_OPERAND (rhs, 0);
914 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
922 if (!delta && fld == delta_field)
924 rhs = get_ssa_def_if_simple_copy (rhs);
925 if (TREE_CODE (rhs) == INTEGER_CST)
930 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
942 /* Go through the arguments of the CALL and for every member pointer within
943 tries determine whether it is a constant. If it is, create a corresponding
944 constant jump function in FUNCTIONS which is an array of jump functions
945 associated with the call. */
948 compute_cst_member_ptr_arguments (struct ipa_edge_args *args,
952 tree arg, method_field, delta_field;
954 for (num = 0; num < gimple_call_num_args (call); num++)
956 struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, num);
957 arg = gimple_call_arg (call, num);
959 if (jfunc->type == IPA_JF_UNKNOWN
960 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
962 determine_cst_member_ptr (call, arg, method_field, delta_field, jfunc);
966 /* Compute jump function for all arguments of callsite CS and insert the
967 information in the jump_functions array in the ipa_edge_args corresponding
971 ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_info,
972 struct cgraph_edge *cs)
974 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
975 struct ipa_edge_args *args = IPA_EDGE_REF (cs);
976 gimple call = cs->call_stmt;
977 int arg_num = gimple_call_num_args (call);
979 if (arg_num == 0 || args->jump_functions)
981 VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions, arg_num);
983 /* We will deal with constants and SSA scalars first: */
984 compute_scalar_jump_functions (info, args, call);
986 /* Let's check whether there are any potential member pointers and if so,
987 whether we can determine their functions as pass_through. */
988 if (!compute_pass_through_member_ptrs (info, parms_info, args, call))
991 /* Finally, let's check whether we actually pass a new constant member
993 compute_cst_member_ptr_arguments (args, call);
996 /* Compute jump functions for all edges - both direct and indirect - outgoing
997 from NODE. Also count the actual arguments in the process. */
1000 ipa_compute_jump_functions (struct cgraph_node *node,
1001 struct param_analysis_info *parms_info)
1003 struct cgraph_edge *cs;
1005 for (cs = node->callees; cs; cs = cs->next_callee)
1007 struct cgraph_node *callee = cgraph_function_or_thunk_node (cs->callee,
1009 /* We do not need to bother analyzing calls to unknown
1010 functions unless they may become known during lto/whopr. */
1011 if (!callee->analyzed && !flag_lto)
1013 ipa_compute_jump_functions_for_edge (parms_info, cs);
1016 for (cs = node->indirect_calls; cs; cs = cs->next_callee)
1017 ipa_compute_jump_functions_for_edge (parms_info, cs);
1020 /* If RHS looks like a rhs of a statement loading pfn from a member
1021 pointer formal parameter, return the parameter, otherwise return
1022 NULL. If USE_DELTA, then we look for a use of the delta field
1023 rather than the pfn. */
1026 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
1028 tree rec, ref_field, ref_offset, fld, fld_offset, ptr_field, delta_field;
1030 if (TREE_CODE (rhs) == COMPONENT_REF)
1032 ref_field = TREE_OPERAND (rhs, 1);
1033 rhs = TREE_OPERAND (rhs, 0);
1036 ref_field = NULL_TREE;
1037 if (TREE_CODE (rhs) != MEM_REF)
1039 rec = TREE_OPERAND (rhs, 0);
1040 if (TREE_CODE (rec) != ADDR_EXPR)
1042 rec = TREE_OPERAND (rec, 0);
1043 if (TREE_CODE (rec) != PARM_DECL
1044 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
1047 ref_offset = TREE_OPERAND (rhs, 1);
1051 if (integer_nonzerop (ref_offset))
1059 return ref_field == fld ? rec : NULL_TREE;
1063 fld_offset = byte_position (delta_field);
1065 fld_offset = byte_position (ptr_field);
1067 return tree_int_cst_equal (ref_offset, fld_offset) ? rec : NULL_TREE;
1070 /* If STMT looks like a statement loading a value from a member pointer formal
1071 parameter, this function returns that parameter. */
1074 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
1078 if (!gimple_assign_single_p (stmt))
1081 rhs = gimple_assign_rhs1 (stmt);
1082 return ipa_get_member_ptr_load_param (rhs, use_delta);
1085 /* Returns true iff T is an SSA_NAME defined by a statement. */
1088 ipa_is_ssa_with_stmt_def (tree t)
1090 if (TREE_CODE (t) == SSA_NAME
1091 && !SSA_NAME_IS_DEFAULT_DEF (t))
1097 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1098 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1099 indirect call graph edge. */
1101 static struct cgraph_edge *
1102 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt)
1104 struct cgraph_edge *cs;
1106 cs = cgraph_edge (node, stmt);
1107 cs->indirect_info->param_index = param_index;
1108 cs->indirect_info->anc_offset = 0;
1109 cs->indirect_info->polymorphic = 0;
1113 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1114 (described by INFO). PARMS_INFO is a pointer to a vector containing
1115 intermediate information about each formal parameter. Currently it checks
1116 whether the call calls a pointer that is a formal parameter and if so, the
1117 parameter is marked with the called flag and an indirect call graph edge
1118 describing the call is created. This is very simple for ordinary pointers
1119 represented in SSA but not-so-nice when it comes to member pointers. The
1120 ugly part of this function does nothing more than trying to match the
1121 pattern of such a call. An example of such a pattern is the gimple dump
1122 below, the call is on the last line:
1125 f$__delta_5 = f.__delta;
1126 f$__pfn_24 = f.__pfn;
1130 f$__delta_5 = MEM[(struct *)&f];
1131 f$__pfn_24 = MEM[(struct *)&f + 4B];
1133 and a few lines below:
1136 D.2496_3 = (int) f$__pfn_24;
1137 D.2497_4 = D.2496_3 & 1;
1144 D.2500_7 = (unsigned int) f$__delta_5;
1145 D.2501_8 = &S + D.2500_7;
1146 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1147 D.2503_10 = *D.2502_9;
1148 D.2504_12 = f$__pfn_24 + -1;
1149 D.2505_13 = (unsigned int) D.2504_12;
1150 D.2506_14 = D.2503_10 + D.2505_13;
1151 D.2507_15 = *D.2506_14;
1152 iftmp.11_16 = (String:: *) D.2507_15;
1155 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1156 D.2500_19 = (unsigned int) f$__delta_5;
1157 D.2508_20 = &S + D.2500_19;
1158 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1160 Such patterns are results of simple calls to a member pointer:
1162 int doprinting (int (MyString::* f)(int) const)
1164 MyString S ("somestring");
1171 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1172 struct ipa_node_params *info,
1173 struct param_analysis_info *parms_info,
1174 gimple call, tree target)
1179 tree rec, rec2, cond;
1182 basic_block bb, virt_bb, join;
1184 if (SSA_NAME_IS_DEFAULT_DEF (target))
1186 tree var = SSA_NAME_VAR (target);
1187 index = ipa_get_param_decl_index (info, var);
1189 ipa_note_param_call (node, index, call);
1193 /* Now we need to try to match the complex pattern of calling a member
1196 if (!POINTER_TYPE_P (TREE_TYPE (target))
1197 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1200 def = SSA_NAME_DEF_STMT (target);
1201 if (gimple_code (def) != GIMPLE_PHI)
1204 if (gimple_phi_num_args (def) != 2)
1207 /* First, we need to check whether one of these is a load from a member
1208 pointer that is a parameter to this function. */
1209 n1 = PHI_ARG_DEF (def, 0);
1210 n2 = PHI_ARG_DEF (def, 1);
1211 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1213 d1 = SSA_NAME_DEF_STMT (n1);
1214 d2 = SSA_NAME_DEF_STMT (n2);
1216 join = gimple_bb (def);
1217 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1219 if (ipa_get_stmt_member_ptr_load_param (d2, false))
1222 bb = EDGE_PRED (join, 0)->src;
1223 virt_bb = gimple_bb (d2);
1225 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1227 bb = EDGE_PRED (join, 1)->src;
1228 virt_bb = gimple_bb (d1);
1233 /* Second, we need to check that the basic blocks are laid out in the way
1234 corresponding to the pattern. */
1236 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1237 || single_pred (virt_bb) != bb
1238 || single_succ (virt_bb) != join)
1241 /* Third, let's see that the branching is done depending on the least
1242 significant bit of the pfn. */
1244 branch = last_stmt (bb);
1245 if (!branch || gimple_code (branch) != GIMPLE_COND)
1248 if ((gimple_cond_code (branch) != NE_EXPR
1249 && gimple_cond_code (branch) != EQ_EXPR)
1250 || !integer_zerop (gimple_cond_rhs (branch)))
1253 cond = gimple_cond_lhs (branch);
1254 if (!ipa_is_ssa_with_stmt_def (cond))
1257 def = SSA_NAME_DEF_STMT (cond);
1258 if (!is_gimple_assign (def)
1259 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1260 || !integer_onep (gimple_assign_rhs2 (def)))
1263 cond = gimple_assign_rhs1 (def);
1264 if (!ipa_is_ssa_with_stmt_def (cond))
1267 def = SSA_NAME_DEF_STMT (cond);
1269 if (is_gimple_assign (def)
1270 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1272 cond = gimple_assign_rhs1 (def);
1273 if (!ipa_is_ssa_with_stmt_def (cond))
1275 def = SSA_NAME_DEF_STMT (cond);
1278 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1279 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1280 == ptrmemfunc_vbit_in_delta));
1285 index = ipa_get_param_decl_index (info, rec);
1286 if (index >= 0 && !is_parm_modified_before_call (&parms_info[index],
1288 ipa_note_param_call (node, index, call);
1293 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1294 object referenced in the expression is a formal parameter of the caller
1295 (described by INFO), create a call note for the statement. */
1298 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1299 struct ipa_node_params *info, gimple call,
1302 struct cgraph_edge *cs;
1303 struct cgraph_indirect_call_info *ii;
1304 struct ipa_jump_func jfunc;
1305 tree obj = OBJ_TYPE_REF_OBJECT (target);
1307 HOST_WIDE_INT anc_offset;
1309 if (!flag_devirtualize)
1312 if (TREE_CODE (obj) != SSA_NAME)
1315 if (SSA_NAME_IS_DEFAULT_DEF (obj))
1317 if (TREE_CODE (SSA_NAME_VAR (obj)) != PARM_DECL)
1321 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (obj));
1322 gcc_assert (index >= 0);
1323 if (detect_type_change_ssa (obj, call, &jfunc))
1328 gimple stmt = SSA_NAME_DEF_STMT (obj);
1331 expr = get_ancestor_addr_info (stmt, &obj, &anc_offset);
1334 index = ipa_get_param_decl_index (info,
1335 SSA_NAME_VAR (TREE_OPERAND (expr, 0)));
1336 gcc_assert (index >= 0);
1337 if (detect_type_change (obj, expr, call, &jfunc, anc_offset))
1341 cs = ipa_note_param_call (node, index, call);
1342 ii = cs->indirect_info;
1343 ii->anc_offset = anc_offset;
1344 ii->otr_token = tree_low_cst (OBJ_TYPE_REF_TOKEN (target), 1);
1345 ii->otr_type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (target)));
1346 ii->polymorphic = 1;
1349 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1350 of the caller (described by INFO). PARMS_INFO is a pointer to a vector
1351 containing intermediate information about each formal parameter. */
1354 ipa_analyze_call_uses (struct cgraph_node *node,
1355 struct ipa_node_params *info,
1356 struct param_analysis_info *parms_info, gimple call)
1358 tree target = gimple_call_fn (call);
1362 if (TREE_CODE (target) == SSA_NAME)
1363 ipa_analyze_indirect_call_uses (node, info, parms_info, call, target);
1364 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1365 ipa_analyze_virtual_call_uses (node, info, call, target);
1369 /* Analyze the call statement STMT with respect to formal parameters (described
1370 in INFO) of caller given by NODE. Currently it only checks whether formal
1371 parameters are called. PARMS_INFO is a pointer to a vector containing
1372 intermediate information about each formal parameter. */
1375 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1376 struct param_analysis_info *parms_info, gimple stmt)
1378 if (is_gimple_call (stmt))
1379 ipa_analyze_call_uses (node, info, parms_info, stmt);
1382 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1383 If OP is a parameter declaration, mark it as used in the info structure
1387 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
1388 tree op, void *data)
1390 struct ipa_node_params *info = (struct ipa_node_params *) data;
1392 op = get_base_address (op);
1394 && TREE_CODE (op) == PARM_DECL)
1396 int index = ipa_get_param_decl_index (info, op);
1397 gcc_assert (index >= 0);
1398 ipa_set_param_used (info, index, true);
1404 /* Scan the function body of NODE and inspect the uses of formal parameters.
1405 Store the findings in various structures of the associated ipa_node_params
1406 structure, such as parameter flags, notes etc. PARMS_INFO is a pointer to a
1407 vector containing intermediate information about each formal parameter. */
1410 ipa_analyze_params_uses (struct cgraph_node *node,
1411 struct param_analysis_info *parms_info)
1413 tree decl = node->decl;
1415 struct function *func;
1416 gimple_stmt_iterator gsi;
1417 struct ipa_node_params *info = IPA_NODE_REF (node);
1420 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1423 for (i = 0; i < ipa_get_param_count (info); i++)
1425 tree parm = ipa_get_param (info, i);
1426 /* For SSA regs see if parameter is used. For non-SSA we compute
1427 the flag during modification analysis. */
1428 if (is_gimple_reg (parm)
1429 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
1430 ipa_set_param_used (info, i, true);
1433 func = DECL_STRUCT_FUNCTION (decl);
1434 FOR_EACH_BB_FN (bb, func)
1436 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1438 gimple stmt = gsi_stmt (gsi);
1440 if (is_gimple_debug (stmt))
1443 ipa_analyze_stmt_uses (node, info, parms_info, stmt);
1444 walk_stmt_load_store_addr_ops (stmt, info,
1445 visit_ref_for_mod_analysis,
1446 visit_ref_for_mod_analysis,
1447 visit_ref_for_mod_analysis);
1449 for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
1450 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
1451 visit_ref_for_mod_analysis,
1452 visit_ref_for_mod_analysis,
1453 visit_ref_for_mod_analysis);
1456 info->uses_analysis_done = 1;
1459 /* Initialize the array describing properties of of formal parameters
1460 of NODE, analyze their uses and compute jump functions associated
1461 with actual arguments of calls from within NODE. */
1464 ipa_analyze_node (struct cgraph_node *node)
1466 struct ipa_node_params *info;
1467 struct param_analysis_info *parms_info;
1470 ipa_check_create_node_params ();
1471 ipa_check_create_edge_args ();
1472 info = IPA_NODE_REF (node);
1473 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1474 current_function_decl = node->decl;
1475 ipa_initialize_node_params (node);
1477 param_count = ipa_get_param_count (info);
1478 parms_info = XALLOCAVEC (struct param_analysis_info, param_count);
1479 memset (parms_info, 0, sizeof (struct param_analysis_info) * param_count);
1481 ipa_analyze_params_uses (node, parms_info);
1482 ipa_compute_jump_functions (node, parms_info);
1484 for (i = 0; i < param_count; i++)
1485 if (parms_info[i].visited_statements)
1486 BITMAP_FREE (parms_info[i].visited_statements);
1488 current_function_decl = NULL;
1493 /* Update the jump function DST when the call graph edge corresponding to SRC is
1494 is being inlined, knowing that DST is of type ancestor and src of known
1498 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1499 struct ipa_jump_func *dst)
1501 HOST_WIDE_INT combined_offset;
1504 combined_offset = src->value.known_type.offset + dst->value.ancestor.offset;
1505 combined_type = dst->value.ancestor.type;
1507 dst->type = IPA_JF_KNOWN_TYPE;
1508 dst->value.known_type.base_type = src->value.known_type.base_type;
1509 dst->value.known_type.offset = combined_offset;
1510 dst->value.known_type.component_type = combined_type;
1513 /* Update the jump functions associated with call graph edge E when the call
1514 graph edge CS is being inlined, assuming that E->caller is already (possibly
1515 indirectly) inlined into CS->callee and that E has not been inlined. */
1518 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1519 struct cgraph_edge *e)
1521 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1522 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1523 int count = ipa_get_cs_argument_count (args);
1526 for (i = 0; i < count; i++)
1528 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1530 if (dst->type == IPA_JF_ANCESTOR)
1532 struct ipa_jump_func *src;
1534 /* Variable number of arguments can cause havoc if we try to access
1535 one that does not exist in the inlined edge. So make sure we
1537 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1539 dst->type = IPA_JF_UNKNOWN;
1543 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1544 if (src->type == IPA_JF_KNOWN_TYPE)
1545 combine_known_type_and_ancestor_jfs (src, dst);
1546 else if (src->type == IPA_JF_PASS_THROUGH
1547 && src->value.pass_through.operation == NOP_EXPR)
1548 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1549 else if (src->type == IPA_JF_ANCESTOR)
1551 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1552 dst->value.ancestor.offset += src->value.ancestor.offset;
1555 dst->type = IPA_JF_UNKNOWN;
1557 else if (dst->type == IPA_JF_PASS_THROUGH)
1559 struct ipa_jump_func *src;
1560 /* We must check range due to calls with variable number of arguments
1561 and we cannot combine jump functions with operations. */
1562 if (dst->value.pass_through.operation == NOP_EXPR
1563 && (dst->value.pass_through.formal_id
1564 < ipa_get_cs_argument_count (top)))
1566 src = ipa_get_ith_jump_func (top,
1567 dst->value.pass_through.formal_id);
1571 dst->type = IPA_JF_UNKNOWN;
1576 /* If TARGET is an addr_expr of a function declaration, make it the destination
1577 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1579 struct cgraph_edge *
1580 ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
1582 struct cgraph_node *callee;
1584 if (TREE_CODE (target) == ADDR_EXPR)
1585 target = TREE_OPERAND (target, 0);
1586 if (TREE_CODE (target) != FUNCTION_DECL)
1588 callee = cgraph_get_node (target);
1591 ipa_check_create_node_params ();
1593 /* We can not make edges to inline clones. It is bug that someone removed
1594 the cgraph node too early. */
1595 gcc_assert (!callee->global.inlined_to);
1597 cgraph_make_edge_direct (ie, callee);
1600 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1601 "(%s/%i -> %s/%i), for stmt ",
1602 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1603 cgraph_node_name (ie->caller), ie->caller->uid,
1604 cgraph_node_name (ie->callee), ie->callee->uid);
1606 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1608 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1610 callee = cgraph_function_or_thunk_node (callee, NULL);
1615 /* Try to find a destination for indirect edge IE that corresponds to a simple
1616 call or a call of a member function pointer and where the destination is a
1617 pointer formal parameter described by jump function JFUNC. If it can be
1618 determined, return the newly direct edge, otherwise return NULL. */
1620 static struct cgraph_edge *
1621 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1622 struct ipa_jump_func *jfunc)
1626 if (jfunc->type == IPA_JF_CONST)
1627 target = jfunc->value.constant;
1628 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1629 target = jfunc->value.member_cst.pfn;
1633 return ipa_make_edge_direct_to_target (ie, target);
1636 /* Try to find a destination for indirect edge IE that corresponds to a
1637 virtual call based on a formal parameter which is described by jump
1638 function JFUNC and if it can be determined, make it direct and return the
1639 direct edge. Otherwise, return NULL. */
1641 static struct cgraph_edge *
1642 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1643 struct ipa_jump_func *jfunc)
1647 if (jfunc->type != IPA_JF_KNOWN_TYPE)
1650 binfo = TYPE_BINFO (jfunc->value.known_type.base_type);
1651 gcc_checking_assert (binfo);
1652 binfo = get_binfo_at_offset (binfo, jfunc->value.known_type.offset
1653 + ie->indirect_info->anc_offset,
1654 ie->indirect_info->otr_type);
1656 target = gimple_get_virt_method_for_binfo (ie->indirect_info->otr_token,
1662 return ipa_make_edge_direct_to_target (ie, target);
1667 /* Update the param called notes associated with NODE when CS is being inlined,
1668 assuming NODE is (potentially indirectly) inlined into CS->callee.
1669 Moreover, if the callee is discovered to be constant, create a new cgraph
1670 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1671 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1674 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1675 struct cgraph_node *node,
1676 VEC (cgraph_edge_p, heap) **new_edges)
1678 struct ipa_edge_args *top;
1679 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1682 ipa_check_create_edge_args ();
1683 top = IPA_EDGE_REF (cs);
1685 for (ie = node->indirect_calls; ie; ie = next_ie)
1687 struct cgraph_indirect_call_info *ici = ie->indirect_info;
1688 struct ipa_jump_func *jfunc;
1690 next_ie = ie->next_callee;
1692 if (ici->param_index == -1)
1695 /* We must check range due to calls with variable number of arguments: */
1696 if (ici->param_index >= ipa_get_cs_argument_count (top))
1698 ici->param_index = -1;
1702 jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1703 if (jfunc->type == IPA_JF_PASS_THROUGH
1704 && jfunc->value.pass_through.operation == NOP_EXPR)
1705 ici->param_index = jfunc->value.pass_through.formal_id;
1706 else if (jfunc->type == IPA_JF_ANCESTOR)
1708 ici->param_index = jfunc->value.ancestor.formal_id;
1709 ici->anc_offset += jfunc->value.ancestor.offset;
1712 /* Either we can find a destination for this edge now or never. */
1713 ici->param_index = -1;
1715 if (!flag_indirect_inlining)
1718 if (ici->polymorphic)
1719 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1721 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1723 if (new_direct_edge)
1725 new_direct_edge->indirect_inlining_edge = 1;
1728 VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1730 top = IPA_EDGE_REF (cs);
1739 /* Recursively traverse subtree of NODE (including node) made of inlined
1740 cgraph_edges when CS has been inlined and invoke
1741 update_indirect_edges_after_inlining on all nodes and
1742 update_jump_functions_after_inlining on all non-inlined edges that lead out
1743 of this subtree. Newly discovered indirect edges will be added to
1744 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1748 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1749 struct cgraph_node *node,
1750 VEC (cgraph_edge_p, heap) **new_edges)
1752 struct cgraph_edge *e;
1755 res = update_indirect_edges_after_inlining (cs, node, new_edges);
1757 for (e = node->callees; e; e = e->next_callee)
1758 if (!e->inline_failed)
1759 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1761 update_jump_functions_after_inlining (cs, e);
1762 for (e = node->indirect_calls; e; e = e->next_callee)
1763 update_jump_functions_after_inlining (cs, e);
1768 /* Update jump functions and call note functions on inlining the call site CS.
1769 CS is expected to lead to a node already cloned by
1770 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1771 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1775 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1776 VEC (cgraph_edge_p, heap) **new_edges)
1779 /* Do nothing if the preparation phase has not been carried out yet
1780 (i.e. during early inlining). */
1781 if (!ipa_node_params_vector)
1783 gcc_assert (ipa_edge_args_vector);
1785 changed = propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1787 /* We do not keep jump functions of inlined edges up to date. Better to free
1788 them so we do not access them accidentally. */
1789 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1793 /* Frees all dynamically allocated structures that the argument info points
1797 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1799 if (args->jump_functions)
1800 ggc_free (args->jump_functions);
1802 memset (args, 0, sizeof (*args));
1805 /* Free all ipa_edge structures. */
1808 ipa_free_all_edge_args (void)
1811 struct ipa_edge_args *args;
1813 FOR_EACH_VEC_ELT (ipa_edge_args_t, ipa_edge_args_vector, i, args)
1814 ipa_free_edge_args_substructures (args);
1816 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1817 ipa_edge_args_vector = NULL;
1820 /* Frees all dynamically allocated structures that the param info points
1824 ipa_free_node_params_substructures (struct ipa_node_params *info)
1826 VEC_free (ipa_param_descriptor_t, heap, info->descriptors);
1827 free (info->lattices);
1828 /* Lattice values and their sources are deallocated with their alocation
1830 VEC_free (tree, heap, info->known_vals);
1831 memset (info, 0, sizeof (*info));
1834 /* Free all ipa_node_params structures. */
1837 ipa_free_all_node_params (void)
1840 struct ipa_node_params *info;
1842 FOR_EACH_VEC_ELT (ipa_node_params_t, ipa_node_params_vector, i, info)
1843 ipa_free_node_params_substructures (info);
1845 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1846 ipa_node_params_vector = NULL;
1849 /* Hook that is called by cgraph.c when an edge is removed. */
1852 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1854 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1855 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1856 <= (unsigned)cs->uid)
1858 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1861 /* Hook that is called by cgraph.c when a node is removed. */
1864 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1866 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1867 if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1868 <= (unsigned)node->uid)
1870 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1873 /* Hook that is called by cgraph.c when a node is duplicated. */
1876 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1877 __attribute__((unused)) void *data)
1879 struct ipa_edge_args *old_args, *new_args;
1881 ipa_check_create_edge_args ();
1883 old_args = IPA_EDGE_REF (src);
1884 new_args = IPA_EDGE_REF (dst);
1886 new_args->jump_functions = VEC_copy (ipa_jump_func_t, gc,
1887 old_args->jump_functions);
1890 /* Hook that is called by cgraph.c when a node is duplicated. */
1893 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1894 ATTRIBUTE_UNUSED void *data)
1896 struct ipa_node_params *old_info, *new_info;
1898 ipa_check_create_node_params ();
1899 old_info = IPA_NODE_REF (src);
1900 new_info = IPA_NODE_REF (dst);
1902 new_info->descriptors = VEC_copy (ipa_param_descriptor_t, heap,
1903 old_info->descriptors);
1904 new_info->lattices = NULL;
1905 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1907 new_info->uses_analysis_done = old_info->uses_analysis_done;
1908 new_info->node_enqueued = old_info->node_enqueued;
1912 /* Analyze newly added function into callgraph. */
1915 ipa_add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1917 ipa_analyze_node (node);
1920 /* Register our cgraph hooks if they are not already there. */
1923 ipa_register_cgraph_hooks (void)
1925 if (!edge_removal_hook_holder)
1926 edge_removal_hook_holder =
1927 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1928 if (!node_removal_hook_holder)
1929 node_removal_hook_holder =
1930 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1931 if (!edge_duplication_hook_holder)
1932 edge_duplication_hook_holder =
1933 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1934 if (!node_duplication_hook_holder)
1935 node_duplication_hook_holder =
1936 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1937 function_insertion_hook_holder =
1938 cgraph_add_function_insertion_hook (&ipa_add_new_function, NULL);
1941 /* Unregister our cgraph hooks if they are not already there. */
1944 ipa_unregister_cgraph_hooks (void)
1946 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1947 edge_removal_hook_holder = NULL;
1948 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1949 node_removal_hook_holder = NULL;
1950 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1951 edge_duplication_hook_holder = NULL;
1952 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1953 node_duplication_hook_holder = NULL;
1954 cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
1955 function_insertion_hook_holder = NULL;
1958 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1959 longer needed after ipa-cp. */
1962 ipa_free_all_structures_after_ipa_cp (void)
1966 ipa_free_all_edge_args ();
1967 ipa_free_all_node_params ();
1968 free_alloc_pool (ipcp_sources_pool);
1969 free_alloc_pool (ipcp_values_pool);
1970 ipa_unregister_cgraph_hooks ();
1974 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1975 longer needed after indirect inlining. */
1978 ipa_free_all_structures_after_iinln (void)
1980 ipa_free_all_edge_args ();
1981 ipa_free_all_node_params ();
1982 ipa_unregister_cgraph_hooks ();
1983 if (ipcp_sources_pool)
1984 free_alloc_pool (ipcp_sources_pool);
1985 if (ipcp_values_pool)
1986 free_alloc_pool (ipcp_values_pool);
1989 /* Print ipa_tree_map data structures of all functions in the
1993 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1997 struct ipa_node_params *info;
1999 if (!node->analyzed)
2001 info = IPA_NODE_REF (node);
2002 fprintf (f, " function %s parameter descriptors:\n",
2003 cgraph_node_name (node));
2004 count = ipa_get_param_count (info);
2005 for (i = 0; i < count; i++)
2007 temp = ipa_get_param (info, i);
2008 if (TREE_CODE (temp) == PARM_DECL)
2009 fprintf (f, " param %d : %s", i,
2011 ? (*lang_hooks.decl_printable_name) (temp, 2)
2013 if (ipa_is_param_used (info, i))
2014 fprintf (f, " used");
2019 /* Print ipa_tree_map data structures of all functions in the
2023 ipa_print_all_params (FILE * f)
2025 struct cgraph_node *node;
2027 fprintf (f, "\nFunction parameters:\n");
2028 for (node = cgraph_nodes; node; node = node->next)
2029 ipa_print_node_params (f, node);
2032 /* Return a heap allocated vector containing formal parameters of FNDECL. */
2035 ipa_get_vector_of_formal_parms (tree fndecl)
2037 VEC(tree, heap) *args;
2041 count = count_formal_params (fndecl);
2042 args = VEC_alloc (tree, heap, count);
2043 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
2044 VEC_quick_push (tree, args, parm);
2049 /* Return a heap allocated vector containing types of formal parameters of
2050 function type FNTYPE. */
2052 static inline VEC(tree, heap) *
2053 get_vector_of_formal_parm_types (tree fntype)
2055 VEC(tree, heap) *types;
2059 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
2062 types = VEC_alloc (tree, heap, count);
2063 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
2064 VEC_quick_push (tree, types, TREE_VALUE (t));
2069 /* Modify the function declaration FNDECL and its type according to the plan in
2070 ADJUSTMENTS. It also sets base fields of individual adjustments structures
2071 to reflect the actual parameters being modified which are determined by the
2072 base_index field. */
2075 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
2076 const char *synth_parm_prefix)
2078 VEC(tree, heap) *oparms, *otypes;
2079 tree orig_type, new_type = NULL;
2080 tree old_arg_types, t, new_arg_types = NULL;
2081 tree parm, *link = &DECL_ARGUMENTS (fndecl);
2082 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2083 tree new_reversed = NULL;
2084 bool care_for_types, last_parm_void;
2086 if (!synth_parm_prefix)
2087 synth_parm_prefix = "SYNTH";
2089 oparms = ipa_get_vector_of_formal_parms (fndecl);
2090 orig_type = TREE_TYPE (fndecl);
2091 old_arg_types = TYPE_ARG_TYPES (orig_type);
2093 /* The following test is an ugly hack, some functions simply don't have any
2094 arguments in their type. This is probably a bug but well... */
2095 care_for_types = (old_arg_types != NULL_TREE);
2098 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
2100 otypes = get_vector_of_formal_parm_types (orig_type);
2102 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
2104 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
2108 last_parm_void = false;
2112 for (i = 0; i < len; i++)
2114 struct ipa_parm_adjustment *adj;
2117 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2118 parm = VEC_index (tree, oparms, adj->base_index);
2121 if (adj->copy_param)
2124 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
2128 link = &DECL_CHAIN (parm);
2130 else if (!adj->remove_param)
2136 ptype = build_pointer_type (adj->type);
2141 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
2143 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
2145 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
2147 DECL_ARTIFICIAL (new_parm) = 1;
2148 DECL_ARG_TYPE (new_parm) = ptype;
2149 DECL_CONTEXT (new_parm) = fndecl;
2150 TREE_USED (new_parm) = 1;
2151 DECL_IGNORED_P (new_parm) = 1;
2152 layout_decl (new_parm, 0);
2154 add_referenced_var (new_parm);
2155 mark_sym_for_renaming (new_parm);
2157 adj->reduction = new_parm;
2161 link = &DECL_CHAIN (new_parm);
2169 new_reversed = nreverse (new_arg_types);
2173 TREE_CHAIN (new_arg_types) = void_list_node;
2175 new_reversed = void_list_node;
2179 /* Use copy_node to preserve as much as possible from original type
2180 (debug info, attribute lists etc.)
2181 Exception is METHOD_TYPEs must have THIS argument.
2182 When we are asked to remove it, we need to build new FUNCTION_TYPE
2184 if (TREE_CODE (orig_type) != METHOD_TYPE
2185 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
2186 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
2188 new_type = build_distinct_type_copy (orig_type);
2189 TYPE_ARG_TYPES (new_type) = new_reversed;
2194 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
2196 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
2197 DECL_VINDEX (fndecl) = NULL_TREE;
2200 /* When signature changes, we need to clear builtin info. */
2201 if (DECL_BUILT_IN (fndecl))
2203 DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
2204 DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
2207 /* This is a new type, not a copy of an old type. Need to reassociate
2208 variants. We can handle everything except the main variant lazily. */
2209 t = TYPE_MAIN_VARIANT (orig_type);
2212 TYPE_MAIN_VARIANT (new_type) = t;
2213 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
2214 TYPE_NEXT_VARIANT (t) = new_type;
2218 TYPE_MAIN_VARIANT (new_type) = new_type;
2219 TYPE_NEXT_VARIANT (new_type) = NULL;
2222 TREE_TYPE (fndecl) = new_type;
2223 DECL_VIRTUAL_P (fndecl) = 0;
2225 VEC_free (tree, heap, otypes);
2226 VEC_free (tree, heap, oparms);
2229 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2230 If this is a directly recursive call, CS must be NULL. Otherwise it must
2231 contain the corresponding call graph edge. */
2234 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2235 ipa_parm_adjustment_vec adjustments)
2237 VEC(tree, heap) *vargs;
2238 VEC(tree, gc) **debug_args = NULL;
2240 gimple_stmt_iterator gsi;
2244 len = VEC_length (ipa_parm_adjustment_t, adjustments);
2245 vargs = VEC_alloc (tree, heap, len);
2246 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2248 gsi = gsi_for_stmt (stmt);
2249 for (i = 0; i < len; i++)
2251 struct ipa_parm_adjustment *adj;
2253 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2255 if (adj->copy_param)
2257 tree arg = gimple_call_arg (stmt, adj->base_index);
2259 VEC_quick_push (tree, vargs, arg);
2261 else if (!adj->remove_param)
2263 tree expr, base, off;
2266 /* We create a new parameter out of the value of the old one, we can
2267 do the following kind of transformations:
2269 - A scalar passed by reference is converted to a scalar passed by
2270 value. (adj->by_ref is false and the type of the original
2271 actual argument is a pointer to a scalar).
2273 - A part of an aggregate is passed instead of the whole aggregate.
2274 The part can be passed either by value or by reference, this is
2275 determined by value of adj->by_ref. Moreover, the code below
2276 handles both situations when the original aggregate is passed by
2277 value (its type is not a pointer) and when it is passed by
2278 reference (it is a pointer to an aggregate).
2280 When the new argument is passed by reference (adj->by_ref is true)
2281 it must be a part of an aggregate and therefore we form it by
2282 simply taking the address of a reference inside the original
2285 gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0);
2286 base = gimple_call_arg (stmt, adj->base_index);
2287 loc = EXPR_LOCATION (base);
2289 if (TREE_CODE (base) != ADDR_EXPR
2290 && POINTER_TYPE_P (TREE_TYPE (base)))
2291 off = build_int_cst (adj->alias_ptr_type,
2292 adj->offset / BITS_PER_UNIT);
2295 HOST_WIDE_INT base_offset;
2298 if (TREE_CODE (base) == ADDR_EXPR)
2299 base = TREE_OPERAND (base, 0);
2301 base = get_addr_base_and_unit_offset (base, &base_offset);
2302 /* Aggregate arguments can have non-invariant addresses. */
2305 base = build_fold_addr_expr (prev_base);
2306 off = build_int_cst (adj->alias_ptr_type,
2307 adj->offset / BITS_PER_UNIT);
2309 else if (TREE_CODE (base) == MEM_REF)
2311 off = build_int_cst (adj->alias_ptr_type,
2313 + adj->offset / BITS_PER_UNIT);
2314 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1),
2316 base = TREE_OPERAND (base, 0);
2320 off = build_int_cst (adj->alias_ptr_type,
2322 + adj->offset / BITS_PER_UNIT);
2323 base = build_fold_addr_expr (base);
2327 expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off);
2329 expr = build_fold_addr_expr (expr);
2331 expr = force_gimple_operand_gsi (&gsi, expr,
2333 || is_gimple_reg_type (adj->type),
2334 NULL, true, GSI_SAME_STMT);
2335 VEC_quick_push (tree, vargs, expr);
2337 if (!adj->copy_param && MAY_HAVE_DEBUG_STMTS)
2340 tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg;
2343 arg = gimple_call_arg (stmt, adj->base_index);
2344 if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg)))
2346 if (!fold_convertible_p (TREE_TYPE (origin), arg))
2348 arg = fold_convert_loc (gimple_location (stmt),
2349 TREE_TYPE (origin), arg);
2351 if (debug_args == NULL)
2352 debug_args = decl_debug_args_insert (callee_decl);
2353 for (ix = 0; VEC_iterate (tree, *debug_args, ix, ddecl); ix += 2)
2354 if (ddecl == origin)
2356 ddecl = VEC_index (tree, *debug_args, ix + 1);
2361 ddecl = make_node (DEBUG_EXPR_DECL);
2362 DECL_ARTIFICIAL (ddecl) = 1;
2363 TREE_TYPE (ddecl) = TREE_TYPE (origin);
2364 DECL_MODE (ddecl) = DECL_MODE (origin);
2366 VEC_safe_push (tree, gc, *debug_args, origin);
2367 VEC_safe_push (tree, gc, *debug_args, ddecl);
2369 def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg),
2371 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT);
2375 if (dump_file && (dump_flags & TDF_DETAILS))
2377 fprintf (dump_file, "replacing stmt:");
2378 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2381 new_stmt = gimple_build_call_vec (callee_decl, vargs);
2382 VEC_free (tree, heap, vargs);
2383 if (gimple_call_lhs (stmt))
2384 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2386 gimple_set_block (new_stmt, gimple_block (stmt));
2387 if (gimple_has_location (stmt))
2388 gimple_set_location (new_stmt, gimple_location (stmt));
2389 gimple_call_copy_flags (new_stmt, stmt);
2390 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2392 if (dump_file && (dump_flags & TDF_DETAILS))
2394 fprintf (dump_file, "with stmt:");
2395 print_gimple_stmt (dump_file, new_stmt, 0, 0);
2396 fprintf (dump_file, "\n");
2398 gsi_replace (&gsi, new_stmt, true);
2400 cgraph_set_call_stmt (cs, new_stmt);
2401 update_ssa (TODO_update_ssa);
2402 free_dominance_info (CDI_DOMINATORS);
2405 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2408 index_in_adjustments_multiple_times_p (int base_index,
2409 ipa_parm_adjustment_vec adjustments)
2411 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2414 for (i = 0; i < len; i++)
2416 struct ipa_parm_adjustment *adj;
2417 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2419 if (adj->base_index == base_index)
2431 /* Return adjustments that should have the same effect on function parameters
2432 and call arguments as if they were first changed according to adjustments in
2433 INNER and then by adjustments in OUTER. */
2435 ipa_parm_adjustment_vec
2436 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2437 ipa_parm_adjustment_vec outer)
2439 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2440 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2442 ipa_parm_adjustment_vec adjustments, tmp;
2444 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2445 for (i = 0; i < inlen; i++)
2447 struct ipa_parm_adjustment *n;
2448 n = VEC_index (ipa_parm_adjustment_t, inner, i);
2450 if (n->remove_param)
2453 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2456 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2457 for (i = 0; i < outlen; i++)
2459 struct ipa_parm_adjustment *r;
2460 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2462 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2465 gcc_assert (!in->remove_param);
2466 if (out->remove_param)
2468 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2470 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2471 memset (r, 0, sizeof (*r));
2472 r->remove_param = true;
2477 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2478 memset (r, 0, sizeof (*r));
2479 r->base_index = in->base_index;
2480 r->type = out->type;
2482 /* FIXME: Create nonlocal value too. */
2484 if (in->copy_param && out->copy_param)
2485 r->copy_param = true;
2486 else if (in->copy_param)
2487 r->offset = out->offset;
2488 else if (out->copy_param)
2489 r->offset = in->offset;
2491 r->offset = in->offset + out->offset;
2494 for (i = 0; i < inlen; i++)
2496 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2499 if (n->remove_param)
2500 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2503 VEC_free (ipa_parm_adjustment_t, heap, tmp);
2507 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2508 friendly way, assuming they are meant to be applied to FNDECL. */
2511 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2514 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2516 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2518 fprintf (file, "IPA param adjustments: ");
2519 for (i = 0; i < len; i++)
2521 struct ipa_parm_adjustment *adj;
2522 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2525 fprintf (file, " ");
2529 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2530 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2533 fprintf (file, ", base: ");
2534 print_generic_expr (file, adj->base, 0);
2538 fprintf (file, ", reduction: ");
2539 print_generic_expr (file, adj->reduction, 0);
2541 if (adj->new_ssa_base)
2543 fprintf (file, ", new_ssa_base: ");
2544 print_generic_expr (file, adj->new_ssa_base, 0);
2547 if (adj->copy_param)
2548 fprintf (file, ", copy_param");
2549 else if (adj->remove_param)
2550 fprintf (file, ", remove_param");
2552 fprintf (file, ", offset %li", (long) adj->offset);
2554 fprintf (file, ", by_ref");
2555 print_node_brief (file, ", type: ", adj->type, 0);
2556 fprintf (file, "\n");
2558 VEC_free (tree, heap, parms);
2561 /* Stream out jump function JUMP_FUNC to OB. */
2564 ipa_write_jump_function (struct output_block *ob,
2565 struct ipa_jump_func *jump_func)
2567 streamer_write_uhwi (ob, jump_func->type);
2569 switch (jump_func->type)
2571 case IPA_JF_UNKNOWN:
2573 case IPA_JF_KNOWN_TYPE:
2574 streamer_write_uhwi (ob, jump_func->value.known_type.offset);
2575 stream_write_tree (ob, jump_func->value.known_type.base_type, true);
2576 stream_write_tree (ob, jump_func->value.known_type.component_type, true);
2579 stream_write_tree (ob, jump_func->value.constant, true);
2581 case IPA_JF_PASS_THROUGH:
2582 stream_write_tree (ob, jump_func->value.pass_through.operand, true);
2583 streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
2584 streamer_write_uhwi (ob, jump_func->value.pass_through.operation);
2586 case IPA_JF_ANCESTOR:
2587 streamer_write_uhwi (ob, jump_func->value.ancestor.offset);
2588 stream_write_tree (ob, jump_func->value.ancestor.type, true);
2589 streamer_write_uhwi (ob, jump_func->value.ancestor.formal_id);
2591 case IPA_JF_CONST_MEMBER_PTR:
2592 stream_write_tree (ob, jump_func->value.member_cst.pfn, true);
2593 stream_write_tree (ob, jump_func->value.member_cst.delta, false);
2598 /* Read in jump function JUMP_FUNC from IB. */
2601 ipa_read_jump_function (struct lto_input_block *ib,
2602 struct ipa_jump_func *jump_func,
2603 struct data_in *data_in)
2605 jump_func->type = (enum jump_func_type) streamer_read_uhwi (ib);
2607 switch (jump_func->type)
2609 case IPA_JF_UNKNOWN:
2611 case IPA_JF_KNOWN_TYPE:
2612 jump_func->value.known_type.offset = streamer_read_uhwi (ib);
2613 jump_func->value.known_type.base_type = stream_read_tree (ib, data_in);
2614 jump_func->value.known_type.component_type = stream_read_tree (ib,
2618 jump_func->value.constant = stream_read_tree (ib, data_in);
2620 case IPA_JF_PASS_THROUGH:
2621 jump_func->value.pass_through.operand = stream_read_tree (ib, data_in);
2622 jump_func->value.pass_through.formal_id = streamer_read_uhwi (ib);
2623 jump_func->value.pass_through.operation
2624 = (enum tree_code) streamer_read_uhwi (ib);
2626 case IPA_JF_ANCESTOR:
2627 jump_func->value.ancestor.offset = streamer_read_uhwi (ib);
2628 jump_func->value.ancestor.type = stream_read_tree (ib, data_in);
2629 jump_func->value.ancestor.formal_id = streamer_read_uhwi (ib);
2631 case IPA_JF_CONST_MEMBER_PTR:
2632 jump_func->value.member_cst.pfn = stream_read_tree (ib, data_in);
2633 jump_func->value.member_cst.delta = stream_read_tree (ib, data_in);
2638 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2639 relevant to indirect inlining to OB. */
2642 ipa_write_indirect_edge_info (struct output_block *ob,
2643 struct cgraph_edge *cs)
2645 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2646 struct bitpack_d bp;
2648 streamer_write_hwi (ob, ii->param_index);
2649 streamer_write_hwi (ob, ii->anc_offset);
2650 bp = bitpack_create (ob->main_stream);
2651 bp_pack_value (&bp, ii->polymorphic, 1);
2652 streamer_write_bitpack (&bp);
2654 if (ii->polymorphic)
2656 streamer_write_hwi (ob, ii->otr_token);
2657 stream_write_tree (ob, ii->otr_type, true);
2661 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2662 relevant to indirect inlining from IB. */
2665 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2666 struct data_in *data_in ATTRIBUTE_UNUSED,
2667 struct cgraph_edge *cs)
2669 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2670 struct bitpack_d bp;
2672 ii->param_index = (int) streamer_read_hwi (ib);
2673 ii->anc_offset = (HOST_WIDE_INT) streamer_read_hwi (ib);
2674 bp = streamer_read_bitpack (ib);
2675 ii->polymorphic = bp_unpack_value (&bp, 1);
2676 if (ii->polymorphic)
2678 ii->otr_token = (HOST_WIDE_INT) streamer_read_hwi (ib);
2679 ii->otr_type = stream_read_tree (ib, data_in);
2683 /* Stream out NODE info to OB. */
2686 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2689 lto_cgraph_encoder_t encoder;
2690 struct ipa_node_params *info = IPA_NODE_REF (node);
2692 struct cgraph_edge *e;
2693 struct bitpack_d bp;
2695 encoder = ob->decl_state->cgraph_node_encoder;
2696 node_ref = lto_cgraph_encoder_encode (encoder, node);
2697 streamer_write_uhwi (ob, node_ref);
2699 bp = bitpack_create (ob->main_stream);
2700 gcc_assert (info->uses_analysis_done
2701 || ipa_get_param_count (info) == 0);
2702 gcc_assert (!info->node_enqueued);
2703 gcc_assert (!info->ipcp_orig_node);
2704 for (j = 0; j < ipa_get_param_count (info); j++)
2705 bp_pack_value (&bp, ipa_is_param_used (info, j), 1);
2706 streamer_write_bitpack (&bp);
2707 for (e = node->callees; e; e = e->next_callee)
2709 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2711 streamer_write_uhwi (ob, ipa_get_cs_argument_count (args));
2712 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2713 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2715 for (e = node->indirect_calls; e; e = e->next_callee)
2717 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2719 streamer_write_uhwi (ob, ipa_get_cs_argument_count (args));
2720 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2721 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2722 ipa_write_indirect_edge_info (ob, e);
2726 /* Stream in NODE info from IB. */
2729 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2730 struct data_in *data_in)
2732 struct ipa_node_params *info = IPA_NODE_REF (node);
2734 struct cgraph_edge *e;
2735 struct bitpack_d bp;
2737 ipa_initialize_node_params (node);
2739 bp = streamer_read_bitpack (ib);
2740 if (ipa_get_param_count (info) != 0)
2741 info->uses_analysis_done = true;
2742 info->node_enqueued = false;
2743 for (k = 0; k < ipa_get_param_count (info); k++)
2744 ipa_set_param_used (info, k, bp_unpack_value (&bp, 1));
2745 for (e = node->callees; e; e = e->next_callee)
2747 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2748 int count = streamer_read_uhwi (ib);
2752 VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions, count);
2754 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2755 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2757 for (e = node->indirect_calls; e; e = e->next_callee)
2759 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2760 int count = streamer_read_uhwi (ib);
2764 VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions,
2766 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2767 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k),
2770 ipa_read_indirect_edge_info (ib, data_in, e);
2774 /* Write jump functions for nodes in SET. */
2777 ipa_prop_write_jump_functions (cgraph_node_set set)
2779 struct cgraph_node *node;
2780 struct output_block *ob;
2781 unsigned int count = 0;
2782 cgraph_node_set_iterator csi;
2784 if (!ipa_node_params_vector)
2787 ob = create_output_block (LTO_section_jump_functions);
2788 ob->cgraph_node = NULL;
2789 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2791 node = csi_node (csi);
2792 if (cgraph_function_with_gimple_body_p (node)
2793 && IPA_NODE_REF (node) != NULL)
2797 streamer_write_uhwi (ob, count);
2799 /* Process all of the functions. */
2800 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2802 node = csi_node (csi);
2803 if (cgraph_function_with_gimple_body_p (node)
2804 && IPA_NODE_REF (node) != NULL)
2805 ipa_write_node_info (ob, node);
2807 streamer_write_char_stream (ob->main_stream, 0);
2808 produce_asm (ob, NULL);
2809 destroy_output_block (ob);
2812 /* Read section in file FILE_DATA of length LEN with data DATA. */
2815 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2818 const struct lto_function_header *header =
2819 (const struct lto_function_header *) data;
2820 const int32_t cfg_offset = sizeof (struct lto_function_header);
2821 const int32_t main_offset = cfg_offset + header->cfg_size;
2822 const int32_t string_offset = main_offset + header->main_size;
2823 struct data_in *data_in;
2824 struct lto_input_block ib_main;
2828 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2832 lto_data_in_create (file_data, (const char *) data + string_offset,
2833 header->string_size, NULL);
2834 count = streamer_read_uhwi (&ib_main);
2836 for (i = 0; i < count; i++)
2839 struct cgraph_node *node;
2840 lto_cgraph_encoder_t encoder;
2842 index = streamer_read_uhwi (&ib_main);
2843 encoder = file_data->cgraph_node_encoder;
2844 node = lto_cgraph_encoder_deref (encoder, index);
2845 gcc_assert (node->analyzed);
2846 ipa_read_node_info (&ib_main, node, data_in);
2848 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2850 lto_data_in_delete (data_in);
2853 /* Read ipcp jump functions. */
2856 ipa_prop_read_jump_functions (void)
2858 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2859 struct lto_file_decl_data *file_data;
2862 ipa_check_create_node_params ();
2863 ipa_check_create_edge_args ();
2864 ipa_register_cgraph_hooks ();
2866 while ((file_data = file_data_vec[j++]))
2869 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2872 ipa_prop_read_section (file_data, data, len);
2876 /* After merging units, we can get mismatch in argument counts.
2877 Also decl merging might've rendered parameter lists obsolete.
2878 Also compute called_with_variable_arg info. */
2881 ipa_update_after_lto_read (void)
2883 struct cgraph_node *node;
2885 ipa_check_create_node_params ();
2886 ipa_check_create_edge_args ();
2888 for (node = cgraph_nodes; node; node = node->next)
2890 ipa_initialize_node_params (node);