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_ainfo
,
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_ainfo
[index
], call
,
819 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
,
821 jfunc
->type
= IPA_JF_PASS_THROUGH
;
822 jfunc
->value
.pass_through
.formal_id
= index
;
823 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
826 undecided_members
= true;
829 undecided_members
= true;
833 return undecided_members
;
836 /* Simple function filling in a member pointer constant jump function (with PFN
837 and DELTA as the constant value) into JFUNC. */
840 fill_member_ptr_cst_jump_function (struct ipa_jump_func
*jfunc
,
841 tree pfn
, tree delta
)
843 jfunc
->type
= IPA_JF_CONST_MEMBER_PTR
;
844 jfunc
->value
.member_cst
.pfn
= pfn
;
845 jfunc
->value
.member_cst
.delta
= delta
;
848 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
849 return the rhs of its defining statement. */
852 get_ssa_def_if_simple_copy (tree rhs
)
854 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
856 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs
);
858 if (gimple_assign_single_p (def_stmt
))
859 rhs
= gimple_assign_rhs1 (def_stmt
);
866 /* Traverse statements from CALL backwards, scanning whether the argument ARG
867 which is a member pointer is filled in with constant values. If it is, fill
868 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
869 fields of the record type of the member pointer. To give an example, we
870 look for a pattern looking like the following:
872 D.2515.__pfn ={v} printStuff;
873 D.2515.__delta ={v} 0;
874 i_1 = doprinting (D.2515); */
877 determine_cst_member_ptr (gimple call
, tree arg
, tree method_field
,
878 tree delta_field
, struct ipa_jump_func
*jfunc
)
880 gimple_stmt_iterator gsi
;
881 tree method
= NULL_TREE
;
882 tree delta
= NULL_TREE
;
884 gsi
= gsi_for_stmt (call
);
887 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
889 gimple stmt
= gsi_stmt (gsi
);
892 if (!stmt_may_clobber_ref_p (stmt
, arg
))
894 if (!gimple_assign_single_p (stmt
))
897 lhs
= gimple_assign_lhs (stmt
);
898 rhs
= gimple_assign_rhs1 (stmt
);
900 if (TREE_CODE (lhs
) != COMPONENT_REF
901 || TREE_OPERAND (lhs
, 0) != arg
)
904 fld
= TREE_OPERAND (lhs
, 1);
905 if (!method
&& fld
== method_field
)
907 rhs
= get_ssa_def_if_simple_copy (rhs
);
908 if (TREE_CODE (rhs
) == ADDR_EXPR
909 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == FUNCTION_DECL
910 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) == METHOD_TYPE
)
912 method
= TREE_OPERAND (rhs
, 0);
915 fill_member_ptr_cst_jump_function (jfunc
, rhs
, delta
);
923 if (!delta
&& fld
== delta_field
)
925 rhs
= get_ssa_def_if_simple_copy (rhs
);
926 if (TREE_CODE (rhs
) == INTEGER_CST
)
931 fill_member_ptr_cst_jump_function (jfunc
, rhs
, delta
);
943 /* Go through the arguments of the CALL and for every member pointer within
944 tries determine whether it is a constant. If it is, create a corresponding
945 constant jump function in FUNCTIONS which is an array of jump functions
946 associated with the call. */
949 compute_cst_member_ptr_arguments (struct ipa_edge_args
*args
,
953 tree arg
, method_field
, delta_field
;
955 for (num
= 0; num
< gimple_call_num_args (call
); num
++)
957 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
, num
);
958 arg
= gimple_call_arg (call
, num
);
960 if (jfunc
->type
== IPA_JF_UNKNOWN
961 && type_like_member_ptr_p (TREE_TYPE (arg
), &method_field
,
963 determine_cst_member_ptr (call
, arg
, method_field
, delta_field
, jfunc
);
967 /* Compute jump function for all arguments of callsite CS and insert the
968 information in the jump_functions array in the ipa_edge_args corresponding
972 ipa_compute_jump_functions_for_edge (struct param_analysis_info
*parms_ainfo
,
973 struct cgraph_edge
*cs
)
975 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
976 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
977 gimple call
= cs
->call_stmt
;
978 int arg_num
= gimple_call_num_args (call
);
980 if (arg_num
== 0 || args
->jump_functions
)
982 VEC_safe_grow_cleared (ipa_jump_func_t
, gc
, args
->jump_functions
, arg_num
);
984 /* We will deal with constants and SSA scalars first: */
985 compute_scalar_jump_functions (info
, args
, call
);
987 /* Let's check whether there are any potential member pointers and if so,
988 whether we can determine their functions as pass_through. */
989 if (!compute_pass_through_member_ptrs (info
, parms_ainfo
, args
, call
))
992 /* Finally, let's check whether we actually pass a new constant member
994 compute_cst_member_ptr_arguments (args
, call
);
997 /* Compute jump functions for all edges - both direct and indirect - outgoing
998 from NODE. Also count the actual arguments in the process. */
1001 ipa_compute_jump_functions (struct cgraph_node
*node
,
1002 struct param_analysis_info
*parms_ainfo
)
1004 struct cgraph_edge
*cs
;
1006 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
1008 struct cgraph_node
*callee
= cgraph_function_or_thunk_node (cs
->callee
,
1010 /* We do not need to bother analyzing calls to unknown
1011 functions unless they may become known during lto/whopr. */
1012 if (!callee
->analyzed
&& !flag_lto
)
1014 ipa_compute_jump_functions_for_edge (parms_ainfo
, cs
);
1017 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
1018 ipa_compute_jump_functions_for_edge (parms_ainfo
, cs
);
1021 /* If RHS looks like a rhs of a statement loading pfn from a member
1022 pointer formal parameter, return the parameter, otherwise return
1023 NULL. If USE_DELTA, then we look for a use of the delta field
1024 rather than the pfn. */
1027 ipa_get_member_ptr_load_param (tree rhs
, bool use_delta
)
1029 tree rec
, ref_field
, ref_offset
, fld
, fld_offset
, ptr_field
, delta_field
;
1031 if (TREE_CODE (rhs
) == COMPONENT_REF
)
1033 ref_field
= TREE_OPERAND (rhs
, 1);
1034 rhs
= TREE_OPERAND (rhs
, 0);
1037 ref_field
= NULL_TREE
;
1038 if (TREE_CODE (rhs
) != MEM_REF
)
1040 rec
= TREE_OPERAND (rhs
, 0);
1041 if (TREE_CODE (rec
) != ADDR_EXPR
)
1043 rec
= TREE_OPERAND (rec
, 0);
1044 if (TREE_CODE (rec
) != PARM_DECL
1045 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
1048 ref_offset
= TREE_OPERAND (rhs
, 1);
1052 if (integer_nonzerop (ref_offset
))
1060 return ref_field
== fld
? rec
: NULL_TREE
;
1064 fld_offset
= byte_position (delta_field
);
1066 fld_offset
= byte_position (ptr_field
);
1068 return tree_int_cst_equal (ref_offset
, fld_offset
) ? rec
: NULL_TREE
;
1071 /* If STMT looks like a statement loading a value from a member pointer formal
1072 parameter, this function returns that parameter. */
1075 ipa_get_stmt_member_ptr_load_param (gimple stmt
, bool use_delta
)
1079 if (!gimple_assign_single_p (stmt
))
1082 rhs
= gimple_assign_rhs1 (stmt
);
1083 return ipa_get_member_ptr_load_param (rhs
, use_delta
);
1086 /* Returns true iff T is an SSA_NAME defined by a statement. */
1089 ipa_is_ssa_with_stmt_def (tree t
)
1091 if (TREE_CODE (t
) == SSA_NAME
1092 && !SSA_NAME_IS_DEFAULT_DEF (t
))
1098 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1099 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1100 indirect call graph edge. */
1102 static struct cgraph_edge
*
1103 ipa_note_param_call (struct cgraph_node
*node
, int param_index
, gimple stmt
)
1105 struct cgraph_edge
*cs
;
1107 cs
= cgraph_edge (node
, stmt
);
1108 cs
->indirect_info
->param_index
= param_index
;
1109 cs
->indirect_info
->anc_offset
= 0;
1110 cs
->indirect_info
->polymorphic
= 0;
1114 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1115 (described by INFO). PARMS_AINFO is a pointer to a vector containing
1116 intermediate information about each formal parameter. Currently it checks
1117 whether the call calls a pointer that is a formal parameter and if so, the
1118 parameter is marked with the called flag and an indirect call graph edge
1119 describing the call is created. This is very simple for ordinary pointers
1120 represented in SSA but not-so-nice when it comes to member pointers. The
1121 ugly part of this function does nothing more than trying to match the
1122 pattern of such a call. An example of such a pattern is the gimple dump
1123 below, the call is on the last line:
1126 f$__delta_5 = f.__delta;
1127 f$__pfn_24 = f.__pfn;
1131 f$__delta_5 = MEM[(struct *)&f];
1132 f$__pfn_24 = MEM[(struct *)&f + 4B];
1134 and a few lines below:
1137 D.2496_3 = (int) f$__pfn_24;
1138 D.2497_4 = D.2496_3 & 1;
1145 D.2500_7 = (unsigned int) f$__delta_5;
1146 D.2501_8 = &S + D.2500_7;
1147 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1148 D.2503_10 = *D.2502_9;
1149 D.2504_12 = f$__pfn_24 + -1;
1150 D.2505_13 = (unsigned int) D.2504_12;
1151 D.2506_14 = D.2503_10 + D.2505_13;
1152 D.2507_15 = *D.2506_14;
1153 iftmp.11_16 = (String:: *) D.2507_15;
1156 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1157 D.2500_19 = (unsigned int) f$__delta_5;
1158 D.2508_20 = &S + D.2500_19;
1159 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1161 Such patterns are results of simple calls to a member pointer:
1163 int doprinting (int (MyString::* f)(int) const)
1165 MyString S ("somestring");
1172 ipa_analyze_indirect_call_uses (struct cgraph_node
*node
,
1173 struct ipa_node_params
*info
,
1174 struct param_analysis_info
*parms_ainfo
,
1175 gimple call
, tree target
)
1180 tree rec
, rec2
, cond
;
1183 basic_block bb
, virt_bb
, join
;
1185 if (SSA_NAME_IS_DEFAULT_DEF (target
))
1187 tree var
= SSA_NAME_VAR (target
);
1188 index
= ipa_get_param_decl_index (info
, var
);
1190 ipa_note_param_call (node
, index
, call
);
1194 /* Now we need to try to match the complex pattern of calling a member
1197 if (!POINTER_TYPE_P (TREE_TYPE (target
))
1198 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
1201 def
= SSA_NAME_DEF_STMT (target
);
1202 if (gimple_code (def
) != GIMPLE_PHI
)
1205 if (gimple_phi_num_args (def
) != 2)
1208 /* First, we need to check whether one of these is a load from a member
1209 pointer that is a parameter to this function. */
1210 n1
= PHI_ARG_DEF (def
, 0);
1211 n2
= PHI_ARG_DEF (def
, 1);
1212 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
1214 d1
= SSA_NAME_DEF_STMT (n1
);
1215 d2
= SSA_NAME_DEF_STMT (n2
);
1217 join
= gimple_bb (def
);
1218 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false)))
1220 if (ipa_get_stmt_member_ptr_load_param (d2
, false))
1223 bb
= EDGE_PRED (join
, 0)->src
;
1224 virt_bb
= gimple_bb (d2
);
1226 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false)))
1228 bb
= EDGE_PRED (join
, 1)->src
;
1229 virt_bb
= gimple_bb (d1
);
1234 /* Second, we need to check that the basic blocks are laid out in the way
1235 corresponding to the pattern. */
1237 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
1238 || single_pred (virt_bb
) != bb
1239 || single_succ (virt_bb
) != join
)
1242 /* Third, let's see that the branching is done depending on the least
1243 significant bit of the pfn. */
1245 branch
= last_stmt (bb
);
1246 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
1249 if ((gimple_cond_code (branch
) != NE_EXPR
1250 && gimple_cond_code (branch
) != EQ_EXPR
)
1251 || !integer_zerop (gimple_cond_rhs (branch
)))
1254 cond
= gimple_cond_lhs (branch
);
1255 if (!ipa_is_ssa_with_stmt_def (cond
))
1258 def
= SSA_NAME_DEF_STMT (cond
);
1259 if (!is_gimple_assign (def
)
1260 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
1261 || !integer_onep (gimple_assign_rhs2 (def
)))
1264 cond
= gimple_assign_rhs1 (def
);
1265 if (!ipa_is_ssa_with_stmt_def (cond
))
1268 def
= SSA_NAME_DEF_STMT (cond
);
1270 if (is_gimple_assign (def
)
1271 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
1273 cond
= gimple_assign_rhs1 (def
);
1274 if (!ipa_is_ssa_with_stmt_def (cond
))
1276 def
= SSA_NAME_DEF_STMT (cond
);
1279 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
1280 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1281 == ptrmemfunc_vbit_in_delta
));
1286 index
= ipa_get_param_decl_index (info
, rec
);
1287 if (index
>= 0 && !is_parm_modified_before_call (&parms_ainfo
[index
],
1289 ipa_note_param_call (node
, index
, call
);
1294 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1295 object referenced in the expression is a formal parameter of the caller
1296 (described by INFO), create a call note for the statement. */
1299 ipa_analyze_virtual_call_uses (struct cgraph_node
*node
,
1300 struct ipa_node_params
*info
, gimple call
,
1303 struct cgraph_edge
*cs
;
1304 struct cgraph_indirect_call_info
*ii
;
1305 struct ipa_jump_func jfunc
;
1306 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
1308 HOST_WIDE_INT anc_offset
;
1310 if (!flag_devirtualize
)
1313 if (TREE_CODE (obj
) != SSA_NAME
)
1316 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
1318 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
1322 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
1323 gcc_assert (index
>= 0);
1324 if (detect_type_change_ssa (obj
, call
, &jfunc
))
1329 gimple stmt
= SSA_NAME_DEF_STMT (obj
);
1332 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
1335 index
= ipa_get_param_decl_index (info
,
1336 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
1337 gcc_assert (index
>= 0);
1338 if (detect_type_change (obj
, expr
, call
, &jfunc
, anc_offset
))
1342 cs
= ipa_note_param_call (node
, index
, call
);
1343 ii
= cs
->indirect_info
;
1344 ii
->anc_offset
= anc_offset
;
1345 ii
->otr_token
= tree_low_cst (OBJ_TYPE_REF_TOKEN (target
), 1);
1346 ii
->otr_type
= TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (target
)));
1347 ii
->polymorphic
= 1;
1350 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1351 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
1352 containing intermediate information about each formal parameter. */
1355 ipa_analyze_call_uses (struct cgraph_node
*node
,
1356 struct ipa_node_params
*info
,
1357 struct param_analysis_info
*parms_ainfo
, gimple call
)
1359 tree target
= gimple_call_fn (call
);
1363 if (TREE_CODE (target
) == SSA_NAME
)
1364 ipa_analyze_indirect_call_uses (node
, info
, parms_ainfo
, call
, target
);
1365 else if (TREE_CODE (target
) == OBJ_TYPE_REF
)
1366 ipa_analyze_virtual_call_uses (node
, info
, call
, target
);
1370 /* Analyze the call statement STMT with respect to formal parameters (described
1371 in INFO) of caller given by NODE. Currently it only checks whether formal
1372 parameters are called. PARMS_AINFO is a pointer to a vector containing
1373 intermediate information about each formal parameter. */
1376 ipa_analyze_stmt_uses (struct cgraph_node
*node
, struct ipa_node_params
*info
,
1377 struct param_analysis_info
*parms_ainfo
, gimple stmt
)
1379 if (is_gimple_call (stmt
))
1380 ipa_analyze_call_uses (node
, info
, parms_ainfo
, stmt
);
1383 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1384 If OP is a parameter declaration, mark it as used in the info structure
1388 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED
,
1389 tree op
, void *data
)
1391 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
1393 op
= get_base_address (op
);
1395 && TREE_CODE (op
) == PARM_DECL
)
1397 int index
= ipa_get_param_decl_index (info
, op
);
1398 gcc_assert (index
>= 0);
1399 ipa_set_param_used (info
, index
, true);
1405 /* Scan the function body of NODE and inspect the uses of formal parameters.
1406 Store the findings in various structures of the associated ipa_node_params
1407 structure, such as parameter flags, notes etc. PARMS_AINFO is a pointer to a
1408 vector containing intermediate information about each formal parameter. */
1411 ipa_analyze_params_uses (struct cgraph_node
*node
,
1412 struct param_analysis_info
*parms_ainfo
)
1414 tree decl
= node
->decl
;
1416 struct function
*func
;
1417 gimple_stmt_iterator gsi
;
1418 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
1421 if (ipa_get_param_count (info
) == 0 || info
->uses_analysis_done
)
1424 for (i
= 0; i
< ipa_get_param_count (info
); i
++)
1426 tree parm
= ipa_get_param (info
, i
);
1427 /* For SSA regs see if parameter is used. For non-SSA we compute
1428 the flag during modification analysis. */
1429 if (is_gimple_reg (parm
)
1430 && gimple_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
))
1431 ipa_set_param_used (info
, i
, true);
1434 func
= DECL_STRUCT_FUNCTION (decl
);
1435 FOR_EACH_BB_FN (bb
, func
)
1437 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1439 gimple stmt
= gsi_stmt (gsi
);
1441 if (is_gimple_debug (stmt
))
1444 ipa_analyze_stmt_uses (node
, info
, parms_ainfo
, stmt
);
1445 walk_stmt_load_store_addr_ops (stmt
, info
,
1446 visit_ref_for_mod_analysis
,
1447 visit_ref_for_mod_analysis
,
1448 visit_ref_for_mod_analysis
);
1450 for (gsi
= gsi_start (phi_nodes (bb
)); !gsi_end_p (gsi
); gsi_next (&gsi
))
1451 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), info
,
1452 visit_ref_for_mod_analysis
,
1453 visit_ref_for_mod_analysis
,
1454 visit_ref_for_mod_analysis
);
1457 info
->uses_analysis_done
= 1;
1460 /* Initialize the array describing properties of of formal parameters
1461 of NODE, analyze their uses and compute jump functions associated
1462 with actual arguments of calls from within NODE. */
1465 ipa_analyze_node (struct cgraph_node
*node
)
1467 struct ipa_node_params
*info
;
1468 struct param_analysis_info
*parms_ainfo
;
1471 ipa_check_create_node_params ();
1472 ipa_check_create_edge_args ();
1473 info
= IPA_NODE_REF (node
);
1474 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1475 current_function_decl
= node
->decl
;
1476 ipa_initialize_node_params (node
);
1478 param_count
= ipa_get_param_count (info
);
1479 parms_ainfo
= XALLOCAVEC (struct param_analysis_info
, param_count
);
1480 memset (parms_ainfo
, 0, sizeof (struct param_analysis_info
) * param_count
);
1482 ipa_analyze_params_uses (node
, parms_ainfo
);
1483 ipa_compute_jump_functions (node
, parms_ainfo
);
1485 for (i
= 0; i
< param_count
; i
++)
1486 if (parms_ainfo
[i
].visited_statements
)
1487 BITMAP_FREE (parms_ainfo
[i
].visited_statements
);
1489 current_function_decl
= NULL
;
1494 /* Update the jump function DST when the call graph edge corresponding to SRC is
1495 is being inlined, knowing that DST is of type ancestor and src of known
1499 combine_known_type_and_ancestor_jfs (struct ipa_jump_func
*src
,
1500 struct ipa_jump_func
*dst
)
1502 HOST_WIDE_INT combined_offset
;
1505 combined_offset
= src
->value
.known_type
.offset
+ dst
->value
.ancestor
.offset
;
1506 combined_type
= dst
->value
.ancestor
.type
;
1508 dst
->type
= IPA_JF_KNOWN_TYPE
;
1509 dst
->value
.known_type
.base_type
= src
->value
.known_type
.base_type
;
1510 dst
->value
.known_type
.offset
= combined_offset
;
1511 dst
->value
.known_type
.component_type
= combined_type
;
1514 /* Update the jump functions associated with call graph edge E when the call
1515 graph edge CS is being inlined, assuming that E->caller is already (possibly
1516 indirectly) inlined into CS->callee and that E has not been inlined. */
1519 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
1520 struct cgraph_edge
*e
)
1522 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
1523 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
1524 int count
= ipa_get_cs_argument_count (args
);
1527 for (i
= 0; i
< count
; i
++)
1529 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
1531 if (dst
->type
== IPA_JF_ANCESTOR
)
1533 struct ipa_jump_func
*src
;
1535 /* Variable number of arguments can cause havoc if we try to access
1536 one that does not exist in the inlined edge. So make sure we
1538 if (dst
->value
.ancestor
.formal_id
>= ipa_get_cs_argument_count (top
))
1540 dst
->type
= IPA_JF_UNKNOWN
;
1544 src
= ipa_get_ith_jump_func (top
, dst
->value
.ancestor
.formal_id
);
1545 if (src
->type
== IPA_JF_KNOWN_TYPE
)
1546 combine_known_type_and_ancestor_jfs (src
, dst
);
1547 else if (src
->type
== IPA_JF_PASS_THROUGH
1548 && src
->value
.pass_through
.operation
== NOP_EXPR
)
1549 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
1550 else if (src
->type
== IPA_JF_ANCESTOR
)
1552 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
1553 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
1556 dst
->type
= IPA_JF_UNKNOWN
;
1558 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
1560 struct ipa_jump_func
*src
;
1561 /* We must check range due to calls with variable number of arguments
1562 and we cannot combine jump functions with operations. */
1563 if (dst
->value
.pass_through
.operation
== NOP_EXPR
1564 && (dst
->value
.pass_through
.formal_id
1565 < ipa_get_cs_argument_count (top
)))
1567 src
= ipa_get_ith_jump_func (top
,
1568 dst
->value
.pass_through
.formal_id
);
1572 dst
->type
= IPA_JF_UNKNOWN
;
1577 /* If TARGET is an addr_expr of a function declaration, make it the destination
1578 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1580 struct cgraph_edge
*
1581 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
)
1583 struct cgraph_node
*callee
;
1585 if (TREE_CODE (target
) == ADDR_EXPR
)
1586 target
= TREE_OPERAND (target
, 0);
1587 if (TREE_CODE (target
) != FUNCTION_DECL
)
1589 callee
= cgraph_get_node (target
);
1592 ipa_check_create_node_params ();
1594 /* We can not make edges to inline clones. It is bug that someone removed
1595 the cgraph node too early. */
1596 gcc_assert (!callee
->global
.inlined_to
);
1598 cgraph_make_edge_direct (ie
, callee
);
1601 fprintf (dump_file
, "ipa-prop: Discovered %s call to a known target "
1602 "(%s/%i -> %s/%i), for stmt ",
1603 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
1604 cgraph_node_name (ie
->caller
), ie
->caller
->uid
,
1605 cgraph_node_name (ie
->callee
), ie
->callee
->uid
);
1607 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
1609 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
1611 callee
= cgraph_function_or_thunk_node (callee
, NULL
);
1616 /* Try to find a destination for indirect edge IE that corresponds to a simple
1617 call or a call of a member function pointer and where the destination is a
1618 pointer formal parameter described by jump function JFUNC. If it can be
1619 determined, return the newly direct edge, otherwise return NULL. */
1621 static struct cgraph_edge
*
1622 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
1623 struct ipa_jump_func
*jfunc
)
1627 if (jfunc
->type
== IPA_JF_CONST
)
1628 target
= jfunc
->value
.constant
;
1629 else if (jfunc
->type
== IPA_JF_CONST_MEMBER_PTR
)
1630 target
= jfunc
->value
.member_cst
.pfn
;
1634 return ipa_make_edge_direct_to_target (ie
, target
);
1637 /* Try to find a destination for indirect edge IE that corresponds to a
1638 virtual call based on a formal parameter which is described by jump
1639 function JFUNC and if it can be determined, make it direct and return the
1640 direct edge. Otherwise, return NULL. */
1642 static struct cgraph_edge
*
1643 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
1644 struct ipa_jump_func
*jfunc
)
1648 if (jfunc
->type
!= IPA_JF_KNOWN_TYPE
)
1651 binfo
= TYPE_BINFO (jfunc
->value
.known_type
.base_type
);
1652 gcc_checking_assert (binfo
);
1653 binfo
= get_binfo_at_offset (binfo
, jfunc
->value
.known_type
.offset
1654 + ie
->indirect_info
->anc_offset
,
1655 ie
->indirect_info
->otr_type
);
1657 target
= gimple_get_virt_method_for_binfo (ie
->indirect_info
->otr_token
,
1663 return ipa_make_edge_direct_to_target (ie
, target
);
1668 /* Update the param called notes associated with NODE when CS is being inlined,
1669 assuming NODE is (potentially indirectly) inlined into CS->callee.
1670 Moreover, if the callee is discovered to be constant, create a new cgraph
1671 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1672 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1675 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
1676 struct cgraph_node
*node
,
1677 VEC (cgraph_edge_p
, heap
) **new_edges
)
1679 struct ipa_edge_args
*top
;
1680 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
1683 ipa_check_create_edge_args ();
1684 top
= IPA_EDGE_REF (cs
);
1686 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
1688 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
1689 struct ipa_jump_func
*jfunc
;
1691 next_ie
= ie
->next_callee
;
1693 if (ici
->param_index
== -1)
1696 /* We must check range due to calls with variable number of arguments: */
1697 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
1699 ici
->param_index
= -1;
1703 jfunc
= ipa_get_ith_jump_func (top
, ici
->param_index
);
1704 if (jfunc
->type
== IPA_JF_PASS_THROUGH
1705 && jfunc
->value
.pass_through
.operation
== NOP_EXPR
)
1706 ici
->param_index
= jfunc
->value
.pass_through
.formal_id
;
1707 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
1709 ici
->param_index
= jfunc
->value
.ancestor
.formal_id
;
1710 ici
->anc_offset
+= jfunc
->value
.ancestor
.offset
;
1713 /* Either we can find a destination for this edge now or never. */
1714 ici
->param_index
= -1;
1716 if (!flag_indirect_inlining
)
1719 if (ici
->polymorphic
)
1720 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
);
1722 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
);
1724 if (new_direct_edge
)
1726 new_direct_edge
->indirect_inlining_edge
= 1;
1729 VEC_safe_push (cgraph_edge_p
, heap
, *new_edges
,
1731 top
= IPA_EDGE_REF (cs
);
1740 /* Recursively traverse subtree of NODE (including node) made of inlined
1741 cgraph_edges when CS has been inlined and invoke
1742 update_indirect_edges_after_inlining on all nodes and
1743 update_jump_functions_after_inlining on all non-inlined edges that lead out
1744 of this subtree. Newly discovered indirect edges will be added to
1745 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1749 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
1750 struct cgraph_node
*node
,
1751 VEC (cgraph_edge_p
, heap
) **new_edges
)
1753 struct cgraph_edge
*e
;
1756 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
1758 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1759 if (!e
->inline_failed
)
1760 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
1762 update_jump_functions_after_inlining (cs
, e
);
1763 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
1764 update_jump_functions_after_inlining (cs
, e
);
1769 /* Update jump functions and call note functions on inlining the call site CS.
1770 CS is expected to lead to a node already cloned by
1771 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1772 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1776 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
1777 VEC (cgraph_edge_p
, heap
) **new_edges
)
1780 /* Do nothing if the preparation phase has not been carried out yet
1781 (i.e. during early inlining). */
1782 if (!ipa_node_params_vector
)
1784 gcc_assert (ipa_edge_args_vector
);
1786 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
1788 /* We do not keep jump functions of inlined edges up to date. Better to free
1789 them so we do not access them accidentally. */
1790 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
1794 /* Frees all dynamically allocated structures that the argument info points
1798 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
1800 if (args
->jump_functions
)
1801 ggc_free (args
->jump_functions
);
1803 memset (args
, 0, sizeof (*args
));
1806 /* Free all ipa_edge structures. */
1809 ipa_free_all_edge_args (void)
1812 struct ipa_edge_args
*args
;
1814 FOR_EACH_VEC_ELT (ipa_edge_args_t
, ipa_edge_args_vector
, i
, args
)
1815 ipa_free_edge_args_substructures (args
);
1817 VEC_free (ipa_edge_args_t
, gc
, ipa_edge_args_vector
);
1818 ipa_edge_args_vector
= NULL
;
1821 /* Frees all dynamically allocated structures that the param info points
1825 ipa_free_node_params_substructures (struct ipa_node_params
*info
)
1827 VEC_free (ipa_param_descriptor_t
, heap
, info
->descriptors
);
1828 free (info
->lattices
);
1829 /* Lattice values and their sources are deallocated with their alocation
1831 VEC_free (tree
, heap
, info
->known_vals
);
1832 memset (info
, 0, sizeof (*info
));
1835 /* Free all ipa_node_params structures. */
1838 ipa_free_all_node_params (void)
1841 struct ipa_node_params
*info
;
1843 FOR_EACH_VEC_ELT (ipa_node_params_t
, ipa_node_params_vector
, i
, info
)
1844 ipa_free_node_params_substructures (info
);
1846 VEC_free (ipa_node_params_t
, heap
, ipa_node_params_vector
);
1847 ipa_node_params_vector
= NULL
;
1850 /* Hook that is called by cgraph.c when an edge is removed. */
1853 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
1855 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1856 if (VEC_length (ipa_edge_args_t
, ipa_edge_args_vector
)
1857 <= (unsigned)cs
->uid
)
1859 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
1862 /* Hook that is called by cgraph.c when a node is removed. */
1865 ipa_node_removal_hook (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
1867 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1868 if (VEC_length (ipa_node_params_t
, ipa_node_params_vector
)
1869 <= (unsigned)node
->uid
)
1871 ipa_free_node_params_substructures (IPA_NODE_REF (node
));
1874 /* Hook that is called by cgraph.c when a node is duplicated. */
1877 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
1878 __attribute__((unused
)) void *data
)
1880 struct ipa_edge_args
*old_args
, *new_args
;
1882 ipa_check_create_edge_args ();
1884 old_args
= IPA_EDGE_REF (src
);
1885 new_args
= IPA_EDGE_REF (dst
);
1887 new_args
->jump_functions
= VEC_copy (ipa_jump_func_t
, gc
,
1888 old_args
->jump_functions
);
1891 /* Hook that is called by cgraph.c when a node is duplicated. */
1894 ipa_node_duplication_hook (struct cgraph_node
*src
, struct cgraph_node
*dst
,
1895 ATTRIBUTE_UNUSED
void *data
)
1897 struct ipa_node_params
*old_info
, *new_info
;
1899 ipa_check_create_node_params ();
1900 old_info
= IPA_NODE_REF (src
);
1901 new_info
= IPA_NODE_REF (dst
);
1903 new_info
->descriptors
= VEC_copy (ipa_param_descriptor_t
, heap
,
1904 old_info
->descriptors
);
1905 new_info
->lattices
= NULL
;
1906 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
1908 new_info
->uses_analysis_done
= old_info
->uses_analysis_done
;
1909 new_info
->node_enqueued
= old_info
->node_enqueued
;
1913 /* Analyze newly added function into callgraph. */
1916 ipa_add_new_function (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
1918 ipa_analyze_node (node
);
1921 /* Register our cgraph hooks if they are not already there. */
1924 ipa_register_cgraph_hooks (void)
1926 if (!edge_removal_hook_holder
)
1927 edge_removal_hook_holder
=
1928 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
1929 if (!node_removal_hook_holder
)
1930 node_removal_hook_holder
=
1931 cgraph_add_node_removal_hook (&ipa_node_removal_hook
, NULL
);
1932 if (!edge_duplication_hook_holder
)
1933 edge_duplication_hook_holder
=
1934 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
1935 if (!node_duplication_hook_holder
)
1936 node_duplication_hook_holder
=
1937 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook
, NULL
);
1938 function_insertion_hook_holder
=
1939 cgraph_add_function_insertion_hook (&ipa_add_new_function
, NULL
);
1942 /* Unregister our cgraph hooks if they are not already there. */
1945 ipa_unregister_cgraph_hooks (void)
1947 cgraph_remove_edge_removal_hook (edge_removal_hook_holder
);
1948 edge_removal_hook_holder
= NULL
;
1949 cgraph_remove_node_removal_hook (node_removal_hook_holder
);
1950 node_removal_hook_holder
= NULL
;
1951 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder
);
1952 edge_duplication_hook_holder
= NULL
;
1953 cgraph_remove_node_duplication_hook (node_duplication_hook_holder
);
1954 node_duplication_hook_holder
= NULL
;
1955 cgraph_remove_function_insertion_hook (function_insertion_hook_holder
);
1956 function_insertion_hook_holder
= NULL
;
1959 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1960 longer needed after ipa-cp. */
1963 ipa_free_all_structures_after_ipa_cp (void)
1967 ipa_free_all_edge_args ();
1968 ipa_free_all_node_params ();
1969 free_alloc_pool (ipcp_sources_pool
);
1970 free_alloc_pool (ipcp_values_pool
);
1971 ipa_unregister_cgraph_hooks ();
1975 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1976 longer needed after indirect inlining. */
1979 ipa_free_all_structures_after_iinln (void)
1981 ipa_free_all_edge_args ();
1982 ipa_free_all_node_params ();
1983 ipa_unregister_cgraph_hooks ();
1984 if (ipcp_sources_pool
)
1985 free_alloc_pool (ipcp_sources_pool
);
1986 if (ipcp_values_pool
)
1987 free_alloc_pool (ipcp_values_pool
);
1990 /* Print ipa_tree_map data structures of all functions in the
1994 ipa_print_node_params (FILE * f
, struct cgraph_node
*node
)
1998 struct ipa_node_params
*info
;
2000 if (!node
->analyzed
)
2002 info
= IPA_NODE_REF (node
);
2003 fprintf (f
, " function %s parameter descriptors:\n",
2004 cgraph_node_name (node
));
2005 count
= ipa_get_param_count (info
);
2006 for (i
= 0; i
< count
; i
++)
2008 temp
= ipa_get_param (info
, i
);
2009 if (TREE_CODE (temp
) == PARM_DECL
)
2010 fprintf (f
, " param %d : %s", i
,
2012 ? (*lang_hooks
.decl_printable_name
) (temp
, 2)
2014 if (ipa_is_param_used (info
, i
))
2015 fprintf (f
, " used");
2020 /* Print ipa_tree_map data structures of all functions in the
2024 ipa_print_all_params (FILE * f
)
2026 struct cgraph_node
*node
;
2028 fprintf (f
, "\nFunction parameters:\n");
2029 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2030 ipa_print_node_params (f
, node
);
2033 /* Return a heap allocated vector containing formal parameters of FNDECL. */
2036 ipa_get_vector_of_formal_parms (tree fndecl
)
2038 VEC(tree
, heap
) *args
;
2042 count
= count_formal_params (fndecl
);
2043 args
= VEC_alloc (tree
, heap
, count
);
2044 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
2045 VEC_quick_push (tree
, args
, parm
);
2050 /* Return a heap allocated vector containing types of formal parameters of
2051 function type FNTYPE. */
2053 static inline VEC(tree
, heap
) *
2054 get_vector_of_formal_parm_types (tree fntype
)
2056 VEC(tree
, heap
) *types
;
2060 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
2063 types
= VEC_alloc (tree
, heap
, count
);
2064 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
2065 VEC_quick_push (tree
, types
, TREE_VALUE (t
));
2070 /* Modify the function declaration FNDECL and its type according to the plan in
2071 ADJUSTMENTS. It also sets base fields of individual adjustments structures
2072 to reflect the actual parameters being modified which are determined by the
2073 base_index field. */
2076 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
,
2077 const char *synth_parm_prefix
)
2079 VEC(tree
, heap
) *oparms
, *otypes
;
2080 tree orig_type
, new_type
= NULL
;
2081 tree old_arg_types
, t
, new_arg_types
= NULL
;
2082 tree parm
, *link
= &DECL_ARGUMENTS (fndecl
);
2083 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2084 tree new_reversed
= NULL
;
2085 bool care_for_types
, last_parm_void
;
2087 if (!synth_parm_prefix
)
2088 synth_parm_prefix
= "SYNTH";
2090 oparms
= ipa_get_vector_of_formal_parms (fndecl
);
2091 orig_type
= TREE_TYPE (fndecl
);
2092 old_arg_types
= TYPE_ARG_TYPES (orig_type
);
2094 /* The following test is an ugly hack, some functions simply don't have any
2095 arguments in their type. This is probably a bug but well... */
2096 care_for_types
= (old_arg_types
!= NULL_TREE
);
2099 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
2101 otypes
= get_vector_of_formal_parm_types (orig_type
);
2103 gcc_assert (VEC_length (tree
, oparms
) + 1 == VEC_length (tree
, otypes
));
2105 gcc_assert (VEC_length (tree
, oparms
) == VEC_length (tree
, otypes
));
2109 last_parm_void
= false;
2113 for (i
= 0; i
< len
; i
++)
2115 struct ipa_parm_adjustment
*adj
;
2118 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2119 parm
= VEC_index (tree
, oparms
, adj
->base_index
);
2122 if (adj
->copy_param
)
2125 new_arg_types
= tree_cons (NULL_TREE
, VEC_index (tree
, otypes
,
2129 link
= &DECL_CHAIN (parm
);
2131 else if (!adj
->remove_param
)
2137 ptype
= build_pointer_type (adj
->type
);
2142 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
2144 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
2146 DECL_NAME (new_parm
) = create_tmp_var_name (synth_parm_prefix
);
2148 DECL_ARTIFICIAL (new_parm
) = 1;
2149 DECL_ARG_TYPE (new_parm
) = ptype
;
2150 DECL_CONTEXT (new_parm
) = fndecl
;
2151 TREE_USED (new_parm
) = 1;
2152 DECL_IGNORED_P (new_parm
) = 1;
2153 layout_decl (new_parm
, 0);
2155 add_referenced_var (new_parm
);
2156 mark_sym_for_renaming (new_parm
);
2158 adj
->reduction
= new_parm
;
2162 link
= &DECL_CHAIN (new_parm
);
2170 new_reversed
= nreverse (new_arg_types
);
2174 TREE_CHAIN (new_arg_types
) = void_list_node
;
2176 new_reversed
= void_list_node
;
2180 /* Use copy_node to preserve as much as possible from original type
2181 (debug info, attribute lists etc.)
2182 Exception is METHOD_TYPEs must have THIS argument.
2183 When we are asked to remove it, we need to build new FUNCTION_TYPE
2185 if (TREE_CODE (orig_type
) != METHOD_TYPE
2186 || (VEC_index (ipa_parm_adjustment_t
, adjustments
, 0)->copy_param
2187 && VEC_index (ipa_parm_adjustment_t
, adjustments
, 0)->base_index
== 0))
2189 new_type
= build_distinct_type_copy (orig_type
);
2190 TYPE_ARG_TYPES (new_type
) = new_reversed
;
2195 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
2197 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
2198 DECL_VINDEX (fndecl
) = NULL_TREE
;
2201 /* When signature changes, we need to clear builtin info. */
2202 if (DECL_BUILT_IN (fndecl
))
2204 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
2205 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
2208 /* This is a new type, not a copy of an old type. Need to reassociate
2209 variants. We can handle everything except the main variant lazily. */
2210 t
= TYPE_MAIN_VARIANT (orig_type
);
2213 TYPE_MAIN_VARIANT (new_type
) = t
;
2214 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
2215 TYPE_NEXT_VARIANT (t
) = new_type
;
2219 TYPE_MAIN_VARIANT (new_type
) = new_type
;
2220 TYPE_NEXT_VARIANT (new_type
) = NULL
;
2223 TREE_TYPE (fndecl
) = new_type
;
2224 DECL_VIRTUAL_P (fndecl
) = 0;
2226 VEC_free (tree
, heap
, otypes
);
2227 VEC_free (tree
, heap
, oparms
);
2230 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2231 If this is a directly recursive call, CS must be NULL. Otherwise it must
2232 contain the corresponding call graph edge. */
2235 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gimple stmt
,
2236 ipa_parm_adjustment_vec adjustments
)
2238 VEC(tree
, heap
) *vargs
;
2239 VEC(tree
, gc
) **debug_args
= NULL
;
2241 gimple_stmt_iterator gsi
;
2245 len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2246 vargs
= VEC_alloc (tree
, heap
, len
);
2247 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
2249 gsi
= gsi_for_stmt (stmt
);
2250 for (i
= 0; i
< len
; i
++)
2252 struct ipa_parm_adjustment
*adj
;
2254 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2256 if (adj
->copy_param
)
2258 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
2260 VEC_quick_push (tree
, vargs
, arg
);
2262 else if (!adj
->remove_param
)
2264 tree expr
, base
, off
;
2267 /* We create a new parameter out of the value of the old one, we can
2268 do the following kind of transformations:
2270 - A scalar passed by reference is converted to a scalar passed by
2271 value. (adj->by_ref is false and the type of the original
2272 actual argument is a pointer to a scalar).
2274 - A part of an aggregate is passed instead of the whole aggregate.
2275 The part can be passed either by value or by reference, this is
2276 determined by value of adj->by_ref. Moreover, the code below
2277 handles both situations when the original aggregate is passed by
2278 value (its type is not a pointer) and when it is passed by
2279 reference (it is a pointer to an aggregate).
2281 When the new argument is passed by reference (adj->by_ref is true)
2282 it must be a part of an aggregate and therefore we form it by
2283 simply taking the address of a reference inside the original
2286 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
2287 base
= gimple_call_arg (stmt
, adj
->base_index
);
2288 loc
= EXPR_LOCATION (base
);
2290 if (TREE_CODE (base
) != ADDR_EXPR
2291 && POINTER_TYPE_P (TREE_TYPE (base
)))
2292 off
= build_int_cst (adj
->alias_ptr_type
,
2293 adj
->offset
/ BITS_PER_UNIT
);
2296 HOST_WIDE_INT base_offset
;
2299 if (TREE_CODE (base
) == ADDR_EXPR
)
2300 base
= TREE_OPERAND (base
, 0);
2302 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
2303 /* Aggregate arguments can have non-invariant addresses. */
2306 base
= build_fold_addr_expr (prev_base
);
2307 off
= build_int_cst (adj
->alias_ptr_type
,
2308 adj
->offset
/ BITS_PER_UNIT
);
2310 else if (TREE_CODE (base
) == MEM_REF
)
2312 off
= build_int_cst (adj
->alias_ptr_type
,
2314 + adj
->offset
/ BITS_PER_UNIT
);
2315 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
2317 base
= TREE_OPERAND (base
, 0);
2321 off
= build_int_cst (adj
->alias_ptr_type
,
2323 + adj
->offset
/ BITS_PER_UNIT
);
2324 base
= build_fold_addr_expr (base
);
2328 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
2330 expr
= build_fold_addr_expr (expr
);
2332 expr
= force_gimple_operand_gsi (&gsi
, expr
,
2334 || is_gimple_reg_type (adj
->type
),
2335 NULL
, true, GSI_SAME_STMT
);
2336 VEC_quick_push (tree
, vargs
, expr
);
2338 if (!adj
->copy_param
&& MAY_HAVE_DEBUG_STMTS
)
2341 tree ddecl
= NULL_TREE
, origin
= DECL_ORIGIN (adj
->base
), arg
;
2344 arg
= gimple_call_arg (stmt
, adj
->base_index
);
2345 if (!useless_type_conversion_p (TREE_TYPE (origin
), TREE_TYPE (arg
)))
2347 if (!fold_convertible_p (TREE_TYPE (origin
), arg
))
2349 arg
= fold_convert_loc (gimple_location (stmt
),
2350 TREE_TYPE (origin
), arg
);
2352 if (debug_args
== NULL
)
2353 debug_args
= decl_debug_args_insert (callee_decl
);
2354 for (ix
= 0; VEC_iterate (tree
, *debug_args
, ix
, ddecl
); ix
+= 2)
2355 if (ddecl
== origin
)
2357 ddecl
= VEC_index (tree
, *debug_args
, ix
+ 1);
2362 ddecl
= make_node (DEBUG_EXPR_DECL
);
2363 DECL_ARTIFICIAL (ddecl
) = 1;
2364 TREE_TYPE (ddecl
) = TREE_TYPE (origin
);
2365 DECL_MODE (ddecl
) = DECL_MODE (origin
);
2367 VEC_safe_push (tree
, gc
, *debug_args
, origin
);
2368 VEC_safe_push (tree
, gc
, *debug_args
, ddecl
);
2370 def_temp
= gimple_build_debug_bind (ddecl
, unshare_expr (arg
),
2372 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
2376 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2378 fprintf (dump_file
, "replacing stmt:");
2379 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
2382 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
2383 VEC_free (tree
, heap
, vargs
);
2384 if (gimple_call_lhs (stmt
))
2385 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2387 gimple_set_block (new_stmt
, gimple_block (stmt
));
2388 if (gimple_has_location (stmt
))
2389 gimple_set_location (new_stmt
, gimple_location (stmt
));
2390 gimple_call_copy_flags (new_stmt
, stmt
);
2391 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2393 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2395 fprintf (dump_file
, "with stmt:");
2396 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
2397 fprintf (dump_file
, "\n");
2399 gsi_replace (&gsi
, new_stmt
, true);
2401 cgraph_set_call_stmt (cs
, new_stmt
);
2402 update_ssa (TODO_update_ssa
);
2403 free_dominance_info (CDI_DOMINATORS
);
2406 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2409 index_in_adjustments_multiple_times_p (int base_index
,
2410 ipa_parm_adjustment_vec adjustments
)
2412 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2415 for (i
= 0; i
< len
; i
++)
2417 struct ipa_parm_adjustment
*adj
;
2418 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2420 if (adj
->base_index
== base_index
)
2432 /* Return adjustments that should have the same effect on function parameters
2433 and call arguments as if they were first changed according to adjustments in
2434 INNER and then by adjustments in OUTER. */
2436 ipa_parm_adjustment_vec
2437 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
2438 ipa_parm_adjustment_vec outer
)
2440 int i
, outlen
= VEC_length (ipa_parm_adjustment_t
, outer
);
2441 int inlen
= VEC_length (ipa_parm_adjustment_t
, inner
);
2443 ipa_parm_adjustment_vec adjustments
, tmp
;
2445 tmp
= VEC_alloc (ipa_parm_adjustment_t
, heap
, inlen
);
2446 for (i
= 0; i
< inlen
; i
++)
2448 struct ipa_parm_adjustment
*n
;
2449 n
= VEC_index (ipa_parm_adjustment_t
, inner
, i
);
2451 if (n
->remove_param
)
2454 VEC_quick_push (ipa_parm_adjustment_t
, tmp
, n
);
2457 adjustments
= VEC_alloc (ipa_parm_adjustment_t
, heap
, outlen
+ removals
);
2458 for (i
= 0; i
< outlen
; i
++)
2460 struct ipa_parm_adjustment
*r
;
2461 struct ipa_parm_adjustment
*out
= VEC_index (ipa_parm_adjustment_t
,
2463 struct ipa_parm_adjustment
*in
= VEC_index (ipa_parm_adjustment_t
, tmp
,
2466 gcc_assert (!in
->remove_param
);
2467 if (out
->remove_param
)
2469 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
2471 r
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
2472 memset (r
, 0, sizeof (*r
));
2473 r
->remove_param
= true;
2478 r
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
2479 memset (r
, 0, sizeof (*r
));
2480 r
->base_index
= in
->base_index
;
2481 r
->type
= out
->type
;
2483 /* FIXME: Create nonlocal value too. */
2485 if (in
->copy_param
&& out
->copy_param
)
2486 r
->copy_param
= true;
2487 else if (in
->copy_param
)
2488 r
->offset
= out
->offset
;
2489 else if (out
->copy_param
)
2490 r
->offset
= in
->offset
;
2492 r
->offset
= in
->offset
+ out
->offset
;
2495 for (i
= 0; i
< inlen
; i
++)
2497 struct ipa_parm_adjustment
*n
= VEC_index (ipa_parm_adjustment_t
,
2500 if (n
->remove_param
)
2501 VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, n
);
2504 VEC_free (ipa_parm_adjustment_t
, heap
, tmp
);
2508 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2509 friendly way, assuming they are meant to be applied to FNDECL. */
2512 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
2515 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2517 VEC(tree
, heap
) *parms
= ipa_get_vector_of_formal_parms (fndecl
);
2519 fprintf (file
, "IPA param adjustments: ");
2520 for (i
= 0; i
< len
; i
++)
2522 struct ipa_parm_adjustment
*adj
;
2523 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2526 fprintf (file
, " ");
2530 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
2531 print_generic_expr (file
, VEC_index (tree
, parms
, adj
->base_index
), 0);
2534 fprintf (file
, ", base: ");
2535 print_generic_expr (file
, adj
->base
, 0);
2539 fprintf (file
, ", reduction: ");
2540 print_generic_expr (file
, adj
->reduction
, 0);
2542 if (adj
->new_ssa_base
)
2544 fprintf (file
, ", new_ssa_base: ");
2545 print_generic_expr (file
, adj
->new_ssa_base
, 0);
2548 if (adj
->copy_param
)
2549 fprintf (file
, ", copy_param");
2550 else if (adj
->remove_param
)
2551 fprintf (file
, ", remove_param");
2553 fprintf (file
, ", offset %li", (long) adj
->offset
);
2555 fprintf (file
, ", by_ref");
2556 print_node_brief (file
, ", type: ", adj
->type
, 0);
2557 fprintf (file
, "\n");
2559 VEC_free (tree
, heap
, parms
);
2562 /* Stream out jump function JUMP_FUNC to OB. */
2565 ipa_write_jump_function (struct output_block
*ob
,
2566 struct ipa_jump_func
*jump_func
)
2568 streamer_write_uhwi (ob
, jump_func
->type
);
2570 switch (jump_func
->type
)
2572 case IPA_JF_UNKNOWN
:
2574 case IPA_JF_KNOWN_TYPE
:
2575 streamer_write_uhwi (ob
, jump_func
->value
.known_type
.offset
);
2576 stream_write_tree (ob
, jump_func
->value
.known_type
.base_type
, true);
2577 stream_write_tree (ob
, jump_func
->value
.known_type
.component_type
, true);
2580 stream_write_tree (ob
, jump_func
->value
.constant
, true);
2582 case IPA_JF_PASS_THROUGH
:
2583 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
2584 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
2585 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
2587 case IPA_JF_ANCESTOR
:
2588 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
2589 stream_write_tree (ob
, jump_func
->value
.ancestor
.type
, true);
2590 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
2592 case IPA_JF_CONST_MEMBER_PTR
:
2593 stream_write_tree (ob
, jump_func
->value
.member_cst
.pfn
, true);
2594 stream_write_tree (ob
, jump_func
->value
.member_cst
.delta
, false);
2599 /* Read in jump function JUMP_FUNC from IB. */
2602 ipa_read_jump_function (struct lto_input_block
*ib
,
2603 struct ipa_jump_func
*jump_func
,
2604 struct data_in
*data_in
)
2606 jump_func
->type
= (enum jump_func_type
) streamer_read_uhwi (ib
);
2608 switch (jump_func
->type
)
2610 case IPA_JF_UNKNOWN
:
2612 case IPA_JF_KNOWN_TYPE
:
2613 jump_func
->value
.known_type
.offset
= streamer_read_uhwi (ib
);
2614 jump_func
->value
.known_type
.base_type
= stream_read_tree (ib
, data_in
);
2615 jump_func
->value
.known_type
.component_type
= stream_read_tree (ib
,
2619 jump_func
->value
.constant
= stream_read_tree (ib
, data_in
);
2621 case IPA_JF_PASS_THROUGH
:
2622 jump_func
->value
.pass_through
.operand
= stream_read_tree (ib
, data_in
);
2623 jump_func
->value
.pass_through
.formal_id
= streamer_read_uhwi (ib
);
2624 jump_func
->value
.pass_through
.operation
2625 = (enum tree_code
) streamer_read_uhwi (ib
);
2627 case IPA_JF_ANCESTOR
:
2628 jump_func
->value
.ancestor
.offset
= streamer_read_uhwi (ib
);
2629 jump_func
->value
.ancestor
.type
= stream_read_tree (ib
, data_in
);
2630 jump_func
->value
.ancestor
.formal_id
= streamer_read_uhwi (ib
);
2632 case IPA_JF_CONST_MEMBER_PTR
:
2633 jump_func
->value
.member_cst
.pfn
= stream_read_tree (ib
, data_in
);
2634 jump_func
->value
.member_cst
.delta
= stream_read_tree (ib
, data_in
);
2639 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2640 relevant to indirect inlining to OB. */
2643 ipa_write_indirect_edge_info (struct output_block
*ob
,
2644 struct cgraph_edge
*cs
)
2646 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2647 struct bitpack_d bp
;
2649 streamer_write_hwi (ob
, ii
->param_index
);
2650 streamer_write_hwi (ob
, ii
->anc_offset
);
2651 bp
= bitpack_create (ob
->main_stream
);
2652 bp_pack_value (&bp
, ii
->polymorphic
, 1);
2653 streamer_write_bitpack (&bp
);
2655 if (ii
->polymorphic
)
2657 streamer_write_hwi (ob
, ii
->otr_token
);
2658 stream_write_tree (ob
, ii
->otr_type
, true);
2662 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2663 relevant to indirect inlining from IB. */
2666 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
2667 struct data_in
*data_in ATTRIBUTE_UNUSED
,
2668 struct cgraph_edge
*cs
)
2670 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2671 struct bitpack_d bp
;
2673 ii
->param_index
= (int) streamer_read_hwi (ib
);
2674 ii
->anc_offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
2675 bp
= streamer_read_bitpack (ib
);
2676 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
2677 if (ii
->polymorphic
)
2679 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
2680 ii
->otr_type
= stream_read_tree (ib
, data_in
);
2684 /* Stream out NODE info to OB. */
2687 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
2690 lto_cgraph_encoder_t encoder
;
2691 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2693 struct cgraph_edge
*e
;
2694 struct bitpack_d bp
;
2696 encoder
= ob
->decl_state
->cgraph_node_encoder
;
2697 node_ref
= lto_cgraph_encoder_encode (encoder
, node
);
2698 streamer_write_uhwi (ob
, node_ref
);
2700 bp
= bitpack_create (ob
->main_stream
);
2701 gcc_assert (info
->uses_analysis_done
2702 || ipa_get_param_count (info
) == 0);
2703 gcc_assert (!info
->node_enqueued
);
2704 gcc_assert (!info
->ipcp_orig_node
);
2705 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
2706 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
2707 streamer_write_bitpack (&bp
);
2708 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2710 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2712 streamer_write_uhwi (ob
, ipa_get_cs_argument_count (args
));
2713 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
2714 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
2716 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2718 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2720 streamer_write_uhwi (ob
, ipa_get_cs_argument_count (args
));
2721 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
2722 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
2723 ipa_write_indirect_edge_info (ob
, e
);
2727 /* Stream in NODE info from IB. */
2730 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
2731 struct data_in
*data_in
)
2733 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2735 struct cgraph_edge
*e
;
2736 struct bitpack_d bp
;
2738 ipa_initialize_node_params (node
);
2740 bp
= streamer_read_bitpack (ib
);
2741 if (ipa_get_param_count (info
) != 0)
2742 info
->uses_analysis_done
= true;
2743 info
->node_enqueued
= false;
2744 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
2745 ipa_set_param_used (info
, k
, bp_unpack_value (&bp
, 1));
2746 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2748 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2749 int count
= streamer_read_uhwi (ib
);
2753 VEC_safe_grow_cleared (ipa_jump_func_t
, gc
, args
->jump_functions
, count
);
2755 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
2756 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), data_in
);
2758 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2760 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2761 int count
= streamer_read_uhwi (ib
);
2765 VEC_safe_grow_cleared (ipa_jump_func_t
, gc
, args
->jump_functions
,
2767 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
2768 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
),
2771 ipa_read_indirect_edge_info (ib
, data_in
, e
);
2775 /* Write jump functions for nodes in SET. */
2778 ipa_prop_write_jump_functions (cgraph_node_set set
)
2780 struct cgraph_node
*node
;
2781 struct output_block
*ob
;
2782 unsigned int count
= 0;
2783 cgraph_node_set_iterator csi
;
2785 if (!ipa_node_params_vector
)
2788 ob
= create_output_block (LTO_section_jump_functions
);
2789 ob
->cgraph_node
= NULL
;
2790 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2792 node
= csi_node (csi
);
2793 if (cgraph_function_with_gimple_body_p (node
)
2794 && IPA_NODE_REF (node
) != NULL
)
2798 streamer_write_uhwi (ob
, count
);
2800 /* Process all of the functions. */
2801 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2803 node
= csi_node (csi
);
2804 if (cgraph_function_with_gimple_body_p (node
)
2805 && IPA_NODE_REF (node
) != NULL
)
2806 ipa_write_node_info (ob
, node
);
2808 streamer_write_char_stream (ob
->main_stream
, 0);
2809 produce_asm (ob
, NULL
);
2810 destroy_output_block (ob
);
2813 /* Read section in file FILE_DATA of length LEN with data DATA. */
2816 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
2819 const struct lto_function_header
*header
=
2820 (const struct lto_function_header
*) data
;
2821 const int32_t cfg_offset
= sizeof (struct lto_function_header
);
2822 const int32_t main_offset
= cfg_offset
+ header
->cfg_size
;
2823 const int32_t string_offset
= main_offset
+ header
->main_size
;
2824 struct data_in
*data_in
;
2825 struct lto_input_block ib_main
;
2829 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
2833 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
2834 header
->string_size
, NULL
);
2835 count
= streamer_read_uhwi (&ib_main
);
2837 for (i
= 0; i
< count
; i
++)
2840 struct cgraph_node
*node
;
2841 lto_cgraph_encoder_t encoder
;
2843 index
= streamer_read_uhwi (&ib_main
);
2844 encoder
= file_data
->cgraph_node_encoder
;
2845 node
= lto_cgraph_encoder_deref (encoder
, index
);
2846 gcc_assert (node
->analyzed
);
2847 ipa_read_node_info (&ib_main
, node
, data_in
);
2849 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
2851 lto_data_in_delete (data_in
);
2854 /* Read ipcp jump functions. */
2857 ipa_prop_read_jump_functions (void)
2859 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
2860 struct lto_file_decl_data
*file_data
;
2863 ipa_check_create_node_params ();
2864 ipa_check_create_edge_args ();
2865 ipa_register_cgraph_hooks ();
2867 while ((file_data
= file_data_vec
[j
++]))
2870 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
2873 ipa_prop_read_section (file_data
, data
, len
);
2877 /* After merging units, we can get mismatch in argument counts.
2878 Also decl merging might've rendered parameter lists obsolete.
2879 Also compute called_with_variable_arg info. */
2882 ipa_update_after_lto_read (void)
2884 struct cgraph_node
*node
;
2886 ipa_check_create_node_params ();
2887 ipa_check_create_edge_args ();
2889 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2891 ipa_initialize_node_params (node
);