1 /* Interprocedural analyses.
2 Copyright (C) 2005-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "basic-block.h"
25 #include "tree-ssa-alias.h"
26 #include "internal-fn.h"
27 #include "gimple-fold.h"
29 #include "gimple-expr.h"
33 #include "stor-layout.h"
34 #include "print-tree.h"
36 #include "gimple-iterator.h"
37 #include "gimplify-me.h"
38 #include "gimple-walk.h"
39 #include "langhooks.h"
43 #include "gimple-ssa.h"
45 #include "tree-phinodes.h"
46 #include "ssa-iterators.h"
47 #include "tree-into-ssa.h"
49 #include "tree-pass.h"
50 #include "tree-inline.h"
51 #include "ipa-inline.h"
53 #include "diagnostic.h"
54 #include "gimple-pretty-print.h"
55 #include "lto-streamer.h"
56 #include "data-streamer.h"
57 #include "tree-streamer.h"
59 #include "ipa-utils.h"
60 #include "stringpool.h"
61 #include "tree-ssanames.h"
63 /* Intermediate information about a parameter that is only useful during the
64 run of ipa_analyze_node and is not kept afterwards. */
66 struct param_analysis_info
68 bool parm_modified
, ref_modified
, pt_modified
;
69 bitmap parm_visited_statements
, pt_visited_statements
;
72 /* Vector where the parameter infos are actually stored. */
73 vec
<ipa_node_params
> ipa_node_params_vector
;
74 /* Vector of known aggregate values in cloned nodes. */
75 vec
<ipa_agg_replacement_value_p
, va_gc
> *ipa_node_agg_replacements
;
76 /* Vector where the parameter infos are actually stored. */
77 vec
<ipa_edge_args
, va_gc
> *ipa_edge_args_vector
;
79 /* Holders of ipa cgraph hooks: */
80 static struct cgraph_edge_hook_list
*edge_removal_hook_holder
;
81 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
82 static struct cgraph_2edge_hook_list
*edge_duplication_hook_holder
;
83 static struct cgraph_2node_hook_list
*node_duplication_hook_holder
;
84 static struct cgraph_node_hook_list
*function_insertion_hook_holder
;
86 /* Description of a reference to an IPA constant. */
87 struct ipa_cst_ref_desc
89 /* Edge that corresponds to the statement which took the reference. */
90 struct cgraph_edge
*cs
;
91 /* Linked list of duplicates created when call graph edges are cloned. */
92 struct ipa_cst_ref_desc
*next_duplicate
;
93 /* Number of references in IPA structures, IPA_UNDESCRIBED_USE if the value
98 /* Allocation pool for reference descriptions. */
100 static alloc_pool ipa_refdesc_pool
;
102 /* Return true if DECL_FUNCTION_SPECIFIC_OPTIMIZATION of the decl associated
103 with NODE should prevent us from analyzing it for the purposes of IPA-CP. */
106 ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node
*node
)
108 tree fs_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node
->decl
);
109 struct cl_optimization
*os
;
113 os
= TREE_OPTIMIZATION (fs_opts
);
114 return !os
->x_optimize
|| !os
->x_flag_ipa_cp
;
117 /* Return index of the formal whose tree is PTREE in function which corresponds
121 ipa_get_param_decl_index_1 (vec
<ipa_param_descriptor
> descriptors
, tree ptree
)
125 count
= descriptors
.length ();
126 for (i
= 0; i
< count
; i
++)
127 if (descriptors
[i
].decl
== ptree
)
133 /* Return index of the formal whose tree is PTREE in function which corresponds
137 ipa_get_param_decl_index (struct ipa_node_params
*info
, tree ptree
)
139 return ipa_get_param_decl_index_1 (info
->descriptors
, ptree
);
142 /* Populate the param_decl field in parameter DESCRIPTORS that correspond to
146 ipa_populate_param_decls (struct cgraph_node
*node
,
147 vec
<ipa_param_descriptor
> &descriptors
)
155 gcc_assert (gimple_has_body_p (fndecl
));
156 fnargs
= DECL_ARGUMENTS (fndecl
);
158 for (parm
= fnargs
; parm
; parm
= DECL_CHAIN (parm
))
160 descriptors
[param_num
].decl
= parm
;
161 descriptors
[param_num
].move_cost
= estimate_move_cost (TREE_TYPE (parm
));
166 /* Return how many formal parameters FNDECL has. */
169 count_formal_params (tree fndecl
)
173 gcc_assert (gimple_has_body_p (fndecl
));
175 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
181 /* Return the declaration of Ith formal parameter of the function corresponding
182 to INFO. Note there is no setter function as this array is built just once
183 using ipa_initialize_node_params. */
186 ipa_dump_param (FILE *file
, struct ipa_node_params
*info
, int i
)
188 fprintf (file
, "param #%i", i
);
189 if (info
->descriptors
[i
].decl
)
192 print_generic_expr (file
, info
->descriptors
[i
].decl
, 0);
196 /* Initialize the ipa_node_params structure associated with NODE
197 to hold PARAM_COUNT parameters. */
200 ipa_alloc_node_params (struct cgraph_node
*node
, int param_count
)
202 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
204 if (!info
->descriptors
.exists () && param_count
)
205 info
->descriptors
.safe_grow_cleared (param_count
);
208 /* Initialize the ipa_node_params structure associated with NODE by counting
209 the function parameters, creating the descriptors and populating their
213 ipa_initialize_node_params (struct cgraph_node
*node
)
215 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
217 if (!info
->descriptors
.exists ())
219 ipa_alloc_node_params (node
, count_formal_params (node
->decl
));
220 ipa_populate_param_decls (node
, info
->descriptors
);
224 /* Print the jump functions associated with call graph edge CS to file F. */
227 ipa_print_node_jump_functions_for_edge (FILE *f
, struct cgraph_edge
*cs
)
231 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
232 for (i
= 0; i
< count
; i
++)
234 struct ipa_jump_func
*jump_func
;
235 enum jump_func_type type
;
237 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
238 type
= jump_func
->type
;
240 fprintf (f
, " param %d: ", i
);
241 if (type
== IPA_JF_UNKNOWN
)
242 fprintf (f
, "UNKNOWN\n");
243 else if (type
== IPA_JF_KNOWN_TYPE
)
245 fprintf (f
, "KNOWN TYPE: base ");
246 print_generic_expr (f
, jump_func
->value
.known_type
.base_type
, 0);
247 fprintf (f
, ", offset "HOST_WIDE_INT_PRINT_DEC
", component ",
248 jump_func
->value
.known_type
.offset
);
249 print_generic_expr (f
, jump_func
->value
.known_type
.component_type
, 0);
252 else if (type
== IPA_JF_CONST
)
254 tree val
= jump_func
->value
.constant
.value
;
255 fprintf (f
, "CONST: ");
256 print_generic_expr (f
, val
, 0);
257 if (TREE_CODE (val
) == ADDR_EXPR
258 && TREE_CODE (TREE_OPERAND (val
, 0)) == CONST_DECL
)
261 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (val
, 0)),
266 else if (type
== IPA_JF_PASS_THROUGH
)
268 fprintf (f
, "PASS THROUGH: ");
269 fprintf (f
, "%d, op %s",
270 jump_func
->value
.pass_through
.formal_id
,
271 get_tree_code_name(jump_func
->value
.pass_through
.operation
));
272 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
275 print_generic_expr (f
,
276 jump_func
->value
.pass_through
.operand
, 0);
278 if (jump_func
->value
.pass_through
.agg_preserved
)
279 fprintf (f
, ", agg_preserved");
280 if (jump_func
->value
.pass_through
.type_preserved
)
281 fprintf (f
, ", type_preserved");
284 else if (type
== IPA_JF_ANCESTOR
)
286 fprintf (f
, "ANCESTOR: ");
287 fprintf (f
, "%d, offset "HOST_WIDE_INT_PRINT_DEC
", ",
288 jump_func
->value
.ancestor
.formal_id
,
289 jump_func
->value
.ancestor
.offset
);
290 print_generic_expr (f
, jump_func
->value
.ancestor
.type
, 0);
291 if (jump_func
->value
.ancestor
.agg_preserved
)
292 fprintf (f
, ", agg_preserved");
293 if (jump_func
->value
.ancestor
.type_preserved
)
294 fprintf (f
, ", type_preserved");
298 if (jump_func
->agg
.items
)
300 struct ipa_agg_jf_item
*item
;
303 fprintf (f
, " Aggregate passed by %s:\n",
304 jump_func
->agg
.by_ref
? "reference" : "value");
305 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, j
, item
)
307 fprintf (f
, " offset: " HOST_WIDE_INT_PRINT_DEC
", ",
309 if (TYPE_P (item
->value
))
310 fprintf (f
, "clobber of " HOST_WIDE_INT_PRINT_DEC
" bits",
311 tree_to_uhwi (TYPE_SIZE (item
->value
)));
314 fprintf (f
, "cst: ");
315 print_generic_expr (f
, item
->value
, 0);
324 /* Print the jump functions of all arguments on all call graph edges going from
328 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
330 struct cgraph_edge
*cs
;
332 fprintf (f
, " Jump functions of caller %s/%i:\n", node
->name (),
334 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
336 if (!ipa_edge_args_info_available_for_edge_p (cs
))
339 fprintf (f
, " callsite %s/%i -> %s/%i : \n",
340 xstrdup (node
->name ()), node
->order
,
341 xstrdup (cs
->callee
->name ()),
343 ipa_print_node_jump_functions_for_edge (f
, cs
);
346 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
348 struct cgraph_indirect_call_info
*ii
;
349 if (!ipa_edge_args_info_available_for_edge_p (cs
))
352 ii
= cs
->indirect_info
;
353 if (ii
->agg_contents
)
354 fprintf (f
, " indirect %s callsite, calling param %i, "
355 "offset " HOST_WIDE_INT_PRINT_DEC
", %s",
356 ii
->member_ptr
? "member ptr" : "aggregate",
357 ii
->param_index
, ii
->offset
,
358 ii
->by_ref
? "by reference" : "by_value");
360 fprintf (f
, " indirect %s callsite, calling param %i, "
361 "offset " HOST_WIDE_INT_PRINT_DEC
,
362 ii
->polymorphic
? "polymorphic" : "simple", ii
->param_index
,
367 fprintf (f
, ", for stmt ");
368 print_gimple_stmt (f
, cs
->call_stmt
, 0, TDF_SLIM
);
372 ipa_print_node_jump_functions_for_edge (f
, cs
);
376 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
379 ipa_print_all_jump_functions (FILE *f
)
381 struct cgraph_node
*node
;
383 fprintf (f
, "\nJump functions:\n");
384 FOR_EACH_FUNCTION (node
)
386 ipa_print_node_jump_functions (f
, node
);
390 /* Set JFUNC to be a known type jump function. */
393 ipa_set_jf_known_type (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
394 tree base_type
, tree component_type
)
396 gcc_assert (TREE_CODE (component_type
) == RECORD_TYPE
397 && TYPE_BINFO (component_type
));
398 if (!flag_devirtualize
)
400 gcc_assert (BINFO_VTABLE (TYPE_BINFO (component_type
)));
401 jfunc
->type
= IPA_JF_KNOWN_TYPE
;
402 jfunc
->value
.known_type
.offset
= offset
,
403 jfunc
->value
.known_type
.base_type
= base_type
;
404 jfunc
->value
.known_type
.component_type
= component_type
;
405 gcc_assert (component_type
);
408 /* Set JFUNC to be a copy of another jmp (to be used by jump function
409 combination code). The two functions will share their rdesc. */
412 ipa_set_jf_cst_copy (struct ipa_jump_func
*dst
,
413 struct ipa_jump_func
*src
)
416 gcc_checking_assert (src
->type
== IPA_JF_CONST
);
417 dst
->type
= IPA_JF_CONST
;
418 dst
->value
.constant
= src
->value
.constant
;
421 /* Set JFUNC to be a constant jmp function. */
424 ipa_set_jf_constant (struct ipa_jump_func
*jfunc
, tree constant
,
425 struct cgraph_edge
*cs
)
427 constant
= unshare_expr (constant
);
428 if (constant
&& EXPR_P (constant
))
429 SET_EXPR_LOCATION (constant
, UNKNOWN_LOCATION
);
430 jfunc
->type
= IPA_JF_CONST
;
431 jfunc
->value
.constant
.value
= unshare_expr_without_location (constant
);
433 if (TREE_CODE (constant
) == ADDR_EXPR
434 && TREE_CODE (TREE_OPERAND (constant
, 0)) == FUNCTION_DECL
)
436 struct ipa_cst_ref_desc
*rdesc
;
437 if (!ipa_refdesc_pool
)
438 ipa_refdesc_pool
= create_alloc_pool ("IPA-PROP ref descriptions",
439 sizeof (struct ipa_cst_ref_desc
), 32);
441 rdesc
= (struct ipa_cst_ref_desc
*) pool_alloc (ipa_refdesc_pool
);
443 rdesc
->next_duplicate
= NULL
;
445 jfunc
->value
.constant
.rdesc
= rdesc
;
448 jfunc
->value
.constant
.rdesc
= NULL
;
451 /* Set JFUNC to be a simple pass-through jump function. */
453 ipa_set_jf_simple_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
454 bool agg_preserved
, bool type_preserved
)
456 jfunc
->type
= IPA_JF_PASS_THROUGH
;
457 jfunc
->value
.pass_through
.operand
= NULL_TREE
;
458 jfunc
->value
.pass_through
.formal_id
= formal_id
;
459 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
460 jfunc
->value
.pass_through
.agg_preserved
= agg_preserved
;
461 jfunc
->value
.pass_through
.type_preserved
= type_preserved
;
464 /* Set JFUNC to be an arithmetic pass through jump function. */
467 ipa_set_jf_arith_pass_through (struct ipa_jump_func
*jfunc
, int formal_id
,
468 tree operand
, enum tree_code operation
)
470 jfunc
->type
= IPA_JF_PASS_THROUGH
;
471 jfunc
->value
.pass_through
.operand
= unshare_expr_without_location (operand
);
472 jfunc
->value
.pass_through
.formal_id
= formal_id
;
473 jfunc
->value
.pass_through
.operation
= operation
;
474 jfunc
->value
.pass_through
.agg_preserved
= false;
475 jfunc
->value
.pass_through
.type_preserved
= false;
478 /* Set JFUNC to be an ancestor jump function. */
481 ipa_set_ancestor_jf (struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
,
482 tree type
, int formal_id
, bool agg_preserved
,
485 if (!flag_devirtualize
)
486 type_preserved
= false;
487 gcc_assert (!type_preserved
488 || (TREE_CODE (type
) == RECORD_TYPE
490 && BINFO_VTABLE (TYPE_BINFO (type
))));
491 jfunc
->type
= IPA_JF_ANCESTOR
;
492 jfunc
->value
.ancestor
.formal_id
= formal_id
;
493 jfunc
->value
.ancestor
.offset
= offset
;
494 jfunc
->value
.ancestor
.type
= type_preserved
? type
: NULL
;
495 jfunc
->value
.ancestor
.agg_preserved
= agg_preserved
;
496 jfunc
->value
.ancestor
.type_preserved
= type_preserved
;
499 /* Extract the acual BINFO being described by JFUNC which must be a known type
503 ipa_binfo_from_known_type_jfunc (struct ipa_jump_func
*jfunc
)
505 tree base_binfo
= TYPE_BINFO (jfunc
->value
.known_type
.base_type
);
508 return get_binfo_at_offset (base_binfo
,
509 jfunc
->value
.known_type
.offset
,
510 jfunc
->value
.known_type
.component_type
);
513 /* Structure to be passed in between detect_type_change and
514 check_stmt_for_type_change. */
516 struct type_change_info
518 /* Offset into the object where there is the virtual method pointer we are
520 HOST_WIDE_INT offset
;
521 /* The declaration or SSA_NAME pointer of the base that we are checking for
524 /* If we actually can tell the type that the object has changed to, it is
525 stored in this field. Otherwise it remains NULL_TREE. */
526 tree known_current_type
;
527 /* Set to true if dynamic type change has been detected. */
528 bool type_maybe_changed
;
529 /* Set to true if multiple types have been encountered. known_current_type
530 must be disregarded in that case. */
531 bool multiple_types_encountered
;
534 /* Return true if STMT can modify a virtual method table pointer.
536 This function makes special assumptions about both constructors and
537 destructors which are all the functions that are allowed to alter the VMT
538 pointers. It assumes that destructors begin with assignment into all VMT
539 pointers and that constructors essentially look in the following way:
541 1) The very first thing they do is that they call constructors of ancestor
542 sub-objects that have them.
544 2) Then VMT pointers of this and all its ancestors is set to new values
545 corresponding to the type corresponding to the constructor.
547 3) Only afterwards, other stuff such as constructor of member sub-objects
548 and the code written by the user is run. Only this may include calling
549 virtual functions, directly or indirectly.
551 There is no way to call a constructor of an ancestor sub-object in any
554 This means that we do not have to care whether constructors get the correct
555 type information because they will always change it (in fact, if we define
556 the type to be given by the VMT pointer, it is undefined).
558 The most important fact to derive from the above is that if, for some
559 statement in the section 3, we try to detect whether the dynamic type has
560 changed, we can safely ignore all calls as we examine the function body
561 backwards until we reach statements in section 2 because these calls cannot
562 be ancestor constructors or destructors (if the input is not bogus) and so
563 do not change the dynamic type (this holds true only for automatically
564 allocated objects but at the moment we devirtualize only these). We then
565 must detect that statements in section 2 change the dynamic type and can try
566 to derive the new type. That is enough and we can stop, we will never see
567 the calls into constructors of sub-objects in this code. Therefore we can
568 safely ignore all call statements that we traverse.
572 stmt_may_be_vtbl_ptr_store (gimple stmt
)
574 if (is_gimple_call (stmt
))
576 /* TODO: Skip clobbers, doing so triggers problem in PR60306. */
577 else if (is_gimple_assign (stmt
))
579 tree lhs
= gimple_assign_lhs (stmt
);
581 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
583 if (flag_strict_aliasing
584 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
587 if (TREE_CODE (lhs
) == COMPONENT_REF
588 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
590 /* In the future we might want to use get_base_ref_and_offset to find
591 if there is a field corresponding to the offset and if so, proceed
592 almost like if it was a component ref. */
598 /* If STMT can be proved to be an assignment to the virtual method table
599 pointer of ANALYZED_OBJ and the type associated with the new table
600 identified, return the type. Otherwise return NULL_TREE. */
603 extr_type_from_vtbl_ptr_store (gimple stmt
, struct type_change_info
*tci
)
605 HOST_WIDE_INT offset
, size
, max_size
;
606 tree lhs
, rhs
, base
, binfo
;
608 if (!gimple_assign_single_p (stmt
))
611 lhs
= gimple_assign_lhs (stmt
);
612 rhs
= gimple_assign_rhs1 (stmt
);
613 if (TREE_CODE (lhs
) != COMPONENT_REF
614 || !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
617 base
= get_ref_base_and_extent (lhs
, &offset
, &size
, &max_size
);
618 if (offset
!= tci
->offset
619 || size
!= POINTER_SIZE
620 || max_size
!= POINTER_SIZE
)
622 if (TREE_CODE (base
) == MEM_REF
)
624 if (TREE_CODE (tci
->object
) != MEM_REF
625 || TREE_OPERAND (tci
->object
, 0) != TREE_OPERAND (base
, 0)
626 || !tree_int_cst_equal (TREE_OPERAND (tci
->object
, 1),
627 TREE_OPERAND (base
, 1)))
630 else if (tci
->object
!= base
)
633 binfo
= vtable_pointer_value_to_binfo (rhs
);
635 /* FIXME: vtable_pointer_value_to_binfo may return BINFO of a
636 base of outer type. In this case we would need to either
637 work on binfos or translate it back to outer type and offset.
638 KNOWN_TYPE jump functions are not ready for that, yet. */
639 if (!binfo
|| TYPE_BINFO (BINFO_TYPE (binfo
)) != binfo
)
642 return BINFO_TYPE (binfo
);
645 /* Callback of walk_aliased_vdefs and a helper function for
646 detect_type_change to check whether a particular statement may modify
647 the virtual table pointer, and if possible also determine the new type of
648 the (sub-)object. It stores its result into DATA, which points to a
649 type_change_info structure. */
652 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
654 gimple stmt
= SSA_NAME_DEF_STMT (vdef
);
655 struct type_change_info
*tci
= (struct type_change_info
*) data
;
657 if (stmt_may_be_vtbl_ptr_store (stmt
))
660 type
= extr_type_from_vtbl_ptr_store (stmt
, tci
);
661 if (tci
->type_maybe_changed
662 && type
!= tci
->known_current_type
)
663 tci
->multiple_types_encountered
= true;
664 tci
->known_current_type
= type
;
665 tci
->type_maybe_changed
= true;
674 /* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
675 callsite CALL) by looking for assignments to its virtual table pointer. If
676 it is, return true and fill in the jump function JFUNC with relevant type
677 information or set it to unknown. ARG is the object itself (not a pointer
678 to it, unless dereferenced). BASE is the base of the memory access as
679 returned by get_ref_base_and_extent, as is the offset. */
682 detect_type_change (tree arg
, tree base
, tree comp_type
, gimple call
,
683 struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
)
685 struct type_change_info tci
;
688 gcc_checking_assert (DECL_P (arg
)
689 || TREE_CODE (arg
) == MEM_REF
690 || handled_component_p (arg
));
691 /* Const calls cannot call virtual methods through VMT and so type changes do
693 if (!flag_devirtualize
|| !gimple_vuse (call
)
694 /* Be sure expected_type is polymorphic. */
696 || TREE_CODE (comp_type
) != RECORD_TYPE
697 || !TYPE_BINFO (comp_type
)
698 || !BINFO_VTABLE (TYPE_BINFO (comp_type
)))
701 /* C++ methods are not allowed to change THIS pointer unless they
702 are constructors or destructors. */
703 if (TREE_CODE (base
) == MEM_REF
704 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
705 && SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0))
706 && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (base
, 0))) == PARM_DECL
707 && TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
708 && !DECL_CXX_CONSTRUCTOR_P (current_function_decl
)
709 && !DECL_CXX_DESTRUCTOR_P (current_function_decl
)
710 && (SSA_NAME_VAR (TREE_OPERAND (base
, 0))
711 == DECL_ARGUMENTS (current_function_decl
)))
714 ao_ref_init (&ao
, arg
);
717 ao
.size
= POINTER_SIZE
;
718 ao
.max_size
= ao
.size
;
721 tci
.object
= get_base_address (arg
);
722 tci
.known_current_type
= NULL_TREE
;
723 tci
.type_maybe_changed
= false;
724 tci
.multiple_types_encountered
= false;
726 walk_aliased_vdefs (&ao
, gimple_vuse (call
), check_stmt_for_type_change
,
728 if (!tci
.type_maybe_changed
)
731 if (!tci
.known_current_type
732 || tci
.multiple_types_encountered
734 jfunc
->type
= IPA_JF_UNKNOWN
;
736 ipa_set_jf_known_type (jfunc
, 0, tci
.known_current_type
, comp_type
);
741 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
742 SSA name (its dereference will become the base and the offset is assumed to
746 detect_type_change_ssa (tree arg
, tree comp_type
,
747 gimple call
, struct ipa_jump_func
*jfunc
)
749 gcc_checking_assert (TREE_CODE (arg
) == SSA_NAME
);
750 if (!flag_devirtualize
751 || !POINTER_TYPE_P (TREE_TYPE (arg
)))
754 arg
= build2 (MEM_REF
, ptr_type_node
, arg
,
755 build_int_cst (ptr_type_node
, 0));
757 return detect_type_change (arg
, arg
, comp_type
, call
, jfunc
, 0);
760 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
761 boolean variable pointed to by DATA. */
764 mark_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
767 bool *b
= (bool *) data
;
772 /* Return true if a load from a formal parameter PARM_LOAD is known to retrieve
773 a value known not to be modified in this function before reaching the
774 statement STMT. PARM_AINFO is a pointer to a structure containing temporary
775 information about the parameter. */
778 parm_preserved_before_stmt_p (struct param_analysis_info
*parm_ainfo
,
779 gimple stmt
, tree parm_load
)
781 bool modified
= false;
782 bitmap
*visited_stmts
;
785 if (parm_ainfo
&& parm_ainfo
->parm_modified
)
788 gcc_checking_assert (gimple_vuse (stmt
) != NULL_TREE
);
789 ao_ref_init (&refd
, parm_load
);
790 /* We can cache visited statements only when parm_ainfo is available and when
791 we are looking at a naked load of the whole parameter. */
792 if (!parm_ainfo
|| TREE_CODE (parm_load
) != PARM_DECL
)
793 visited_stmts
= NULL
;
795 visited_stmts
= &parm_ainfo
->parm_visited_statements
;
796 walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
, &modified
,
798 if (parm_ainfo
&& modified
)
799 parm_ainfo
->parm_modified
= true;
803 /* If STMT is an assignment that loads a value from an parameter declaration,
804 return the index of the parameter in ipa_node_params which has not been
805 modified. Otherwise return -1. */
808 load_from_unmodified_param (vec
<ipa_param_descriptor
> descriptors
,
809 struct param_analysis_info
*parms_ainfo
,
815 if (!gimple_assign_single_p (stmt
))
818 op1
= gimple_assign_rhs1 (stmt
);
819 if (TREE_CODE (op1
) != PARM_DECL
)
822 index
= ipa_get_param_decl_index_1 (descriptors
, op1
);
824 || !parm_preserved_before_stmt_p (parms_ainfo
? &parms_ainfo
[index
]
831 /* Return true if memory reference REF loads data that are known to be
832 unmodified in this function before reaching statement STMT. PARM_AINFO, if
833 non-NULL, is a pointer to a structure containing temporary information about
837 parm_ref_data_preserved_p (struct param_analysis_info
*parm_ainfo
,
838 gimple stmt
, tree ref
)
840 bool modified
= false;
843 gcc_checking_assert (gimple_vuse (stmt
));
844 if (parm_ainfo
&& parm_ainfo
->ref_modified
)
847 ao_ref_init (&refd
, ref
);
848 walk_aliased_vdefs (&refd
, gimple_vuse (stmt
), mark_modified
, &modified
,
850 if (parm_ainfo
&& modified
)
851 parm_ainfo
->ref_modified
= true;
855 /* Return true if the data pointed to by PARM is known to be unmodified in this
856 function before reaching call statement CALL into which it is passed.
857 PARM_AINFO is a pointer to a structure containing temporary information
861 parm_ref_data_pass_through_p (struct param_analysis_info
*parm_ainfo
,
862 gimple call
, tree parm
)
864 bool modified
= false;
867 /* It's unnecessary to calculate anything about memory contnets for a const
868 function because it is not goin to use it. But do not cache the result
869 either. Also, no such calculations for non-pointers. */
870 if (!gimple_vuse (call
)
871 || !POINTER_TYPE_P (TREE_TYPE (parm
)))
874 if (parm_ainfo
->pt_modified
)
877 ao_ref_init_from_ptr_and_size (&refd
, parm
, NULL_TREE
);
878 walk_aliased_vdefs (&refd
, gimple_vuse (call
), mark_modified
, &modified
,
879 parm_ainfo
? &parm_ainfo
->pt_visited_statements
: NULL
);
881 parm_ainfo
->pt_modified
= true;
885 /* Return true if we can prove that OP is a memory reference loading unmodified
886 data from an aggregate passed as a parameter and if the aggregate is passed
887 by reference, that the alias type of the load corresponds to the type of the
888 formal parameter (so that we can rely on this type for TBAA in callers).
889 INFO and PARMS_AINFO describe parameters of the current function (but the
890 latter can be NULL), STMT is the load statement. If function returns true,
891 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
892 within the aggregate and whether it is a load from a value passed by
893 reference respectively. */
896 ipa_load_from_parm_agg_1 (vec
<ipa_param_descriptor
> descriptors
,
897 struct param_analysis_info
*parms_ainfo
, gimple stmt
,
898 tree op
, int *index_p
, HOST_WIDE_INT
*offset_p
,
899 HOST_WIDE_INT
*size_p
, bool *by_ref_p
)
902 HOST_WIDE_INT size
, max_size
;
903 tree base
= get_ref_base_and_extent (op
, offset_p
, &size
, &max_size
);
905 if (max_size
== -1 || max_size
!= size
|| *offset_p
< 0)
910 int index
= ipa_get_param_decl_index_1 (descriptors
, base
);
912 && parm_preserved_before_stmt_p (parms_ainfo
? &parms_ainfo
[index
]
924 if (TREE_CODE (base
) != MEM_REF
925 || TREE_CODE (TREE_OPERAND (base
, 0)) != SSA_NAME
926 || !integer_zerop (TREE_OPERAND (base
, 1)))
929 if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base
, 0)))
931 tree parm
= SSA_NAME_VAR (TREE_OPERAND (base
, 0));
932 index
= ipa_get_param_decl_index_1 (descriptors
, parm
);
936 /* This branch catches situations where a pointer parameter is not a
937 gimple register, for example:
939 void hip7(S*) (struct S * p)
941 void (*<T2e4>) (struct S *) D.1867;
951 gimple def
= SSA_NAME_DEF_STMT (TREE_OPERAND (base
, 0));
952 index
= load_from_unmodified_param (descriptors
, parms_ainfo
, def
);
956 && parm_ref_data_preserved_p (parms_ainfo
? &parms_ainfo
[index
] : NULL
,
968 /* Just like the previous function, just without the param_analysis_info
969 pointer, for users outside of this file. */
972 ipa_load_from_parm_agg (struct ipa_node_params
*info
, gimple stmt
,
973 tree op
, int *index_p
, HOST_WIDE_INT
*offset_p
,
976 return ipa_load_from_parm_agg_1 (info
->descriptors
, NULL
, stmt
, op
, index_p
,
977 offset_p
, NULL
, by_ref_p
);
980 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
981 of an assignment statement STMT, try to determine whether we are actually
982 handling any of the following cases and construct an appropriate jump
983 function into JFUNC if so:
985 1) The passed value is loaded from a formal parameter which is not a gimple
986 register (most probably because it is addressable, the value has to be
987 scalar) and we can guarantee the value has not changed. This case can
988 therefore be described by a simple pass-through jump function. For example:
997 2) The passed value can be described by a simple arithmetic pass-through
1004 D.2064_4 = a.1(D) + 4;
1007 This case can also occur in combination of the previous one, e.g.:
1015 D.2064_4 = a.0_3 + 4;
1018 3) The passed value is an address of an object within another one (which
1019 also passed by reference). Such situations are described by an ancestor
1020 jump function and describe situations such as:
1022 B::foo() (struct B * const this)
1026 D.1845_2 = &this_1(D)->D.1748;
1029 INFO is the structure describing individual parameters access different
1030 stages of IPA optimizations. PARMS_AINFO contains the information that is
1031 only needed for intraprocedural analysis. */
1034 compute_complex_assign_jump_func (struct ipa_node_params
*info
,
1035 struct param_analysis_info
*parms_ainfo
,
1036 struct ipa_jump_func
*jfunc
,
1037 gimple call
, gimple stmt
, tree name
,
1040 HOST_WIDE_INT offset
, size
, max_size
;
1041 tree op1
, tc_ssa
, base
, ssa
;
1044 op1
= gimple_assign_rhs1 (stmt
);
1046 if (TREE_CODE (op1
) == SSA_NAME
)
1048 if (SSA_NAME_IS_DEFAULT_DEF (op1
))
1049 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
1051 index
= load_from_unmodified_param (info
->descriptors
, parms_ainfo
,
1052 SSA_NAME_DEF_STMT (op1
));
1057 index
= load_from_unmodified_param (info
->descriptors
, parms_ainfo
, stmt
);
1058 tc_ssa
= gimple_assign_lhs (stmt
);
1063 tree op2
= gimple_assign_rhs2 (stmt
);
1067 if (!is_gimple_ip_invariant (op2
)
1068 || (TREE_CODE_CLASS (gimple_expr_code (stmt
)) != tcc_comparison
1069 && !useless_type_conversion_p (TREE_TYPE (name
),
1073 ipa_set_jf_arith_pass_through (jfunc
, index
, op2
,
1074 gimple_assign_rhs_code (stmt
));
1076 else if (gimple_assign_single_p (stmt
))
1078 bool agg_p
= parm_ref_data_pass_through_p (&parms_ainfo
[index
],
1080 bool type_p
= false;
1082 if (param_type
&& POINTER_TYPE_P (param_type
))
1083 type_p
= !detect_type_change_ssa (tc_ssa
, TREE_TYPE (param_type
),
1085 if (type_p
|| jfunc
->type
== IPA_JF_UNKNOWN
)
1086 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
, type_p
);
1091 if (TREE_CODE (op1
) != ADDR_EXPR
)
1093 op1
= TREE_OPERAND (op1
, 0);
1094 if (TREE_CODE (TREE_TYPE (op1
)) != RECORD_TYPE
)
1096 base
= get_ref_base_and_extent (op1
, &offset
, &size
, &max_size
);
1097 if (TREE_CODE (base
) != MEM_REF
1098 /* If this is a varying address, punt. */
1100 || max_size
!= size
)
1102 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
1103 ssa
= TREE_OPERAND (base
, 0);
1104 if (TREE_CODE (ssa
) != SSA_NAME
1105 || !SSA_NAME_IS_DEFAULT_DEF (ssa
)
1109 /* Dynamic types are changed in constructors and destructors. */
1110 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (ssa
));
1111 if (index
>= 0 && param_type
&& POINTER_TYPE_P (param_type
))
1113 bool type_p
= !detect_type_change (op1
, base
, TREE_TYPE (param_type
),
1114 call
, jfunc
, offset
);
1115 if (type_p
|| jfunc
->type
== IPA_JF_UNKNOWN
)
1116 ipa_set_ancestor_jf (jfunc
, offset
,
1117 type_p
? TREE_TYPE (param_type
) : NULL
, index
,
1118 parm_ref_data_pass_through_p (&parms_ainfo
[index
],
1119 call
, ssa
), type_p
);
1123 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
1126 iftmp.1_3 = &obj_2(D)->D.1762;
1128 The base of the MEM_REF must be a default definition SSA NAME of a
1129 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
1130 whole MEM_REF expression is returned and the offset calculated from any
1131 handled components and the MEM_REF itself is stored into *OFFSET. The whole
1132 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
1135 get_ancestor_addr_info (gimple assign
, tree
*obj_p
, HOST_WIDE_INT
*offset
)
1137 HOST_WIDE_INT size
, max_size
;
1138 tree expr
, parm
, obj
;
1140 if (!gimple_assign_single_p (assign
))
1142 expr
= gimple_assign_rhs1 (assign
);
1144 if (TREE_CODE (expr
) != ADDR_EXPR
)
1146 expr
= TREE_OPERAND (expr
, 0);
1148 expr
= get_ref_base_and_extent (expr
, offset
, &size
, &max_size
);
1150 if (TREE_CODE (expr
) != MEM_REF
1151 /* If this is a varying address, punt. */
1156 parm
= TREE_OPERAND (expr
, 0);
1157 if (TREE_CODE (parm
) != SSA_NAME
1158 || !SSA_NAME_IS_DEFAULT_DEF (parm
)
1159 || TREE_CODE (SSA_NAME_VAR (parm
)) != PARM_DECL
)
1162 *offset
+= mem_ref_offset (expr
).to_short_addr () * BITS_PER_UNIT
;
1168 /* Given that an actual argument is an SSA_NAME that is a result of a phi
1169 statement PHI, try to find out whether NAME is in fact a
1170 multiple-inheritance typecast from a descendant into an ancestor of a formal
1171 parameter and thus can be described by an ancestor jump function and if so,
1172 write the appropriate function into JFUNC.
1174 Essentially we want to match the following pattern:
1182 iftmp.1_3 = &obj_2(D)->D.1762;
1185 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
1186 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
1190 compute_complex_ancestor_jump_func (struct ipa_node_params
*info
,
1191 struct param_analysis_info
*parms_ainfo
,
1192 struct ipa_jump_func
*jfunc
,
1193 gimple call
, gimple phi
, tree param_type
)
1195 HOST_WIDE_INT offset
;
1196 gimple assign
, cond
;
1197 basic_block phi_bb
, assign_bb
, cond_bb
;
1198 tree tmp
, parm
, expr
, obj
;
1201 if (gimple_phi_num_args (phi
) != 2)
1204 if (integer_zerop (PHI_ARG_DEF (phi
, 1)))
1205 tmp
= PHI_ARG_DEF (phi
, 0);
1206 else if (integer_zerop (PHI_ARG_DEF (phi
, 0)))
1207 tmp
= PHI_ARG_DEF (phi
, 1);
1210 if (TREE_CODE (tmp
) != SSA_NAME
1211 || SSA_NAME_IS_DEFAULT_DEF (tmp
)
1212 || !POINTER_TYPE_P (TREE_TYPE (tmp
))
1213 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp
))) != RECORD_TYPE
)
1216 assign
= SSA_NAME_DEF_STMT (tmp
);
1217 assign_bb
= gimple_bb (assign
);
1218 if (!single_pred_p (assign_bb
))
1220 expr
= get_ancestor_addr_info (assign
, &obj
, &offset
);
1223 parm
= TREE_OPERAND (expr
, 0);
1224 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (parm
));
1228 cond_bb
= single_pred (assign_bb
);
1229 cond
= last_stmt (cond_bb
);
1231 || gimple_code (cond
) != GIMPLE_COND
1232 || gimple_cond_code (cond
) != NE_EXPR
1233 || gimple_cond_lhs (cond
) != parm
1234 || !integer_zerop (gimple_cond_rhs (cond
)))
1237 phi_bb
= gimple_bb (phi
);
1238 for (i
= 0; i
< 2; i
++)
1240 basic_block pred
= EDGE_PRED (phi_bb
, i
)->src
;
1241 if (pred
!= assign_bb
&& pred
!= cond_bb
)
1245 bool type_p
= false;
1246 if (param_type
&& POINTER_TYPE_P (param_type
))
1247 type_p
= !detect_type_change (obj
, expr
, TREE_TYPE (param_type
),
1248 call
, jfunc
, offset
);
1249 if (type_p
|| jfunc
->type
== IPA_JF_UNKNOWN
)
1250 ipa_set_ancestor_jf (jfunc
, offset
, type_p
? TREE_TYPE (param_type
) : NULL
, index
,
1251 parm_ref_data_pass_through_p (&parms_ainfo
[index
],
1252 call
, parm
), type_p
);
1255 /* Given OP which is passed as an actual argument to a called function,
1256 determine if it is possible to construct a KNOWN_TYPE jump function for it
1257 and if so, create one and store it to JFUNC.
1258 EXPECTED_TYPE represents a type the argument should be in */
1261 compute_known_type_jump_func (tree op
, struct ipa_jump_func
*jfunc
,
1262 gimple call
, tree expected_type
)
1264 HOST_WIDE_INT offset
, size
, max_size
;
1267 if (!flag_devirtualize
1268 || TREE_CODE (op
) != ADDR_EXPR
1269 || TREE_CODE (TREE_TYPE (TREE_TYPE (op
))) != RECORD_TYPE
1270 /* Be sure expected_type is polymorphic. */
1272 || TREE_CODE (expected_type
) != RECORD_TYPE
1273 || !TYPE_BINFO (expected_type
)
1274 || !BINFO_VTABLE (TYPE_BINFO (expected_type
)))
1277 op
= TREE_OPERAND (op
, 0);
1278 base
= get_ref_base_and_extent (op
, &offset
, &size
, &max_size
);
1282 || TREE_CODE (TREE_TYPE (base
)) != RECORD_TYPE
1283 || is_global_var (base
))
1286 if (detect_type_change (op
, base
, expected_type
, call
, jfunc
, offset
))
1289 ipa_set_jf_known_type (jfunc
, offset
, TREE_TYPE (base
),
1293 /* Inspect the given TYPE and return true iff it has the same structure (the
1294 same number of fields of the same types) as a C++ member pointer. If
1295 METHOD_PTR and DELTA are non-NULL, store the trees representing the
1296 corresponding fields there. */
1299 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
1303 if (TREE_CODE (type
) != RECORD_TYPE
)
1306 fld
= TYPE_FIELDS (type
);
1307 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
1308 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
1309 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1315 fld
= DECL_CHAIN (fld
);
1316 if (!fld
|| INTEGRAL_TYPE_P (fld
)
1317 || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld
)))
1322 if (DECL_CHAIN (fld
))
1328 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
1329 return the rhs of its defining statement. Otherwise return RHS as it
1333 get_ssa_def_if_simple_copy (tree rhs
)
1335 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
1337 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs
);
1339 if (gimple_assign_single_p (def_stmt
))
1340 rhs
= gimple_assign_rhs1 (def_stmt
);
1347 /* Simple linked list, describing known contents of an aggregate beforere
1350 struct ipa_known_agg_contents_list
1352 /* Offset and size of the described part of the aggregate. */
1353 HOST_WIDE_INT offset
, size
;
1354 /* Known constant value or NULL if the contents is known to be unknown. */
1356 /* Pointer to the next structure in the list. */
1357 struct ipa_known_agg_contents_list
*next
;
1360 /* Traverse statements from CALL backwards, scanning whether an aggregate given
1361 in ARG is filled in with constant values. ARG can either be an aggregate
1362 expression or a pointer to an aggregate. ARG_TYPE is the type of the aggregate.
1363 JFUNC is the jump function into which the constants are subsequently stored. */
1366 determine_known_aggregate_parts (gimple call
, tree arg
, tree arg_type
,
1367 struct ipa_jump_func
*jfunc
)
1369 struct ipa_known_agg_contents_list
*list
= NULL
;
1370 int item_count
= 0, const_count
= 0;
1371 HOST_WIDE_INT arg_offset
, arg_size
;
1372 gimple_stmt_iterator gsi
;
1374 bool check_ref
, by_ref
;
1377 /* The function operates in three stages. First, we prepare check_ref, r,
1378 arg_base and arg_offset based on what is actually passed as an actual
1381 if (POINTER_TYPE_P (arg_type
))
1384 if (TREE_CODE (arg
) == SSA_NAME
)
1387 if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (arg_type
))))
1392 type_size
= TYPE_SIZE (TREE_TYPE (arg_type
));
1393 arg_size
= tree_to_uhwi (type_size
);
1394 ao_ref_init_from_ptr_and_size (&r
, arg_base
, NULL_TREE
);
1396 else if (TREE_CODE (arg
) == ADDR_EXPR
)
1398 HOST_WIDE_INT arg_max_size
;
1400 arg
= TREE_OPERAND (arg
, 0);
1401 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1403 if (arg_max_size
== -1
1404 || arg_max_size
!= arg_size
1407 if (DECL_P (arg_base
))
1411 size
= build_int_cst (integer_type_node
, arg_size
);
1412 ao_ref_init_from_ptr_and_size (&r
, arg_base
, size
);
1422 HOST_WIDE_INT arg_max_size
;
1424 gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg
)));
1428 arg_base
= get_ref_base_and_extent (arg
, &arg_offset
, &arg_size
,
1430 if (arg_max_size
== -1
1431 || arg_max_size
!= arg_size
1435 ao_ref_init (&r
, arg
);
1438 /* Second stage walks back the BB, looks at individual statements and as long
1439 as it is confident of how the statements affect contents of the
1440 aggregates, it builds a sorted linked list of ipa_agg_jf_list structures
1442 gsi
= gsi_for_stmt (call
);
1444 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
1446 struct ipa_known_agg_contents_list
*n
, **p
;
1447 gimple stmt
= gsi_stmt (gsi
);
1448 HOST_WIDE_INT lhs_offset
, lhs_size
, lhs_max_size
;
1449 tree lhs
, rhs
, lhs_base
;
1450 bool partial_overlap
;
1452 if (!stmt_may_clobber_ref_p_1 (stmt
, &r
))
1454 if (!gimple_assign_single_p (stmt
))
1457 lhs
= gimple_assign_lhs (stmt
);
1458 rhs
= gimple_assign_rhs1 (stmt
);
1459 if (!is_gimple_reg_type (TREE_TYPE (rhs
))
1460 || TREE_CODE (lhs
) == BIT_FIELD_REF
1461 || contains_bitfld_component_ref_p (lhs
))
1464 lhs_base
= get_ref_base_and_extent (lhs
, &lhs_offset
, &lhs_size
,
1466 if (lhs_max_size
== -1
1467 || lhs_max_size
!= lhs_size
1468 || (lhs_offset
< arg_offset
1469 && lhs_offset
+ lhs_size
> arg_offset
)
1470 || (lhs_offset
< arg_offset
+ arg_size
1471 && lhs_offset
+ lhs_size
> arg_offset
+ arg_size
))
1476 if (TREE_CODE (lhs_base
) != MEM_REF
1477 || TREE_OPERAND (lhs_base
, 0) != arg_base
1478 || !integer_zerop (TREE_OPERAND (lhs_base
, 1)))
1481 else if (lhs_base
!= arg_base
)
1483 if (DECL_P (lhs_base
))
1489 if (lhs_offset
+ lhs_size
< arg_offset
1490 || lhs_offset
>= (arg_offset
+ arg_size
))
1493 partial_overlap
= false;
1495 while (*p
&& (*p
)->offset
< lhs_offset
)
1497 if ((*p
)->offset
+ (*p
)->size
> lhs_offset
)
1499 partial_overlap
= true;
1504 if (partial_overlap
)
1506 if (*p
&& (*p
)->offset
< lhs_offset
+ lhs_size
)
1508 if ((*p
)->offset
== lhs_offset
&& (*p
)->size
== lhs_size
)
1509 /* We already know this value is subsequently overwritten with
1513 /* Otherwise this is a partial overlap which we cannot
1518 rhs
= get_ssa_def_if_simple_copy (rhs
);
1519 n
= XALLOCA (struct ipa_known_agg_contents_list
);
1521 n
->offset
= lhs_offset
;
1522 if (is_gimple_ip_invariant (rhs
))
1528 n
->constant
= NULL_TREE
;
1533 if (const_count
== PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
)
1534 || item_count
== 2 * PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS
))
1538 /* Third stage just goes over the list and creates an appropriate vector of
1539 ipa_agg_jf_item structures out of it, of sourse only if there are
1540 any known constants to begin with. */
1544 jfunc
->agg
.by_ref
= by_ref
;
1545 vec_alloc (jfunc
->agg
.items
, const_count
);
1550 struct ipa_agg_jf_item item
;
1551 item
.offset
= list
->offset
- arg_offset
;
1552 gcc_assert ((item
.offset
% BITS_PER_UNIT
) == 0);
1553 item
.value
= unshare_expr_without_location (list
->constant
);
1554 jfunc
->agg
.items
->quick_push (item
);
1562 ipa_get_callee_param_type (struct cgraph_edge
*e
, int i
)
1565 tree type
= (e
->callee
1566 ? TREE_TYPE (e
->callee
->decl
)
1567 : gimple_call_fntype (e
->call_stmt
));
1568 tree t
= TYPE_ARG_TYPES (type
);
1570 for (n
= 0; n
< i
; n
++)
1577 return TREE_VALUE (t
);
1580 t
= DECL_ARGUMENTS (e
->callee
->decl
);
1581 for (n
= 0; n
< i
; n
++)
1588 return TREE_TYPE (t
);
1592 /* Compute jump function for all arguments of callsite CS and insert the
1593 information in the jump_functions array in the ipa_edge_args corresponding
1594 to this callsite. */
1597 ipa_compute_jump_functions_for_edge (struct param_analysis_info
*parms_ainfo
,
1598 struct cgraph_edge
*cs
)
1600 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
1601 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
1602 gimple call
= cs
->call_stmt
;
1603 int n
, arg_num
= gimple_call_num_args (call
);
1605 if (arg_num
== 0 || args
->jump_functions
)
1607 vec_safe_grow_cleared (args
->jump_functions
, arg_num
);
1609 if (gimple_call_internal_p (call
))
1611 if (ipa_func_spec_opts_forbid_analysis_p (cs
->caller
))
1614 for (n
= 0; n
< arg_num
; n
++)
1616 struct ipa_jump_func
*jfunc
= ipa_get_ith_jump_func (args
, n
);
1617 tree arg
= gimple_call_arg (call
, n
);
1618 tree param_type
= ipa_get_callee_param_type (cs
, n
);
1620 if (is_gimple_ip_invariant (arg
))
1621 ipa_set_jf_constant (jfunc
, arg
, cs
);
1622 else if (!is_gimple_reg_type (TREE_TYPE (arg
))
1623 && TREE_CODE (arg
) == PARM_DECL
)
1625 int index
= ipa_get_param_decl_index (info
, arg
);
1627 gcc_assert (index
>=0);
1628 /* Aggregate passed by value, check for pass-through, otherwise we
1629 will attempt to fill in aggregate contents later in this
1631 if (parm_preserved_before_stmt_p (&parms_ainfo
[index
], call
, arg
))
1633 ipa_set_jf_simple_pass_through (jfunc
, index
, false, false);
1637 else if (TREE_CODE (arg
) == SSA_NAME
)
1639 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
1641 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
1645 agg_p
= parm_ref_data_pass_through_p (&parms_ainfo
[index
],
1647 if (param_type
&& POINTER_TYPE_P (param_type
))
1648 type_p
= !detect_type_change_ssa (arg
, TREE_TYPE (param_type
),
1652 if (type_p
|| jfunc
->type
== IPA_JF_UNKNOWN
)
1653 ipa_set_jf_simple_pass_through (jfunc
, index
, agg_p
,
1659 gimple stmt
= SSA_NAME_DEF_STMT (arg
);
1660 if (is_gimple_assign (stmt
))
1661 compute_complex_assign_jump_func (info
, parms_ainfo
, jfunc
,
1662 call
, stmt
, arg
, param_type
);
1663 else if (gimple_code (stmt
) == GIMPLE_PHI
)
1664 compute_complex_ancestor_jump_func (info
, parms_ainfo
, jfunc
,
1665 call
, stmt
, param_type
);
1669 compute_known_type_jump_func (arg
, jfunc
, call
,
1671 && POINTER_TYPE_P (param_type
)
1672 ? TREE_TYPE (param_type
)
1675 /* If ARG is pointer, we can not use its type to determine the type of aggregate
1676 passed (because type conversions are ignored in gimple). Usually we can
1677 safely get type from function declaration, but in case of K&R prototypes or
1678 variadic functions we can try our luck with type of the pointer passed.
1679 TODO: Since we look for actual initialization of the memory object, we may better
1680 work out the type based on the memory stores we find. */
1682 param_type
= TREE_TYPE (arg
);
1684 if ((jfunc
->type
!= IPA_JF_PASS_THROUGH
1685 || !ipa_get_jf_pass_through_agg_preserved (jfunc
))
1686 && (jfunc
->type
!= IPA_JF_ANCESTOR
1687 || !ipa_get_jf_ancestor_agg_preserved (jfunc
))
1688 && (AGGREGATE_TYPE_P (TREE_TYPE (arg
))
1689 || POINTER_TYPE_P (param_type
)))
1690 determine_known_aggregate_parts (call
, arg
, param_type
, jfunc
);
1694 /* Compute jump functions for all edges - both direct and indirect - outgoing
1695 from NODE. Also count the actual arguments in the process. */
1698 ipa_compute_jump_functions (struct cgraph_node
*node
,
1699 struct param_analysis_info
*parms_ainfo
)
1701 struct cgraph_edge
*cs
;
1703 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
1705 struct cgraph_node
*callee
= cgraph_function_or_thunk_node (cs
->callee
,
1707 /* We do not need to bother analyzing calls to unknown
1708 functions unless they may become known during lto/whopr. */
1709 if (!callee
->definition
&& !flag_lto
)
1711 ipa_compute_jump_functions_for_edge (parms_ainfo
, cs
);
1714 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
1715 ipa_compute_jump_functions_for_edge (parms_ainfo
, cs
);
1718 /* If STMT looks like a statement loading a value from a member pointer formal
1719 parameter, return that parameter and store the offset of the field to
1720 *OFFSET_P, if it is non-NULL. Otherwise return NULL (but *OFFSET_P still
1721 might be clobbered). If USE_DELTA, then we look for a use of the delta
1722 field rather than the pfn. */
1725 ipa_get_stmt_member_ptr_load_param (gimple stmt
, bool use_delta
,
1726 HOST_WIDE_INT
*offset_p
)
1728 tree rhs
, rec
, ref_field
, ref_offset
, fld
, ptr_field
, delta_field
;
1730 if (!gimple_assign_single_p (stmt
))
1733 rhs
= gimple_assign_rhs1 (stmt
);
1734 if (TREE_CODE (rhs
) == COMPONENT_REF
)
1736 ref_field
= TREE_OPERAND (rhs
, 1);
1737 rhs
= TREE_OPERAND (rhs
, 0);
1740 ref_field
= NULL_TREE
;
1741 if (TREE_CODE (rhs
) != MEM_REF
)
1743 rec
= TREE_OPERAND (rhs
, 0);
1744 if (TREE_CODE (rec
) != ADDR_EXPR
)
1746 rec
= TREE_OPERAND (rec
, 0);
1747 if (TREE_CODE (rec
) != PARM_DECL
1748 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
1750 ref_offset
= TREE_OPERAND (rhs
, 1);
1757 *offset_p
= int_bit_position (fld
);
1761 if (integer_nonzerop (ref_offset
))
1763 return ref_field
== fld
? rec
: NULL_TREE
;
1766 return tree_int_cst_equal (byte_position (fld
), ref_offset
) ? rec
1770 /* Returns true iff T is an SSA_NAME defined by a statement. */
1773 ipa_is_ssa_with_stmt_def (tree t
)
1775 if (TREE_CODE (t
) == SSA_NAME
1776 && !SSA_NAME_IS_DEFAULT_DEF (t
))
1782 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1783 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1784 indirect call graph edge. */
1786 static struct cgraph_edge
*
1787 ipa_note_param_call (struct cgraph_node
*node
, int param_index
, gimple stmt
)
1789 struct cgraph_edge
*cs
;
1791 cs
= cgraph_edge (node
, stmt
);
1792 cs
->indirect_info
->param_index
= param_index
;
1793 cs
->indirect_info
->agg_contents
= 0;
1794 cs
->indirect_info
->member_ptr
= 0;
1798 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1799 (described by INFO). PARMS_AINFO is a pointer to a vector containing
1800 intermediate information about each formal parameter. Currently it checks
1801 whether the call calls a pointer that is a formal parameter and if so, the
1802 parameter is marked with the called flag and an indirect call graph edge
1803 describing the call is created. This is very simple for ordinary pointers
1804 represented in SSA but not-so-nice when it comes to member pointers. The
1805 ugly part of this function does nothing more than trying to match the
1806 pattern of such a call. An example of such a pattern is the gimple dump
1807 below, the call is on the last line:
1810 f$__delta_5 = f.__delta;
1811 f$__pfn_24 = f.__pfn;
1815 f$__delta_5 = MEM[(struct *)&f];
1816 f$__pfn_24 = MEM[(struct *)&f + 4B];
1818 and a few lines below:
1821 D.2496_3 = (int) f$__pfn_24;
1822 D.2497_4 = D.2496_3 & 1;
1829 D.2500_7 = (unsigned int) f$__delta_5;
1830 D.2501_8 = &S + D.2500_7;
1831 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1832 D.2503_10 = *D.2502_9;
1833 D.2504_12 = f$__pfn_24 + -1;
1834 D.2505_13 = (unsigned int) D.2504_12;
1835 D.2506_14 = D.2503_10 + D.2505_13;
1836 D.2507_15 = *D.2506_14;
1837 iftmp.11_16 = (String:: *) D.2507_15;
1840 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1841 D.2500_19 = (unsigned int) f$__delta_5;
1842 D.2508_20 = &S + D.2500_19;
1843 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1845 Such patterns are results of simple calls to a member pointer:
1847 int doprinting (int (MyString::* f)(int) const)
1849 MyString S ("somestring");
1854 Moreover, the function also looks for called pointers loaded from aggregates
1855 passed by value or reference. */
1858 ipa_analyze_indirect_call_uses (struct cgraph_node
*node
,
1859 struct ipa_node_params
*info
,
1860 struct param_analysis_info
*parms_ainfo
,
1861 gimple call
, tree target
)
1866 tree rec
, rec2
, cond
;
1869 basic_block bb
, virt_bb
, join
;
1870 HOST_WIDE_INT offset
;
1873 if (SSA_NAME_IS_DEFAULT_DEF (target
))
1875 tree var
= SSA_NAME_VAR (target
);
1876 index
= ipa_get_param_decl_index (info
, var
);
1878 ipa_note_param_call (node
, index
, call
);
1882 def
= SSA_NAME_DEF_STMT (target
);
1883 if (gimple_assign_single_p (def
)
1884 && ipa_load_from_parm_agg_1 (info
->descriptors
, parms_ainfo
, def
,
1885 gimple_assign_rhs1 (def
), &index
, &offset
,
1888 struct cgraph_edge
*cs
= ipa_note_param_call (node
, index
, call
);
1889 if (cs
->indirect_info
->offset
!= offset
)
1890 cs
->indirect_info
->outer_type
= NULL
;
1891 cs
->indirect_info
->offset
= offset
;
1892 cs
->indirect_info
->agg_contents
= 1;
1893 cs
->indirect_info
->by_ref
= by_ref
;
1897 /* Now we need to try to match the complex pattern of calling a member
1899 if (gimple_code (def
) != GIMPLE_PHI
1900 || gimple_phi_num_args (def
) != 2
1901 || !POINTER_TYPE_P (TREE_TYPE (target
))
1902 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
1905 /* First, we need to check whether one of these is a load from a member
1906 pointer that is a parameter to this function. */
1907 n1
= PHI_ARG_DEF (def
, 0);
1908 n2
= PHI_ARG_DEF (def
, 1);
1909 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
1911 d1
= SSA_NAME_DEF_STMT (n1
);
1912 d2
= SSA_NAME_DEF_STMT (n2
);
1914 join
= gimple_bb (def
);
1915 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false, &offset
)))
1917 if (ipa_get_stmt_member_ptr_load_param (d2
, false, NULL
))
1920 bb
= EDGE_PRED (join
, 0)->src
;
1921 virt_bb
= gimple_bb (d2
);
1923 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false, &offset
)))
1925 bb
= EDGE_PRED (join
, 1)->src
;
1926 virt_bb
= gimple_bb (d1
);
1931 /* Second, we need to check that the basic blocks are laid out in the way
1932 corresponding to the pattern. */
1934 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
1935 || single_pred (virt_bb
) != bb
1936 || single_succ (virt_bb
) != join
)
1939 /* Third, let's see that the branching is done depending on the least
1940 significant bit of the pfn. */
1942 branch
= last_stmt (bb
);
1943 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
1946 if ((gimple_cond_code (branch
) != NE_EXPR
1947 && gimple_cond_code (branch
) != EQ_EXPR
)
1948 || !integer_zerop (gimple_cond_rhs (branch
)))
1951 cond
= gimple_cond_lhs (branch
);
1952 if (!ipa_is_ssa_with_stmt_def (cond
))
1955 def
= SSA_NAME_DEF_STMT (cond
);
1956 if (!is_gimple_assign (def
)
1957 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
1958 || !integer_onep (gimple_assign_rhs2 (def
)))
1961 cond
= gimple_assign_rhs1 (def
);
1962 if (!ipa_is_ssa_with_stmt_def (cond
))
1965 def
= SSA_NAME_DEF_STMT (cond
);
1967 if (is_gimple_assign (def
)
1968 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
1970 cond
= gimple_assign_rhs1 (def
);
1971 if (!ipa_is_ssa_with_stmt_def (cond
))
1973 def
= SSA_NAME_DEF_STMT (cond
);
1976 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
1977 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1978 == ptrmemfunc_vbit_in_delta
),
1983 index
= ipa_get_param_decl_index (info
, rec
);
1985 && parm_preserved_before_stmt_p (&parms_ainfo
[index
], call
, rec
))
1987 struct cgraph_edge
*cs
= ipa_note_param_call (node
, index
, call
);
1988 if (cs
->indirect_info
->offset
!= offset
)
1989 cs
->indirect_info
->outer_type
= NULL
;
1990 cs
->indirect_info
->offset
= offset
;
1991 cs
->indirect_info
->agg_contents
= 1;
1992 cs
->indirect_info
->member_ptr
= 1;
1998 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1999 object referenced in the expression is a formal parameter of the caller
2000 (described by INFO), create a call note for the statement. */
2003 ipa_analyze_virtual_call_uses (struct cgraph_node
*node
,
2004 struct ipa_node_params
*info
, gimple call
,
2007 struct cgraph_edge
*cs
;
2008 struct cgraph_indirect_call_info
*ii
;
2009 struct ipa_jump_func jfunc
;
2010 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
2012 HOST_WIDE_INT anc_offset
;
2014 if (!flag_devirtualize
)
2017 if (TREE_CODE (obj
) != SSA_NAME
)
2020 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
2022 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
2026 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
2027 gcc_assert (index
>= 0);
2028 if (detect_type_change_ssa (obj
, obj_type_ref_class (target
),
2034 gimple stmt
= SSA_NAME_DEF_STMT (obj
);
2037 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
2040 index
= ipa_get_param_decl_index (info
,
2041 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
2042 gcc_assert (index
>= 0);
2043 if (detect_type_change (obj
, expr
, obj_type_ref_class (target
),
2044 call
, &jfunc
, anc_offset
))
2048 cs
= ipa_note_param_call (node
, index
, call
);
2049 ii
= cs
->indirect_info
;
2050 ii
->offset
= anc_offset
;
2051 ii
->otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target
));
2052 ii
->otr_type
= obj_type_ref_class (target
);
2053 ii
->polymorphic
= 1;
2056 /* Analyze a call statement CALL whether and how it utilizes formal parameters
2057 of the caller (described by INFO). PARMS_AINFO is a pointer to a vector
2058 containing intermediate information about each formal parameter. */
2061 ipa_analyze_call_uses (struct cgraph_node
*node
,
2062 struct ipa_node_params
*info
,
2063 struct param_analysis_info
*parms_ainfo
, gimple call
)
2065 tree target
= gimple_call_fn (call
);
2066 struct cgraph_edge
*cs
;
2069 || (TREE_CODE (target
) != SSA_NAME
2070 && !virtual_method_call_p (target
)))
2073 /* If we previously turned the call into a direct call, there is
2074 no need to analyze. */
2075 cs
= cgraph_edge (node
, call
);
2076 if (cs
&& !cs
->indirect_unknown_callee
)
2078 if (TREE_CODE (target
) == SSA_NAME
)
2079 ipa_analyze_indirect_call_uses (node
, info
, parms_ainfo
, call
, target
);
2080 else if (virtual_method_call_p (target
))
2081 ipa_analyze_virtual_call_uses (node
, info
, call
, target
);
2085 /* Analyze the call statement STMT with respect to formal parameters (described
2086 in INFO) of caller given by NODE. Currently it only checks whether formal
2087 parameters are called. PARMS_AINFO is a pointer to a vector containing
2088 intermediate information about each formal parameter. */
2091 ipa_analyze_stmt_uses (struct cgraph_node
*node
, struct ipa_node_params
*info
,
2092 struct param_analysis_info
*parms_ainfo
, gimple stmt
)
2094 if (is_gimple_call (stmt
))
2095 ipa_analyze_call_uses (node
, info
, parms_ainfo
, stmt
);
2098 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
2099 If OP is a parameter declaration, mark it as used in the info structure
2103 visit_ref_for_mod_analysis (gimple
, tree op
, tree
, void *data
)
2105 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
2107 op
= get_base_address (op
);
2109 && TREE_CODE (op
) == PARM_DECL
)
2111 int index
= ipa_get_param_decl_index (info
, op
);
2112 gcc_assert (index
>= 0);
2113 ipa_set_param_used (info
, index
, true);
2119 /* Scan the function body of NODE and inspect the uses of formal parameters.
2120 Store the findings in various structures of the associated ipa_node_params
2121 structure, such as parameter flags, notes etc. PARMS_AINFO is a pointer to a
2122 vector containing intermediate information about each formal parameter. */
2125 ipa_analyze_params_uses (struct cgraph_node
*node
,
2126 struct param_analysis_info
*parms_ainfo
)
2128 tree decl
= node
->decl
;
2130 struct function
*func
;
2131 gimple_stmt_iterator gsi
;
2132 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2135 if (ipa_get_param_count (info
) == 0 || info
->uses_analysis_done
)
2138 info
->uses_analysis_done
= 1;
2139 if (ipa_func_spec_opts_forbid_analysis_p (node
))
2141 for (i
= 0; i
< ipa_get_param_count (info
); i
++)
2143 ipa_set_param_used (info
, i
, true);
2144 ipa_set_controlled_uses (info
, i
, IPA_UNDESCRIBED_USE
);
2149 for (i
= 0; i
< ipa_get_param_count (info
); i
++)
2151 tree parm
= ipa_get_param (info
, i
);
2152 int controlled_uses
= 0;
2154 /* For SSA regs see if parameter is used. For non-SSA we compute
2155 the flag during modification analysis. */
2156 if (is_gimple_reg (parm
))
2158 tree ddef
= ssa_default_def (DECL_STRUCT_FUNCTION (node
->decl
),
2160 if (ddef
&& !has_zero_uses (ddef
))
2162 imm_use_iterator imm_iter
;
2163 use_operand_p use_p
;
2165 ipa_set_param_used (info
, i
, true);
2166 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, ddef
)
2167 if (!is_gimple_call (USE_STMT (use_p
)))
2169 if (!is_gimple_debug (USE_STMT (use_p
)))
2171 controlled_uses
= IPA_UNDESCRIBED_USE
;
2179 controlled_uses
= 0;
2182 controlled_uses
= IPA_UNDESCRIBED_USE
;
2183 ipa_set_controlled_uses (info
, i
, controlled_uses
);
2186 func
= DECL_STRUCT_FUNCTION (decl
);
2187 FOR_EACH_BB_FN (bb
, func
)
2189 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2191 gimple stmt
= gsi_stmt (gsi
);
2193 if (is_gimple_debug (stmt
))
2196 ipa_analyze_stmt_uses (node
, info
, parms_ainfo
, stmt
);
2197 walk_stmt_load_store_addr_ops (stmt
, info
,
2198 visit_ref_for_mod_analysis
,
2199 visit_ref_for_mod_analysis
,
2200 visit_ref_for_mod_analysis
);
2202 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2203 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), info
,
2204 visit_ref_for_mod_analysis
,
2205 visit_ref_for_mod_analysis
,
2206 visit_ref_for_mod_analysis
);
2210 /* Free stuff in PARMS_AINFO, assume there are PARAM_COUNT parameters. */
2213 free_parms_ainfo (struct param_analysis_info
*parms_ainfo
, int param_count
)
2217 for (i
= 0; i
< param_count
; i
++)
2219 if (parms_ainfo
[i
].parm_visited_statements
)
2220 BITMAP_FREE (parms_ainfo
[i
].parm_visited_statements
);
2221 if (parms_ainfo
[i
].pt_visited_statements
)
2222 BITMAP_FREE (parms_ainfo
[i
].pt_visited_statements
);
2226 /* Initialize the array describing properties of of formal parameters
2227 of NODE, analyze their uses and compute jump functions associated
2228 with actual arguments of calls from within NODE. */
2231 ipa_analyze_node (struct cgraph_node
*node
)
2233 struct ipa_node_params
*info
;
2234 struct param_analysis_info
*parms_ainfo
;
2237 ipa_check_create_node_params ();
2238 ipa_check_create_edge_args ();
2239 info
= IPA_NODE_REF (node
);
2240 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
2241 ipa_initialize_node_params (node
);
2243 param_count
= ipa_get_param_count (info
);
2244 parms_ainfo
= XALLOCAVEC (struct param_analysis_info
, param_count
);
2245 memset (parms_ainfo
, 0, sizeof (struct param_analysis_info
) * param_count
);
2247 ipa_analyze_params_uses (node
, parms_ainfo
);
2248 ipa_compute_jump_functions (node
, parms_ainfo
);
2250 free_parms_ainfo (parms_ainfo
, param_count
);
2254 /* Given a statement CALL which must be a GIMPLE_CALL calling an OBJ_TYPE_REF
2255 attempt a type-based devirtualization. If successful, return the
2256 target function declaration, otherwise return NULL. */
2259 ipa_intraprocedural_devirtualization (gimple call
)
2261 tree binfo
, token
, fndecl
;
2262 struct ipa_jump_func jfunc
;
2263 tree otr
= gimple_call_fn (call
);
2265 jfunc
.type
= IPA_JF_UNKNOWN
;
2266 compute_known_type_jump_func (OBJ_TYPE_REF_OBJECT (otr
), &jfunc
,
2267 call
, obj_type_ref_class (otr
));
2268 if (jfunc
.type
!= IPA_JF_KNOWN_TYPE
)
2270 binfo
= ipa_binfo_from_known_type_jfunc (&jfunc
);
2273 token
= OBJ_TYPE_REF_TOKEN (otr
);
2274 fndecl
= gimple_get_virt_method_for_binfo (tree_to_uhwi (token
),
2276 #ifdef ENABLE_CHECKING
2278 gcc_assert (possible_polymorphic_call_target_p
2279 (otr
, cgraph_get_node (fndecl
)));
2284 /* Update the jump function DST when the call graph edge corresponding to SRC is
2285 is being inlined, knowing that DST is of type ancestor and src of known
2289 combine_known_type_and_ancestor_jfs (struct ipa_jump_func
*src
,
2290 struct ipa_jump_func
*dst
)
2292 HOST_WIDE_INT combined_offset
;
2295 if (!ipa_get_jf_ancestor_type_preserved (dst
))
2297 dst
->type
= IPA_JF_UNKNOWN
;
2301 combined_offset
= ipa_get_jf_known_type_offset (src
)
2302 + ipa_get_jf_ancestor_offset (dst
);
2303 combined_type
= ipa_get_jf_ancestor_type (dst
);
2305 ipa_set_jf_known_type (dst
, combined_offset
,
2306 ipa_get_jf_known_type_base_type (src
),
2310 /* Update the jump functions associated with call graph edge E when the call
2311 graph edge CS is being inlined, assuming that E->caller is already (possibly
2312 indirectly) inlined into CS->callee and that E has not been inlined. */
2315 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
2316 struct cgraph_edge
*e
)
2318 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
2319 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2320 int count
= ipa_get_cs_argument_count (args
);
2323 for (i
= 0; i
< count
; i
++)
2325 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
2327 if (dst
->type
== IPA_JF_ANCESTOR
)
2329 struct ipa_jump_func
*src
;
2330 int dst_fid
= dst
->value
.ancestor
.formal_id
;
2332 /* Variable number of arguments can cause havoc if we try to access
2333 one that does not exist in the inlined edge. So make sure we
2335 if (dst_fid
>= ipa_get_cs_argument_count (top
))
2337 dst
->type
= IPA_JF_UNKNOWN
;
2341 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2344 && (dst
->value
.ancestor
.agg_preserved
|| !src
->agg
.by_ref
))
2346 struct ipa_agg_jf_item
*item
;
2349 /* Currently we do not produce clobber aggregate jump functions,
2350 replace with merging when we do. */
2351 gcc_assert (!dst
->agg
.items
);
2353 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2354 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2355 FOR_EACH_VEC_SAFE_ELT (dst
->agg
.items
, j
, item
)
2356 item
->offset
-= dst
->value
.ancestor
.offset
;
2359 if (src
->type
== IPA_JF_KNOWN_TYPE
)
2360 combine_known_type_and_ancestor_jfs (src
, dst
);
2361 else if (src
->type
== IPA_JF_PASS_THROUGH
2362 && src
->value
.pass_through
.operation
== NOP_EXPR
)
2364 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
2365 dst
->value
.ancestor
.agg_preserved
&=
2366 src
->value
.pass_through
.agg_preserved
;
2367 dst
->value
.ancestor
.type_preserved
&=
2368 src
->value
.pass_through
.type_preserved
;
2370 else if (src
->type
== IPA_JF_ANCESTOR
)
2372 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
2373 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
2374 dst
->value
.ancestor
.agg_preserved
&=
2375 src
->value
.ancestor
.agg_preserved
;
2376 dst
->value
.ancestor
.type_preserved
&=
2377 src
->value
.ancestor
.type_preserved
;
2380 dst
->type
= IPA_JF_UNKNOWN
;
2382 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
2384 struct ipa_jump_func
*src
;
2385 /* We must check range due to calls with variable number of arguments
2386 and we cannot combine jump functions with operations. */
2387 if (dst
->value
.pass_through
.operation
== NOP_EXPR
2388 && (dst
->value
.pass_through
.formal_id
2389 < ipa_get_cs_argument_count (top
)))
2391 int dst_fid
= dst
->value
.pass_through
.formal_id
;
2392 src
= ipa_get_ith_jump_func (top
, dst_fid
);
2393 bool dst_agg_p
= ipa_get_jf_pass_through_agg_preserved (dst
);
2397 case IPA_JF_UNKNOWN
:
2398 dst
->type
= IPA_JF_UNKNOWN
;
2400 case IPA_JF_KNOWN_TYPE
:
2401 if (ipa_get_jf_pass_through_type_preserved (dst
))
2402 ipa_set_jf_known_type (dst
,
2403 ipa_get_jf_known_type_offset (src
),
2404 ipa_get_jf_known_type_base_type (src
),
2405 ipa_get_jf_known_type_component_type (src
));
2407 dst
->type
= IPA_JF_UNKNOWN
;
2410 ipa_set_jf_cst_copy (dst
, src
);
2413 case IPA_JF_PASS_THROUGH
:
2415 int formal_id
= ipa_get_jf_pass_through_formal_id (src
);
2416 enum tree_code operation
;
2417 operation
= ipa_get_jf_pass_through_operation (src
);
2419 if (operation
== NOP_EXPR
)
2423 && ipa_get_jf_pass_through_agg_preserved (src
);
2424 type_p
= ipa_get_jf_pass_through_type_preserved (src
)
2425 && ipa_get_jf_pass_through_type_preserved (dst
);
2426 ipa_set_jf_simple_pass_through (dst
, formal_id
,
2431 tree operand
= ipa_get_jf_pass_through_operand (src
);
2432 ipa_set_jf_arith_pass_through (dst
, formal_id
, operand
,
2437 case IPA_JF_ANCESTOR
:
2441 && ipa_get_jf_ancestor_agg_preserved (src
);
2442 type_p
= ipa_get_jf_ancestor_type_preserved (src
)
2443 && ipa_get_jf_pass_through_type_preserved (dst
);
2444 ipa_set_ancestor_jf (dst
,
2445 ipa_get_jf_ancestor_offset (src
),
2446 ipa_get_jf_ancestor_type (src
),
2447 ipa_get_jf_ancestor_formal_id (src
),
2456 && (dst_agg_p
|| !src
->agg
.by_ref
))
2458 /* Currently we do not produce clobber aggregate jump
2459 functions, replace with merging when we do. */
2460 gcc_assert (!dst
->agg
.items
);
2462 dst
->agg
.by_ref
= src
->agg
.by_ref
;
2463 dst
->agg
.items
= vec_safe_copy (src
->agg
.items
);
2467 dst
->type
= IPA_JF_UNKNOWN
;
2472 /* If TARGET is an addr_expr of a function declaration, make it the destination
2473 of an indirect edge IE and return the edge. Otherwise, return NULL. */
2475 struct cgraph_edge
*
2476 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
)
2478 struct cgraph_node
*callee
;
2479 struct inline_edge_summary
*es
= inline_edge_summary (ie
);
2480 bool unreachable
= false;
2482 if (TREE_CODE (target
) == ADDR_EXPR
)
2483 target
= TREE_OPERAND (target
, 0);
2484 if (TREE_CODE (target
) != FUNCTION_DECL
)
2486 target
= canonicalize_constructor_val (target
, NULL
);
2487 if (!target
|| TREE_CODE (target
) != FUNCTION_DECL
)
2489 if (ie
->indirect_info
->member_ptr
)
2490 /* Member pointer call that goes through a VMT lookup. */
2494 fprintf (dump_file
, "ipa-prop: Discovered direct call to non-function"
2495 " in %s/%i, making it unreachable.\n",
2496 ie
->caller
->name (), ie
->caller
->order
);
2497 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2498 callee
= cgraph_get_create_node (target
);
2502 callee
= cgraph_get_node (target
);
2505 callee
= cgraph_get_node (target
);
2507 /* Because may-edges are not explicitely represented and vtable may be external,
2508 we may create the first reference to the object in the unit. */
2509 if (!callee
|| callee
->global
.inlined_to
)
2512 /* We are better to ensure we can refer to it.
2513 In the case of static functions we are out of luck, since we already
2514 removed its body. In the case of public functions we may or may
2515 not introduce the reference. */
2516 if (!canonicalize_constructor_val (target
, NULL
)
2517 || !TREE_PUBLIC (target
))
2520 fprintf (dump_file
, "ipa-prop: Discovered call to a known target "
2521 "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n",
2522 xstrdup (ie
->caller
->name ()),
2524 xstrdup (ie
->callee
->name ()),
2528 callee
= cgraph_get_create_node (target
);
2530 ipa_check_create_node_params ();
2532 /* We can not make edges to inline clones. It is bug that someone removed
2533 the cgraph node too early. */
2534 gcc_assert (!callee
->global
.inlined_to
);
2536 if (dump_file
&& !unreachable
)
2538 fprintf (dump_file
, "ipa-prop: Discovered %s call to a known target "
2539 "(%s/%i -> %s/%i), for stmt ",
2540 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
2541 xstrdup (ie
->caller
->name ()),
2543 xstrdup (callee
->name ()),
2546 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
2548 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
2550 ie
= cgraph_make_edge_direct (ie
, callee
);
2551 es
= inline_edge_summary (ie
);
2552 es
->call_stmt_size
-= (eni_size_weights
.indirect_call_cost
2553 - eni_size_weights
.call_cost
);
2554 es
->call_stmt_time
-= (eni_time_weights
.indirect_call_cost
2555 - eni_time_weights
.call_cost
);
2560 /* Retrieve value from aggregate jump function AGG for the given OFFSET or
2561 return NULL if there is not any. BY_REF specifies whether the value has to
2562 be passed by reference or by value. */
2565 ipa_find_agg_cst_for_param (struct ipa_agg_jump_function
*agg
,
2566 HOST_WIDE_INT offset
, bool by_ref
)
2568 struct ipa_agg_jf_item
*item
;
2571 if (by_ref
!= agg
->by_ref
)
2574 FOR_EACH_VEC_SAFE_ELT (agg
->items
, i
, item
)
2575 if (item
->offset
== offset
)
2577 /* Currently we do not have clobber values, return NULL for them once
2579 gcc_checking_assert (is_gimple_ip_invariant (item
->value
));
2585 /* Remove a reference to SYMBOL from the list of references of a node given by
2586 reference description RDESC. Return true if the reference has been
2587 successfully found and removed. */
2590 remove_described_reference (symtab_node
*symbol
, struct ipa_cst_ref_desc
*rdesc
)
2592 struct ipa_ref
*to_del
;
2593 struct cgraph_edge
*origin
;
2598 to_del
= ipa_find_reference (origin
->caller
, symbol
,
2599 origin
->call_stmt
, origin
->lto_stmt_uid
);
2603 ipa_remove_reference (to_del
);
2605 fprintf (dump_file
, "ipa-prop: Removed a reference from %s/%i to %s.\n",
2606 xstrdup (origin
->caller
->name ()),
2607 origin
->caller
->order
, xstrdup (symbol
->name ()));
2611 /* If JFUNC has a reference description with refcount different from
2612 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
2613 NULL. JFUNC must be a constant jump function. */
2615 static struct ipa_cst_ref_desc
*
2616 jfunc_rdesc_usable (struct ipa_jump_func
*jfunc
)
2618 struct ipa_cst_ref_desc
*rdesc
= ipa_get_jf_constant_rdesc (jfunc
);
2619 if (rdesc
&& rdesc
->refcount
!= IPA_UNDESCRIBED_USE
)
2625 /* If the value of constant jump function JFUNC is an address of a function
2626 declaration, return the associated call graph node. Otherwise return
2629 static cgraph_node
*
2630 cgraph_node_for_jfunc (struct ipa_jump_func
*jfunc
)
2632 gcc_checking_assert (jfunc
->type
== IPA_JF_CONST
);
2633 tree cst
= ipa_get_jf_constant (jfunc
);
2634 if (TREE_CODE (cst
) != ADDR_EXPR
2635 || TREE_CODE (TREE_OPERAND (cst
, 0)) != FUNCTION_DECL
)
2638 return cgraph_get_node (TREE_OPERAND (cst
, 0));
2642 /* If JFUNC is a constant jump function with a usable rdesc, decrement its
2643 refcount and if it hits zero, remove reference to SYMBOL from the caller of
2644 the edge specified in the rdesc. Return false if either the symbol or the
2645 reference could not be found, otherwise return true. */
2648 try_decrement_rdesc_refcount (struct ipa_jump_func
*jfunc
)
2650 struct ipa_cst_ref_desc
*rdesc
;
2651 if (jfunc
->type
== IPA_JF_CONST
2652 && (rdesc
= jfunc_rdesc_usable (jfunc
))
2653 && --rdesc
->refcount
== 0)
2655 symtab_node
*symbol
= cgraph_node_for_jfunc (jfunc
);
2659 return remove_described_reference (symbol
, rdesc
);
2664 /* Try to find a destination for indirect edge IE that corresponds to a simple
2665 call or a call of a member function pointer and where the destination is a
2666 pointer formal parameter described by jump function JFUNC. If it can be
2667 determined, return the newly direct edge, otherwise return NULL.
2668 NEW_ROOT_INFO is the node info that JFUNC lattices are relative to. */
2670 static struct cgraph_edge
*
2671 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
2672 struct ipa_jump_func
*jfunc
,
2673 struct ipa_node_params
*new_root_info
)
2675 struct cgraph_edge
*cs
;
2677 bool agg_contents
= ie
->indirect_info
->agg_contents
;
2679 if (ie
->indirect_info
->agg_contents
)
2680 target
= ipa_find_agg_cst_for_param (&jfunc
->agg
,
2681 ie
->indirect_info
->offset
,
2682 ie
->indirect_info
->by_ref
);
2684 target
= ipa_value_from_jfunc (new_root_info
, jfunc
);
2687 cs
= ipa_make_edge_direct_to_target (ie
, target
);
2689 if (cs
&& !agg_contents
)
2692 gcc_checking_assert (cs
->callee
2694 || jfunc
->type
!= IPA_JF_CONST
2695 || !cgraph_node_for_jfunc (jfunc
)
2696 || cs
->callee
== cgraph_node_for_jfunc (jfunc
)));
2697 ok
= try_decrement_rdesc_refcount (jfunc
);
2698 gcc_checking_assert (ok
);
2704 /* Try to find a destination for indirect edge IE that corresponds to a virtual
2705 call based on a formal parameter which is described by jump function JFUNC
2706 and if it can be determined, make it direct and return the direct edge.
2707 Otherwise, return NULL. NEW_ROOT_INFO is the node info that JFUNC lattices
2710 static struct cgraph_edge
*
2711 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
2712 struct ipa_jump_func
*jfunc
,
2713 struct ipa_node_params
*new_root_info
)
2717 if (!flag_devirtualize
)
2720 /* First try to do lookup via known virtual table pointer value. */
2721 if (!ie
->indirect_info
->by_ref
)
2724 unsigned HOST_WIDE_INT offset
;
2725 tree t
= ipa_find_agg_cst_for_param (&jfunc
->agg
,
2726 ie
->indirect_info
->offset
,
2728 if (t
&& vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
2730 target
= gimple_get_virt_method_for_vtable (ie
->indirect_info
->otr_token
,
2734 if ((TREE_CODE (TREE_TYPE (target
)) == FUNCTION_TYPE
2735 && DECL_FUNCTION_CODE (target
) == BUILT_IN_UNREACHABLE
)
2736 || !possible_polymorphic_call_target_p
2737 (ie
, cgraph_get_node (target
)))
2741 "Type inconsident devirtualization: %s/%i->%s\n",
2742 ie
->caller
->name (), ie
->caller
->order
,
2743 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target
)));
2744 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2745 cgraph_get_create_node (target
);
2747 return ipa_make_edge_direct_to_target (ie
, target
);
2752 binfo
= ipa_value_from_jfunc (new_root_info
, jfunc
);
2757 if (TREE_CODE (binfo
) != TREE_BINFO
)
2759 ipa_polymorphic_call_context context
;
2760 vec
<cgraph_node
*>targets
;
2763 if (!get_polymorphic_call_info_from_invariant
2764 (&context
, binfo
, ie
->indirect_info
->otr_type
,
2765 ie
->indirect_info
->offset
))
2767 targets
= possible_polymorphic_call_targets
2768 (ie
->indirect_info
->otr_type
,
2769 ie
->indirect_info
->otr_token
,
2771 if (!final
|| targets
.length () > 1)
2773 if (targets
.length () == 1)
2774 target
= targets
[0]->decl
;
2777 target
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
2778 cgraph_get_create_node (target
);
2783 binfo
= get_binfo_at_offset (binfo
, ie
->indirect_info
->offset
,
2784 ie
->indirect_info
->otr_type
);
2786 target
= gimple_get_virt_method_for_binfo (ie
->indirect_info
->otr_token
,
2794 #ifdef ENABLE_CHECKING
2795 gcc_assert (possible_polymorphic_call_target_p
2796 (ie
, cgraph_get_node (target
)));
2798 return ipa_make_edge_direct_to_target (ie
, target
);
2804 /* Update the param called notes associated with NODE when CS is being inlined,
2805 assuming NODE is (potentially indirectly) inlined into CS->callee.
2806 Moreover, if the callee is discovered to be constant, create a new cgraph
2807 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
2808 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
2811 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
2812 struct cgraph_node
*node
,
2813 vec
<cgraph_edge_p
> *new_edges
)
2815 struct ipa_edge_args
*top
;
2816 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
2817 struct ipa_node_params
*new_root_info
;
2820 ipa_check_create_edge_args ();
2821 top
= IPA_EDGE_REF (cs
);
2822 new_root_info
= IPA_NODE_REF (cs
->caller
->global
.inlined_to
2823 ? cs
->caller
->global
.inlined_to
2826 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
2828 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
2829 struct ipa_jump_func
*jfunc
;
2832 next_ie
= ie
->next_callee
;
2834 if (ici
->param_index
== -1)
2837 /* We must check range due to calls with variable number of arguments: */
2838 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
2840 ici
->param_index
= -1;
2844 param_index
= ici
->param_index
;
2845 jfunc
= ipa_get_ith_jump_func (top
, param_index
);
2847 if (!flag_indirect_inlining
)
2848 new_direct_edge
= NULL
;
2849 else if (ici
->polymorphic
)
2850 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
,
2853 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
,
2855 /* If speculation was removed, then we need to do nothing. */
2856 if (new_direct_edge
&& new_direct_edge
!= ie
)
2858 new_direct_edge
->indirect_inlining_edge
= 1;
2859 top
= IPA_EDGE_REF (cs
);
2862 else if (new_direct_edge
)
2864 new_direct_edge
->indirect_inlining_edge
= 1;
2865 if (new_direct_edge
->call_stmt
)
2866 new_direct_edge
->call_stmt_cannot_inline_p
2867 = !gimple_check_call_matching_types (
2868 new_direct_edge
->call_stmt
,
2869 new_direct_edge
->callee
->decl
, false);
2872 new_edges
->safe_push (new_direct_edge
);
2875 top
= IPA_EDGE_REF (cs
);
2877 else if (jfunc
->type
== IPA_JF_PASS_THROUGH
2878 && ipa_get_jf_pass_through_operation (jfunc
) == NOP_EXPR
)
2880 if (ici
->agg_contents
2881 && !ipa_get_jf_pass_through_agg_preserved (jfunc
))
2882 ici
->param_index
= -1;
2884 ici
->param_index
= ipa_get_jf_pass_through_formal_id (jfunc
);
2886 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
2888 if (ici
->agg_contents
2889 && !ipa_get_jf_ancestor_agg_preserved (jfunc
))
2890 ici
->param_index
= -1;
2893 ici
->param_index
= ipa_get_jf_ancestor_formal_id (jfunc
);
2894 if (ipa_get_jf_ancestor_offset (jfunc
))
2895 ici
->outer_type
= NULL
;
2896 ici
->offset
+= ipa_get_jf_ancestor_offset (jfunc
);
2900 /* Either we can find a destination for this edge now or never. */
2901 ici
->param_index
= -1;
2907 /* Recursively traverse subtree of NODE (including node) made of inlined
2908 cgraph_edges when CS has been inlined and invoke
2909 update_indirect_edges_after_inlining on all nodes and
2910 update_jump_functions_after_inlining on all non-inlined edges that lead out
2911 of this subtree. Newly discovered indirect edges will be added to
2912 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
2916 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
2917 struct cgraph_node
*node
,
2918 vec
<cgraph_edge_p
> *new_edges
)
2920 struct cgraph_edge
*e
;
2923 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
2925 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2926 if (!e
->inline_failed
)
2927 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
2929 update_jump_functions_after_inlining (cs
, e
);
2930 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2931 update_jump_functions_after_inlining (cs
, e
);
2936 /* Combine two controlled uses counts as done during inlining. */
2939 combine_controlled_uses_counters (int c
, int d
)
2941 if (c
== IPA_UNDESCRIBED_USE
|| d
== IPA_UNDESCRIBED_USE
)
2942 return IPA_UNDESCRIBED_USE
;
2947 /* Propagate number of controlled users from CS->caleee to the new root of the
2948 tree of inlined nodes. */
2951 propagate_controlled_uses (struct cgraph_edge
*cs
)
2953 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
2954 struct cgraph_node
*new_root
= cs
->caller
->global
.inlined_to
2955 ? cs
->caller
->global
.inlined_to
: cs
->caller
;
2956 struct ipa_node_params
*new_root_info
= IPA_NODE_REF (new_root
);
2957 struct ipa_node_params
*old_root_info
= IPA_NODE_REF (cs
->callee
);
2960 count
= MIN (ipa_get_cs_argument_count (args
),
2961 ipa_get_param_count (old_root_info
));
2962 for (i
= 0; i
< count
; i
++)
2964 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
2965 struct ipa_cst_ref_desc
*rdesc
;
2967 if (jf
->type
== IPA_JF_PASS_THROUGH
)
2970 src_idx
= ipa_get_jf_pass_through_formal_id (jf
);
2971 c
= ipa_get_controlled_uses (new_root_info
, src_idx
);
2972 d
= ipa_get_controlled_uses (old_root_info
, i
);
2974 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf
)
2975 == NOP_EXPR
|| c
== IPA_UNDESCRIBED_USE
);
2976 c
= combine_controlled_uses_counters (c
, d
);
2977 ipa_set_controlled_uses (new_root_info
, src_idx
, c
);
2978 if (c
== 0 && new_root_info
->ipcp_orig_node
)
2980 struct cgraph_node
*n
;
2981 struct ipa_ref
*ref
;
2982 tree t
= new_root_info
->known_vals
[src_idx
];
2984 if (t
&& TREE_CODE (t
) == ADDR_EXPR
2985 && TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2986 && (n
= cgraph_get_node (TREE_OPERAND (t
, 0)))
2987 && (ref
= ipa_find_reference (new_root
,
2991 fprintf (dump_file
, "ipa-prop: Removing cloning-created "
2992 "reference from %s/%i to %s/%i.\n",
2993 xstrdup (new_root
->name ()),
2995 xstrdup (n
->name ()), n
->order
);
2996 ipa_remove_reference (ref
);
3000 else if (jf
->type
== IPA_JF_CONST
3001 && (rdesc
= jfunc_rdesc_usable (jf
)))
3003 int d
= ipa_get_controlled_uses (old_root_info
, i
);
3004 int c
= rdesc
->refcount
;
3005 rdesc
->refcount
= combine_controlled_uses_counters (c
, d
);
3006 if (rdesc
->refcount
== 0)
3008 tree cst
= ipa_get_jf_constant (jf
);
3009 struct cgraph_node
*n
;
3010 gcc_checking_assert (TREE_CODE (cst
) == ADDR_EXPR
3011 && TREE_CODE (TREE_OPERAND (cst
, 0))
3013 n
= cgraph_get_node (TREE_OPERAND (cst
, 0));
3016 struct cgraph_node
*clone
;
3018 ok
= remove_described_reference (n
, rdesc
);
3019 gcc_checking_assert (ok
);
3022 while (clone
->global
.inlined_to
3023 && clone
!= rdesc
->cs
->caller
3024 && IPA_NODE_REF (clone
)->ipcp_orig_node
)
3026 struct ipa_ref
*ref
;
3027 ref
= ipa_find_reference (clone
,
3032 fprintf (dump_file
, "ipa-prop: Removing "
3033 "cloning-created reference "
3034 "from %s/%i to %s/%i.\n",
3035 xstrdup (clone
->name ()),
3037 xstrdup (n
->name ()),
3039 ipa_remove_reference (ref
);
3041 clone
= clone
->callers
->caller
;
3048 for (i
= ipa_get_param_count (old_root_info
);
3049 i
< ipa_get_cs_argument_count (args
);
3052 struct ipa_jump_func
*jf
= ipa_get_ith_jump_func (args
, i
);
3054 if (jf
->type
== IPA_JF_CONST
)
3056 struct ipa_cst_ref_desc
*rdesc
= jfunc_rdesc_usable (jf
);
3058 rdesc
->refcount
= IPA_UNDESCRIBED_USE
;
3060 else if (jf
->type
== IPA_JF_PASS_THROUGH
)
3061 ipa_set_controlled_uses (new_root_info
,
3062 jf
->value
.pass_through
.formal_id
,
3063 IPA_UNDESCRIBED_USE
);
3067 /* Update jump functions and call note functions on inlining the call site CS.
3068 CS is expected to lead to a node already cloned by
3069 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
3070 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
3074 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
3075 vec
<cgraph_edge_p
> *new_edges
)
3078 /* Do nothing if the preparation phase has not been carried out yet
3079 (i.e. during early inlining). */
3080 if (!ipa_node_params_vector
.exists ())
3082 gcc_assert (ipa_edge_args_vector
);
3084 propagate_controlled_uses (cs
);
3085 changed
= propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
3090 /* Frees all dynamically allocated structures that the argument info points
3094 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
3096 vec_free (args
->jump_functions
);
3097 memset (args
, 0, sizeof (*args
));
3100 /* Free all ipa_edge structures. */
3103 ipa_free_all_edge_args (void)
3106 struct ipa_edge_args
*args
;
3108 if (!ipa_edge_args_vector
)
3111 FOR_EACH_VEC_ELT (*ipa_edge_args_vector
, i
, args
)
3112 ipa_free_edge_args_substructures (args
);
3114 vec_free (ipa_edge_args_vector
);
3117 /* Frees all dynamically allocated structures that the param info points
3121 ipa_free_node_params_substructures (struct ipa_node_params
*info
)
3123 info
->descriptors
.release ();
3124 free (info
->lattices
);
3125 /* Lattice values and their sources are deallocated with their alocation
3127 info
->known_vals
.release ();
3128 memset (info
, 0, sizeof (*info
));
3131 /* Free all ipa_node_params structures. */
3134 ipa_free_all_node_params (void)
3137 struct ipa_node_params
*info
;
3139 FOR_EACH_VEC_ELT (ipa_node_params_vector
, i
, info
)
3140 ipa_free_node_params_substructures (info
);
3142 ipa_node_params_vector
.release ();
3145 /* Set the aggregate replacements of NODE to be AGGVALS. */
3148 ipa_set_node_agg_value_chain (struct cgraph_node
*node
,
3149 struct ipa_agg_replacement_value
*aggvals
)
3151 if (vec_safe_length (ipa_node_agg_replacements
) <= (unsigned) cgraph_max_uid
)
3152 vec_safe_grow_cleared (ipa_node_agg_replacements
, cgraph_max_uid
+ 1);
3154 (*ipa_node_agg_replacements
)[node
->uid
] = aggvals
;
3157 /* Hook that is called by cgraph.c when an edge is removed. */
3160 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
3162 struct ipa_edge_args
*args
;
3164 /* During IPA-CP updating we can be called on not-yet analyzed clones. */
3165 if (vec_safe_length (ipa_edge_args_vector
) <= (unsigned)cs
->uid
)
3168 args
= IPA_EDGE_REF (cs
);
3169 if (args
->jump_functions
)
3171 struct ipa_jump_func
*jf
;
3173 FOR_EACH_VEC_ELT (*args
->jump_functions
, i
, jf
)
3175 struct ipa_cst_ref_desc
*rdesc
;
3176 try_decrement_rdesc_refcount (jf
);
3177 if (jf
->type
== IPA_JF_CONST
3178 && (rdesc
= ipa_get_jf_constant_rdesc (jf
))
3184 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
3187 /* Hook that is called by cgraph.c when a node is removed. */
3190 ipa_node_removal_hook (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3192 /* During IPA-CP updating we can be called on not-yet analyze clones. */
3193 if (ipa_node_params_vector
.length () > (unsigned)node
->uid
)
3194 ipa_free_node_params_substructures (IPA_NODE_REF (node
));
3195 if (vec_safe_length (ipa_node_agg_replacements
) > (unsigned)node
->uid
)
3196 (*ipa_node_agg_replacements
)[(unsigned)node
->uid
] = NULL
;
3199 /* Hook that is called by cgraph.c when an edge is duplicated. */
3202 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
3203 __attribute__((unused
)) void *data
)
3205 struct ipa_edge_args
*old_args
, *new_args
;
3208 ipa_check_create_edge_args ();
3210 old_args
= IPA_EDGE_REF (src
);
3211 new_args
= IPA_EDGE_REF (dst
);
3213 new_args
->jump_functions
= vec_safe_copy (old_args
->jump_functions
);
3215 for (i
= 0; i
< vec_safe_length (old_args
->jump_functions
); i
++)
3217 struct ipa_jump_func
*src_jf
= ipa_get_ith_jump_func (old_args
, i
);
3218 struct ipa_jump_func
*dst_jf
= ipa_get_ith_jump_func (new_args
, i
);
3220 dst_jf
->agg
.items
= vec_safe_copy (dst_jf
->agg
.items
);
3222 if (src_jf
->type
== IPA_JF_CONST
)
3224 struct ipa_cst_ref_desc
*src_rdesc
= jfunc_rdesc_usable (src_jf
);
3227 dst_jf
->value
.constant
.rdesc
= NULL
;
3228 else if (src
->caller
== dst
->caller
)
3230 struct ipa_ref
*ref
;
3231 symtab_node
*n
= cgraph_node_for_jfunc (src_jf
);
3232 gcc_checking_assert (n
);
3233 ref
= ipa_find_reference (src
->caller
, n
,
3234 src
->call_stmt
, src
->lto_stmt_uid
);
3235 gcc_checking_assert (ref
);
3236 ipa_clone_ref (ref
, dst
->caller
, ref
->stmt
);
3238 gcc_checking_assert (ipa_refdesc_pool
);
3239 struct ipa_cst_ref_desc
*dst_rdesc
3240 = (struct ipa_cst_ref_desc
*) pool_alloc (ipa_refdesc_pool
);
3241 dst_rdesc
->cs
= dst
;
3242 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3243 dst_rdesc
->next_duplicate
= NULL
;
3244 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3246 else if (src_rdesc
->cs
== src
)
3248 struct ipa_cst_ref_desc
*dst_rdesc
;
3249 gcc_checking_assert (ipa_refdesc_pool
);
3251 = (struct ipa_cst_ref_desc
*) pool_alloc (ipa_refdesc_pool
);
3252 dst_rdesc
->cs
= dst
;
3253 dst_rdesc
->refcount
= src_rdesc
->refcount
;
3254 dst_rdesc
->next_duplicate
= src_rdesc
->next_duplicate
;
3255 src_rdesc
->next_duplicate
= dst_rdesc
;
3256 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3260 struct ipa_cst_ref_desc
*dst_rdesc
;
3261 /* This can happen during inlining, when a JFUNC can refer to a
3262 reference taken in a function up in the tree of inline clones.
3263 We need to find the duplicate that refers to our tree of
3266 gcc_assert (dst
->caller
->global
.inlined_to
);
3267 for (dst_rdesc
= src_rdesc
->next_duplicate
;
3269 dst_rdesc
= dst_rdesc
->next_duplicate
)
3271 struct cgraph_node
*top
;
3272 top
= dst_rdesc
->cs
->caller
->global
.inlined_to
3273 ? dst_rdesc
->cs
->caller
->global
.inlined_to
3274 : dst_rdesc
->cs
->caller
;
3275 if (dst
->caller
->global
.inlined_to
== top
)
3278 gcc_assert (dst_rdesc
);
3279 dst_jf
->value
.constant
.rdesc
= dst_rdesc
;
3285 /* Hook that is called by cgraph.c when a node is duplicated. */
3288 ipa_node_duplication_hook (struct cgraph_node
*src
, struct cgraph_node
*dst
,
3289 ATTRIBUTE_UNUSED
void *data
)
3291 struct ipa_node_params
*old_info
, *new_info
;
3292 struct ipa_agg_replacement_value
*old_av
, *new_av
;
3294 ipa_check_create_node_params ();
3295 old_info
= IPA_NODE_REF (src
);
3296 new_info
= IPA_NODE_REF (dst
);
3298 new_info
->descriptors
= old_info
->descriptors
.copy ();
3299 new_info
->lattices
= NULL
;
3300 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
3302 new_info
->uses_analysis_done
= old_info
->uses_analysis_done
;
3303 new_info
->node_enqueued
= old_info
->node_enqueued
;
3305 old_av
= ipa_get_agg_replacements_for_node (src
);
3312 struct ipa_agg_replacement_value
*v
;
3314 v
= ggc_alloc_ipa_agg_replacement_value ();
3315 memcpy (v
, old_av
, sizeof (*v
));
3318 old_av
= old_av
->next
;
3320 ipa_set_node_agg_value_chain (dst
, new_av
);
3324 /* Analyze newly added function into callgraph. */
3327 ipa_add_new_function (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3329 if (cgraph_function_with_gimple_body_p (node
))
3330 ipa_analyze_node (node
);
3333 /* Register our cgraph hooks if they are not already there. */
3336 ipa_register_cgraph_hooks (void)
3338 if (!edge_removal_hook_holder
)
3339 edge_removal_hook_holder
=
3340 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
3341 if (!node_removal_hook_holder
)
3342 node_removal_hook_holder
=
3343 cgraph_add_node_removal_hook (&ipa_node_removal_hook
, NULL
);
3344 if (!edge_duplication_hook_holder
)
3345 edge_duplication_hook_holder
=
3346 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
3347 if (!node_duplication_hook_holder
)
3348 node_duplication_hook_holder
=
3349 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook
, NULL
);
3350 function_insertion_hook_holder
=
3351 cgraph_add_function_insertion_hook (&ipa_add_new_function
, NULL
);
3354 /* Unregister our cgraph hooks if they are not already there. */
3357 ipa_unregister_cgraph_hooks (void)
3359 cgraph_remove_edge_removal_hook (edge_removal_hook_holder
);
3360 edge_removal_hook_holder
= NULL
;
3361 cgraph_remove_node_removal_hook (node_removal_hook_holder
);
3362 node_removal_hook_holder
= NULL
;
3363 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder
);
3364 edge_duplication_hook_holder
= NULL
;
3365 cgraph_remove_node_duplication_hook (node_duplication_hook_holder
);
3366 node_duplication_hook_holder
= NULL
;
3367 cgraph_remove_function_insertion_hook (function_insertion_hook_holder
);
3368 function_insertion_hook_holder
= NULL
;
3371 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3372 longer needed after ipa-cp. */
3375 ipa_free_all_structures_after_ipa_cp (void)
3379 ipa_free_all_edge_args ();
3380 ipa_free_all_node_params ();
3381 free_alloc_pool (ipcp_sources_pool
);
3382 free_alloc_pool (ipcp_values_pool
);
3383 free_alloc_pool (ipcp_agg_lattice_pool
);
3384 ipa_unregister_cgraph_hooks ();
3385 if (ipa_refdesc_pool
)
3386 free_alloc_pool (ipa_refdesc_pool
);
3390 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
3391 longer needed after indirect inlining. */
3394 ipa_free_all_structures_after_iinln (void)
3396 ipa_free_all_edge_args ();
3397 ipa_free_all_node_params ();
3398 ipa_unregister_cgraph_hooks ();
3399 if (ipcp_sources_pool
)
3400 free_alloc_pool (ipcp_sources_pool
);
3401 if (ipcp_values_pool
)
3402 free_alloc_pool (ipcp_values_pool
);
3403 if (ipcp_agg_lattice_pool
)
3404 free_alloc_pool (ipcp_agg_lattice_pool
);
3405 if (ipa_refdesc_pool
)
3406 free_alloc_pool (ipa_refdesc_pool
);
3409 /* Print ipa_tree_map data structures of all functions in the
3413 ipa_print_node_params (FILE *f
, struct cgraph_node
*node
)
3416 struct ipa_node_params
*info
;
3418 if (!node
->definition
)
3420 info
= IPA_NODE_REF (node
);
3421 fprintf (f
, " function %s/%i parameter descriptors:\n",
3422 node
->name (), node
->order
);
3423 count
= ipa_get_param_count (info
);
3424 for (i
= 0; i
< count
; i
++)
3429 ipa_dump_param (f
, info
, i
);
3430 if (ipa_is_param_used (info
, i
))
3431 fprintf (f
, " used");
3432 c
= ipa_get_controlled_uses (info
, i
);
3433 if (c
== IPA_UNDESCRIBED_USE
)
3434 fprintf (f
, " undescribed_use");
3436 fprintf (f
, " controlled_uses=%i", c
);
3441 /* Print ipa_tree_map data structures of all functions in the
3445 ipa_print_all_params (FILE * f
)
3447 struct cgraph_node
*node
;
3449 fprintf (f
, "\nFunction parameters:\n");
3450 FOR_EACH_FUNCTION (node
)
3451 ipa_print_node_params (f
, node
);
3454 /* Return a heap allocated vector containing formal parameters of FNDECL. */
3457 ipa_get_vector_of_formal_parms (tree fndecl
)
3463 gcc_assert (!flag_wpa
);
3464 count
= count_formal_params (fndecl
);
3465 args
.create (count
);
3466 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
3467 args
.quick_push (parm
);
3472 /* Return a heap allocated vector containing types of formal parameters of
3473 function type FNTYPE. */
3476 ipa_get_vector_of_formal_parm_types (tree fntype
)
3482 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3485 types
.create (count
);
3486 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
3487 types
.quick_push (TREE_VALUE (t
));
3492 /* Modify the function declaration FNDECL and its type according to the plan in
3493 ADJUSTMENTS. It also sets base fields of individual adjustments structures
3494 to reflect the actual parameters being modified which are determined by the
3495 base_index field. */
3498 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
)
3500 vec
<tree
> oparms
= ipa_get_vector_of_formal_parms (fndecl
);
3501 tree orig_type
= TREE_TYPE (fndecl
);
3502 tree old_arg_types
= TYPE_ARG_TYPES (orig_type
);
3504 /* The following test is an ugly hack, some functions simply don't have any
3505 arguments in their type. This is probably a bug but well... */
3506 bool care_for_types
= (old_arg_types
!= NULL_TREE
);
3507 bool last_parm_void
;
3511 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
3513 otypes
= ipa_get_vector_of_formal_parm_types (orig_type
);
3515 gcc_assert (oparms
.length () + 1 == otypes
.length ());
3517 gcc_assert (oparms
.length () == otypes
.length ());
3521 last_parm_void
= false;
3525 int len
= adjustments
.length ();
3526 tree
*link
= &DECL_ARGUMENTS (fndecl
);
3527 tree new_arg_types
= NULL
;
3528 for (int i
= 0; i
< len
; i
++)
3530 struct ipa_parm_adjustment
*adj
;
3533 adj
= &adjustments
[i
];
3535 if (adj
->op
== IPA_PARM_OP_NEW
)
3538 parm
= oparms
[adj
->base_index
];
3541 if (adj
->op
== IPA_PARM_OP_COPY
)
3544 new_arg_types
= tree_cons (NULL_TREE
, otypes
[adj
->base_index
],
3547 link
= &DECL_CHAIN (parm
);
3549 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
3555 ptype
= build_pointer_type (adj
->type
);
3559 if (is_gimple_reg_type (ptype
))
3561 unsigned malign
= GET_MODE_ALIGNMENT (TYPE_MODE (ptype
));
3562 if (TYPE_ALIGN (ptype
) < malign
)
3563 ptype
= build_aligned_type (ptype
, malign
);
3568 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
3570 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
3572 const char *prefix
= adj
->arg_prefix
? adj
->arg_prefix
: "SYNTH";
3573 DECL_NAME (new_parm
) = create_tmp_var_name (prefix
);
3574 DECL_ARTIFICIAL (new_parm
) = 1;
3575 DECL_ARG_TYPE (new_parm
) = ptype
;
3576 DECL_CONTEXT (new_parm
) = fndecl
;
3577 TREE_USED (new_parm
) = 1;
3578 DECL_IGNORED_P (new_parm
) = 1;
3579 layout_decl (new_parm
, 0);
3581 if (adj
->op
== IPA_PARM_OP_NEW
)
3585 adj
->new_decl
= new_parm
;
3588 link
= &DECL_CHAIN (new_parm
);
3594 tree new_reversed
= NULL
;
3597 new_reversed
= nreverse (new_arg_types
);
3601 TREE_CHAIN (new_arg_types
) = void_list_node
;
3603 new_reversed
= void_list_node
;
3607 /* Use copy_node to preserve as much as possible from original type
3608 (debug info, attribute lists etc.)
3609 Exception is METHOD_TYPEs must have THIS argument.
3610 When we are asked to remove it, we need to build new FUNCTION_TYPE
3612 tree new_type
= NULL
;
3613 if (TREE_CODE (orig_type
) != METHOD_TYPE
3614 || (adjustments
[0].op
== IPA_PARM_OP_COPY
3615 && adjustments
[0].base_index
== 0))
3617 new_type
= build_distinct_type_copy (orig_type
);
3618 TYPE_ARG_TYPES (new_type
) = new_reversed
;
3623 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
3625 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
3626 DECL_VINDEX (fndecl
) = NULL_TREE
;
3629 /* When signature changes, we need to clear builtin info. */
3630 if (DECL_BUILT_IN (fndecl
))
3632 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
3633 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
3636 /* This is a new type, not a copy of an old type. Need to reassociate
3637 variants. We can handle everything except the main variant lazily. */
3638 tree t
= TYPE_MAIN_VARIANT (orig_type
);
3641 TYPE_MAIN_VARIANT (new_type
) = t
;
3642 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
3643 TYPE_NEXT_VARIANT (t
) = new_type
;
3647 TYPE_MAIN_VARIANT (new_type
) = new_type
;
3648 TYPE_NEXT_VARIANT (new_type
) = NULL
;
3651 TREE_TYPE (fndecl
) = new_type
;
3652 DECL_VIRTUAL_P (fndecl
) = 0;
3653 DECL_LANG_SPECIFIC (fndecl
) = NULL
;
3658 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
3659 If this is a directly recursive call, CS must be NULL. Otherwise it must
3660 contain the corresponding call graph edge. */
3663 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gimple stmt
,
3664 ipa_parm_adjustment_vec adjustments
)
3666 struct cgraph_node
*current_node
= cgraph_get_node (current_function_decl
);
3668 vec
<tree
, va_gc
> **debug_args
= NULL
;
3670 gimple_stmt_iterator gsi
, prev_gsi
;
3674 len
= adjustments
.length ();
3676 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
3677 ipa_remove_stmt_references (current_node
, stmt
);
3679 gsi
= gsi_for_stmt (stmt
);
3681 gsi_prev (&prev_gsi
);
3682 for (i
= 0; i
< len
; i
++)
3684 struct ipa_parm_adjustment
*adj
;
3686 adj
= &adjustments
[i
];
3688 if (adj
->op
== IPA_PARM_OP_COPY
)
3690 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
3692 vargs
.quick_push (arg
);
3694 else if (adj
->op
!= IPA_PARM_OP_REMOVE
)
3696 tree expr
, base
, off
;
3698 unsigned int deref_align
= 0;
3699 bool deref_base
= false;
3701 /* We create a new parameter out of the value of the old one, we can
3702 do the following kind of transformations:
3704 - A scalar passed by reference is converted to a scalar passed by
3705 value. (adj->by_ref is false and the type of the original
3706 actual argument is a pointer to a scalar).
3708 - A part of an aggregate is passed instead of the whole aggregate.
3709 The part can be passed either by value or by reference, this is
3710 determined by value of adj->by_ref. Moreover, the code below
3711 handles both situations when the original aggregate is passed by
3712 value (its type is not a pointer) and when it is passed by
3713 reference (it is a pointer to an aggregate).
3715 When the new argument is passed by reference (adj->by_ref is true)
3716 it must be a part of an aggregate and therefore we form it by
3717 simply taking the address of a reference inside the original
3720 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
3721 base
= gimple_call_arg (stmt
, adj
->base_index
);
3722 loc
= DECL_P (base
) ? DECL_SOURCE_LOCATION (base
)
3723 : EXPR_LOCATION (base
);
3725 if (TREE_CODE (base
) != ADDR_EXPR
3726 && POINTER_TYPE_P (TREE_TYPE (base
)))
3727 off
= build_int_cst (adj
->alias_ptr_type
,
3728 adj
->offset
/ BITS_PER_UNIT
);
3731 HOST_WIDE_INT base_offset
;
3735 if (TREE_CODE (base
) == ADDR_EXPR
)
3737 base
= TREE_OPERAND (base
, 0);
3743 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
3744 /* Aggregate arguments can have non-invariant addresses. */
3747 base
= build_fold_addr_expr (prev_base
);
3748 off
= build_int_cst (adj
->alias_ptr_type
,
3749 adj
->offset
/ BITS_PER_UNIT
);
3751 else if (TREE_CODE (base
) == MEM_REF
)
3756 deref_align
= TYPE_ALIGN (TREE_TYPE (base
));
3758 off
= build_int_cst (adj
->alias_ptr_type
,
3760 + adj
->offset
/ BITS_PER_UNIT
);
3761 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
3763 base
= TREE_OPERAND (base
, 0);
3767 off
= build_int_cst (adj
->alias_ptr_type
,
3769 + adj
->offset
/ BITS_PER_UNIT
);
3770 base
= build_fold_addr_expr (base
);
3776 tree type
= adj
->type
;
3778 unsigned HOST_WIDE_INT misalign
;
3782 align
= deref_align
;
3787 get_pointer_alignment_1 (base
, &align
, &misalign
);
3788 if (TYPE_ALIGN (type
) > align
)
3789 align
= TYPE_ALIGN (type
);
3791 misalign
+= (offset_int::from (off
, SIGNED
).to_short_addr ()
3793 misalign
= misalign
& (align
- 1);
3795 align
= (misalign
& -misalign
);
3796 if (align
< TYPE_ALIGN (type
))
3797 type
= build_aligned_type (type
, align
);
3798 base
= force_gimple_operand_gsi (&gsi
, base
,
3799 true, NULL
, true, GSI_SAME_STMT
);
3800 expr
= fold_build2_loc (loc
, MEM_REF
, type
, base
, off
);
3801 /* If expr is not a valid gimple call argument emit
3802 a load into a temporary. */
3803 if (is_gimple_reg_type (TREE_TYPE (expr
)))
3805 gimple tem
= gimple_build_assign (NULL_TREE
, expr
);
3806 if (gimple_in_ssa_p (cfun
))
3808 gimple_set_vuse (tem
, gimple_vuse (stmt
));
3809 expr
= make_ssa_name (TREE_TYPE (expr
), tem
);
3812 expr
= create_tmp_reg (TREE_TYPE (expr
), NULL
);
3813 gimple_assign_set_lhs (tem
, expr
);
3814 gsi_insert_before (&gsi
, tem
, GSI_SAME_STMT
);
3819 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
3820 expr
= build_fold_addr_expr (expr
);
3821 expr
= force_gimple_operand_gsi (&gsi
, expr
,
3822 true, NULL
, true, GSI_SAME_STMT
);
3824 vargs
.quick_push (expr
);
3826 if (adj
->op
!= IPA_PARM_OP_COPY
&& MAY_HAVE_DEBUG_STMTS
)
3829 tree ddecl
= NULL_TREE
, origin
= DECL_ORIGIN (adj
->base
), arg
;
3832 arg
= gimple_call_arg (stmt
, adj
->base_index
);
3833 if (!useless_type_conversion_p (TREE_TYPE (origin
), TREE_TYPE (arg
)))
3835 if (!fold_convertible_p (TREE_TYPE (origin
), arg
))
3837 arg
= fold_convert_loc (gimple_location (stmt
),
3838 TREE_TYPE (origin
), arg
);
3840 if (debug_args
== NULL
)
3841 debug_args
= decl_debug_args_insert (callee_decl
);
3842 for (ix
= 0; vec_safe_iterate (*debug_args
, ix
, &ddecl
); ix
+= 2)
3843 if (ddecl
== origin
)
3845 ddecl
= (**debug_args
)[ix
+ 1];
3850 ddecl
= make_node (DEBUG_EXPR_DECL
);
3851 DECL_ARTIFICIAL (ddecl
) = 1;
3852 TREE_TYPE (ddecl
) = TREE_TYPE (origin
);
3853 DECL_MODE (ddecl
) = DECL_MODE (origin
);
3855 vec_safe_push (*debug_args
, origin
);
3856 vec_safe_push (*debug_args
, ddecl
);
3858 def_temp
= gimple_build_debug_bind (ddecl
, unshare_expr (arg
), stmt
);
3859 gsi_insert_before (&gsi
, def_temp
, GSI_SAME_STMT
);
3863 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3865 fprintf (dump_file
, "replacing stmt:");
3866 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
3869 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
3871 if (gimple_call_lhs (stmt
))
3872 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
3874 gimple_set_block (new_stmt
, gimple_block (stmt
));
3875 if (gimple_has_location (stmt
))
3876 gimple_set_location (new_stmt
, gimple_location (stmt
));
3877 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
3878 gimple_call_copy_flags (new_stmt
, stmt
);
3879 if (gimple_in_ssa_p (cfun
))
3881 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
3882 if (gimple_vdef (stmt
))
3884 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
3885 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
3889 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3891 fprintf (dump_file
, "with stmt:");
3892 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
3893 fprintf (dump_file
, "\n");
3895 gsi_replace (&gsi
, new_stmt
, true);
3897 cgraph_set_call_stmt (cs
, new_stmt
);
3900 ipa_record_stmt_references (current_node
, gsi_stmt (gsi
));
3903 while (gsi_stmt (gsi
) != gsi_stmt (prev_gsi
));
3906 /* If the expression *EXPR should be replaced by a reduction of a parameter, do
3907 so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
3908 specifies whether the function should care about type incompatibility the
3909 current and new expressions. If it is false, the function will leave
3910 incompatibility issues to the caller. Return true iff the expression
3914 ipa_modify_expr (tree
*expr
, bool convert
,
3915 ipa_parm_adjustment_vec adjustments
)
3917 struct ipa_parm_adjustment
*cand
3918 = ipa_get_adjustment_candidate (&expr
, &convert
, adjustments
, false);
3924 src
= build_simple_mem_ref (cand
->new_decl
);
3926 src
= cand
->new_decl
;
3928 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3930 fprintf (dump_file
, "About to replace expr ");
3931 print_generic_expr (dump_file
, *expr
, 0);
3932 fprintf (dump_file
, " with ");
3933 print_generic_expr (dump_file
, src
, 0);
3934 fprintf (dump_file
, "\n");
3937 if (convert
&& !useless_type_conversion_p (TREE_TYPE (*expr
), cand
->type
))
3939 tree vce
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (*expr
), src
);
3947 /* If T is an SSA_NAME, return NULL if it is not a default def or
3948 return its base variable if it is. If IGNORE_DEFAULT_DEF is true,
3949 the base variable is always returned, regardless if it is a default
3950 def. Return T if it is not an SSA_NAME. */
3953 get_ssa_base_param (tree t
, bool ignore_default_def
)
3955 if (TREE_CODE (t
) == SSA_NAME
)
3957 if (ignore_default_def
|| SSA_NAME_IS_DEFAULT_DEF (t
))
3958 return SSA_NAME_VAR (t
);
3965 /* Given an expression, return an adjustment entry specifying the
3966 transformation to be done on EXPR. If no suitable adjustment entry
3967 was found, returns NULL.
3969 If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a
3970 default def, otherwise bail on them.
3972 If CONVERT is non-NULL, this function will set *CONVERT if the
3973 expression provided is a component reference. ADJUSTMENTS is the
3974 adjustments vector. */
3976 ipa_parm_adjustment
*
3977 ipa_get_adjustment_candidate (tree
**expr
, bool *convert
,
3978 ipa_parm_adjustment_vec adjustments
,
3979 bool ignore_default_def
)
3981 if (TREE_CODE (**expr
) == BIT_FIELD_REF
3982 || TREE_CODE (**expr
) == IMAGPART_EXPR
3983 || TREE_CODE (**expr
) == REALPART_EXPR
)
3985 *expr
= &TREE_OPERAND (**expr
, 0);
3990 HOST_WIDE_INT offset
, size
, max_size
;
3991 tree base
= get_ref_base_and_extent (**expr
, &offset
, &size
, &max_size
);
3992 if (!base
|| size
== -1 || max_size
== -1)
3995 if (TREE_CODE (base
) == MEM_REF
)
3997 offset
+= mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
3998 base
= TREE_OPERAND (base
, 0);
4001 base
= get_ssa_base_param (base
, ignore_default_def
);
4002 if (!base
|| TREE_CODE (base
) != PARM_DECL
)
4005 struct ipa_parm_adjustment
*cand
= NULL
;
4006 unsigned int len
= adjustments
.length ();
4007 for (unsigned i
= 0; i
< len
; i
++)
4009 struct ipa_parm_adjustment
*adj
= &adjustments
[i
];
4011 if (adj
->base
== base
4012 && (adj
->offset
== offset
|| adj
->op
== IPA_PARM_OP_REMOVE
))
4019 if (!cand
|| cand
->op
== IPA_PARM_OP_COPY
|| cand
->op
== IPA_PARM_OP_REMOVE
)
4024 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
4027 index_in_adjustments_multiple_times_p (int base_index
,
4028 ipa_parm_adjustment_vec adjustments
)
4030 int i
, len
= adjustments
.length ();
4033 for (i
= 0; i
< len
; i
++)
4035 struct ipa_parm_adjustment
*adj
;
4036 adj
= &adjustments
[i
];
4038 if (adj
->base_index
== base_index
)
4050 /* Return adjustments that should have the same effect on function parameters
4051 and call arguments as if they were first changed according to adjustments in
4052 INNER and then by adjustments in OUTER. */
4054 ipa_parm_adjustment_vec
4055 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
4056 ipa_parm_adjustment_vec outer
)
4058 int i
, outlen
= outer
.length ();
4059 int inlen
= inner
.length ();
4061 ipa_parm_adjustment_vec adjustments
, tmp
;
4064 for (i
= 0; i
< inlen
; i
++)
4066 struct ipa_parm_adjustment
*n
;
4069 if (n
->op
== IPA_PARM_OP_REMOVE
)
4073 /* FIXME: Handling of new arguments are not implemented yet. */
4074 gcc_assert (n
->op
!= IPA_PARM_OP_NEW
);
4075 tmp
.quick_push (*n
);
4079 adjustments
.create (outlen
+ removals
);
4080 for (i
= 0; i
< outlen
; i
++)
4082 struct ipa_parm_adjustment r
;
4083 struct ipa_parm_adjustment
*out
= &outer
[i
];
4084 struct ipa_parm_adjustment
*in
= &tmp
[out
->base_index
];
4086 memset (&r
, 0, sizeof (r
));
4087 gcc_assert (in
->op
!= IPA_PARM_OP_REMOVE
);
4088 if (out
->op
== IPA_PARM_OP_REMOVE
)
4090 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
4092 r
.op
= IPA_PARM_OP_REMOVE
;
4093 adjustments
.quick_push (r
);
4099 /* FIXME: Handling of new arguments are not implemented yet. */
4100 gcc_assert (out
->op
!= IPA_PARM_OP_NEW
);
4103 r
.base_index
= in
->base_index
;
4106 /* FIXME: Create nonlocal value too. */
4108 if (in
->op
== IPA_PARM_OP_COPY
&& out
->op
== IPA_PARM_OP_COPY
)
4109 r
.op
= IPA_PARM_OP_COPY
;
4110 else if (in
->op
== IPA_PARM_OP_COPY
)
4111 r
.offset
= out
->offset
;
4112 else if (out
->op
== IPA_PARM_OP_COPY
)
4113 r
.offset
= in
->offset
;
4115 r
.offset
= in
->offset
+ out
->offset
;
4116 adjustments
.quick_push (r
);
4119 for (i
= 0; i
< inlen
; i
++)
4121 struct ipa_parm_adjustment
*n
= &inner
[i
];
4123 if (n
->op
== IPA_PARM_OP_REMOVE
)
4124 adjustments
.quick_push (*n
);
4131 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
4132 friendly way, assuming they are meant to be applied to FNDECL. */
4135 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
4138 int i
, len
= adjustments
.length ();
4140 vec
<tree
> parms
= ipa_get_vector_of_formal_parms (fndecl
);
4142 fprintf (file
, "IPA param adjustments: ");
4143 for (i
= 0; i
< len
; i
++)
4145 struct ipa_parm_adjustment
*adj
;
4146 adj
= &adjustments
[i
];
4149 fprintf (file
, " ");
4153 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
4154 print_generic_expr (file
, parms
[adj
->base_index
], 0);
4157 fprintf (file
, ", base: ");
4158 print_generic_expr (file
, adj
->base
, 0);
4162 fprintf (file
, ", new_decl: ");
4163 print_generic_expr (file
, adj
->new_decl
, 0);
4165 if (adj
->new_ssa_base
)
4167 fprintf (file
, ", new_ssa_base: ");
4168 print_generic_expr (file
, adj
->new_ssa_base
, 0);
4171 if (adj
->op
== IPA_PARM_OP_COPY
)
4172 fprintf (file
, ", copy_param");
4173 else if (adj
->op
== IPA_PARM_OP_REMOVE
)
4174 fprintf (file
, ", remove_param");
4176 fprintf (file
, ", offset %li", (long) adj
->offset
);
4178 fprintf (file
, ", by_ref");
4179 print_node_brief (file
, ", type: ", adj
->type
, 0);
4180 fprintf (file
, "\n");
4185 /* Dump the AV linked list. */
4188 ipa_dump_agg_replacement_values (FILE *f
, struct ipa_agg_replacement_value
*av
)
4191 fprintf (f
, " Aggregate replacements:");
4192 for (; av
; av
= av
->next
)
4194 fprintf (f
, "%s %i[" HOST_WIDE_INT_PRINT_DEC
"]=", comma
? "," : "",
4195 av
->index
, av
->offset
);
4196 print_generic_expr (f
, av
->value
, 0);
4202 /* Stream out jump function JUMP_FUNC to OB. */
4205 ipa_write_jump_function (struct output_block
*ob
,
4206 struct ipa_jump_func
*jump_func
)
4208 struct ipa_agg_jf_item
*item
;
4209 struct bitpack_d bp
;
4212 streamer_write_uhwi (ob
, jump_func
->type
);
4213 switch (jump_func
->type
)
4215 case IPA_JF_UNKNOWN
:
4217 case IPA_JF_KNOWN_TYPE
:
4218 streamer_write_uhwi (ob
, jump_func
->value
.known_type
.offset
);
4219 stream_write_tree (ob
, jump_func
->value
.known_type
.base_type
, true);
4220 stream_write_tree (ob
, jump_func
->value
.known_type
.component_type
, true);
4224 EXPR_LOCATION (jump_func
->value
.constant
.value
) == UNKNOWN_LOCATION
);
4225 stream_write_tree (ob
, jump_func
->value
.constant
.value
, true);
4227 case IPA_JF_PASS_THROUGH
:
4228 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.operation
);
4229 if (jump_func
->value
.pass_through
.operation
== NOP_EXPR
)
4231 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4232 bp
= bitpack_create (ob
->main_stream
);
4233 bp_pack_value (&bp
, jump_func
->value
.pass_through
.agg_preserved
, 1);
4234 bp_pack_value (&bp
, jump_func
->value
.pass_through
.type_preserved
, 1);
4235 streamer_write_bitpack (&bp
);
4239 stream_write_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
4240 streamer_write_uhwi (ob
, jump_func
->value
.pass_through
.formal_id
);
4243 case IPA_JF_ANCESTOR
:
4244 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.offset
);
4245 stream_write_tree (ob
, jump_func
->value
.ancestor
.type
, true);
4246 streamer_write_uhwi (ob
, jump_func
->value
.ancestor
.formal_id
);
4247 bp
= bitpack_create (ob
->main_stream
);
4248 bp_pack_value (&bp
, jump_func
->value
.ancestor
.agg_preserved
, 1);
4249 bp_pack_value (&bp
, jump_func
->value
.ancestor
.type_preserved
, 1);
4250 streamer_write_bitpack (&bp
);
4254 count
= vec_safe_length (jump_func
->agg
.items
);
4255 streamer_write_uhwi (ob
, count
);
4258 bp
= bitpack_create (ob
->main_stream
);
4259 bp_pack_value (&bp
, jump_func
->agg
.by_ref
, 1);
4260 streamer_write_bitpack (&bp
);
4263 FOR_EACH_VEC_SAFE_ELT (jump_func
->agg
.items
, i
, item
)
4265 streamer_write_uhwi (ob
, item
->offset
);
4266 stream_write_tree (ob
, item
->value
, true);
4270 /* Read in jump function JUMP_FUNC from IB. */
4273 ipa_read_jump_function (struct lto_input_block
*ib
,
4274 struct ipa_jump_func
*jump_func
,
4275 struct cgraph_edge
*cs
,
4276 struct data_in
*data_in
)
4278 enum jump_func_type jftype
;
4279 enum tree_code operation
;
4282 jftype
= (enum jump_func_type
) streamer_read_uhwi (ib
);
4285 case IPA_JF_UNKNOWN
:
4286 jump_func
->type
= IPA_JF_UNKNOWN
;
4288 case IPA_JF_KNOWN_TYPE
:
4290 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4291 tree base_type
= stream_read_tree (ib
, data_in
);
4292 tree component_type
= stream_read_tree (ib
, data_in
);
4294 ipa_set_jf_known_type (jump_func
, offset
, base_type
, component_type
);
4298 ipa_set_jf_constant (jump_func
, stream_read_tree (ib
, data_in
), cs
);
4300 case IPA_JF_PASS_THROUGH
:
4301 operation
= (enum tree_code
) streamer_read_uhwi (ib
);
4302 if (operation
== NOP_EXPR
)
4304 int formal_id
= streamer_read_uhwi (ib
);
4305 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4306 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4307 bool type_preserved
= bp_unpack_value (&bp
, 1);
4308 ipa_set_jf_simple_pass_through (jump_func
, formal_id
, agg_preserved
,
4313 tree operand
= stream_read_tree (ib
, data_in
);
4314 int formal_id
= streamer_read_uhwi (ib
);
4315 ipa_set_jf_arith_pass_through (jump_func
, formal_id
, operand
,
4319 case IPA_JF_ANCESTOR
:
4321 HOST_WIDE_INT offset
= streamer_read_uhwi (ib
);
4322 tree type
= stream_read_tree (ib
, data_in
);
4323 int formal_id
= streamer_read_uhwi (ib
);
4324 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4325 bool agg_preserved
= bp_unpack_value (&bp
, 1);
4326 bool type_preserved
= bp_unpack_value (&bp
, 1);
4328 ipa_set_ancestor_jf (jump_func
, offset
, type
, formal_id
, agg_preserved
,
4334 count
= streamer_read_uhwi (ib
);
4335 vec_alloc (jump_func
->agg
.items
, count
);
4338 struct bitpack_d bp
= streamer_read_bitpack (ib
);
4339 jump_func
->agg
.by_ref
= bp_unpack_value (&bp
, 1);
4341 for (i
= 0; i
< count
; i
++)
4343 struct ipa_agg_jf_item item
;
4344 item
.offset
= streamer_read_uhwi (ib
);
4345 item
.value
= stream_read_tree (ib
, data_in
);
4346 jump_func
->agg
.items
->quick_push (item
);
4350 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
4351 relevant to indirect inlining to OB. */
4354 ipa_write_indirect_edge_info (struct output_block
*ob
,
4355 struct cgraph_edge
*cs
)
4357 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4358 struct bitpack_d bp
;
4360 streamer_write_hwi (ob
, ii
->param_index
);
4361 streamer_write_hwi (ob
, ii
->offset
);
4362 bp
= bitpack_create (ob
->main_stream
);
4363 bp_pack_value (&bp
, ii
->polymorphic
, 1);
4364 bp_pack_value (&bp
, ii
->agg_contents
, 1);
4365 bp_pack_value (&bp
, ii
->member_ptr
, 1);
4366 bp_pack_value (&bp
, ii
->by_ref
, 1);
4367 bp_pack_value (&bp
, ii
->maybe_in_construction
, 1);
4368 bp_pack_value (&bp
, ii
->maybe_derived_type
, 1);
4369 streamer_write_bitpack (&bp
);
4371 if (ii
->polymorphic
)
4373 streamer_write_hwi (ob
, ii
->otr_token
);
4374 stream_write_tree (ob
, ii
->otr_type
, true);
4375 stream_write_tree (ob
, ii
->outer_type
, true);
4379 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
4380 relevant to indirect inlining from IB. */
4383 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
4384 struct data_in
*data_in ATTRIBUTE_UNUSED
,
4385 struct cgraph_edge
*cs
)
4387 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
4388 struct bitpack_d bp
;
4390 ii
->param_index
= (int) streamer_read_hwi (ib
);
4391 ii
->offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4392 bp
= streamer_read_bitpack (ib
);
4393 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
4394 ii
->agg_contents
= bp_unpack_value (&bp
, 1);
4395 ii
->member_ptr
= bp_unpack_value (&bp
, 1);
4396 ii
->by_ref
= bp_unpack_value (&bp
, 1);
4397 ii
->maybe_in_construction
= bp_unpack_value (&bp
, 1);
4398 ii
->maybe_derived_type
= bp_unpack_value (&bp
, 1);
4399 if (ii
->polymorphic
)
4401 ii
->otr_token
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
4402 ii
->otr_type
= stream_read_tree (ib
, data_in
);
4403 ii
->outer_type
= stream_read_tree (ib
, data_in
);
4407 /* Stream out NODE info to OB. */
4410 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
4413 lto_symtab_encoder_t encoder
;
4414 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4416 struct cgraph_edge
*e
;
4417 struct bitpack_d bp
;
4419 encoder
= ob
->decl_state
->symtab_node_encoder
;
4420 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4421 streamer_write_uhwi (ob
, node_ref
);
4423 streamer_write_uhwi (ob
, ipa_get_param_count (info
));
4424 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4425 streamer_write_uhwi (ob
, ipa_get_param_move_cost (info
, j
));
4426 bp
= bitpack_create (ob
->main_stream
);
4427 gcc_assert (info
->uses_analysis_done
4428 || ipa_get_param_count (info
) == 0);
4429 gcc_assert (!info
->node_enqueued
);
4430 gcc_assert (!info
->ipcp_orig_node
);
4431 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4432 bp_pack_value (&bp
, ipa_is_param_used (info
, j
), 1);
4433 streamer_write_bitpack (&bp
);
4434 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
4435 streamer_write_hwi (ob
, ipa_get_controlled_uses (info
, j
));
4436 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4438 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4440 streamer_write_uhwi (ob
, ipa_get_cs_argument_count (args
));
4441 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4442 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4444 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4446 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4448 streamer_write_uhwi (ob
, ipa_get_cs_argument_count (args
));
4449 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
4450 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
4451 ipa_write_indirect_edge_info (ob
, e
);
4455 /* Stream in NODE info from IB. */
4458 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
4459 struct data_in
*data_in
)
4461 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
4463 struct cgraph_edge
*e
;
4464 struct bitpack_d bp
;
4466 ipa_alloc_node_params (node
, streamer_read_uhwi (ib
));
4468 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4469 info
->descriptors
[k
].move_cost
= streamer_read_uhwi (ib
);
4471 bp
= streamer_read_bitpack (ib
);
4472 if (ipa_get_param_count (info
) != 0)
4473 info
->uses_analysis_done
= true;
4474 info
->node_enqueued
= false;
4475 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4476 ipa_set_param_used (info
, k
, bp_unpack_value (&bp
, 1));
4477 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
4478 ipa_set_controlled_uses (info
, k
, streamer_read_hwi (ib
));
4479 for (e
= node
->callees
; e
; e
= e
->next_callee
)
4481 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4482 int count
= streamer_read_uhwi (ib
);
4486 vec_safe_grow_cleared (args
->jump_functions
, count
);
4488 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4489 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4492 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
4494 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
4495 int count
= streamer_read_uhwi (ib
);
4499 vec_safe_grow_cleared (args
->jump_functions
, count
);
4500 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
4501 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), e
,
4504 ipa_read_indirect_edge_info (ib
, data_in
, e
);
4508 /* Write jump functions for nodes in SET. */
4511 ipa_prop_write_jump_functions (void)
4513 struct cgraph_node
*node
;
4514 struct output_block
*ob
;
4515 unsigned int count
= 0;
4516 lto_symtab_encoder_iterator lsei
;
4517 lto_symtab_encoder_t encoder
;
4520 if (!ipa_node_params_vector
.exists ())
4523 ob
= create_output_block (LTO_section_jump_functions
);
4524 encoder
= ob
->decl_state
->symtab_node_encoder
;
4525 ob
->cgraph_node
= NULL
;
4526 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4527 lsei_next_function_in_partition (&lsei
))
4529 node
= lsei_cgraph_node (lsei
);
4530 if (cgraph_function_with_gimple_body_p (node
)
4531 && IPA_NODE_REF (node
) != NULL
)
4535 streamer_write_uhwi (ob
, count
);
4537 /* Process all of the functions. */
4538 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4539 lsei_next_function_in_partition (&lsei
))
4541 node
= lsei_cgraph_node (lsei
);
4542 if (cgraph_function_with_gimple_body_p (node
)
4543 && IPA_NODE_REF (node
) != NULL
)
4544 ipa_write_node_info (ob
, node
);
4546 streamer_write_char_stream (ob
->main_stream
, 0);
4547 produce_asm (ob
, NULL
);
4548 destroy_output_block (ob
);
4551 /* Read section in file FILE_DATA of length LEN with data DATA. */
4554 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
4557 const struct lto_function_header
*header
=
4558 (const struct lto_function_header
*) data
;
4559 const int cfg_offset
= sizeof (struct lto_function_header
);
4560 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4561 const int string_offset
= main_offset
+ header
->main_size
;
4562 struct data_in
*data_in
;
4563 struct lto_input_block ib_main
;
4567 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
4571 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4572 header
->string_size
, vNULL
);
4573 count
= streamer_read_uhwi (&ib_main
);
4575 for (i
= 0; i
< count
; i
++)
4578 struct cgraph_node
*node
;
4579 lto_symtab_encoder_t encoder
;
4581 index
= streamer_read_uhwi (&ib_main
);
4582 encoder
= file_data
->symtab_node_encoder
;
4583 node
= cgraph (lto_symtab_encoder_deref (encoder
, index
));
4584 gcc_assert (node
->definition
);
4585 ipa_read_node_info (&ib_main
, node
, data_in
);
4587 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4589 lto_data_in_delete (data_in
);
4592 /* Read ipcp jump functions. */
4595 ipa_prop_read_jump_functions (void)
4597 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4598 struct lto_file_decl_data
*file_data
;
4601 ipa_check_create_node_params ();
4602 ipa_check_create_edge_args ();
4603 ipa_register_cgraph_hooks ();
4605 while ((file_data
= file_data_vec
[j
++]))
4608 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
4611 ipa_prop_read_section (file_data
, data
, len
);
4615 /* After merging units, we can get mismatch in argument counts.
4616 Also decl merging might've rendered parameter lists obsolete.
4617 Also compute called_with_variable_arg info. */
4620 ipa_update_after_lto_read (void)
4622 ipa_check_create_node_params ();
4623 ipa_check_create_edge_args ();
4627 write_agg_replacement_chain (struct output_block
*ob
, struct cgraph_node
*node
)
4630 unsigned int count
= 0;
4631 lto_symtab_encoder_t encoder
;
4632 struct ipa_agg_replacement_value
*aggvals
, *av
;
4634 aggvals
= ipa_get_agg_replacements_for_node (node
);
4635 encoder
= ob
->decl_state
->symtab_node_encoder
;
4636 node_ref
= lto_symtab_encoder_encode (encoder
, node
);
4637 streamer_write_uhwi (ob
, node_ref
);
4639 for (av
= aggvals
; av
; av
= av
->next
)
4641 streamer_write_uhwi (ob
, count
);
4643 for (av
= aggvals
; av
; av
= av
->next
)
4645 struct bitpack_d bp
;
4647 streamer_write_uhwi (ob
, av
->offset
);
4648 streamer_write_uhwi (ob
, av
->index
);
4649 stream_write_tree (ob
, av
->value
, true);
4651 bp
= bitpack_create (ob
->main_stream
);
4652 bp_pack_value (&bp
, av
->by_ref
, 1);
4653 streamer_write_bitpack (&bp
);
4657 /* Stream in the aggregate value replacement chain for NODE from IB. */
4660 read_agg_replacement_chain (struct lto_input_block
*ib
,
4661 struct cgraph_node
*node
,
4662 struct data_in
*data_in
)
4664 struct ipa_agg_replacement_value
*aggvals
= NULL
;
4665 unsigned int count
, i
;
4667 count
= streamer_read_uhwi (ib
);
4668 for (i
= 0; i
<count
; i
++)
4670 struct ipa_agg_replacement_value
*av
;
4671 struct bitpack_d bp
;
4673 av
= ggc_alloc_ipa_agg_replacement_value ();
4674 av
->offset
= streamer_read_uhwi (ib
);
4675 av
->index
= streamer_read_uhwi (ib
);
4676 av
->value
= stream_read_tree (ib
, data_in
);
4677 bp
= streamer_read_bitpack (ib
);
4678 av
->by_ref
= bp_unpack_value (&bp
, 1);
4682 ipa_set_node_agg_value_chain (node
, aggvals
);
4685 /* Write all aggregate replacement for nodes in set. */
4688 ipa_prop_write_all_agg_replacement (void)
4690 struct cgraph_node
*node
;
4691 struct output_block
*ob
;
4692 unsigned int count
= 0;
4693 lto_symtab_encoder_iterator lsei
;
4694 lto_symtab_encoder_t encoder
;
4696 if (!ipa_node_agg_replacements
)
4699 ob
= create_output_block (LTO_section_ipcp_transform
);
4700 encoder
= ob
->decl_state
->symtab_node_encoder
;
4701 ob
->cgraph_node
= NULL
;
4702 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4703 lsei_next_function_in_partition (&lsei
))
4705 node
= lsei_cgraph_node (lsei
);
4706 if (cgraph_function_with_gimple_body_p (node
)
4707 && ipa_get_agg_replacements_for_node (node
) != NULL
)
4711 streamer_write_uhwi (ob
, count
);
4713 for (lsei
= lsei_start_function_in_partition (encoder
); !lsei_end_p (lsei
);
4714 lsei_next_function_in_partition (&lsei
))
4716 node
= lsei_cgraph_node (lsei
);
4717 if (cgraph_function_with_gimple_body_p (node
)
4718 && ipa_get_agg_replacements_for_node (node
) != NULL
)
4719 write_agg_replacement_chain (ob
, node
);
4721 streamer_write_char_stream (ob
->main_stream
, 0);
4722 produce_asm (ob
, NULL
);
4723 destroy_output_block (ob
);
4726 /* Read replacements section in file FILE_DATA of length LEN with data
4730 read_replacements_section (struct lto_file_decl_data
*file_data
,
4734 const struct lto_function_header
*header
=
4735 (const struct lto_function_header
*) data
;
4736 const int cfg_offset
= sizeof (struct lto_function_header
);
4737 const int main_offset
= cfg_offset
+ header
->cfg_size
;
4738 const int string_offset
= main_offset
+ header
->main_size
;
4739 struct data_in
*data_in
;
4740 struct lto_input_block ib_main
;
4744 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
4747 data_in
= lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
4748 header
->string_size
, vNULL
);
4749 count
= streamer_read_uhwi (&ib_main
);
4751 for (i
= 0; i
< count
; i
++)
4754 struct cgraph_node
*node
;
4755 lto_symtab_encoder_t encoder
;
4757 index
= streamer_read_uhwi (&ib_main
);
4758 encoder
= file_data
->symtab_node_encoder
;
4759 node
= cgraph (lto_symtab_encoder_deref (encoder
, index
));
4760 gcc_assert (node
->definition
);
4761 read_agg_replacement_chain (&ib_main
, node
, data_in
);
4763 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
4765 lto_data_in_delete (data_in
);
4768 /* Read IPA-CP aggregate replacements. */
4771 ipa_prop_read_all_agg_replacement (void)
4773 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
4774 struct lto_file_decl_data
*file_data
;
4777 while ((file_data
= file_data_vec
[j
++]))
4780 const char *data
= lto_get_section_data (file_data
,
4781 LTO_section_ipcp_transform
,
4784 read_replacements_section (file_data
, data
, len
);
4788 /* Adjust the aggregate replacements in AGGVAL to reflect parameters skipped in
4792 adjust_agg_replacement_values (struct cgraph_node
*node
,
4793 struct ipa_agg_replacement_value
*aggval
)
4795 struct ipa_agg_replacement_value
*v
;
4796 int i
, c
= 0, d
= 0, *adj
;
4798 if (!node
->clone
.combined_args_to_skip
)
4801 for (v
= aggval
; v
; v
= v
->next
)
4803 gcc_assert (v
->index
>= 0);
4809 adj
= XALLOCAVEC (int, c
);
4810 for (i
= 0; i
< c
; i
++)
4811 if (bitmap_bit_p (node
->clone
.combined_args_to_skip
, i
))
4819 for (v
= aggval
; v
; v
= v
->next
)
4820 v
->index
= adj
[v
->index
];
4824 /* Function body transformation phase. */
4827 ipcp_transform_function (struct cgraph_node
*node
)
4829 vec
<ipa_param_descriptor
> descriptors
= vNULL
;
4830 struct param_analysis_info
*parms_ainfo
;
4831 struct ipa_agg_replacement_value
*aggval
;
4832 gimple_stmt_iterator gsi
;
4835 bool cfg_changed
= false, something_changed
= false;
4837 gcc_checking_assert (cfun
);
4838 gcc_checking_assert (current_function_decl
);
4841 fprintf (dump_file
, "Modification phase of node %s/%i\n",
4842 node
->name (), node
->order
);
4844 aggval
= ipa_get_agg_replacements_for_node (node
);
4847 param_count
= count_formal_params (node
->decl
);
4848 if (param_count
== 0)
4850 adjust_agg_replacement_values (node
, aggval
);
4852 ipa_dump_agg_replacement_values (dump_file
, aggval
);
4853 parms_ainfo
= XALLOCAVEC (struct param_analysis_info
, param_count
);
4854 memset (parms_ainfo
, 0, sizeof (struct param_analysis_info
) * param_count
);
4855 descriptors
.safe_grow_cleared (param_count
);
4856 ipa_populate_param_decls (node
, descriptors
);
4858 FOR_EACH_BB_FN (bb
, cfun
)
4859 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4861 struct ipa_agg_replacement_value
*v
;
4862 gimple stmt
= gsi_stmt (gsi
);
4864 HOST_WIDE_INT offset
, size
;
4868 if (!gimple_assign_load_p (stmt
))
4870 rhs
= gimple_assign_rhs1 (stmt
);
4871 if (!is_gimple_reg_type (TREE_TYPE (rhs
)))
4876 while (handled_component_p (t
))
4878 /* V_C_E can do things like convert an array of integers to one
4879 bigger integer and similar things we do not handle below. */
4880 if (TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
)
4885 t
= TREE_OPERAND (t
, 0);
4890 if (!ipa_load_from_parm_agg_1 (descriptors
, parms_ainfo
, stmt
,
4891 rhs
, &index
, &offset
, &size
, &by_ref
))
4893 for (v
= aggval
; v
; v
= v
->next
)
4894 if (v
->index
== index
4895 && v
->offset
== offset
)
4898 || v
->by_ref
!= by_ref
4899 || tree_to_shwi (TYPE_SIZE (TREE_TYPE (v
->value
))) != size
)
4902 gcc_checking_assert (is_gimple_ip_invariant (v
->value
));
4903 if (!useless_type_conversion_p (TREE_TYPE (rhs
), TREE_TYPE (v
->value
)))
4905 if (fold_convertible_p (TREE_TYPE (rhs
), v
->value
))
4906 val
= fold_build1 (NOP_EXPR
, TREE_TYPE (rhs
), v
->value
);
4907 else if (TYPE_SIZE (TREE_TYPE (rhs
))
4908 == TYPE_SIZE (TREE_TYPE (v
->value
)))
4909 val
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (rhs
), v
->value
);
4914 fprintf (dump_file
, " const ");
4915 print_generic_expr (dump_file
, v
->value
, 0);
4916 fprintf (dump_file
, " can't be converted to type of ");
4917 print_generic_expr (dump_file
, rhs
, 0);
4918 fprintf (dump_file
, "\n");
4926 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4928 fprintf (dump_file
, "Modifying stmt:\n ");
4929 print_gimple_stmt (dump_file
, stmt
, 0, 0);
4931 gimple_assign_set_rhs_from_tree (&gsi
, val
);
4934 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4936 fprintf (dump_file
, "into:\n ");
4937 print_gimple_stmt (dump_file
, stmt
, 0, 0);
4938 fprintf (dump_file
, "\n");
4941 something_changed
= true;
4942 if (maybe_clean_eh_stmt (stmt
)
4943 && gimple_purge_dead_eh_edges (gimple_bb (stmt
)))
4947 (*ipa_node_agg_replacements
)[node
->uid
] = NULL
;
4948 free_parms_ainfo (parms_ainfo
, param_count
);
4949 descriptors
.release ();
4951 if (!something_changed
)
4953 else if (cfg_changed
)
4954 return TODO_update_ssa_only_virtuals
| TODO_cleanup_cfg
;
4956 return TODO_update_ssa_only_virtuals
;