1 /* Basic IPA utilities for type inheritance graph construction and
3 Copyright (C) 2013-2014 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 ODR = One Definition Rule
24 In short, the ODR states that:
25 1 In any translation unit, a template, type, function, or object can
26 have no more than one definition. Some of these can have any number
27 of declarations. A definition provides an instance.
28 2 In the entire program, an object or non-inline function cannot have
29 more than one definition; if an object or function is used, it must
30 have exactly one definition. You can declare an object or function
31 that is never used, in which case you don't have to provide
32 a definition. In no event can there be more than one definition.
33 3 Some things, like types, templates, and extern inline functions, can
34 be defined in more than one translation unit. For a given entity,
35 each definition must be the same. Non-extern objects and functions
36 in different translation units are different entities, even if their
37 names and types are the same.
40 This is the Gimple representation of type information of a polymorphic call.
41 It contains two parameters:
42 otr_type is a type of class whose method is called.
43 otr_token is the index into virtual table where address is taken.
46 This is the type inheritance information attached to each tree
47 RECORD_TYPE by the C++ frotend. It provides information about base
48 types and virtual tables.
50 BINFO is linked to the RECORD_TYPE by TYPE_BINFO.
51 BINFO also links to its type by BINFO_TYPE and to the virtual table by
54 Base types of a given type are enumerated by BINFO_BASE_BINFO
55 vector. Members of this vectors are not BINFOs associated
56 with a base type. Rather they are new copies of BINFOs
57 (base BINFOs). Their virtual tables may differ from
58 virtual table of the base type. Also BINFO_OFFSET specifies
59 offset of the base within the type.
61 In the case of single inheritance, the virtual table is shared
62 and BINFO_VTABLE of base BINFO is NULL. In the case of multiple
63 inheritance the individual virtual tables are pointer to by
64 BINFO_VTABLE of base binfos (that differs of BINFO_VTABLE of
65 binfo associated to the base type).
67 BINFO lookup for a given base type and offset can be done by
68 get_binfo_at_offset. It returns proper BINFO whose virtual table
69 can be used for lookup of virtual methods associated with the
73 This is an index of virtual method in virtual table associated
74 to the type defining it. Token can be looked up from OBJ_TYPE_REF
75 or from DECL_VINDEX of a given virtual table.
77 polymorphic (indirect) call
78 This is callgraph represention of virtual method call. Every
79 polymorphic call contains otr_type and otr_token taken from
80 original OBJ_TYPE_REF at callgraph construction time.
84 build_type_inheritance_graph triggers a construction of the type inheritance
87 We reconstruct it based on types of methods we see in the unit.
88 This means that the graph is not complete. Types with no methods are not
89 inserted into the graph. Also types without virtual methods are not
90 represented at all, though it may be easy to add this.
92 The inheritance graph is represented as follows:
94 Vertices are structures odr_type. Every odr_type may correspond
95 to one or more tree type nodes that are equivalent by ODR rule.
96 (the multiple type nodes appear only with linktime optimization)
98 Edges are represented by odr_type->base and odr_type->derived_types.
99 At the moment we do not track offsets of types for multiple inheritance.
102 possible_polymorphic_call_targets returns, given an parameters found in
103 indirect polymorphic edge all possible polymorphic call targets of the call.
105 pass_ipa_devirt performs simple speculative devirtualization.
110 #include "coretypes.h"
113 #include "print-tree.h"
117 #include "tree-pass.h"
118 #include "pointer-set.h"
120 #include "hash-table.h"
121 #include "tree-pretty-print.h"
122 #include "ipa-utils.h"
123 #include "tree-ssa-alias.h"
124 #include "internal-fn.h"
125 #include "gimple-fold.h"
126 #include "gimple-expr.h"
128 #include "ipa-inline.h"
129 #include "diagnostic.h"
130 #include "tree-dfa.h"
131 #include "demangle.h"
134 static bool odr_violation_reported
= false;
136 /* Dummy polymorphic call context. */
138 const ipa_polymorphic_call_context ipa_dummy_polymorphic_call_context
139 = {0, NULL
, false, true};
141 /* Pointer set of all call targets appearing in the cache. */
142 static pointer_set_t
*cached_polymorphic_call_targets
;
144 /* The node of type inheritance graph. For each type unique in
145 One Defintion Rule (ODR) sense, we produce one node linking all
146 main variants of types equivalent to it, bases and derived types. */
148 struct GTY(()) odr_type_d
153 vec
<odr_type
> GTY((skip
)) bases
;
154 /* All derrived types with virtual methods seen in unit. */
155 vec
<odr_type
> GTY((skip
)) derived_types
;
157 /* All equivalent types, if more than one. */
158 vec
<tree
, va_gc
> *types
;
159 /* Set of all equivalent types, if NON-NULL. */
160 pointer_set_t
* GTY((skip
)) types_set
;
162 /* Unique ID indexing the type in odr_types array. */
164 /* Is it in anonymous namespace? */
165 bool anonymous_namespace
;
166 /* Do we know about all derivations of given type? */
167 bool all_derivations_known
;
171 /* Return true if BINFO corresponds to a type with virtual methods.
173 Every type has several BINFOs. One is the BINFO associated by the type
174 while other represents bases of derived types. The BINFOs representing
175 bases do not have BINFO_VTABLE pointer set when this is the single
176 inheritance (because vtables are shared). Look up the BINFO of type
177 and check presence of its vtable. */
180 polymorphic_type_binfo_p (tree binfo
)
182 /* See if BINFO's type has an virtual table associtated with it. */
183 return BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (binfo
)));
186 /* Return TRUE if all derived types of T are known and thus
187 we may consider the walk of derived type complete.
189 This is typically true only for final anonymous namespace types and types
190 defined within functions (that may be COMDAT and thus shared across units,
191 but with the same set of derived types). */
194 type_all_derivations_known_p (tree t
)
196 if (TYPE_FINAL_P (t
))
200 if (type_in_anonymous_namespace_p (t
))
202 return (decl_function_context (TYPE_NAME (t
)) != NULL
);
205 /* Return TURE if type's constructors are all visible. */
208 type_all_ctors_visible_p (tree t
)
211 && cgraph_state
>= CGRAPH_STATE_CONSTRUCTION
212 /* We can not always use type_all_derivations_known_p.
213 For function local types we must assume case where
214 the function is COMDAT and shared in between units.
216 TODO: These cases are quite easy to get, but we need
217 to keep track of C++ privatizing via -Wno-weak
218 as well as the IPA privatizing. */
219 && type_in_anonymous_namespace_p (t
);
222 /* Return TRUE if type may have instance. */
225 type_possibly_instantiated_p (tree t
)
230 /* TODO: Add abstract types here. */
231 if (!type_all_ctors_visible_p (t
))
234 vtable
= BINFO_VTABLE (TYPE_BINFO (t
));
235 if (TREE_CODE (vtable
) == POINTER_PLUS_EXPR
)
236 vtable
= TREE_OPERAND (TREE_OPERAND (vtable
, 0), 0);
237 vnode
= varpool_get_node (vtable
);
238 return vnode
&& vnode
->definition
;
241 /* One Definition Rule hashtable helpers. */
245 typedef odr_type_d value_type
;
246 typedef union tree_node compare_type
;
247 static inline hashval_t
hash (const value_type
*);
248 static inline bool equal (const value_type
*, const compare_type
*);
249 static inline void remove (value_type
*);
252 /* Produce hash based on type name. */
255 hash_type_name (tree t
)
257 gcc_checking_assert (TYPE_MAIN_VARIANT (t
) == t
);
259 /* If not in LTO, all main variants are unique, so we can do
262 return htab_hash_pointer (t
);
264 /* Anonymous types are unique. */
265 if (type_in_anonymous_namespace_p (t
))
266 return htab_hash_pointer (t
);
268 /* For polymorphic types, we can simply hash the virtual table. */
269 if (TYPE_BINFO (t
) && BINFO_VTABLE (TYPE_BINFO (t
)))
271 tree v
= BINFO_VTABLE (TYPE_BINFO (t
));
274 if (TREE_CODE (v
) == POINTER_PLUS_EXPR
)
276 hash
= TREE_INT_CST_LOW (TREE_OPERAND (v
, 1));
277 v
= TREE_OPERAND (TREE_OPERAND (v
, 0), 0);
280 v
= DECL_ASSEMBLER_NAME (v
);
281 hash
= iterative_hash_hashval_t (hash
, htab_hash_pointer (v
));
285 /* Rest is not implemented yet. */
289 /* Return the computed hashcode for ODR_TYPE. */
292 odr_hasher::hash (const value_type
*odr_type
)
294 return hash_type_name (odr_type
->type
);
297 /* Compare types T1 and T2 and return true if they are
301 odr_hasher::equal (const value_type
*t1
, const compare_type
*ct2
)
303 tree t2
= const_cast <tree
> (ct2
);
305 gcc_checking_assert (TYPE_MAIN_VARIANT (ct2
) == ct2
);
310 return types_same_for_odr (t1
->type
, t2
);
313 /* Free ODR type V. */
316 odr_hasher::remove (value_type
*v
)
319 v
->derived_types
.release ();
321 pointer_set_destroy (v
->types_set
);
325 /* ODR type hash used to lookup ODR type based on tree type node. */
327 typedef hash_table
<odr_hasher
> odr_hash_type
;
328 static odr_hash_type
*odr_hash
;
330 /* ODR types are also stored into ODR_TYPE vector to allow consistent
331 walking. Bases appear before derived types. Vector is garbage collected
332 so we won't end up visiting empty types. */
334 static GTY(()) vec
<odr_type
, va_gc
> *odr_types_ptr
;
335 #define odr_types (*odr_types_ptr)
337 /* TYPE is equivalent to VAL by ODR, but its tree representation differs
338 from VAL->type. This may happen in LTO where tree merging did not merge
339 all variants of the same type. It may or may not mean the ODR violation.
340 Add it to the list of duplicates and warn on some violations. */
343 add_type_duplicate (odr_type val
, tree type
)
346 val
->types_set
= pointer_set_create ();
348 /* See if this duplicate is new. */
349 if (!pointer_set_insert (val
->types_set
, type
))
352 bool base_mismatch
= false;
353 gcc_assert (in_lto_p
);
354 vec_safe_push (val
->types
, type
);
357 /* First we compare memory layout. */
358 if (!types_compatible_p (val
->type
, type
))
361 odr_violation_reported
= true;
362 if (BINFO_VTABLE (TYPE_BINFO (val
->type
))
363 && warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (type
)), 0,
364 "type %qD violates one definition rule ",
366 inform (DECL_SOURCE_LOCATION (TYPE_NAME (val
->type
)),
367 "a type with the same name but different layout is "
368 "defined in another translation unit");
369 if (cgraph_dump_file
)
371 fprintf (cgraph_dump_file
, "ODR violation or merging or ODR type bug?\n");
373 print_node (cgraph_dump_file
, "", val
->type
, 0);
374 putc ('\n',cgraph_dump_file
);
375 print_node (cgraph_dump_file
, "", type
, 0);
376 putc ('\n',cgraph_dump_file
);
380 /* Next sanity check that bases are the same. If not, we will end
381 up producing wrong answers. */
382 for (j
= 0, i
= 0; i
< BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)); i
++)
383 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (TYPE_BINFO (type
), i
)))
385 odr_type base
= get_odr_type
387 (BINFO_BASE_BINFO (TYPE_BINFO (type
),
390 if (val
->bases
.length () <= j
|| val
->bases
[j
] != base
)
391 base_mismatch
= true;
397 odr_violation_reported
= true;
399 if (warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (type
)), 0,
400 "type %qD violates one definition rule ",
402 inform (DECL_SOURCE_LOCATION (TYPE_NAME (val
->type
)),
403 "a type with the same name but different bases is "
404 "defined in another translation unit");
405 if (cgraph_dump_file
)
407 fprintf (cgraph_dump_file
, "ODR bse violation or merging bug?\n");
409 print_node (cgraph_dump_file
, "", val
->type
, 0);
410 putc ('\n',cgraph_dump_file
);
411 print_node (cgraph_dump_file
, "", type
, 0);
412 putc ('\n',cgraph_dump_file
);
416 /* Regularize things a little. During LTO same types may come with
417 different BINFOs. Either because their virtual table was
418 not merged by tree merging and only later at decl merging or
419 because one type comes with external vtable, while other
420 with internal. We want to merge equivalent binfos to conserve
421 memory and streaming overhead.
423 The external vtables are more harmful: they contain references
424 to external declarations of methods that may be defined in the
425 merged LTO unit. For this reason we absolutely need to remove
426 them and replace by internal variants. Not doing so will lead
427 to incomplete answers from possible_polymorphic_call_targets. */
428 if (!flag_ltrans
&& merge
)
430 tree master_binfo
= TYPE_BINFO (val
->type
);
431 tree v1
= BINFO_VTABLE (master_binfo
);
432 tree v2
= BINFO_VTABLE (TYPE_BINFO (type
));
434 if (TREE_CODE (v1
) == POINTER_PLUS_EXPR
)
436 gcc_assert (TREE_CODE (v2
) == POINTER_PLUS_EXPR
437 && operand_equal_p (TREE_OPERAND (v1
, 1),
438 TREE_OPERAND (v2
, 1), 0));
439 v1
= TREE_OPERAND (TREE_OPERAND (v1
, 0), 0);
440 v2
= TREE_OPERAND (TREE_OPERAND (v2
, 0), 0);
442 gcc_assert (DECL_ASSEMBLER_NAME (v1
)
443 == DECL_ASSEMBLER_NAME (v2
));
445 if (DECL_EXTERNAL (v1
) && !DECL_EXTERNAL (v2
))
449 TYPE_BINFO (val
->type
) = TYPE_BINFO (type
);
450 for (i
= 0; i
< val
->types
->length (); i
++)
452 if (TYPE_BINFO ((*val
->types
)[i
])
454 TYPE_BINFO ((*val
->types
)[i
]) = TYPE_BINFO (type
);
458 TYPE_BINFO (type
) = master_binfo
;
463 /* Get ODR type hash entry for TYPE. If INSERT is true, create
464 possibly new entry. */
467 get_odr_type (tree type
, bool insert
)
473 type
= TYPE_MAIN_VARIANT (type
);
474 gcc_checking_assert (TYPE_MAIN_VARIANT (type
) == type
);
475 hash
= hash_type_name (type
);
477 = odr_hash
->find_slot_with_hash (type
, hash
, insert
? INSERT
: NO_INSERT
);
481 /* See if we already have entry for type. */
486 /* With LTO we need to support multiple tree representation of
487 the same ODR type. */
488 if (val
->type
!= type
)
489 add_type_duplicate (val
, type
);
493 tree binfo
= TYPE_BINFO (type
);
496 val
= ggc_cleared_alloc
<odr_type_d
> ();
499 val
->derived_types
= vNULL
;
500 val
->anonymous_namespace
= type_in_anonymous_namespace_p (type
);
501 val
->all_derivations_known
= type_all_derivations_known_p (type
);
503 for (i
= 0; i
< BINFO_N_BASE_BINFOS (binfo
); i
++)
504 /* For now record only polymorphic types. other are
505 pointless for devirtualization and we can not precisely
506 determine ODR equivalency of these during LTO. */
507 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (binfo
, i
)))
509 odr_type base
= get_odr_type (BINFO_TYPE (BINFO_BASE_BINFO (binfo
,
512 base
->derived_types
.safe_push (val
);
513 val
->bases
.safe_push (base
);
515 /* First record bases, then add into array so ids are increasing. */
517 val
->id
= odr_types
.length ();
518 vec_safe_push (odr_types_ptr
, val
);
523 /* Dump ODR type T and all its derrived type. INDENT specify indentation for
524 recusive printing. */
527 dump_odr_type (FILE *f
, odr_type t
, int indent
=0)
530 fprintf (f
, "%*s type %i: ", indent
* 2, "", t
->id
);
531 print_generic_expr (f
, t
->type
, TDF_SLIM
);
532 fprintf (f
, "%s", t
->anonymous_namespace
? " (anonymous namespace)":"");
533 fprintf (f
, "%s\n", t
->all_derivations_known
? " (derivations known)":"");
534 if (TYPE_NAME (t
->type
))
536 fprintf (f
, "%*s defined at: %s:%i\n", indent
* 2, "",
537 DECL_SOURCE_FILE (TYPE_NAME (t
->type
)),
538 DECL_SOURCE_LINE (TYPE_NAME (t
->type
)));
540 if (t
->bases
.length ())
542 fprintf (f
, "%*s base odr type ids: ", indent
* 2, "");
543 for (i
= 0; i
< t
->bases
.length (); i
++)
544 fprintf (f
, " %i", t
->bases
[i
]->id
);
547 if (t
->derived_types
.length ())
549 fprintf (f
, "%*s derived types:\n", indent
* 2, "");
550 for (i
= 0; i
< t
->derived_types
.length (); i
++)
551 dump_odr_type (f
, t
->derived_types
[i
], indent
+ 1);
556 /* Dump the type inheritance graph. */
559 dump_type_inheritance_graph (FILE *f
)
564 fprintf (f
, "\n\nType inheritance graph:\n");
565 for (i
= 0; i
< odr_types
.length (); i
++)
567 if (odr_types
[i
]->bases
.length () == 0)
568 dump_odr_type (f
, odr_types
[i
]);
570 for (i
= 0; i
< odr_types
.length (); i
++)
572 if (odr_types
[i
]->types
&& odr_types
[i
]->types
->length ())
575 fprintf (f
, "Duplicate tree types for odr type %i\n", i
);
576 print_node (f
, "", odr_types
[i
]->type
, 0);
577 for (j
= 0; j
< odr_types
[i
]->types
->length (); j
++)
580 fprintf (f
, "duplicate #%i\n", j
);
581 print_node (f
, "", (*odr_types
[i
]->types
)[j
], 0);
582 t
= (*odr_types
[i
]->types
)[j
];
583 while (TYPE_P (t
) && TYPE_CONTEXT (t
))
585 t
= TYPE_CONTEXT (t
);
586 print_node (f
, "", t
, 0);
594 /* Given method type T, return type of class it belongs to.
595 Lookup this pointer and get its type. */
598 method_class_type (tree t
)
600 tree first_parm_type
= TREE_VALUE (TYPE_ARG_TYPES (t
));
601 gcc_assert (TREE_CODE (t
) == METHOD_TYPE
);
603 return TREE_TYPE (first_parm_type
);
606 /* Initialize IPA devirt and build inheritance tree graph. */
609 build_type_inheritance_graph (void)
611 struct symtab_node
*n
;
612 FILE *inheritance_dump_file
;
617 timevar_push (TV_IPA_INHERITANCE
);
618 inheritance_dump_file
= dump_begin (TDI_inheritance
, &flags
);
619 odr_hash
= new odr_hash_type (23);
621 /* We reconstruct the graph starting of types of all methods seen in the
624 if (is_a
<cgraph_node
*> (n
)
625 && DECL_VIRTUAL_P (n
->decl
)
626 && symtab_real_symbol_p (n
))
627 get_odr_type (method_class_type (TREE_TYPE (n
->decl
)), true);
629 /* Look also for virtual tables of types that do not define any methods.
631 We need it in a case where class B has virtual base of class A
632 re-defining its virtual method and there is class C with no virtual
633 methods with B as virtual base.
635 Here we output B's virtual method in two variant - for non-virtual
636 and virtual inheritance. B's virtual table has non-virtual version,
637 while C's has virtual.
639 For this reason we need to know about C in order to include both
640 variants of B. More correctly, record_target_from_binfo should
641 add both variants of the method when walking B, but we have no
642 link in between them.
644 We rely on fact that either the method is exported and thus we
645 assume it is called externally or C is in anonymous namespace and
646 thus we will see the vtable. */
648 else if (is_a
<varpool_node
*> (n
)
649 && DECL_VIRTUAL_P (n
->decl
)
650 && TREE_CODE (DECL_CONTEXT (n
->decl
)) == RECORD_TYPE
651 && TYPE_BINFO (DECL_CONTEXT (n
->decl
))
652 && polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (n
->decl
))))
653 get_odr_type (DECL_CONTEXT (n
->decl
), true);
654 if (inheritance_dump_file
)
656 dump_type_inheritance_graph (inheritance_dump_file
);
657 dump_end (TDI_inheritance
, inheritance_dump_file
);
659 timevar_pop (TV_IPA_INHERITANCE
);
662 /* Return true if N has reference from live virtual table
663 (and thus can be a destination of polymorphic call).
664 Be conservatively correct when callgraph is not built or
665 if the method may be referred externally. */
668 referenced_from_vtable_p (struct cgraph_node
*node
)
674 if (node
->externally_visible
675 || node
->used_from_other_partition
)
678 /* Keep this test constant time.
679 It is unlikely this can happen except for the case where speculative
680 devirtualization introduced many speculative edges to this node.
681 In this case the target is very likely alive anyway. */
682 if (node
->ref_list
.referring
.length () > 100)
685 /* We need references built. */
686 if (cgraph_state
<= CGRAPH_STATE_CONSTRUCTION
)
689 for (i
= 0; ipa_ref_list_referring_iterate (&node
->ref_list
,
692 if ((ref
->use
== IPA_REF_ALIAS
693 && referenced_from_vtable_p (cgraph (ref
->referring
)))
694 || (ref
->use
== IPA_REF_ADDR
695 && TREE_CODE (ref
->referring
->decl
) == VAR_DECL
696 && DECL_VIRTUAL_P (ref
->referring
->decl
)))
704 /* If TARGET has associated node, record it in the NODES array.
705 CAN_REFER specify if program can refer to the target directly.
706 if TARGET is unknown (NULL) or it can not be inserted (for example because
707 its body was already removed and there is no way to refer to it), clear
711 maybe_record_node (vec
<cgraph_node
*> &nodes
,
712 tree target
, pointer_set_t
*inserted
,
716 struct cgraph_node
*target_node
;
718 /* cxa_pure_virtual and __builtin_unreachable do not need to be added into
719 list of targets; the runtime effect of calling them is undefined.
720 Only "real" virtual methods should be accounted. */
721 if (target
&& TREE_CODE (TREE_TYPE (target
)) != METHOD_TYPE
)
726 /* The only case when method of anonymous namespace becomes unreferable
727 is when we completely optimized it out. */
730 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target
)))
738 target_node
= cgraph_get_node (target
);
740 /* Method can only be called by polymorphic call if any
741 of vtables refering to it are alive.
743 While this holds for non-anonymous functions, too, there are
744 cases where we want to keep them in the list; for example
745 inline functions with -fno-weak are static, but we still
746 may devirtualize them when instance comes from other unit.
747 The same holds for LTO.
749 Currently we ignore these functions in speculative devirtualization.
750 ??? Maybe it would make sense to be more aggressive for LTO even
753 && type_in_anonymous_namespace_p (DECL_CONTEXT (target
))
755 || !referenced_from_vtable_p (target_node
)))
757 /* See if TARGET is useful function we can deal with. */
758 else if (target_node
!= NULL
759 && (TREE_PUBLIC (target
)
760 || DECL_EXTERNAL (target
)
761 || target_node
->definition
)
762 && symtab_real_symbol_p (target_node
))
764 gcc_assert (!target_node
->global
.inlined_to
);
765 gcc_assert (symtab_real_symbol_p (target_node
));
766 if (!pointer_set_insert (inserted
, target
))
768 pointer_set_insert (cached_polymorphic_call_targets
,
770 nodes
.safe_push (target_node
);
774 && (!type_in_anonymous_namespace_p
775 (DECL_CONTEXT (target
))
780 /* See if BINFO's type match OUTER_TYPE. If so, lookup
781 BINFO of subtype of OTR_TYPE at OFFSET and in that BINFO find
782 method in vtable and insert method to NODES array
783 or BASES_TO_CONSIDER if this array is non-NULL.
784 Otherwise recurse to base BINFOs.
785 This match what get_binfo_at_offset does, but with offset
788 TYPE_BINFOS is a stack of BINFOS of types with defined
789 virtual table seen on way from class type to BINFO.
791 MATCHED_VTABLES tracks virtual tables we already did lookup
792 for virtual function in. INSERTED tracks nodes we already
795 ANONYMOUS is true if BINFO is part of anonymous namespace.
797 Clear COMPLETEP when we hit unreferable target.
801 record_target_from_binfo (vec
<cgraph_node
*> &nodes
,
802 vec
<tree
> *bases_to_consider
,
805 vec
<tree
> &type_binfos
,
806 HOST_WIDE_INT otr_token
,
808 HOST_WIDE_INT offset
,
809 pointer_set_t
*inserted
,
810 pointer_set_t
*matched_vtables
,
814 tree type
= BINFO_TYPE (binfo
);
819 if (BINFO_VTABLE (binfo
))
820 type_binfos
.safe_push (binfo
);
821 if (types_same_for_odr (type
, outer_type
))
824 tree type_binfo
= NULL
;
826 /* Lookup BINFO with virtual table. For normal types it is always last
828 for (i
= type_binfos
.length () - 1; i
>= 0; i
--)
829 if (BINFO_OFFSET (type_binfos
[i
]) == BINFO_OFFSET (binfo
))
831 type_binfo
= type_binfos
[i
];
834 if (BINFO_VTABLE (binfo
))
836 /* If this is duplicated BINFO for base shared by virtual inheritance,
837 we may not have its associated vtable. This is not a problem, since
838 we will walk it on the other path. */
841 tree inner_binfo
= get_binfo_at_offset (type_binfo
,
845 gcc_assert (odr_violation_reported
);
848 /* For types in anonymous namespace first check if the respective vtable
849 is alive. If not, we know the type can't be called. */
850 if (!flag_ltrans
&& anonymous
)
852 tree vtable
= BINFO_VTABLE (inner_binfo
);
855 if (TREE_CODE (vtable
) == POINTER_PLUS_EXPR
)
856 vtable
= TREE_OPERAND (TREE_OPERAND (vtable
, 0), 0);
857 vnode
= varpool_get_node (vtable
);
858 if (!vnode
|| !vnode
->definition
)
861 gcc_assert (inner_binfo
);
862 if (bases_to_consider
863 ? !pointer_set_contains (matched_vtables
, BINFO_VTABLE (inner_binfo
))
864 : !pointer_set_insert (matched_vtables
, BINFO_VTABLE (inner_binfo
)))
867 tree target
= gimple_get_virt_method_for_binfo (otr_token
,
870 if (!bases_to_consider
)
871 maybe_record_node (nodes
, target
, inserted
, can_refer
, completep
);
872 /* Destructors are never called via construction vtables. */
873 else if (!target
|| !DECL_CXX_DESTRUCTOR_P (target
))
874 bases_to_consider
->safe_push (target
);
880 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
881 /* Walking bases that have no virtual method is pointless excercise. */
882 if (polymorphic_type_binfo_p (base_binfo
))
883 record_target_from_binfo (nodes
, bases_to_consider
, base_binfo
, otr_type
,
885 otr_token
, outer_type
, offset
, inserted
,
886 matched_vtables
, anonymous
, completep
);
887 if (BINFO_VTABLE (binfo
))
891 /* Lookup virtual methods matching OTR_TYPE (with OFFSET and OTR_TOKEN)
892 of TYPE, insert them to NODES, recurse into derived nodes.
893 INSERTED is used to avoid duplicate insertions of methods into NODES.
894 MATCHED_VTABLES are used to avoid duplicate walking vtables.
895 Clear COMPLETEP if unreferable target is found.
897 If CONSIDER_CONSTURCTION is true, record to BASES_TO_CONSDIER
898 all cases where BASE_SKIPPED is true (because the base is abstract
902 possible_polymorphic_call_targets_1 (vec
<cgraph_node
*> &nodes
,
903 pointer_set_t
*inserted
,
904 pointer_set_t
*matched_vtables
,
907 HOST_WIDE_INT otr_token
,
909 HOST_WIDE_INT offset
,
911 vec
<tree
> &bases_to_consider
,
912 bool consider_construction
)
914 tree binfo
= TYPE_BINFO (type
->type
);
916 vec
<tree
> type_binfos
= vNULL
;
917 bool possibly_instantiated
= type_possibly_instantiated_p (type
->type
);
919 /* We may need to consider types w/o instances because of possible derived
920 types using their methods either directly or via construction vtables.
921 We are safe to skip them when all derivations are known, since we will
923 This is done by recording them to BASES_TO_CONSIDER array. */
924 if (possibly_instantiated
|| consider_construction
)
926 record_target_from_binfo (nodes
,
927 (!possibly_instantiated
928 && type_all_derivations_known_p (type
->type
))
929 ? &bases_to_consider
: NULL
,
930 binfo
, otr_type
, type_binfos
, otr_token
,
932 inserted
, matched_vtables
,
933 type
->anonymous_namespace
, completep
);
935 type_binfos
.release ();
936 for (i
= 0; i
< type
->derived_types
.length (); i
++)
937 possible_polymorphic_call_targets_1 (nodes
, inserted
,
940 type
->derived_types
[i
],
941 otr_token
, outer_type
, offset
, completep
,
942 bases_to_consider
, consider_construction
);
945 /* Cache of queries for polymorphic call targets.
947 Enumerating all call targets may get expensive when there are many
948 polymorphic calls in the program, so we memoize all the previous
949 queries and avoid duplicated work. */
951 struct polymorphic_call_target_d
953 HOST_WIDE_INT otr_token
;
954 ipa_polymorphic_call_context context
;
956 vec
<cgraph_node
*> targets
;
957 int nonconstruction_targets
;
961 /* Polymorphic call target cache helpers. */
963 struct polymorphic_call_target_hasher
965 typedef polymorphic_call_target_d value_type
;
966 typedef polymorphic_call_target_d compare_type
;
967 static inline hashval_t
hash (const value_type
*);
968 static inline bool equal (const value_type
*, const compare_type
*);
969 static inline void remove (value_type
*);
972 /* Return the computed hashcode for ODR_QUERY. */
975 polymorphic_call_target_hasher::hash (const value_type
*odr_query
)
979 hash
= iterative_hash_host_wide_int
980 (odr_query
->otr_token
,
981 odr_query
->type
->id
);
982 hash
= iterative_hash_hashval_t (TYPE_UID (odr_query
->context
.outer_type
),
984 hash
= iterative_hash_host_wide_int (odr_query
->context
.offset
, hash
);
985 return iterative_hash_hashval_t
986 (((int)odr_query
->context
.maybe_in_construction
<< 1)
987 | (int)odr_query
->context
.maybe_derived_type
, hash
);
990 /* Compare cache entries T1 and T2. */
993 polymorphic_call_target_hasher::equal (const value_type
*t1
,
994 const compare_type
*t2
)
996 return (t1
->type
== t2
->type
&& t1
->otr_token
== t2
->otr_token
997 && t1
->context
.offset
== t2
->context
.offset
998 && t1
->context
.outer_type
== t2
->context
.outer_type
999 && t1
->context
.maybe_in_construction
1000 == t2
->context
.maybe_in_construction
1001 && t1
->context
.maybe_derived_type
== t2
->context
.maybe_derived_type
);
1004 /* Remove entry in polymorphic call target cache hash. */
1007 polymorphic_call_target_hasher::remove (value_type
*v
)
1009 v
->targets
.release ();
1013 /* Polymorphic call target query cache. */
1015 typedef hash_table
<polymorphic_call_target_hasher
>
1016 polymorphic_call_target_hash_type
;
1017 static polymorphic_call_target_hash_type
*polymorphic_call_target_hash
;
1019 /* Destroy polymorphic call target query cache. */
1022 free_polymorphic_call_targets_hash ()
1024 if (cached_polymorphic_call_targets
)
1026 delete polymorphic_call_target_hash
;
1027 polymorphic_call_target_hash
= NULL
;
1028 pointer_set_destroy (cached_polymorphic_call_targets
);
1029 cached_polymorphic_call_targets
= NULL
;
1033 /* When virtual function is removed, we may need to flush the cache. */
1036 devirt_node_removal_hook (struct cgraph_node
*n
, void *d ATTRIBUTE_UNUSED
)
1038 if (cached_polymorphic_call_targets
1039 && pointer_set_contains (cached_polymorphic_call_targets
, n
))
1040 free_polymorphic_call_targets_hash ();
1043 /* CONTEXT->OUTER_TYPE is a type of memory object where object of EXPECTED_TYPE
1044 is contained at CONTEXT->OFFSET. Walk the memory representation of
1045 CONTEXT->OUTER_TYPE and find the outermost class type that match
1046 EXPECTED_TYPE or contain EXPECTED_TYPE as a base. Update CONTEXT
1049 For example when CONTEXT represents type
1055 and we look for type at offset sizeof(int), we end up with B and offset 0.
1056 If the same is produced by multiple inheritance, we end up with A and offset
1059 If we can not find corresponding class, give up by setting
1060 CONTEXT->OUTER_TYPE to EXPECTED_TYPE and CONTEXT->OFFSET to NULL.
1061 Return true when lookup was sucesful. */
1064 get_class_context (ipa_polymorphic_call_context
*context
,
1067 tree type
= context
->outer_type
;
1068 HOST_WIDE_INT offset
= context
->offset
;
1070 /* Find the sub-object the constant actually refers to and mark whether it is
1071 an artificial one (as opposed to a user-defined one). */
1074 HOST_WIDE_INT pos
, size
;
1077 /* On a match, just return what we found. */
1078 if (TREE_CODE (type
) == TREE_CODE (expected_type
)
1079 && types_same_for_odr (type
, expected_type
))
1081 /* Type can not contain itself on an non-zero offset. In that case
1085 gcc_assert (offset
== 0);
1089 /* Walk fields and find corresponding on at OFFSET. */
1090 if (TREE_CODE (type
) == RECORD_TYPE
)
1092 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
1094 if (TREE_CODE (fld
) != FIELD_DECL
)
1097 pos
= int_bit_position (fld
);
1098 size
= tree_to_uhwi (DECL_SIZE (fld
));
1099 if (pos
<= offset
&& (pos
+ size
) > offset
)
1106 type
= TREE_TYPE (fld
);
1108 /* DECL_ARTIFICIAL represents a basetype. */
1109 if (!DECL_ARTIFICIAL (fld
))
1111 context
->outer_type
= type
;
1112 context
->offset
= offset
;
1113 /* As soon as we se an field containing the type,
1114 we know we are not looking for derivations. */
1115 context
->maybe_derived_type
= false;
1118 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1120 tree subtype
= TREE_TYPE (type
);
1122 /* Give up if we don't know array size. */
1123 if (!tree_fits_shwi_p (TYPE_SIZE (subtype
))
1124 || !tree_to_shwi (TYPE_SIZE (subtype
)) <= 0)
1126 offset
= offset
% tree_to_shwi (TYPE_SIZE (subtype
));
1128 context
->outer_type
= type
;
1129 context
->offset
= offset
;
1130 context
->maybe_derived_type
= false;
1132 /* Give up on anything else. */
1137 /* If we failed to find subtype we look for, give up and fall back to the
1138 most generic query. */
1140 context
->outer_type
= expected_type
;
1141 context
->offset
= 0;
1142 context
->maybe_derived_type
= true;
1143 context
->maybe_in_construction
= true;
1144 /* POD can be changed to an instance of a polymorphic type by
1145 placement new. Here we play safe and assume that any
1146 non-polymorphic type is POD. */
1147 if ((TREE_CODE (type
) != RECORD_TYPE
1148 || !TYPE_BINFO (type
)
1149 || !polymorphic_type_binfo_p (TYPE_BINFO (type
)))
1150 && (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
1151 || (offset
+ tree_to_uhwi (TYPE_SIZE (expected_type
)) <=
1152 tree_to_uhwi (TYPE_SIZE (type
)))))
1157 /* Return true if OUTER_TYPE contains OTR_TYPE at OFFSET. */
1160 contains_type_p (tree outer_type
, HOST_WIDE_INT offset
,
1163 ipa_polymorphic_call_context context
= {offset
, outer_type
,
1165 return get_class_context (&context
, otr_type
);
1168 /* Lookup base of BINFO that has virtual table VTABLE with OFFSET. */
1171 subbinfo_with_vtable_at_offset (tree binfo
, unsigned HOST_WIDE_INT offset
,
1174 tree v
= BINFO_VTABLE (binfo
);
1177 unsigned HOST_WIDE_INT this_offset
;
1181 if (!vtable_pointer_value_to_vtable (v
, &v
, &this_offset
))
1184 if (offset
== this_offset
1185 && DECL_ASSEMBLER_NAME (v
) == DECL_ASSEMBLER_NAME (vtable
))
1189 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1190 if (polymorphic_type_binfo_p (base_binfo
))
1192 base_binfo
= subbinfo_with_vtable_at_offset (base_binfo
, offset
, vtable
);
1199 /* T is known constant value of virtual table pointer.
1200 Store virtual table to V and its offset to OFFSET.
1201 Return false if T does not look like virtual table reference. */
1204 vtable_pointer_value_to_vtable (tree t
, tree
*v
, unsigned HOST_WIDE_INT
*offset
)
1206 /* We expect &MEM[(void *)&virtual_table + 16B].
1207 We obtain object's BINFO from the context of the virtual table.
1208 This one contains pointer to virtual table represented via
1209 POINTER_PLUS_EXPR. Verify that this pointer match to what
1210 we propagated through.
1212 In the case of virtual inheritance, the virtual tables may
1213 be nested, i.e. the offset may be different from 16 and we may
1214 need to dive into the type representation. */
1215 if (TREE_CODE (t
) == ADDR_EXPR
1216 && TREE_CODE (TREE_OPERAND (t
, 0)) == MEM_REF
1217 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)) == ADDR_EXPR
1218 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 1)) == INTEGER_CST
1219 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 0))
1221 && DECL_VIRTUAL_P (TREE_OPERAND (TREE_OPERAND
1222 (TREE_OPERAND (t
, 0), 0), 0)))
1224 *v
= TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 0);
1225 *offset
= tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (t
, 0), 1));
1229 /* Alternative representation, used by C++ frontend is POINTER_PLUS_EXPR.
1230 We need to handle it when T comes from static variable initializer or
1232 if (TREE_CODE (t
) == POINTER_PLUS_EXPR
)
1234 *offset
= tree_to_uhwi (TREE_OPERAND (t
, 1));
1235 t
= TREE_OPERAND (t
, 0);
1240 if (TREE_CODE (t
) != ADDR_EXPR
)
1242 *v
= TREE_OPERAND (t
, 0);
1246 /* T is known constant value of virtual table pointer. Return BINFO of the
1250 vtable_pointer_value_to_binfo (tree t
)
1253 unsigned HOST_WIDE_INT offset
;
1255 if (!vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
1258 /* FIXME: for stores of construction vtables we return NULL,
1259 because we do not have BINFO for those. Eventually we should fix
1260 our representation to allow this case to be handled, too.
1261 In the case we see store of BINFO we however may assume
1262 that standard folding will be ale to cope with it. */
1263 return subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable
)),
1267 /* Proudce polymorphic call context for call method of instance
1268 that is located within BASE (that is assumed to be a decl) at OFFSET. */
1271 get_polymorphic_call_info_for_decl (ipa_polymorphic_call_context
*context
,
1272 tree base
, HOST_WIDE_INT offset
)
1274 gcc_assert (DECL_P (base
));
1276 context
->outer_type
= TREE_TYPE (base
);
1277 context
->offset
= offset
;
1278 /* Make very conservative assumption that all objects
1279 may be in construction.
1280 TODO: ipa-prop already contains code to tell better.
1282 context
->maybe_in_construction
= true;
1283 context
->maybe_derived_type
= false;
1286 /* CST is an invariant (address of decl), try to get meaningful
1287 polymorphic call context for polymorphic call of method
1288 if instance of OTR_TYPE that is located at OFFSET of this invariant.
1289 Return FALSE if nothing meaningful can be found. */
1292 get_polymorphic_call_info_from_invariant (ipa_polymorphic_call_context
*context
,
1295 HOST_WIDE_INT offset
)
1297 HOST_WIDE_INT offset2
, size
, max_size
;
1300 if (TREE_CODE (cst
) != ADDR_EXPR
)
1303 cst
= TREE_OPERAND (cst
, 0);
1304 base
= get_ref_base_and_extent (cst
, &offset2
, &size
, &max_size
);
1305 if (!DECL_P (base
) || max_size
== -1 || max_size
!= size
)
1308 /* Only type inconsistent programs can have otr_type that is
1309 not part of outer type. */
1310 if (!contains_type_p (TREE_TYPE (base
), offset
, otr_type
))
1313 get_polymorphic_call_info_for_decl (context
, base
, offset
);
1317 /* Given REF call in FNDECL, determine class of the polymorphic
1318 call (OTR_TYPE), its token (OTR_TOKEN) and CONTEXT.
1319 Return pointer to object described by the context */
1322 get_polymorphic_call_info (tree fndecl
,
1325 HOST_WIDE_INT
*otr_token
,
1326 ipa_polymorphic_call_context
*context
)
1329 *otr_type
= obj_type_ref_class (ref
);
1330 *otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1332 /* Set up basic info in case we find nothing interesting in the analysis. */
1333 context
->outer_type
= *otr_type
;
1334 context
->offset
= 0;
1335 base_pointer
= OBJ_TYPE_REF_OBJECT (ref
);
1336 context
->maybe_derived_type
= true;
1337 context
->maybe_in_construction
= true;
1339 /* Walk SSA for outer object. */
1342 if (TREE_CODE (base_pointer
) == SSA_NAME
1343 && !SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
1344 && SSA_NAME_DEF_STMT (base_pointer
)
1345 && gimple_assign_single_p (SSA_NAME_DEF_STMT (base_pointer
)))
1347 base_pointer
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (base_pointer
));
1348 STRIP_NOPS (base_pointer
);
1350 else if (TREE_CODE (base_pointer
) == ADDR_EXPR
)
1352 HOST_WIDE_INT size
, max_size
;
1353 HOST_WIDE_INT offset2
;
1354 tree base
= get_ref_base_and_extent (TREE_OPERAND (base_pointer
, 0),
1355 &offset2
, &size
, &max_size
);
1357 /* If this is a varying address, punt. */
1358 if ((TREE_CODE (base
) == MEM_REF
|| DECL_P (base
))
1360 && max_size
== size
)
1362 /* We found dereference of a pointer. Type of the pointer
1363 and MEM_REF is meaningless, but we can look futher. */
1364 if (TREE_CODE (base
) == MEM_REF
)
1366 base_pointer
= TREE_OPERAND (base
, 0);
1368 += offset2
+ mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
1369 context
->outer_type
= NULL
;
1371 /* We found base object. In this case the outer_type
1373 else if (DECL_P (base
))
1375 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (base
)));
1377 /* Only type inconsistent programs can have otr_type that is
1378 not part of outer type. */
1379 if (!contains_type_p (TREE_TYPE (base
),
1380 context
->offset
+ offset2
, *otr_type
))
1382 /* Use OTR_TOKEN = INT_MAX as a marker of probably type inconsistent
1383 code sequences; we arrange the calls to be builtin_unreachable
1385 *otr_token
= INT_MAX
;
1386 return base_pointer
;
1388 get_polymorphic_call_info_for_decl (context
, base
,
1389 context
->offset
+ offset2
);
1398 else if (TREE_CODE (base_pointer
) == POINTER_PLUS_EXPR
1399 && tree_fits_uhwi_p (TREE_OPERAND (base_pointer
, 1)))
1401 context
->offset
+= tree_to_shwi (TREE_OPERAND (base_pointer
, 1))
1403 base_pointer
= TREE_OPERAND (base_pointer
, 0);
1410 /* Try to determine type of the outer object. */
1411 if (TREE_CODE (base_pointer
) == SSA_NAME
1412 && SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
1413 && TREE_CODE (SSA_NAME_VAR (base_pointer
)) == PARM_DECL
)
1415 /* See if parameter is THIS pointer of a method. */
1416 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
1417 && SSA_NAME_VAR (base_pointer
) == DECL_ARGUMENTS (fndecl
))
1419 context
->outer_type
= TREE_TYPE (TREE_TYPE (base_pointer
));
1420 gcc_assert (TREE_CODE (context
->outer_type
) == RECORD_TYPE
);
1422 /* Dynamic casting has possibly upcasted the type
1423 in the hiearchy. In this case outer type is less
1424 informative than inner type and we should forget
1426 if (!contains_type_p (context
->outer_type
, context
->offset
,
1429 context
->outer_type
= NULL
;
1430 return base_pointer
;
1433 /* If the function is constructor or destructor, then
1434 the type is possibly in construction, but we know
1435 it is not derived type. */
1436 if (DECL_CXX_CONSTRUCTOR_P (fndecl
)
1437 || DECL_CXX_DESTRUCTOR_P (fndecl
))
1439 context
->maybe_in_construction
= true;
1440 context
->maybe_derived_type
= false;
1444 context
->maybe_derived_type
= true;
1445 context
->maybe_in_construction
= false;
1447 return base_pointer
;
1449 /* Non-PODs passed by value are really passed by invisible
1450 reference. In this case we also know the type of the
1452 if (DECL_BY_REFERENCE (SSA_NAME_VAR (base_pointer
)))
1454 context
->outer_type
= TREE_TYPE (TREE_TYPE (base_pointer
));
1455 gcc_assert (!POINTER_TYPE_P (context
->outer_type
));
1456 /* Only type inconsistent programs can have otr_type that is
1457 not part of outer type. */
1458 if (!contains_type_p (context
->outer_type
, context
->offset
,
1461 /* Use OTR_TOKEN = INT_MAX as a marker of probably type inconsistent
1462 code sequences; we arrange the calls to be builtin_unreachable
1464 *otr_token
= INT_MAX
;
1465 return base_pointer
;
1467 context
->maybe_derived_type
= false;
1468 context
->maybe_in_construction
= false;
1469 return base_pointer
;
1472 /* TODO: There are multiple ways to derive a type. For instance
1473 if BASE_POINTER is passed to an constructor call prior our refernece.
1474 We do not make this type of flow sensitive analysis yet. */
1475 return base_pointer
;
1478 /* Walk bases of OUTER_TYPE that contain OTR_TYPE at OFFSET.
1479 Lookup their respecitve virtual methods for OTR_TOKEN and OTR_TYPE
1480 and insert them to NODES.
1482 MATCHED_VTABLES and INSERTED is used to avoid duplicated work. */
1485 record_targets_from_bases (tree otr_type
,
1486 HOST_WIDE_INT otr_token
,
1488 HOST_WIDE_INT offset
,
1489 vec
<cgraph_node
*> &nodes
,
1490 pointer_set_t
*inserted
,
1491 pointer_set_t
*matched_vtables
,
1496 HOST_WIDE_INT pos
, size
;
1500 if (types_same_for_odr (outer_type
, otr_type
))
1503 for (fld
= TYPE_FIELDS (outer_type
); fld
; fld
= DECL_CHAIN (fld
))
1505 if (TREE_CODE (fld
) != FIELD_DECL
)
1508 pos
= int_bit_position (fld
);
1509 size
= tree_to_shwi (DECL_SIZE (fld
));
1510 if (pos
<= offset
&& (pos
+ size
) > offset
1511 /* Do not get confused by zero sized bases. */
1512 && polymorphic_type_binfo_p (TYPE_BINFO (TREE_TYPE (fld
))))
1515 /* Within a class type we should always find correcponding fields. */
1516 gcc_assert (fld
&& TREE_CODE (TREE_TYPE (fld
)) == RECORD_TYPE
);
1518 /* Nonbasetypes should have been stripped by outer_class_type. */
1519 gcc_assert (DECL_ARTIFICIAL (fld
));
1521 outer_type
= TREE_TYPE (fld
);
1524 base_binfo
= get_binfo_at_offset (TYPE_BINFO (outer_type
),
1528 gcc_assert (odr_violation_reported
);
1531 gcc_assert (base_binfo
);
1532 if (!pointer_set_insert (matched_vtables
, BINFO_VTABLE (base_binfo
)))
1535 tree target
= gimple_get_virt_method_for_binfo (otr_token
,
1538 if (!target
|| ! DECL_CXX_DESTRUCTOR_P (target
))
1539 maybe_record_node (nodes
, target
, inserted
, can_refer
, completep
);
1540 pointer_set_insert (matched_vtables
, BINFO_VTABLE (base_binfo
));
1545 /* When virtual table is removed, we may need to flush the cache. */
1548 devirt_variable_node_removal_hook (varpool_node
*n
,
1549 void *d ATTRIBUTE_UNUSED
)
1551 if (cached_polymorphic_call_targets
1552 && DECL_VIRTUAL_P (n
->decl
)
1553 && type_in_anonymous_namespace_p (DECL_CONTEXT (n
->decl
)))
1554 free_polymorphic_call_targets_hash ();
1557 /* Return vector containing possible targets of polymorphic call of type
1558 OTR_TYPE caling method OTR_TOKEN within type of OTR_OUTER_TYPE and OFFSET.
1559 If INCLUDE_BASES is true, walk also base types of OUTER_TYPES containig
1560 OTR_TYPE and include their virtual method. This is useful for types
1561 possibly in construction or destruction where the virtual table may
1562 temporarily change to one of base types. INCLUDE_DERIVER_TYPES make
1563 us to walk the inheritance graph for all derivations.
1565 OTR_TOKEN == INT_MAX is used to mark calls that are provably
1566 undefined and should be redirected to unreachable.
1568 If COMPLETEP is non-NULL, store true if the list is complete.
1569 CACHE_TOKEN (if non-NULL) will get stored to an unique ID of entry
1570 in the target cache. If user needs to visit every target list
1571 just once, it can memoize them.
1573 NONCONSTRUCTION_TARGETS specify number of targets with asumption that
1574 the type is not in the construction. Those targets appear first in the
1577 Returned vector is placed into cache. It is NOT caller's responsibility
1578 to free it. The vector can be freed on cgraph_remove_node call if
1579 the particular node is a virtual function present in the cache. */
1582 possible_polymorphic_call_targets (tree otr_type
,
1583 HOST_WIDE_INT otr_token
,
1584 ipa_polymorphic_call_context context
,
1587 int *nonconstruction_targetsp
)
1589 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
1590 pointer_set_t
*inserted
;
1591 pointer_set_t
*matched_vtables
;
1592 vec
<cgraph_node
*> nodes
= vNULL
;
1593 vec
<tree
> bases_to_consider
= vNULL
;
1594 odr_type type
, outer_type
;
1595 polymorphic_call_target_d key
;
1596 polymorphic_call_target_d
**slot
;
1601 bool skipped
= false;
1603 /* If ODR is not initialized, return empty incomplete list. */
1609 *cache_token
= NULL
;
1610 if (nonconstruction_targetsp
)
1611 *nonconstruction_targetsp
= 0;
1615 /* If we hit type inconsistency, just return empty list of targets. */
1616 if (otr_token
== INT_MAX
)
1621 *cache_token
= NULL
;
1622 if (nonconstruction_targetsp
)
1623 *nonconstruction_targetsp
= 0;
1627 type
= get_odr_type (otr_type
, true);
1629 /* Lookup the outer class type we want to walk. */
1630 if (context
.outer_type
1631 && !get_class_context (&context
, otr_type
))
1636 *cache_token
= NULL
;
1637 if (nonconstruction_targetsp
)
1638 *nonconstruction_targetsp
= 0;
1642 /* We canonicalize our query, so we do not need extra hashtable entries. */
1644 /* Without outer type, we have no use for offset. Just do the
1645 basic search from innter type */
1646 if (!context
.outer_type
)
1648 context
.outer_type
= otr_type
;
1651 /* We need to update our hiearchy if the type does not exist. */
1652 outer_type
= get_odr_type (context
.outer_type
, true);
1653 /* If the type is complete, there are no derivations. */
1654 if (TYPE_FINAL_P (outer_type
->type
))
1655 context
.maybe_derived_type
= false;
1657 /* Initialize query cache. */
1658 if (!cached_polymorphic_call_targets
)
1660 cached_polymorphic_call_targets
= pointer_set_create ();
1661 polymorphic_call_target_hash
1662 = new polymorphic_call_target_hash_type (23);
1663 if (!node_removal_hook_holder
)
1665 node_removal_hook_holder
=
1666 cgraph_add_node_removal_hook (&devirt_node_removal_hook
, NULL
);
1667 varpool_add_node_removal_hook (&devirt_variable_node_removal_hook
,
1672 /* Lookup cached answer. */
1674 key
.otr_token
= otr_token
;
1675 key
.context
= context
;
1676 slot
= polymorphic_call_target_hash
->find_slot (&key
, INSERT
);
1678 *cache_token
= (void *)*slot
;
1682 *completep
= (*slot
)->complete
;
1683 if (nonconstruction_targetsp
)
1684 *nonconstruction_targetsp
= (*slot
)->nonconstruction_targets
;
1685 return (*slot
)->targets
;
1690 /* Do actual search. */
1691 timevar_push (TV_IPA_VIRTUAL_CALL
);
1692 *slot
= XCNEW (polymorphic_call_target_d
);
1694 *cache_token
= (void *)*slot
;
1695 (*slot
)->type
= type
;
1696 (*slot
)->otr_token
= otr_token
;
1697 (*slot
)->context
= context
;
1699 inserted
= pointer_set_create ();
1700 matched_vtables
= pointer_set_create ();
1702 /* First see virtual method of type itself. */
1703 binfo
= get_binfo_at_offset (TYPE_BINFO (outer_type
->type
),
1704 context
.offset
, otr_type
);
1706 target
= gimple_get_virt_method_for_binfo (otr_token
, binfo
,
1710 gcc_assert (odr_violation_reported
);
1714 /* Destructors are never called through construction virtual tables,
1715 because the type is always known. */
1716 if (target
&& DECL_CXX_DESTRUCTOR_P (target
))
1717 context
.maybe_in_construction
= false;
1721 /* In the case we get complete method, we don't need
1722 to walk derivations. */
1723 if (DECL_FINAL_P (target
))
1724 context
.maybe_derived_type
= false;
1727 /* If OUTER_TYPE is abstract, we know we are not seeing its instance. */
1728 if (type_possibly_instantiated_p (outer_type
->type
))
1729 maybe_record_node (nodes
, target
, inserted
, can_refer
, &complete
);
1733 gcc_assert (in_lto_p
|| context
.maybe_derived_type
);
1736 pointer_set_insert (matched_vtables
, BINFO_VTABLE (binfo
));
1738 /* Next walk recursively all derived types. */
1739 if (context
.maybe_derived_type
)
1741 /* For anonymous namespace types we can attempt to build full type.
1742 All derivations must be in this unit (unless we see partial unit). */
1743 if (!type
->all_derivations_known
)
1745 for (i
= 0; i
< outer_type
->derived_types
.length(); i
++)
1746 possible_polymorphic_call_targets_1 (nodes
, inserted
,
1749 outer_type
->derived_types
[i
],
1750 otr_token
, outer_type
->type
,
1751 context
.offset
, &complete
,
1753 context
.maybe_in_construction
);
1756 /* Finally walk bases, if asked to. */
1757 (*slot
)->nonconstruction_targets
= nodes
.length();
1759 /* Destructors are never called through construction virtual tables,
1760 because the type is always known. One of entries may be cxa_pure_virtual
1761 so look to at least two of them. */
1762 if (context
.maybe_in_construction
)
1763 for (i
=0 ; i
< MIN (nodes
.length (), 2); i
++)
1764 if (DECL_CXX_DESTRUCTOR_P (nodes
[i
]->decl
))
1765 context
.maybe_in_construction
= false;
1766 if (context
.maybe_in_construction
)
1768 if (type
!= outer_type
1770 || (context
.maybe_derived_type
1771 && !type_all_derivations_known_p (outer_type
->type
))))
1772 record_targets_from_bases (otr_type
, otr_token
, outer_type
->type
,
1773 context
.offset
, nodes
, inserted
,
1774 matched_vtables
, &complete
);
1776 maybe_record_node (nodes
, target
, inserted
, can_refer
, &complete
);
1777 for (i
= 0; i
< bases_to_consider
.length(); i
++)
1778 maybe_record_node (nodes
, bases_to_consider
[i
], inserted
, can_refer
, &complete
);
1780 bases_to_consider
.release();
1782 (*slot
)->targets
= nodes
;
1783 (*slot
)->complete
= complete
;
1785 *completep
= complete
;
1786 if (nonconstruction_targetsp
)
1787 *nonconstruction_targetsp
= (*slot
)->nonconstruction_targets
;
1789 pointer_set_destroy (inserted
);
1790 pointer_set_destroy (matched_vtables
);
1791 timevar_pop (TV_IPA_VIRTUAL_CALL
);
1795 /* Dump all possible targets of a polymorphic call. */
1798 dump_possible_polymorphic_call_targets (FILE *f
,
1800 HOST_WIDE_INT otr_token
,
1801 const ipa_polymorphic_call_context
&ctx
)
1803 vec
<cgraph_node
*> targets
;
1805 odr_type type
= get_odr_type (otr_type
, false);
1807 int nonconstruction
;
1811 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
,
1813 &final
, NULL
, &nonconstruction
);
1814 fprintf (f
, " Targets of polymorphic call of type %i:", type
->id
);
1815 print_generic_expr (f
, type
->type
, TDF_SLIM
);
1816 fprintf (f
, " token %i\n", (int)otr_token
);
1817 if (ctx
.outer_type
|| ctx
.offset
)
1819 fprintf (f
, " Contained in type:");
1820 print_generic_expr (f
, ctx
.outer_type
, TDF_SLIM
);
1821 fprintf (f
, " at offset "HOST_WIDE_INT_PRINT_DEC
"\n",
1825 fprintf (f
, " %s%s%s\n ",
1826 final
? "This is a complete list." :
1827 "This is partial list; extra targets may be defined in other units.",
1828 ctx
.maybe_in_construction
? " (base types included)" : "",
1829 ctx
.maybe_derived_type
? " (derived types included)" : "");
1830 for (i
= 0; i
< targets
.length (); i
++)
1833 if (i
== (unsigned)nonconstruction
)
1834 fprintf (f
, "\n If the type is in construction,"
1835 " then additional tarets are:\n"
1838 name
= cplus_demangle_v3 (targets
[i
]->asm_name (), 0);
1839 fprintf (f
, " %s/%i", name
? name
: targets
[i
]->name (), targets
[i
]->order
);
1842 if (!targets
[i
]->definition
)
1843 fprintf (f
, " (no definition%s)",
1844 DECL_DECLARED_INLINE_P (targets
[i
]->decl
)
1847 fprintf (f
, "\n\n");
1851 /* Return true if N can be possibly target of a polymorphic call of
1852 OTR_TYPE/OTR_TOKEN. */
1855 possible_polymorphic_call_target_p (tree otr_type
,
1856 HOST_WIDE_INT otr_token
,
1857 const ipa_polymorphic_call_context
&ctx
,
1858 struct cgraph_node
*n
)
1860 vec
<cgraph_node
*> targets
;
1862 enum built_in_function fcode
;
1865 if (TREE_CODE (TREE_TYPE (n
->decl
)) == FUNCTION_TYPE
1866 && ((fcode
= DECL_FUNCTION_CODE (n
->decl
))
1867 == BUILT_IN_UNREACHABLE
1868 || fcode
== BUILT_IN_TRAP
))
1873 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
, ctx
, &final
);
1874 for (i
= 0; i
< targets
.length (); i
++)
1875 if (symtab_semantically_equivalent_p (n
, targets
[i
]))
1878 /* At a moment we allow middle end to dig out new external declarations
1879 as a targets of polymorphic calls. */
1880 if (!final
&& !n
->definition
)
1886 /* After callgraph construction new external nodes may appear.
1887 Add them into the graph. */
1890 update_type_inheritance_graph (void)
1892 struct cgraph_node
*n
;
1896 free_polymorphic_call_targets_hash ();
1897 timevar_push (TV_IPA_INHERITANCE
);
1898 /* We reconstruct the graph starting from types of all methods seen in the
1900 FOR_EACH_FUNCTION (n
)
1901 if (DECL_VIRTUAL_P (n
->decl
)
1903 && symtab_real_symbol_p (n
))
1904 get_odr_type (method_class_type (TREE_TYPE (n
->decl
)), true);
1905 timevar_pop (TV_IPA_INHERITANCE
);
1909 /* Return true if N looks like likely target of a polymorphic call.
1910 Rule out cxa_pure_virtual, noreturns, function declared cold and
1911 other obvious cases. */
1914 likely_target_p (struct cgraph_node
*n
)
1917 /* cxa_pure_virtual and similar things are not likely. */
1918 if (TREE_CODE (TREE_TYPE (n
->decl
)) != METHOD_TYPE
)
1920 flags
= flags_from_decl_or_type (n
->decl
);
1921 if (flags
& ECF_NORETURN
)
1923 if (lookup_attribute ("cold",
1924 DECL_ATTRIBUTES (n
->decl
)))
1926 if (n
->frequency
< NODE_FREQUENCY_NORMAL
)
1928 /* If there are no virtual tables refering the target alive,
1929 the only way the target can be called is an instance comming from other
1930 compilation unit; speculative devirtualization is build around an
1931 assumption that won't happen. */
1932 if (!referenced_from_vtable_p (n
))
1937 /* The ipa-devirt pass.
1938 When polymorphic call has only one likely target in the unit,
1939 turn it into speculative call. */
1944 struct cgraph_node
*n
;
1945 struct pointer_set_t
*bad_call_targets
= pointer_set_create ();
1946 struct cgraph_edge
*e
;
1948 int npolymorphic
= 0, nspeculated
= 0, nconverted
= 0, ncold
= 0;
1949 int nmultiple
= 0, noverwritable
= 0, ndevirtualized
= 0, nnotdefined
= 0;
1950 int nwrong
= 0, nok
= 0, nexternal
= 0, nartificial
= 0;
1952 FOR_EACH_DEFINED_FUNCTION (n
)
1954 bool update
= false;
1955 if (dump_file
&& n
->indirect_calls
)
1956 fprintf (dump_file
, "\n\nProcesing function %s/%i\n",
1957 n
->name (), n
->order
);
1958 for (e
= n
->indirect_calls
; e
; e
= e
->next_callee
)
1959 if (e
->indirect_info
->polymorphic
)
1961 struct cgraph_node
*likely_target
= NULL
;
1964 int nonconstruction_targets
;
1965 vec
<cgraph_node
*>targets
1966 = possible_polymorphic_call_targets
1967 (e
, &final
, &cache_token
, &nonconstruction_targets
);
1971 dump_possible_polymorphic_call_targets
1976 if (!cgraph_maybe_hot_edge_p (e
))
1979 fprintf (dump_file
, "Call is cold\n\n");
1986 fprintf (dump_file
, "Call is aready speculated\n\n");
1989 /* When dumping see if we agree with speculation. */
1993 if (pointer_set_contains (bad_call_targets
,
1997 fprintf (dump_file
, "Target list is known to be useless\n\n");
2001 for (i
= 0; i
< targets
.length (); i
++)
2002 if (likely_target_p (targets
[i
]))
2006 if (i
< (unsigned) nonconstruction_targets
)
2008 likely_target
= NULL
;
2010 fprintf (dump_file
, "More than one likely target\n\n");
2015 likely_target
= targets
[i
];
2019 pointer_set_insert (bad_call_targets
, cache_token
);
2022 /* This is reached only when dumping; check if we agree or disagree
2023 with the speculation. */
2026 struct cgraph_edge
*e2
;
2027 struct ipa_ref
*ref
;
2028 cgraph_speculative_call_info (e
, e2
, e
, ref
);
2029 if (cgraph_function_or_thunk_node (e2
->callee
, NULL
)
2030 == cgraph_function_or_thunk_node (likely_target
, NULL
))
2032 fprintf (dump_file
, "We agree with speculation\n\n");
2037 fprintf (dump_file
, "We disagree with speculation\n\n");
2042 if (!likely_target
->definition
)
2045 fprintf (dump_file
, "Target is not an definition\n\n");
2049 /* Do not introduce new references to external symbols. While we
2050 can handle these just well, it is common for programs to
2051 incorrectly with headers defining methods they are linked
2053 if (DECL_EXTERNAL (likely_target
->decl
))
2056 fprintf (dump_file
, "Target is external\n\n");
2060 /* Don't use an implicitly-declared destructor (c++/58678). */
2061 struct cgraph_node
*non_thunk_target
2062 = cgraph_function_node (likely_target
);
2063 if (DECL_ARTIFICIAL (non_thunk_target
->decl
)
2064 && DECL_COMDAT (non_thunk_target
->decl
))
2067 fprintf (dump_file
, "Target is artificial\n\n");
2071 if (cgraph_function_body_availability (likely_target
)
2072 <= AVAIL_OVERWRITABLE
2073 && symtab_can_be_discarded (likely_target
))
2076 fprintf (dump_file
, "Target is overwritable\n\n");
2080 else if (dbg_cnt (devirt
))
2082 if (dump_enabled_p ())
2084 location_t locus
= gimple_location (e
->call_stmt
);
2085 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, locus
,
2086 "speculatively devirtualizing call in %s/%i to %s/%i\n",
2087 n
->name (), n
->order
,
2088 likely_target
->name (),
2089 likely_target
->order
);
2091 if (!symtab_can_be_discarded (likely_target
))
2094 alias
= cgraph (symtab_nonoverwritable_alias
2097 likely_target
= alias
;
2101 cgraph_turn_edge_to_speculative
2102 (e
, likely_target
, e
->count
* 8 / 10, e
->frequency
* 8 / 10);
2106 inline_update_overall_summary (n
);
2108 pointer_set_destroy (bad_call_targets
);
2112 "%i polymorphic calls, %i devirtualized,"
2113 " %i speculatively devirtualized, %i cold\n"
2114 "%i have multiple targets, %i overwritable,"
2115 " %i already speculated (%i agree, %i disagree),"
2116 " %i external, %i not defined, %i artificial\n",
2117 npolymorphic
, ndevirtualized
, nconverted
, ncold
,
2118 nmultiple
, noverwritable
, nspeculated
, nok
, nwrong
,
2119 nexternal
, nnotdefined
, nartificial
);
2120 return ndevirtualized
? TODO_remove_functions
: 0;
2125 const pass_data pass_data_ipa_devirt
=
2127 IPA_PASS
, /* type */
2128 "devirt", /* name */
2129 OPTGROUP_NONE
, /* optinfo_flags */
2130 true, /* has_execute */
2131 TV_IPA_DEVIRT
, /* tv_id */
2132 0, /* properties_required */
2133 0, /* properties_provided */
2134 0, /* properties_destroyed */
2135 0, /* todo_flags_start */
2136 ( TODO_dump_symtab
), /* todo_flags_finish */
2139 class pass_ipa_devirt
: public ipa_opt_pass_d
2142 pass_ipa_devirt (gcc::context
*ctxt
)
2143 : ipa_opt_pass_d (pass_data_ipa_devirt
, ctxt
,
2144 NULL
, /* generate_summary */
2145 NULL
, /* write_summary */
2146 NULL
, /* read_summary */
2147 NULL
, /* write_optimization_summary */
2148 NULL
, /* read_optimization_summary */
2149 NULL
, /* stmt_fixup */
2150 0, /* function_transform_todo_flags_start */
2151 NULL
, /* function_transform */
2152 NULL
) /* variable_transform */
2155 /* opt_pass methods: */
2156 virtual bool gate (function
*)
2158 return (flag_devirtualize
2159 && flag_devirtualize_speculatively
2163 virtual unsigned int execute (function
*) { return ipa_devirt (); }
2165 }; // class pass_ipa_devirt
2170 make_pass_ipa_devirt (gcc::context
*ctxt
)
2172 return new pass_ipa_devirt (ctxt
);
2175 #include "gt-ipa-devirt.h"