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 /* Bitmap with all UIDs of call graph edges that have been already processed
60 by indirect inlining. */
61 static bitmap iinlining_processed_edges;
63 /* Holders of ipa cgraph hooks: */
64 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
65 static struct cgraph_node_hook_list *node_removal_hook_holder;
66 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
67 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
68 static struct cgraph_node_hook_list *function_insertion_hook_holder;
70 /* Return index of the formal whose tree is PTREE in function which corresponds
74 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
78 count = ipa_get_param_count (info);
79 for (i = 0; i < count; i++)
80 if (ipa_get_param (info, i) == ptree)
86 /* Populate the param_decl field in parameter descriptors of INFO that
87 corresponds to NODE. */
90 ipa_populate_param_decls (struct cgraph_node *node,
91 struct ipa_node_params *info)
99 fnargs = DECL_ARGUMENTS (fndecl);
101 for (parm = fnargs; parm; parm = DECL_CHAIN (parm))
103 VEC_index (ipa_param_descriptor_t,
104 info->descriptors, param_num)->decl = parm;
109 /* Return how many formal parameters FNDECL has. */
112 count_formal_params (tree fndecl)
117 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
123 /* Initialize the ipa_node_params structure associated with NODE by counting
124 the function parameters, creating the descriptors and populating their
128 ipa_initialize_node_params (struct cgraph_node *node)
130 struct ipa_node_params *info = IPA_NODE_REF (node);
132 if (!info->descriptors)
136 param_count = count_formal_params (node->decl);
139 VEC_safe_grow_cleared (ipa_param_descriptor_t, heap,
140 info->descriptors, param_count);
141 ipa_populate_param_decls (node, info);
146 /* Count number of arguments callsite CS has and store it in
147 ipa_edge_args structure corresponding to this callsite. */
150 ipa_count_arguments (struct cgraph_edge *cs)
155 stmt = cs->call_stmt;
156 gcc_assert (is_gimple_call (stmt));
157 arg_num = gimple_call_num_args (stmt);
158 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
159 <= (unsigned) cgraph_edge_max_uid)
160 VEC_safe_grow_cleared (ipa_edge_args_t, gc,
161 ipa_edge_args_vector, cgraph_edge_max_uid + 1);
162 ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
165 /* Print the jump functions associated with call graph edge CS to file F. */
168 ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
172 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
173 for (i = 0; i < count; i++)
175 struct ipa_jump_func *jump_func;
176 enum jump_func_type type;
178 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
179 type = jump_func->type;
181 fprintf (f, " param %d: ", i);
182 if (type == IPA_JF_UNKNOWN)
183 fprintf (f, "UNKNOWN\n");
184 else if (type == IPA_JF_KNOWN_TYPE)
186 tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
187 fprintf (f, "KNOWN TYPE, type in binfo is: ");
188 print_generic_expr (f, binfo_type, 0);
189 fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
191 else if (type == IPA_JF_CONST)
193 tree val = jump_func->value.constant;
194 fprintf (f, "CONST: ");
195 print_generic_expr (f, val, 0);
196 if (TREE_CODE (val) == ADDR_EXPR
197 && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
200 print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
205 else if (type == IPA_JF_CONST_MEMBER_PTR)
207 fprintf (f, "CONST MEMBER PTR: ");
208 print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
210 print_generic_expr (f, jump_func->value.member_cst.delta, 0);
213 else if (type == IPA_JF_PASS_THROUGH)
215 fprintf (f, "PASS THROUGH: ");
216 fprintf (f, "%d, op %s ",
217 jump_func->value.pass_through.formal_id,
219 jump_func->value.pass_through.operation]);
220 if (jump_func->value.pass_through.operation != NOP_EXPR)
221 print_generic_expr (dump_file,
222 jump_func->value.pass_through.operand, 0);
223 fprintf (dump_file, "\n");
225 else if (type == IPA_JF_ANCESTOR)
227 fprintf (f, "ANCESTOR: ");
228 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
229 jump_func->value.ancestor.formal_id,
230 jump_func->value.ancestor.offset);
231 print_generic_expr (f, jump_func->value.ancestor.type, 0);
232 fprintf (dump_file, "\n");
238 /* Print the jump functions of all arguments on all call graph edges going from
242 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
244 struct cgraph_edge *cs;
247 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
248 for (cs = node->callees; cs; cs = cs->next_callee)
250 if (!ipa_edge_args_info_available_for_edge_p (cs))
253 fprintf (f, " callsite %s/%i -> %s/%i : \n",
254 cgraph_node_name (node), node->uid,
255 cgraph_node_name (cs->callee), cs->callee->uid);
256 ipa_print_node_jump_functions_for_edge (f, cs);
259 for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++)
261 if (!ipa_edge_args_info_available_for_edge_p (cs))
266 fprintf (f, " indirect callsite %d for stmt ", i);
267 print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
270 fprintf (f, " indirect callsite %d :\n", i);
271 ipa_print_node_jump_functions_for_edge (f, cs);
276 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
279 ipa_print_all_jump_functions (FILE *f)
281 struct cgraph_node *node;
283 fprintf (f, "\nJump functions:\n");
284 for (node = cgraph_nodes; node; node = node->next)
286 ipa_print_node_jump_functions (f, node);
290 /* Structure to be passed in between detect_type_change and
291 check_stmt_for_type_change. */
293 struct type_change_info
295 /* Set to true if dynamic type change has been detected. */
296 bool type_maybe_changed;
299 /* Return true if STMT can modify a virtual method table pointer.
301 This function makes special assumptions about both constructors and
302 destructors which are all the functions that are allowed to alter the VMT
303 pointers. It assumes that destructors begin with assignment into all VMT
304 pointers and that constructors essentially look in the following way:
306 1) The very first thing they do is that they call constructors of ancestor
307 sub-objects that have them.
309 2) Then VMT pointers of this and all its ancestors is set to new values
310 corresponding to the type corresponding to the constructor.
312 3) Only afterwards, other stuff such as constructor of member sub-objects
313 and the code written by the user is run. Only this may include calling
314 virtual functions, directly or indirectly.
316 There is no way to call a constructor of an ancestor sub-object in any
319 This means that we do not have to care whether constructors get the correct
320 type information because they will always change it (in fact, if we define
321 the type to be given by the VMT pointer, it is undefined).
323 The most important fact to derive from the above is that if, for some
324 statement in the section 3, we try to detect whether the dynamic type has
325 changed, we can safely ignore all calls as we examine the function body
326 backwards until we reach statements in section 2 because these calls cannot
327 be ancestor constructors or destructors (if the input is not bogus) and so
328 do not change the dynamic type (this holds true only for automatically
329 allocated objects but at the moment we devirtualize only these). We then
330 must detect that statements in section 2 change the dynamic type and can try
331 to derive the new type. That is enough and we can stop, we will never see
332 the calls into constructors of sub-objects in this code. Therefore we can
333 safely ignore all call statements that we traverse.
337 stmt_may_be_vtbl_ptr_store (gimple stmt)
339 if (is_gimple_call (stmt))
341 else if (is_gimple_assign (stmt))
343 tree lhs = gimple_assign_lhs (stmt);
345 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs)))
347 if (flag_strict_aliasing
348 && !POINTER_TYPE_P (TREE_TYPE (lhs)))
351 if (TREE_CODE (lhs) == COMPONENT_REF
352 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1)))
354 /* In the future we might want to use get_base_ref_and_offset to find
355 if there is a field corresponding to the offset and if so, proceed
356 almost like if it was a component ref. */
362 /* Callback of walk_aliased_vdefs and a helper function for
363 detect_type_change to check whether a particular statement may modify
364 the virtual table pointer, and if possible also determine the new type of
365 the (sub-)object. It stores its result into DATA, which points to a
366 type_change_info structure. */
369 check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
371 gimple stmt = SSA_NAME_DEF_STMT (vdef);
372 struct type_change_info *tci = (struct type_change_info *) data;
374 if (stmt_may_be_vtbl_ptr_store (stmt))
376 tci->type_maybe_changed = true;
383 /* Detect whether the dynamic type of ARG has changed (before callsite CALL) by
384 looking for assignments to its virtual table pointer. If it is, return true
385 and fill in the jump function JFUNC with relevant type information or set it
386 to unknown. ARG is the object itself (not a pointer to it, unless
387 dereferenced). BASE is the base of the memory access as returned by
388 get_ref_base_and_extent, as is the offset. */
391 detect_type_change (tree arg, tree base, gimple call,
392 struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
394 struct type_change_info tci;
397 gcc_checking_assert (DECL_P (arg)
398 || TREE_CODE (arg) == MEM_REF
399 || handled_component_p (arg));
400 /* Const calls cannot call virtual methods through VMT and so type changes do
402 if (!flag_devirtualize || !gimple_vuse (call))
405 tci.type_maybe_changed = false;
410 ao.size = POINTER_SIZE;
411 ao.max_size = ao.size;
412 ao.ref_alias_set = -1;
413 ao.base_alias_set = -1;
415 walk_aliased_vdefs (&ao, gimple_vuse (call), check_stmt_for_type_change,
417 if (!tci.type_maybe_changed)
420 jfunc->type = IPA_JF_UNKNOWN;
424 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
425 SSA name (its dereference will become the base and the offset is assumed to
429 detect_type_change_ssa (tree arg, gimple call, struct ipa_jump_func *jfunc)
431 gcc_checking_assert (TREE_CODE (arg) == SSA_NAME);
432 if (!flag_devirtualize
433 || !POINTER_TYPE_P (TREE_TYPE (arg))
434 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != RECORD_TYPE)
437 arg = build2 (MEM_REF, ptr_type_node, arg,
438 build_int_cst (ptr_type_node, 0));
440 return detect_type_change (arg, arg, call, jfunc, 0);
444 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
445 of an assignment statement STMT, try to find out whether NAME can be
446 described by a (possibly polynomial) pass-through jump-function or an
447 ancestor jump function and if so, write the appropriate function into
451 compute_complex_assign_jump_func (struct ipa_node_params *info,
452 struct ipa_jump_func *jfunc,
453 gimple call, gimple stmt, tree name)
455 HOST_WIDE_INT offset, size, max_size;
456 tree op1, op2, base, ssa;
459 op1 = gimple_assign_rhs1 (stmt);
460 op2 = gimple_assign_rhs2 (stmt);
462 if (TREE_CODE (op1) == SSA_NAME
463 && SSA_NAME_IS_DEFAULT_DEF (op1))
465 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
471 if (!is_gimple_ip_invariant (op2)
472 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
473 && !useless_type_conversion_p (TREE_TYPE (name),
477 jfunc->type = IPA_JF_PASS_THROUGH;
478 jfunc->value.pass_through.formal_id = index;
479 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
480 jfunc->value.pass_through.operand = op2;
482 else if (gimple_assign_unary_nop_p (stmt)
483 && !detect_type_change_ssa (op1, call, jfunc))
485 jfunc->type = IPA_JF_PASS_THROUGH;
486 jfunc->value.pass_through.formal_id = index;
487 jfunc->value.pass_through.operation = NOP_EXPR;
492 if (TREE_CODE (op1) != ADDR_EXPR)
494 op1 = TREE_OPERAND (op1, 0);
495 if (TREE_CODE (TREE_TYPE (op1)) != RECORD_TYPE)
497 base = get_ref_base_and_extent (op1, &offset, &size, &max_size);
498 if (TREE_CODE (base) != MEM_REF
499 /* If this is a varying address, punt. */
503 offset += mem_ref_offset (base).low * BITS_PER_UNIT;
504 ssa = TREE_OPERAND (base, 0);
505 if (TREE_CODE (ssa) != SSA_NAME
506 || !SSA_NAME_IS_DEFAULT_DEF (ssa)
510 /* Dynamic types are changed only in constructors and destructors and */
511 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (ssa));
513 && !detect_type_change (op1, base, call, jfunc, offset))
515 jfunc->type = IPA_JF_ANCESTOR;
516 jfunc->value.ancestor.formal_id = index;
517 jfunc->value.ancestor.offset = offset;
518 jfunc->value.ancestor.type = TREE_TYPE (op1);
522 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
525 iftmp.1_3 = &obj_2(D)->D.1762;
527 The base of the MEM_REF must be a default definition SSA NAME of a
528 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
529 whole MEM_REF expression is returned and the offset calculated from any
530 handled components and the MEM_REF itself is stored into *OFFSET. The whole
531 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
534 get_ancestor_addr_info (gimple assign, tree *obj_p, HOST_WIDE_INT *offset)
536 HOST_WIDE_INT size, max_size;
537 tree expr, parm, obj;
539 if (!gimple_assign_single_p (assign))
541 expr = gimple_assign_rhs1 (assign);
543 if (TREE_CODE (expr) != ADDR_EXPR)
545 expr = TREE_OPERAND (expr, 0);
547 expr = get_ref_base_and_extent (expr, offset, &size, &max_size);
549 if (TREE_CODE (expr) != MEM_REF
550 /* If this is a varying address, punt. */
555 parm = TREE_OPERAND (expr, 0);
556 if (TREE_CODE (parm) != SSA_NAME
557 || !SSA_NAME_IS_DEFAULT_DEF (parm)
558 || TREE_CODE (SSA_NAME_VAR (parm)) != PARM_DECL)
561 *offset += mem_ref_offset (expr).low * BITS_PER_UNIT;
567 /* Given that an actual argument is an SSA_NAME that is a result of a phi
568 statement PHI, try to find out whether NAME is in fact a
569 multiple-inheritance typecast from a descendant into an ancestor of a formal
570 parameter and thus can be described by an ancestor jump function and if so,
571 write the appropriate function into JFUNC.
573 Essentially we want to match the following pattern:
581 iftmp.1_3 = &obj_2(D)->D.1762;
584 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
585 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
589 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
590 struct ipa_jump_func *jfunc,
591 gimple call, gimple phi)
593 HOST_WIDE_INT offset;
595 basic_block phi_bb, assign_bb, cond_bb;
596 tree tmp, parm, expr, obj;
599 if (gimple_phi_num_args (phi) != 2)
602 if (integer_zerop (PHI_ARG_DEF (phi, 1)))
603 tmp = PHI_ARG_DEF (phi, 0);
604 else if (integer_zerop (PHI_ARG_DEF (phi, 0)))
605 tmp = PHI_ARG_DEF (phi, 1);
608 if (TREE_CODE (tmp) != SSA_NAME
609 || SSA_NAME_IS_DEFAULT_DEF (tmp)
610 || !POINTER_TYPE_P (TREE_TYPE (tmp))
611 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
614 assign = SSA_NAME_DEF_STMT (tmp);
615 assign_bb = gimple_bb (assign);
616 if (!single_pred_p (assign_bb))
618 expr = get_ancestor_addr_info (assign, &obj, &offset);
621 parm = TREE_OPERAND (expr, 0);
622 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
623 gcc_assert (index >= 0);
625 cond_bb = single_pred (assign_bb);
626 cond = last_stmt (cond_bb);
628 || gimple_code (cond) != GIMPLE_COND
629 || gimple_cond_code (cond) != NE_EXPR
630 || gimple_cond_lhs (cond) != parm
631 || !integer_zerop (gimple_cond_rhs (cond)))
634 phi_bb = gimple_bb (phi);
635 for (i = 0; i < 2; i++)
637 basic_block pred = EDGE_PRED (phi_bb, i)->src;
638 if (pred != assign_bb && pred != cond_bb)
642 if (!detect_type_change (obj, expr, call, jfunc, offset))
644 jfunc->type = IPA_JF_ANCESTOR;
645 jfunc->value.ancestor.formal_id = index;
646 jfunc->value.ancestor.offset = offset;
647 jfunc->value.ancestor.type = TREE_TYPE (obj);
651 /* Given OP which is passed as an actual argument to a called function,
652 determine if it is possible to construct a KNOWN_TYPE jump function for it
653 and if so, create one and store it to JFUNC. */
656 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc,
659 HOST_WIDE_INT offset, size, max_size;
662 if (!flag_devirtualize
663 || TREE_CODE (op) != ADDR_EXPR
664 || TREE_CODE (TREE_TYPE (TREE_TYPE (op))) != RECORD_TYPE)
667 op = TREE_OPERAND (op, 0);
668 base = get_ref_base_and_extent (op, &offset, &size, &max_size);
672 || TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE
673 || is_global_var (base))
676 if (detect_type_change (op, base, call, jfunc, offset))
679 binfo = TYPE_BINFO (TREE_TYPE (base));
682 binfo = get_binfo_at_offset (binfo, offset, TREE_TYPE (op));
685 jfunc->type = IPA_JF_KNOWN_TYPE;
686 jfunc->value.base_binfo = binfo;
691 /* Determine the jump functions of scalar arguments. Scalar means SSA names
692 and constants of a number of selected types. INFO is the ipa_node_params
693 structure associated with the caller, FUNCTIONS is a pointer to an array of
694 jump function structures associated with CALL which is the call statement
698 compute_scalar_jump_functions (struct ipa_node_params *info,
699 struct ipa_jump_func *functions,
705 for (num = 0; num < gimple_call_num_args (call); num++)
707 arg = gimple_call_arg (call, num);
709 if (is_gimple_ip_invariant (arg))
711 functions[num].type = IPA_JF_CONST;
712 functions[num].value.constant = arg;
714 else if (TREE_CODE (arg) == SSA_NAME)
716 if (SSA_NAME_IS_DEFAULT_DEF (arg))
718 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
721 && !detect_type_change_ssa (arg, call, &functions[num]))
723 functions[num].type = IPA_JF_PASS_THROUGH;
724 functions[num].value.pass_through.formal_id = index;
725 functions[num].value.pass_through.operation = NOP_EXPR;
730 gimple stmt = SSA_NAME_DEF_STMT (arg);
731 if (is_gimple_assign (stmt))
732 compute_complex_assign_jump_func (info, &functions[num],
734 else if (gimple_code (stmt) == GIMPLE_PHI)
735 compute_complex_ancestor_jump_func (info, &functions[num],
740 compute_known_type_jump_func (arg, &functions[num], call);
744 /* Inspect the given TYPE and return true iff it has the same structure (the
745 same number of fields of the same types) as a C++ member pointer. If
746 METHOD_PTR and DELTA are non-NULL, store the trees representing the
747 corresponding fields there. */
750 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
754 if (TREE_CODE (type) != RECORD_TYPE)
757 fld = TYPE_FIELDS (type);
758 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
759 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
765 fld = DECL_CHAIN (fld);
766 if (!fld || INTEGRAL_TYPE_P (fld))
771 if (DECL_CHAIN (fld))
777 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
778 boolean variable pointed to by DATA. */
781 mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
784 bool *b = (bool *) data;
789 /* Return true if the formal parameter PARM might have been modified in this
790 function before reaching the statement CALL. PARM_INFO is a pointer to a
791 structure containing intermediate information about PARM. */
794 is_parm_modified_before_call (struct param_analysis_info *parm_info,
795 gimple call, tree parm)
797 bool modified = false;
800 if (parm_info->modified)
803 ao_ref_init (&refd, parm);
804 walk_aliased_vdefs (&refd, gimple_vuse (call), mark_modified,
805 &modified, &parm_info->visited_statements);
808 parm_info->modified = true;
814 /* Go through arguments of the CALL and for every one that looks like a member
815 pointer, check whether it can be safely declared pass-through and if so,
816 mark that to the corresponding item of jump FUNCTIONS. Return true iff
817 there are non-pass-through member pointers within the arguments. INFO
818 describes formal parameters of the caller. PARMS_INFO is a pointer to a
819 vector containing intermediate information about each formal parameter. */
822 compute_pass_through_member_ptrs (struct ipa_node_params *info,
823 struct param_analysis_info *parms_info,
824 struct ipa_jump_func *functions,
827 bool undecided_members = false;
831 for (num = 0; num < gimple_call_num_args (call); num++)
833 arg = gimple_call_arg (call, num);
835 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
837 if (TREE_CODE (arg) == PARM_DECL)
839 int index = ipa_get_param_decl_index (info, arg);
841 gcc_assert (index >=0);
842 if (!is_parm_modified_before_call (&parms_info[index], call, arg))
844 functions[num].type = IPA_JF_PASS_THROUGH;
845 functions[num].value.pass_through.formal_id = index;
846 functions[num].value.pass_through.operation = NOP_EXPR;
849 undecided_members = true;
852 undecided_members = true;
856 return undecided_members;
859 /* Simple function filling in a member pointer constant jump function (with PFN
860 and DELTA as the constant value) into JFUNC. */
863 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
864 tree pfn, tree delta)
866 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
867 jfunc->value.member_cst.pfn = pfn;
868 jfunc->value.member_cst.delta = delta;
871 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
872 return the rhs of its defining statement. */
875 get_ssa_def_if_simple_copy (tree rhs)
877 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
879 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
881 if (gimple_assign_single_p (def_stmt))
882 rhs = gimple_assign_rhs1 (def_stmt);
889 /* Traverse statements from CALL backwards, scanning whether the argument ARG
890 which is a member pointer is filled in with constant values. If it is, fill
891 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
892 fields of the record type of the member pointer. To give an example, we
893 look for a pattern looking like the following:
895 D.2515.__pfn ={v} printStuff;
896 D.2515.__delta ={v} 0;
897 i_1 = doprinting (D.2515); */
900 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
901 tree delta_field, struct ipa_jump_func *jfunc)
903 gimple_stmt_iterator gsi;
904 tree method = NULL_TREE;
905 tree delta = NULL_TREE;
907 gsi = gsi_for_stmt (call);
910 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
912 gimple stmt = gsi_stmt (gsi);
915 if (!stmt_may_clobber_ref_p (stmt, arg))
917 if (!gimple_assign_single_p (stmt))
920 lhs = gimple_assign_lhs (stmt);
921 rhs = gimple_assign_rhs1 (stmt);
923 if (TREE_CODE (lhs) != COMPONENT_REF
924 || TREE_OPERAND (lhs, 0) != arg)
927 fld = TREE_OPERAND (lhs, 1);
928 if (!method && fld == method_field)
930 rhs = get_ssa_def_if_simple_copy (rhs);
931 if (TREE_CODE (rhs) == ADDR_EXPR
932 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
933 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
935 method = TREE_OPERAND (rhs, 0);
938 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
946 if (!delta && fld == delta_field)
948 rhs = get_ssa_def_if_simple_copy (rhs);
949 if (TREE_CODE (rhs) == INTEGER_CST)
954 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
966 /* Go through the arguments of the CALL and for every member pointer within
967 tries determine whether it is a constant. If it is, create a corresponding
968 constant jump function in FUNCTIONS which is an array of jump functions
969 associated with the call. */
972 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
976 tree arg, method_field, delta_field;
978 for (num = 0; num < gimple_call_num_args (call); num++)
980 arg = gimple_call_arg (call, num);
982 if (functions[num].type == IPA_JF_UNKNOWN
983 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
985 determine_cst_member_ptr (call, arg, method_field, delta_field,
990 /* Compute jump function for all arguments of callsite CS and insert the
991 information in the jump_functions array in the ipa_edge_args corresponding
995 ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_info,
996 struct cgraph_edge *cs)
998 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
999 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
1002 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
1004 arguments->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
1005 (ipa_get_cs_argument_count (arguments));
1007 call = cs->call_stmt;
1008 gcc_assert (is_gimple_call (call));
1010 /* We will deal with constants and SSA scalars first: */
1011 compute_scalar_jump_functions (info, arguments->jump_functions, call);
1013 /* Let's check whether there are any potential member pointers and if so,
1014 whether we can determine their functions as pass_through. */
1015 if (!compute_pass_through_member_ptrs (info, parms_info,
1016 arguments->jump_functions, call))
1019 /* Finally, let's check whether we actually pass a new constant member
1021 compute_cst_member_ptr_arguments (arguments->jump_functions, call);
1024 /* Compute jump functions for all edges - both direct and indirect - outgoing
1025 from NODE. Also count the actual arguments in the process. */
1028 ipa_compute_jump_functions (struct cgraph_node *node,
1029 struct param_analysis_info *parms_info)
1031 struct cgraph_edge *cs;
1033 for (cs = node->callees; cs; cs = cs->next_callee)
1035 struct cgraph_node *callee = cgraph_function_or_thunk_node (cs->callee,
1037 /* We do not need to bother analyzing calls to unknown
1038 functions unless they may become known during lto/whopr. */
1039 if (!callee->analyzed && !flag_lto)
1041 ipa_count_arguments (cs);
1042 ipa_compute_jump_functions_for_edge (parms_info, cs);
1045 for (cs = node->indirect_calls; cs; cs = cs->next_callee)
1047 ipa_count_arguments (cs);
1048 ipa_compute_jump_functions_for_edge (parms_info, cs);
1052 /* If RHS looks like a rhs of a statement loading pfn from a member
1053 pointer formal parameter, return the parameter, otherwise return
1054 NULL. If USE_DELTA, then we look for a use of the delta field
1055 rather than the pfn. */
1058 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
1060 tree rec, ref_field, ref_offset, fld, fld_offset, ptr_field, delta_field;
1062 if (TREE_CODE (rhs) == COMPONENT_REF)
1064 ref_field = TREE_OPERAND (rhs, 1);
1065 rhs = TREE_OPERAND (rhs, 0);
1068 ref_field = NULL_TREE;
1069 if (TREE_CODE (rhs) != MEM_REF)
1071 rec = TREE_OPERAND (rhs, 0);
1072 if (TREE_CODE (rec) != ADDR_EXPR)
1074 rec = TREE_OPERAND (rec, 0);
1075 if (TREE_CODE (rec) != PARM_DECL
1076 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
1079 ref_offset = TREE_OPERAND (rhs, 1);
1083 if (integer_nonzerop (ref_offset))
1091 return ref_field == fld ? rec : NULL_TREE;
1095 fld_offset = byte_position (delta_field);
1097 fld_offset = byte_position (ptr_field);
1099 return tree_int_cst_equal (ref_offset, fld_offset) ? rec : NULL_TREE;
1102 /* If STMT looks like a statement loading a value from a member pointer formal
1103 parameter, this function returns that parameter. */
1106 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
1110 if (!gimple_assign_single_p (stmt))
1113 rhs = gimple_assign_rhs1 (stmt);
1114 return ipa_get_member_ptr_load_param (rhs, use_delta);
1117 /* Returns true iff T is an SSA_NAME defined by a statement. */
1120 ipa_is_ssa_with_stmt_def (tree t)
1122 if (TREE_CODE (t) == SSA_NAME
1123 && !SSA_NAME_IS_DEFAULT_DEF (t))
1129 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1130 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1131 indirect call graph edge. */
1133 static struct cgraph_edge *
1134 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt)
1136 struct cgraph_edge *cs;
1138 cs = cgraph_edge (node, stmt);
1139 cs->indirect_info->param_index = param_index;
1140 cs->indirect_info->anc_offset = 0;
1141 cs->indirect_info->polymorphic = 0;
1145 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1146 (described by INFO). PARMS_INFO is a pointer to a vector containing
1147 intermediate information about each formal parameter. Currently it checks
1148 whether the call calls a pointer that is a formal parameter and if so, the
1149 parameter is marked with the called flag and an indirect call graph edge
1150 describing the call is created. This is very simple for ordinary pointers
1151 represented in SSA but not-so-nice when it comes to member pointers. The
1152 ugly part of this function does nothing more than trying to match the
1153 pattern of such a call. An example of such a pattern is the gimple dump
1154 below, the call is on the last line:
1157 f$__delta_5 = f.__delta;
1158 f$__pfn_24 = f.__pfn;
1162 f$__delta_5 = MEM[(struct *)&f];
1163 f$__pfn_24 = MEM[(struct *)&f + 4B];
1165 and a few lines below:
1168 D.2496_3 = (int) f$__pfn_24;
1169 D.2497_4 = D.2496_3 & 1;
1176 D.2500_7 = (unsigned int) f$__delta_5;
1177 D.2501_8 = &S + D.2500_7;
1178 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1179 D.2503_10 = *D.2502_9;
1180 D.2504_12 = f$__pfn_24 + -1;
1181 D.2505_13 = (unsigned int) D.2504_12;
1182 D.2506_14 = D.2503_10 + D.2505_13;
1183 D.2507_15 = *D.2506_14;
1184 iftmp.11_16 = (String:: *) D.2507_15;
1187 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1188 D.2500_19 = (unsigned int) f$__delta_5;
1189 D.2508_20 = &S + D.2500_19;
1190 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1192 Such patterns are results of simple calls to a member pointer:
1194 int doprinting (int (MyString::* f)(int) const)
1196 MyString S ("somestring");
1203 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1204 struct ipa_node_params *info,
1205 struct param_analysis_info *parms_info,
1206 gimple call, tree target)
1211 tree rec, rec2, cond;
1214 basic_block bb, virt_bb, join;
1216 if (SSA_NAME_IS_DEFAULT_DEF (target))
1218 tree var = SSA_NAME_VAR (target);
1219 index = ipa_get_param_decl_index (info, var);
1221 ipa_note_param_call (node, index, call);
1225 /* Now we need to try to match the complex pattern of calling a member
1228 if (!POINTER_TYPE_P (TREE_TYPE (target))
1229 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1232 def = SSA_NAME_DEF_STMT (target);
1233 if (gimple_code (def) != GIMPLE_PHI)
1236 if (gimple_phi_num_args (def) != 2)
1239 /* First, we need to check whether one of these is a load from a member
1240 pointer that is a parameter to this function. */
1241 n1 = PHI_ARG_DEF (def, 0);
1242 n2 = PHI_ARG_DEF (def, 1);
1243 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1245 d1 = SSA_NAME_DEF_STMT (n1);
1246 d2 = SSA_NAME_DEF_STMT (n2);
1248 join = gimple_bb (def);
1249 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1251 if (ipa_get_stmt_member_ptr_load_param (d2, false))
1254 bb = EDGE_PRED (join, 0)->src;
1255 virt_bb = gimple_bb (d2);
1257 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1259 bb = EDGE_PRED (join, 1)->src;
1260 virt_bb = gimple_bb (d1);
1265 /* Second, we need to check that the basic blocks are laid out in the way
1266 corresponding to the pattern. */
1268 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1269 || single_pred (virt_bb) != bb
1270 || single_succ (virt_bb) != join)
1273 /* Third, let's see that the branching is done depending on the least
1274 significant bit of the pfn. */
1276 branch = last_stmt (bb);
1277 if (!branch || gimple_code (branch) != GIMPLE_COND)
1280 if ((gimple_cond_code (branch) != NE_EXPR
1281 && gimple_cond_code (branch) != EQ_EXPR)
1282 || !integer_zerop (gimple_cond_rhs (branch)))
1285 cond = gimple_cond_lhs (branch);
1286 if (!ipa_is_ssa_with_stmt_def (cond))
1289 def = SSA_NAME_DEF_STMT (cond);
1290 if (!is_gimple_assign (def)
1291 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1292 || !integer_onep (gimple_assign_rhs2 (def)))
1295 cond = gimple_assign_rhs1 (def);
1296 if (!ipa_is_ssa_with_stmt_def (cond))
1299 def = SSA_NAME_DEF_STMT (cond);
1301 if (is_gimple_assign (def)
1302 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1304 cond = gimple_assign_rhs1 (def);
1305 if (!ipa_is_ssa_with_stmt_def (cond))
1307 def = SSA_NAME_DEF_STMT (cond);
1310 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1311 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1312 == ptrmemfunc_vbit_in_delta));
1317 index = ipa_get_param_decl_index (info, rec);
1318 if (index >= 0 && !is_parm_modified_before_call (&parms_info[index],
1320 ipa_note_param_call (node, index, call);
1325 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1326 object referenced in the expression is a formal parameter of the caller
1327 (described by INFO), create a call note for the statement. */
1330 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1331 struct ipa_node_params *info, gimple call,
1334 struct cgraph_edge *cs;
1335 struct cgraph_indirect_call_info *ii;
1336 struct ipa_jump_func jfunc;
1337 tree obj = OBJ_TYPE_REF_OBJECT (target);
1339 HOST_WIDE_INT anc_offset;
1341 if (!flag_devirtualize)
1344 if (TREE_CODE (obj) != SSA_NAME)
1347 if (SSA_NAME_IS_DEFAULT_DEF (obj))
1349 if (TREE_CODE (SSA_NAME_VAR (obj)) != PARM_DECL)
1353 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (obj));
1354 gcc_assert (index >= 0);
1355 if (detect_type_change_ssa (obj, call, &jfunc))
1360 gimple stmt = SSA_NAME_DEF_STMT (obj);
1363 expr = get_ancestor_addr_info (stmt, &obj, &anc_offset);
1366 index = ipa_get_param_decl_index (info,
1367 SSA_NAME_VAR (TREE_OPERAND (expr, 0)));
1368 gcc_assert (index >= 0);
1369 if (detect_type_change (obj, expr, call, &jfunc, anc_offset))
1373 cs = ipa_note_param_call (node, index, call);
1374 ii = cs->indirect_info;
1375 ii->anc_offset = anc_offset;
1376 ii->otr_token = tree_low_cst (OBJ_TYPE_REF_TOKEN (target), 1);
1377 ii->otr_type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (target)));
1378 ii->polymorphic = 1;
1381 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1382 of the caller (described by INFO). PARMS_INFO is a pointer to a vector
1383 containing intermediate information about each formal parameter. */
1386 ipa_analyze_call_uses (struct cgraph_node *node,
1387 struct ipa_node_params *info,
1388 struct param_analysis_info *parms_info, gimple call)
1390 tree target = gimple_call_fn (call);
1394 if (TREE_CODE (target) == SSA_NAME)
1395 ipa_analyze_indirect_call_uses (node, info, parms_info, call, target);
1396 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1397 ipa_analyze_virtual_call_uses (node, info, call, target);
1401 /* Analyze the call statement STMT with respect to formal parameters (described
1402 in INFO) of caller given by NODE. Currently it only checks whether formal
1403 parameters are called. PARMS_INFO is a pointer to a vector containing
1404 intermediate information about each formal parameter. */
1407 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1408 struct param_analysis_info *parms_info, gimple stmt)
1410 if (is_gimple_call (stmt))
1411 ipa_analyze_call_uses (node, info, parms_info, stmt);
1414 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1415 If OP is a parameter declaration, mark it as used in the info structure
1419 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
1420 tree op, void *data)
1422 struct ipa_node_params *info = (struct ipa_node_params *) data;
1424 op = get_base_address (op);
1426 && TREE_CODE (op) == PARM_DECL)
1428 int index = ipa_get_param_decl_index (info, op);
1429 gcc_assert (index >= 0);
1430 ipa_set_param_used (info, index, true);
1436 /* Scan the function body of NODE and inspect the uses of formal parameters.
1437 Store the findings in various structures of the associated ipa_node_params
1438 structure, such as parameter flags, notes etc. PARMS_INFO is a pointer to a
1439 vector containing intermediate information about each formal parameter. */
1442 ipa_analyze_params_uses (struct cgraph_node *node,
1443 struct param_analysis_info *parms_info)
1445 tree decl = node->decl;
1447 struct function *func;
1448 gimple_stmt_iterator gsi;
1449 struct ipa_node_params *info = IPA_NODE_REF (node);
1452 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1455 for (i = 0; i < ipa_get_param_count (info); i++)
1457 tree parm = ipa_get_param (info, i);
1458 /* For SSA regs see if parameter is used. For non-SSA we compute
1459 the flag during modification analysis. */
1460 if (is_gimple_reg (parm)
1461 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
1462 ipa_set_param_used (info, i, true);
1465 func = DECL_STRUCT_FUNCTION (decl);
1466 FOR_EACH_BB_FN (bb, func)
1468 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1470 gimple stmt = gsi_stmt (gsi);
1472 if (is_gimple_debug (stmt))
1475 ipa_analyze_stmt_uses (node, info, parms_info, stmt);
1476 walk_stmt_load_store_addr_ops (stmt, info,
1477 visit_ref_for_mod_analysis,
1478 visit_ref_for_mod_analysis,
1479 visit_ref_for_mod_analysis);
1481 for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
1482 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
1483 visit_ref_for_mod_analysis,
1484 visit_ref_for_mod_analysis,
1485 visit_ref_for_mod_analysis);
1488 info->uses_analysis_done = 1;
1491 /* Initialize the array describing properties of of formal parameters
1492 of NODE, analyze their uses and compute jump functions associated
1493 with actual arguments of calls from within NODE. */
1496 ipa_analyze_node (struct cgraph_node *node)
1498 struct ipa_node_params *info;
1499 struct param_analysis_info *parms_info;
1502 ipa_check_create_node_params ();
1503 ipa_check_create_edge_args ();
1504 info = IPA_NODE_REF (node);
1505 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1506 current_function_decl = node->decl;
1507 ipa_initialize_node_params (node);
1509 param_count = ipa_get_param_count (info);
1510 parms_info = XALLOCAVEC (struct param_analysis_info, param_count);
1511 memset (parms_info, 0, sizeof (struct param_analysis_info) * param_count);
1513 ipa_analyze_params_uses (node, parms_info);
1514 ipa_compute_jump_functions (node, parms_info);
1516 for (i = 0; i < param_count; i++)
1517 if (parms_info[i].visited_statements)
1518 BITMAP_FREE (parms_info[i].visited_statements);
1520 current_function_decl = NULL;
1525 /* Update the jump function DST when the call graph edge corresponding to SRC is
1526 is being inlined, knowing that DST is of type ancestor and src of known
1530 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1531 struct ipa_jump_func *dst)
1535 new_binfo = get_binfo_at_offset (src->value.base_binfo,
1536 dst->value.ancestor.offset,
1537 dst->value.ancestor.type);
1540 dst->type = IPA_JF_KNOWN_TYPE;
1541 dst->value.base_binfo = new_binfo;
1544 dst->type = IPA_JF_UNKNOWN;
1547 /* Update the jump functions associated with call graph edge E when the call
1548 graph edge CS is being inlined, assuming that E->caller is already (possibly
1549 indirectly) inlined into CS->callee and that E has not been inlined. */
1552 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1553 struct cgraph_edge *e)
1555 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1556 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1557 int count = ipa_get_cs_argument_count (args);
1560 for (i = 0; i < count; i++)
1562 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1564 if (dst->type == IPA_JF_ANCESTOR)
1566 struct ipa_jump_func *src;
1568 /* Variable number of arguments can cause havoc if we try to access
1569 one that does not exist in the inlined edge. So make sure we
1571 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1573 dst->type = IPA_JF_UNKNOWN;
1577 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1578 if (src->type == IPA_JF_KNOWN_TYPE)
1579 combine_known_type_and_ancestor_jfs (src, dst);
1580 else if (src->type == IPA_JF_PASS_THROUGH
1581 && src->value.pass_through.operation == NOP_EXPR)
1582 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1583 else if (src->type == IPA_JF_ANCESTOR)
1585 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1586 dst->value.ancestor.offset += src->value.ancestor.offset;
1589 dst->type = IPA_JF_UNKNOWN;
1591 else if (dst->type == IPA_JF_PASS_THROUGH)
1593 struct ipa_jump_func *src;
1594 /* We must check range due to calls with variable number of arguments
1595 and we cannot combine jump functions with operations. */
1596 if (dst->value.pass_through.operation == NOP_EXPR
1597 && (dst->value.pass_through.formal_id
1598 < ipa_get_cs_argument_count (top)))
1600 src = ipa_get_ith_jump_func (top,
1601 dst->value.pass_through.formal_id);
1605 dst->type = IPA_JF_UNKNOWN;
1610 /* If TARGET is an addr_expr of a function declaration, make it the destination
1611 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1613 struct cgraph_edge *
1614 ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
1616 struct cgraph_node *callee;
1618 if (TREE_CODE (target) == ADDR_EXPR)
1619 target = TREE_OPERAND (target, 0);
1620 if (TREE_CODE (target) != FUNCTION_DECL)
1622 callee = cgraph_get_node (target);
1625 ipa_check_create_node_params ();
1627 /* We can not make edges to inline clones. It is bug that someone removed
1628 the cgraph node too early. */
1629 gcc_assert (!callee->global.inlined_to);
1631 cgraph_make_edge_direct (ie, callee);
1634 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1635 "(%s/%i -> %s/%i), for stmt ",
1636 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1637 cgraph_node_name (ie->caller), ie->caller->uid,
1638 cgraph_node_name (ie->callee), ie->callee->uid);
1640 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1642 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1644 callee = cgraph_function_or_thunk_node (callee, NULL);
1649 /* Try to find a destination for indirect edge IE that corresponds to a simple
1650 call or a call of a member function pointer and where the destination is a
1651 pointer formal parameter described by jump function JFUNC. If it can be
1652 determined, return the newly direct edge, otherwise return NULL. */
1654 static struct cgraph_edge *
1655 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1656 struct ipa_jump_func *jfunc)
1660 if (jfunc->type == IPA_JF_CONST)
1661 target = jfunc->value.constant;
1662 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1663 target = jfunc->value.member_cst.pfn;
1667 return ipa_make_edge_direct_to_target (ie, target);
1670 /* Try to find a destination for indirect edge IE that corresponds to a
1671 virtual call based on a formal parameter which is described by jump
1672 function JFUNC and if it can be determined, make it direct and return the
1673 direct edge. Otherwise, return NULL. */
1675 static struct cgraph_edge *
1676 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1677 struct ipa_jump_func *jfunc)
1679 tree binfo, type, target;
1680 HOST_WIDE_INT token;
1682 if (jfunc->type == IPA_JF_KNOWN_TYPE)
1683 binfo = jfunc->value.base_binfo;
1690 token = ie->indirect_info->otr_token;
1691 type = ie->indirect_info->otr_type;
1692 binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
1694 target = gimple_get_virt_method_for_binfo (token, binfo);
1699 return ipa_make_edge_direct_to_target (ie, target);
1704 /* Update the param called notes associated with NODE when CS is being inlined,
1705 assuming NODE is (potentially indirectly) inlined into CS->callee.
1706 Moreover, if the callee is discovered to be constant, create a new cgraph
1707 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1708 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1711 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1712 struct cgraph_node *node,
1713 VEC (cgraph_edge_p, heap) **new_edges)
1715 struct ipa_edge_args *top;
1716 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1719 ipa_check_create_edge_args ();
1720 top = IPA_EDGE_REF (cs);
1722 for (ie = node->indirect_calls; ie; ie = next_ie)
1724 struct cgraph_indirect_call_info *ici = ie->indirect_info;
1725 struct ipa_jump_func *jfunc;
1727 next_ie = ie->next_callee;
1728 if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
1731 /* If we ever use indirect edges for anything other than indirect
1732 inlining, we will need to skip those with negative param_indices. */
1733 if (ici->param_index == -1)
1736 /* We must check range due to calls with variable number of arguments: */
1737 if (ici->param_index >= ipa_get_cs_argument_count (top))
1739 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1743 jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1744 if (jfunc->type == IPA_JF_PASS_THROUGH
1745 && jfunc->value.pass_through.operation == NOP_EXPR)
1746 ici->param_index = jfunc->value.pass_through.formal_id;
1747 else if (jfunc->type == IPA_JF_ANCESTOR)
1749 ici->param_index = jfunc->value.ancestor.formal_id;
1750 ici->anc_offset += jfunc->value.ancestor.offset;
1753 /* Either we can find a destination for this edge now or never. */
1754 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1756 if (ici->polymorphic)
1757 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1759 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1761 if (new_direct_edge)
1763 new_direct_edge->indirect_inlining_edge = 1;
1766 VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1768 top = IPA_EDGE_REF (cs);
1777 /* Recursively traverse subtree of NODE (including node) made of inlined
1778 cgraph_edges when CS has been inlined and invoke
1779 update_indirect_edges_after_inlining on all nodes and
1780 update_jump_functions_after_inlining on all non-inlined edges that lead out
1781 of this subtree. Newly discovered indirect edges will be added to
1782 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1786 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1787 struct cgraph_node *node,
1788 VEC (cgraph_edge_p, heap) **new_edges)
1790 struct cgraph_edge *e;
1793 res = update_indirect_edges_after_inlining (cs, node, new_edges);
1795 for (e = node->callees; e; e = e->next_callee)
1796 if (!e->inline_failed)
1797 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1799 update_jump_functions_after_inlining (cs, e);
1804 /* Update jump functions and call note functions on inlining the call site CS.
1805 CS is expected to lead to a node already cloned by
1806 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1807 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1811 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1812 VEC (cgraph_edge_p, heap) **new_edges)
1814 /* Do nothing if the preparation phase has not been carried out yet
1815 (i.e. during early inlining). */
1816 if (!ipa_node_params_vector)
1818 gcc_assert (ipa_edge_args_vector);
1820 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1823 /* Frees all dynamically allocated structures that the argument info points
1827 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1829 if (args->jump_functions)
1830 ggc_free (args->jump_functions);
1832 memset (args, 0, sizeof (*args));
1835 /* Free all ipa_edge structures. */
1838 ipa_free_all_edge_args (void)
1841 struct ipa_edge_args *args;
1843 FOR_EACH_VEC_ELT (ipa_edge_args_t, ipa_edge_args_vector, i, args)
1844 ipa_free_edge_args_substructures (args);
1846 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1847 ipa_edge_args_vector = NULL;
1850 /* Frees all dynamically allocated structures that the param info points
1854 ipa_free_node_params_substructures (struct ipa_node_params *info)
1856 VEC_free (ipa_param_descriptor_t, heap, info->descriptors);
1857 free (info->lattices);
1858 /* Lattice values and their sources are deallocated with their alocation
1860 VEC_free (tree, heap, info->known_vals);
1861 memset (info, 0, sizeof (*info));
1864 /* Free all ipa_node_params structures. */
1867 ipa_free_all_node_params (void)
1870 struct ipa_node_params *info;
1872 FOR_EACH_VEC_ELT (ipa_node_params_t, ipa_node_params_vector, i, info)
1873 ipa_free_node_params_substructures (info);
1875 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1876 ipa_node_params_vector = NULL;
1879 /* Hook that is called by cgraph.c when an edge is removed. */
1882 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1884 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1885 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1886 <= (unsigned)cs->uid)
1888 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1891 /* Hook that is called by cgraph.c when a node is removed. */
1894 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1896 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1897 if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1898 <= (unsigned)node->uid)
1900 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1903 static struct ipa_jump_func *
1904 duplicate_ipa_jump_func_array (const struct ipa_jump_func * src, size_t n)
1906 struct ipa_jump_func *p;
1911 p = ggc_alloc_vec_ipa_jump_func (n);
1912 memcpy (p, src, n * sizeof (struct ipa_jump_func));
1916 /* Hook that is called by cgraph.c when a node is duplicated. */
1919 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1920 __attribute__((unused)) void *data)
1922 struct ipa_edge_args *old_args, *new_args;
1925 ipa_check_create_edge_args ();
1927 old_args = IPA_EDGE_REF (src);
1928 new_args = IPA_EDGE_REF (dst);
1930 arg_count = ipa_get_cs_argument_count (old_args);
1931 ipa_set_cs_argument_count (new_args, arg_count);
1932 new_args->jump_functions =
1933 duplicate_ipa_jump_func_array (old_args->jump_functions, arg_count);
1935 if (iinlining_processed_edges
1936 && bitmap_bit_p (iinlining_processed_edges, src->uid))
1937 bitmap_set_bit (iinlining_processed_edges, dst->uid);
1940 /* Hook that is called by cgraph.c when a node is duplicated. */
1943 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1944 ATTRIBUTE_UNUSED void *data)
1946 struct ipa_node_params *old_info, *new_info;
1948 ipa_check_create_node_params ();
1949 old_info = IPA_NODE_REF (src);
1950 new_info = IPA_NODE_REF (dst);
1952 new_info->descriptors = VEC_copy (ipa_param_descriptor_t, heap,
1953 old_info->descriptors);
1954 new_info->lattices = NULL;
1955 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1957 new_info->uses_analysis_done = old_info->uses_analysis_done;
1958 new_info->node_enqueued = old_info->node_enqueued;
1962 /* Analyze newly added function into callgraph. */
1965 ipa_add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1967 ipa_analyze_node (node);
1970 /* Register our cgraph hooks if they are not already there. */
1973 ipa_register_cgraph_hooks (void)
1975 if (!edge_removal_hook_holder)
1976 edge_removal_hook_holder =
1977 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1978 if (!node_removal_hook_holder)
1979 node_removal_hook_holder =
1980 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1981 if (!edge_duplication_hook_holder)
1982 edge_duplication_hook_holder =
1983 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1984 if (!node_duplication_hook_holder)
1985 node_duplication_hook_holder =
1986 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1987 function_insertion_hook_holder =
1988 cgraph_add_function_insertion_hook (&ipa_add_new_function, NULL);
1991 /* Unregister our cgraph hooks if they are not already there. */
1994 ipa_unregister_cgraph_hooks (void)
1996 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1997 edge_removal_hook_holder = NULL;
1998 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1999 node_removal_hook_holder = NULL;
2000 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
2001 edge_duplication_hook_holder = NULL;
2002 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
2003 node_duplication_hook_holder = NULL;
2004 cgraph_remove_function_insertion_hook (function_insertion_hook_holder);
2005 function_insertion_hook_holder = NULL;
2008 /* Allocate all necessary data structures necessary for indirect inlining. */
2011 ipa_create_all_structures_for_iinln (void)
2013 iinlining_processed_edges = BITMAP_ALLOC (NULL);
2016 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
2017 longer needed after ipa-cp. */
2020 ipa_free_all_structures_after_ipa_cp (void)
2022 if (!flag_indirect_inlining)
2024 ipa_free_all_edge_args ();
2025 ipa_free_all_node_params ();
2026 free_alloc_pool (ipcp_sources_pool);
2027 free_alloc_pool (ipcp_values_pool);
2028 ipa_unregister_cgraph_hooks ();
2032 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
2033 longer needed after indirect inlining. */
2036 ipa_free_all_structures_after_iinln (void)
2038 BITMAP_FREE (iinlining_processed_edges);
2040 ipa_free_all_edge_args ();
2041 ipa_free_all_node_params ();
2042 ipa_unregister_cgraph_hooks ();
2043 if (ipcp_sources_pool)
2044 free_alloc_pool (ipcp_sources_pool);
2045 if (ipcp_values_pool)
2046 free_alloc_pool (ipcp_values_pool);
2049 /* Print ipa_tree_map data structures of all functions in the
2053 ipa_print_node_params (FILE * f, struct cgraph_node *node)
2057 struct ipa_node_params *info;
2059 if (!node->analyzed)
2061 info = IPA_NODE_REF (node);
2062 fprintf (f, " function %s parameter descriptors:\n",
2063 cgraph_node_name (node));
2064 count = ipa_get_param_count (info);
2065 for (i = 0; i < count; i++)
2067 temp = ipa_get_param (info, i);
2068 if (TREE_CODE (temp) == PARM_DECL)
2069 fprintf (f, " param %d : %s", i,
2071 ? (*lang_hooks.decl_printable_name) (temp, 2)
2073 if (ipa_is_param_used (info, i))
2074 fprintf (f, " used");
2079 /* Print ipa_tree_map data structures of all functions in the
2083 ipa_print_all_params (FILE * f)
2085 struct cgraph_node *node;
2087 fprintf (f, "\nFunction parameters:\n");
2088 for (node = cgraph_nodes; node; node = node->next)
2089 ipa_print_node_params (f, node);
2092 /* Return a heap allocated vector containing formal parameters of FNDECL. */
2095 ipa_get_vector_of_formal_parms (tree fndecl)
2097 VEC(tree, heap) *args;
2101 count = count_formal_params (fndecl);
2102 args = VEC_alloc (tree, heap, count);
2103 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
2104 VEC_quick_push (tree, args, parm);
2109 /* Return a heap allocated vector containing types of formal parameters of
2110 function type FNTYPE. */
2112 static inline VEC(tree, heap) *
2113 get_vector_of_formal_parm_types (tree fntype)
2115 VEC(tree, heap) *types;
2119 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
2122 types = VEC_alloc (tree, heap, count);
2123 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
2124 VEC_quick_push (tree, types, TREE_VALUE (t));
2129 /* Modify the function declaration FNDECL and its type according to the plan in
2130 ADJUSTMENTS. It also sets base fields of individual adjustments structures
2131 to reflect the actual parameters being modified which are determined by the
2132 base_index field. */
2135 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
2136 const char *synth_parm_prefix)
2138 VEC(tree, heap) *oparms, *otypes;
2139 tree orig_type, new_type = NULL;
2140 tree old_arg_types, t, new_arg_types = NULL;
2141 tree parm, *link = &DECL_ARGUMENTS (fndecl);
2142 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2143 tree new_reversed = NULL;
2144 bool care_for_types, last_parm_void;
2146 if (!synth_parm_prefix)
2147 synth_parm_prefix = "SYNTH";
2149 oparms = ipa_get_vector_of_formal_parms (fndecl);
2150 orig_type = TREE_TYPE (fndecl);
2151 old_arg_types = TYPE_ARG_TYPES (orig_type);
2153 /* The following test is an ugly hack, some functions simply don't have any
2154 arguments in their type. This is probably a bug but well... */
2155 care_for_types = (old_arg_types != NULL_TREE);
2158 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
2160 otypes = get_vector_of_formal_parm_types (orig_type);
2162 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
2164 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
2168 last_parm_void = false;
2172 for (i = 0; i < len; i++)
2174 struct ipa_parm_adjustment *adj;
2177 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2178 parm = VEC_index (tree, oparms, adj->base_index);
2181 if (adj->copy_param)
2184 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
2188 link = &DECL_CHAIN (parm);
2190 else if (!adj->remove_param)
2196 ptype = build_pointer_type (adj->type);
2201 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
2203 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
2205 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
2207 DECL_ARTIFICIAL (new_parm) = 1;
2208 DECL_ARG_TYPE (new_parm) = ptype;
2209 DECL_CONTEXT (new_parm) = fndecl;
2210 TREE_USED (new_parm) = 1;
2211 DECL_IGNORED_P (new_parm) = 1;
2212 layout_decl (new_parm, 0);
2214 add_referenced_var (new_parm);
2215 mark_sym_for_renaming (new_parm);
2217 adj->reduction = new_parm;
2221 link = &DECL_CHAIN (new_parm);
2229 new_reversed = nreverse (new_arg_types);
2233 TREE_CHAIN (new_arg_types) = void_list_node;
2235 new_reversed = void_list_node;
2239 /* Use copy_node to preserve as much as possible from original type
2240 (debug info, attribute lists etc.)
2241 Exception is METHOD_TYPEs must have THIS argument.
2242 When we are asked to remove it, we need to build new FUNCTION_TYPE
2244 if (TREE_CODE (orig_type) != METHOD_TYPE
2245 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
2246 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
2248 new_type = build_distinct_type_copy (orig_type);
2249 TYPE_ARG_TYPES (new_type) = new_reversed;
2254 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
2256 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
2257 DECL_VINDEX (fndecl) = NULL_TREE;
2260 /* When signature changes, we need to clear builtin info. */
2261 if (DECL_BUILT_IN (fndecl))
2263 DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
2264 DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
2267 /* This is a new type, not a copy of an old type. Need to reassociate
2268 variants. We can handle everything except the main variant lazily. */
2269 t = TYPE_MAIN_VARIANT (orig_type);
2272 TYPE_MAIN_VARIANT (new_type) = t;
2273 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
2274 TYPE_NEXT_VARIANT (t) = new_type;
2278 TYPE_MAIN_VARIANT (new_type) = new_type;
2279 TYPE_NEXT_VARIANT (new_type) = NULL;
2282 TREE_TYPE (fndecl) = new_type;
2283 DECL_VIRTUAL_P (fndecl) = 0;
2285 VEC_free (tree, heap, otypes);
2286 VEC_free (tree, heap, oparms);
2289 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2290 If this is a directly recursive call, CS must be NULL. Otherwise it must
2291 contain the corresponding call graph edge. */
2294 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2295 ipa_parm_adjustment_vec adjustments)
2297 VEC(tree, heap) *vargs;
2298 VEC(tree, gc) **debug_args = NULL;
2300 gimple_stmt_iterator gsi;
2304 len = VEC_length (ipa_parm_adjustment_t, adjustments);
2305 vargs = VEC_alloc (tree, heap, len);
2306 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2308 gsi = gsi_for_stmt (stmt);
2309 for (i = 0; i < len; i++)
2311 struct ipa_parm_adjustment *adj;
2313 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2315 if (adj->copy_param)
2317 tree arg = gimple_call_arg (stmt, adj->base_index);
2319 VEC_quick_push (tree, vargs, arg);
2321 else if (!adj->remove_param)
2323 tree expr, base, off;
2326 /* We create a new parameter out of the value of the old one, we can
2327 do the following kind of transformations:
2329 - A scalar passed by reference is converted to a scalar passed by
2330 value. (adj->by_ref is false and the type of the original
2331 actual argument is a pointer to a scalar).
2333 - A part of an aggregate is passed instead of the whole aggregate.
2334 The part can be passed either by value or by reference, this is
2335 determined by value of adj->by_ref. Moreover, the code below
2336 handles both situations when the original aggregate is passed by
2337 value (its type is not a pointer) and when it is passed by
2338 reference (it is a pointer to an aggregate).
2340 When the new argument is passed by reference (adj->by_ref is true)
2341 it must be a part of an aggregate and therefore we form it by
2342 simply taking the address of a reference inside the original
2345 gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0);
2346 base = gimple_call_arg (stmt, adj->base_index);
2347 loc = EXPR_LOCATION (base);
2349 if (TREE_CODE (base) != ADDR_EXPR
2350 && POINTER_TYPE_P (TREE_TYPE (base)))
2351 off = build_int_cst (adj->alias_ptr_type,
2352 adj->offset / BITS_PER_UNIT);
2355 HOST_WIDE_INT base_offset;
2358 if (TREE_CODE (base) == ADDR_EXPR)
2359 base = TREE_OPERAND (base, 0);
2361 base = get_addr_base_and_unit_offset (base, &base_offset);
2362 /* Aggregate arguments can have non-invariant addresses. */
2365 base = build_fold_addr_expr (prev_base);
2366 off = build_int_cst (adj->alias_ptr_type,
2367 adj->offset / BITS_PER_UNIT);
2369 else if (TREE_CODE (base) == MEM_REF)
2371 off = build_int_cst (adj->alias_ptr_type,
2373 + adj->offset / BITS_PER_UNIT);
2374 off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1),
2376 base = TREE_OPERAND (base, 0);
2380 off = build_int_cst (adj->alias_ptr_type,
2382 + adj->offset / BITS_PER_UNIT);
2383 base = build_fold_addr_expr (base);
2387 expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off);
2389 expr = build_fold_addr_expr (expr);
2391 expr = force_gimple_operand_gsi (&gsi, expr,
2393 || is_gimple_reg_type (adj->type),
2394 NULL, true, GSI_SAME_STMT);
2395 VEC_quick_push (tree, vargs, expr);
2397 if (!adj->copy_param && MAY_HAVE_DEBUG_STMTS)
2400 tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg;
2403 arg = gimple_call_arg (stmt, adj->base_index);
2404 if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg)))
2406 if (!fold_convertible_p (TREE_TYPE (origin), arg))
2408 arg = fold_convert_loc (gimple_location (stmt),
2409 TREE_TYPE (origin), arg);
2411 if (debug_args == NULL)
2412 debug_args = decl_debug_args_insert (callee_decl);
2413 for (ix = 0; VEC_iterate (tree, *debug_args, ix, ddecl); ix += 2)
2414 if (ddecl == origin)
2416 ddecl = VEC_index (tree, *debug_args, ix + 1);
2421 ddecl = make_node (DEBUG_EXPR_DECL);
2422 DECL_ARTIFICIAL (ddecl) = 1;
2423 TREE_TYPE (ddecl) = TREE_TYPE (origin);
2424 DECL_MODE (ddecl) = DECL_MODE (origin);
2426 VEC_safe_push (tree, gc, *debug_args, origin);
2427 VEC_safe_push (tree, gc, *debug_args, ddecl);
2429 def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg),
2431 gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT);
2435 if (dump_file && (dump_flags & TDF_DETAILS))
2437 fprintf (dump_file, "replacing stmt:");
2438 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2441 new_stmt = gimple_build_call_vec (callee_decl, vargs);
2442 VEC_free (tree, heap, vargs);
2443 if (gimple_call_lhs (stmt))
2444 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2446 gimple_set_block (new_stmt, gimple_block (stmt));
2447 if (gimple_has_location (stmt))
2448 gimple_set_location (new_stmt, gimple_location (stmt));
2449 gimple_call_copy_flags (new_stmt, stmt);
2450 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2452 if (dump_file && (dump_flags & TDF_DETAILS))
2454 fprintf (dump_file, "with stmt:");
2455 print_gimple_stmt (dump_file, new_stmt, 0, 0);
2456 fprintf (dump_file, "\n");
2458 gsi_replace (&gsi, new_stmt, true);
2460 cgraph_set_call_stmt (cs, new_stmt);
2461 update_ssa (TODO_update_ssa);
2462 free_dominance_info (CDI_DOMINATORS);
2465 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2468 index_in_adjustments_multiple_times_p (int base_index,
2469 ipa_parm_adjustment_vec adjustments)
2471 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2474 for (i = 0; i < len; i++)
2476 struct ipa_parm_adjustment *adj;
2477 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2479 if (adj->base_index == base_index)
2491 /* Return adjustments that should have the same effect on function parameters
2492 and call arguments as if they were first changed according to adjustments in
2493 INNER and then by adjustments in OUTER. */
2495 ipa_parm_adjustment_vec
2496 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2497 ipa_parm_adjustment_vec outer)
2499 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2500 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2502 ipa_parm_adjustment_vec adjustments, tmp;
2504 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2505 for (i = 0; i < inlen; i++)
2507 struct ipa_parm_adjustment *n;
2508 n = VEC_index (ipa_parm_adjustment_t, inner, i);
2510 if (n->remove_param)
2513 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2516 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2517 for (i = 0; i < outlen; i++)
2519 struct ipa_parm_adjustment *r;
2520 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2522 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2525 gcc_assert (!in->remove_param);
2526 if (out->remove_param)
2528 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2530 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2531 memset (r, 0, sizeof (*r));
2532 r->remove_param = true;
2537 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2538 memset (r, 0, sizeof (*r));
2539 r->base_index = in->base_index;
2540 r->type = out->type;
2542 /* FIXME: Create nonlocal value too. */
2544 if (in->copy_param && out->copy_param)
2545 r->copy_param = true;
2546 else if (in->copy_param)
2547 r->offset = out->offset;
2548 else if (out->copy_param)
2549 r->offset = in->offset;
2551 r->offset = in->offset + out->offset;
2554 for (i = 0; i < inlen; i++)
2556 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2559 if (n->remove_param)
2560 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2563 VEC_free (ipa_parm_adjustment_t, heap, tmp);
2567 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2568 friendly way, assuming they are meant to be applied to FNDECL. */
2571 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2574 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2576 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2578 fprintf (file, "IPA param adjustments: ");
2579 for (i = 0; i < len; i++)
2581 struct ipa_parm_adjustment *adj;
2582 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2585 fprintf (file, " ");
2589 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2590 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2593 fprintf (file, ", base: ");
2594 print_generic_expr (file, adj->base, 0);
2598 fprintf (file, ", reduction: ");
2599 print_generic_expr (file, adj->reduction, 0);
2601 if (adj->new_ssa_base)
2603 fprintf (file, ", new_ssa_base: ");
2604 print_generic_expr (file, adj->new_ssa_base, 0);
2607 if (adj->copy_param)
2608 fprintf (file, ", copy_param");
2609 else if (adj->remove_param)
2610 fprintf (file, ", remove_param");
2612 fprintf (file, ", offset %li", (long) adj->offset);
2614 fprintf (file, ", by_ref");
2615 print_node_brief (file, ", type: ", adj->type, 0);
2616 fprintf (file, "\n");
2618 VEC_free (tree, heap, parms);
2621 /* Stream out jump function JUMP_FUNC to OB. */
2624 ipa_write_jump_function (struct output_block *ob,
2625 struct ipa_jump_func *jump_func)
2627 streamer_write_uhwi (ob, jump_func->type);
2629 switch (jump_func->type)
2631 case IPA_JF_UNKNOWN:
2633 case IPA_JF_KNOWN_TYPE:
2634 stream_write_tree (ob, jump_func->value.base_binfo, true);
2637 stream_write_tree (ob, jump_func->value.constant, true);
2639 case IPA_JF_PASS_THROUGH:
2640 stream_write_tree (ob, jump_func->value.pass_through.operand, true);
2641 streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
2642 streamer_write_uhwi (ob, jump_func->value.pass_through.operation);
2644 case IPA_JF_ANCESTOR:
2645 streamer_write_uhwi (ob, jump_func->value.ancestor.offset);
2646 stream_write_tree (ob, jump_func->value.ancestor.type, true);
2647 streamer_write_uhwi (ob, jump_func->value.ancestor.formal_id);
2649 case IPA_JF_CONST_MEMBER_PTR:
2650 stream_write_tree (ob, jump_func->value.member_cst.pfn, true);
2651 stream_write_tree (ob, jump_func->value.member_cst.delta, false);
2656 /* Read in jump function JUMP_FUNC from IB. */
2659 ipa_read_jump_function (struct lto_input_block *ib,
2660 struct ipa_jump_func *jump_func,
2661 struct data_in *data_in)
2663 jump_func->type = (enum jump_func_type) streamer_read_uhwi (ib);
2665 switch (jump_func->type)
2667 case IPA_JF_UNKNOWN:
2669 case IPA_JF_KNOWN_TYPE:
2670 jump_func->value.base_binfo = stream_read_tree (ib, data_in);
2673 jump_func->value.constant = stream_read_tree (ib, data_in);
2675 case IPA_JF_PASS_THROUGH:
2676 jump_func->value.pass_through.operand = stream_read_tree (ib, data_in);
2677 jump_func->value.pass_through.formal_id = streamer_read_uhwi (ib);
2678 jump_func->value.pass_through.operation
2679 = (enum tree_code) streamer_read_uhwi (ib);
2681 case IPA_JF_ANCESTOR:
2682 jump_func->value.ancestor.offset = streamer_read_uhwi (ib);
2683 jump_func->value.ancestor.type = stream_read_tree (ib, data_in);
2684 jump_func->value.ancestor.formal_id = streamer_read_uhwi (ib);
2686 case IPA_JF_CONST_MEMBER_PTR:
2687 jump_func->value.member_cst.pfn = stream_read_tree (ib, data_in);
2688 jump_func->value.member_cst.delta = stream_read_tree (ib, data_in);
2693 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2694 relevant to indirect inlining to OB. */
2697 ipa_write_indirect_edge_info (struct output_block *ob,
2698 struct cgraph_edge *cs)
2700 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2701 struct bitpack_d bp;
2703 streamer_write_hwi (ob, ii->param_index);
2704 streamer_write_hwi (ob, ii->anc_offset);
2705 bp = bitpack_create (ob->main_stream);
2706 bp_pack_value (&bp, ii->polymorphic, 1);
2707 streamer_write_bitpack (&bp);
2709 if (ii->polymorphic)
2711 streamer_write_hwi (ob, ii->otr_token);
2712 stream_write_tree (ob, ii->otr_type, true);
2716 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2717 relevant to indirect inlining from IB. */
2720 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2721 struct data_in *data_in ATTRIBUTE_UNUSED,
2722 struct cgraph_edge *cs)
2724 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2725 struct bitpack_d bp;
2727 ii->param_index = (int) streamer_read_hwi (ib);
2728 ii->anc_offset = (HOST_WIDE_INT) streamer_read_hwi (ib);
2729 bp = streamer_read_bitpack (ib);
2730 ii->polymorphic = bp_unpack_value (&bp, 1);
2731 if (ii->polymorphic)
2733 ii->otr_token = (HOST_WIDE_INT) streamer_read_hwi (ib);
2734 ii->otr_type = stream_read_tree (ib, data_in);
2738 /* Stream out NODE info to OB. */
2741 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2744 lto_cgraph_encoder_t encoder;
2745 struct ipa_node_params *info = IPA_NODE_REF (node);
2747 struct cgraph_edge *e;
2748 struct bitpack_d bp;
2750 encoder = ob->decl_state->cgraph_node_encoder;
2751 node_ref = lto_cgraph_encoder_encode (encoder, node);
2752 streamer_write_uhwi (ob, node_ref);
2754 bp = bitpack_create (ob->main_stream);
2755 gcc_assert (info->uses_analysis_done
2756 || ipa_get_param_count (info) == 0);
2757 gcc_assert (!info->node_enqueued);
2758 gcc_assert (!info->ipcp_orig_node);
2759 for (j = 0; j < ipa_get_param_count (info); j++)
2760 bp_pack_value (&bp, ipa_is_param_used (info, j), 1);
2761 streamer_write_bitpack (&bp);
2762 for (e = node->callees; e; e = e->next_callee)
2764 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2766 streamer_write_uhwi (ob, ipa_get_cs_argument_count (args));
2767 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2768 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2770 for (e = node->indirect_calls; e; e = e->next_callee)
2772 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2774 streamer_write_uhwi (ob, ipa_get_cs_argument_count (args));
2775 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2776 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2777 ipa_write_indirect_edge_info (ob, e);
2781 /* Stream in NODE info from IB. */
2784 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2785 struct data_in *data_in)
2787 struct ipa_node_params *info = IPA_NODE_REF (node);
2789 struct cgraph_edge *e;
2790 struct bitpack_d bp;
2792 ipa_initialize_node_params (node);
2794 bp = streamer_read_bitpack (ib);
2795 if (ipa_get_param_count (info) != 0)
2796 info->uses_analysis_done = true;
2797 info->node_enqueued = false;
2798 for (k = 0; k < ipa_get_param_count (info); k++)
2799 ipa_set_param_used (info, k, bp_unpack_value (&bp, 1));
2800 for (e = node->callees; e; e = e->next_callee)
2802 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2803 int count = streamer_read_uhwi (ib);
2805 ipa_set_cs_argument_count (args, count);
2809 args->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
2810 (ipa_get_cs_argument_count (args));
2811 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2812 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2814 for (e = node->indirect_calls; e; e = e->next_callee)
2816 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2817 int count = streamer_read_uhwi (ib);
2819 ipa_set_cs_argument_count (args, count);
2822 args->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
2823 (ipa_get_cs_argument_count (args));
2824 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2825 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2827 ipa_read_indirect_edge_info (ib, data_in, e);
2831 /* Write jump functions for nodes in SET. */
2834 ipa_prop_write_jump_functions (cgraph_node_set set)
2836 struct cgraph_node *node;
2837 struct output_block *ob;
2838 unsigned int count = 0;
2839 cgraph_node_set_iterator csi;
2841 if (!ipa_node_params_vector)
2844 ob = create_output_block (LTO_section_jump_functions);
2845 ob->cgraph_node = NULL;
2846 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2848 node = csi_node (csi);
2849 if (cgraph_function_with_gimple_body_p (node)
2850 && IPA_NODE_REF (node) != NULL)
2854 streamer_write_uhwi (ob, count);
2856 /* Process all of the functions. */
2857 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2859 node = csi_node (csi);
2860 if (cgraph_function_with_gimple_body_p (node)
2861 && IPA_NODE_REF (node) != NULL)
2862 ipa_write_node_info (ob, node);
2864 streamer_write_char_stream (ob->main_stream, 0);
2865 produce_asm (ob, NULL);
2866 destroy_output_block (ob);
2869 /* Read section in file FILE_DATA of length LEN with data DATA. */
2872 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2875 const struct lto_function_header *header =
2876 (const struct lto_function_header *) data;
2877 const int32_t cfg_offset = sizeof (struct lto_function_header);
2878 const int32_t main_offset = cfg_offset + header->cfg_size;
2879 const int32_t string_offset = main_offset + header->main_size;
2880 struct data_in *data_in;
2881 struct lto_input_block ib_main;
2885 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2889 lto_data_in_create (file_data, (const char *) data + string_offset,
2890 header->string_size, NULL);
2891 count = streamer_read_uhwi (&ib_main);
2893 for (i = 0; i < count; i++)
2896 struct cgraph_node *node;
2897 lto_cgraph_encoder_t encoder;
2899 index = streamer_read_uhwi (&ib_main);
2900 encoder = file_data->cgraph_node_encoder;
2901 node = lto_cgraph_encoder_deref (encoder, index);
2902 gcc_assert (node->analyzed);
2903 ipa_read_node_info (&ib_main, node, data_in);
2905 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2907 lto_data_in_delete (data_in);
2910 /* Read ipcp jump functions. */
2913 ipa_prop_read_jump_functions (void)
2915 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2916 struct lto_file_decl_data *file_data;
2919 ipa_check_create_node_params ();
2920 ipa_check_create_edge_args ();
2921 ipa_register_cgraph_hooks ();
2923 while ((file_data = file_data_vec[j++]))
2926 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2929 ipa_prop_read_section (file_data, data, len);
2933 /* After merging units, we can get mismatch in argument counts.
2934 Also decl merging might've rendered parameter lists obsolete.
2935 Also compute called_with_variable_arg info. */
2938 ipa_update_after_lto_read (void)
2940 struct cgraph_node *node;
2942 ipa_check_create_node_params ();
2943 ipa_check_create_edge_args ();
2945 for (node = cgraph_nodes; node; node = node->next)
2947 ipa_initialize_node_params (node);