1 /* Basic IPA utilities for type inheritance graph construction and
3 Copyright (C) 2013-2018 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++ frontend. 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 representation 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"
115 #include "alloc-pool.h"
116 #include "tree-pass.h"
118 #include "lto-streamer.h"
119 #include "fold-const.h"
120 #include "print-tree.h"
122 #include "ipa-utils.h"
123 #include "gimple-fold.h"
124 #include "symbol-summary.h"
125 #include "tree-vrp.h"
126 #include "ipa-prop.h"
127 #include "ipa-fnsummary.h"
128 #include "demangle.h"
130 #include "gimple-pretty-print.h"
132 #include "stringpool.h"
135 /* Hash based set of pairs of types. */
143 struct default_hash_traits
<type_pair
>
144 : typed_noop_remove
<type_pair
>
146 GTY((skip
)) typedef type_pair value_type
;
147 GTY((skip
)) typedef type_pair compare_type
;
151 return TYPE_UID (p
.first
) ^ TYPE_UID (p
.second
);
154 is_empty (type_pair p
)
156 return p
.first
== NULL
;
159 is_deleted (type_pair p ATTRIBUTE_UNUSED
)
164 equal (const type_pair
&a
, const type_pair
&b
)
166 return a
.first
==b
.first
&& a
.second
== b
.second
;
169 mark_empty (type_pair
&e
)
175 static bool odr_types_equivalent_p (tree
, tree
, bool, bool *,
176 hash_set
<type_pair
> *,
177 location_t
, location_t
);
179 static bool odr_violation_reported
= false;
182 /* Pointer set of all call targets appearing in the cache. */
183 static hash_set
<cgraph_node
*> *cached_polymorphic_call_targets
;
185 /* The node of type inheritance graph. For each type unique in
186 One Definition Rule (ODR) sense, we produce one node linking all
187 main variants of types equivalent to it, bases and derived types. */
189 struct GTY(()) odr_type_d
193 /* All bases; built only for main variants of types. */
194 vec
<odr_type
> GTY((skip
)) bases
;
195 /* All derived types with virtual methods seen in unit;
196 built only for main variants of types. */
197 vec
<odr_type
> GTY((skip
)) derived_types
;
199 /* All equivalent types, if more than one. */
200 vec
<tree
, va_gc
> *types
;
201 /* Set of all equivalent types, if NON-NULL. */
202 hash_set
<tree
> * GTY((skip
)) types_set
;
204 /* Unique ID indexing the type in odr_types array. */
206 /* Is it in anonymous namespace? */
207 bool anonymous_namespace
;
208 /* Do we know about all derivations of given type? */
209 bool all_derivations_known
;
210 /* Did we report ODR violation here? */
212 /* Set when virtual table without RTTI previaled table with. */
216 /* Return TRUE if all derived types of T are known and thus
217 we may consider the walk of derived type complete.
219 This is typically true only for final anonymous namespace types and types
220 defined within functions (that may be COMDAT and thus shared across units,
221 but with the same set of derived types). */
224 type_all_derivations_known_p (const_tree t
)
226 if (TYPE_FINAL_P (t
))
230 /* Non-C++ types may have IDENTIFIER_NODE here, do not crash. */
231 if (!TYPE_NAME (t
) || TREE_CODE (TYPE_NAME (t
)) != TYPE_DECL
)
233 if (type_in_anonymous_namespace_p (t
))
235 return (decl_function_context (TYPE_NAME (t
)) != NULL
);
238 /* Return TRUE if type's constructors are all visible. */
241 type_all_ctors_visible_p (tree t
)
244 && symtab
->state
>= CONSTRUCTION
245 /* We can not always use type_all_derivations_known_p.
246 For function local types we must assume case where
247 the function is COMDAT and shared in between units.
249 TODO: These cases are quite easy to get, but we need
250 to keep track of C++ privatizing via -Wno-weak
251 as well as the IPA privatizing. */
252 && type_in_anonymous_namespace_p (t
);
255 /* Return TRUE if type may have instance. */
258 type_possibly_instantiated_p (tree t
)
263 /* TODO: Add abstract types here. */
264 if (!type_all_ctors_visible_p (t
))
267 vtable
= BINFO_VTABLE (TYPE_BINFO (t
));
268 if (TREE_CODE (vtable
) == POINTER_PLUS_EXPR
)
269 vtable
= TREE_OPERAND (TREE_OPERAND (vtable
, 0), 0);
270 vnode
= varpool_node::get (vtable
);
271 return vnode
&& vnode
->definition
;
274 /* Hash used to unify ODR types based on their mangled name and for anonymous
277 struct odr_name_hasher
: pointer_hash
<odr_type_d
>
279 typedef union tree_node
*compare_type
;
280 static inline hashval_t
hash (const odr_type_d
*);
281 static inline bool equal (const odr_type_d
*, const tree_node
*);
282 static inline void remove (odr_type_d
*);
285 /* Has used to unify ODR types based on their associated virtual table.
286 This hash is needed to keep -fno-lto-odr-type-merging to work and contains
287 only polymorphic types. Types with mangled names are inserted to both. */
289 struct odr_vtable_hasher
:odr_name_hasher
291 static inline hashval_t
hash (const odr_type_d
*);
292 static inline bool equal (const odr_type_d
*, const tree_node
*);
295 /* Return type that was declared with T's name so that T is an
296 qualified variant of it. */
299 main_odr_variant (const_tree t
)
301 if (TYPE_NAME (t
) && TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
)
302 return TREE_TYPE (TYPE_NAME (t
));
303 /* Unnamed types and non-C++ produced types can be compared by variants. */
305 return TYPE_MAIN_VARIANT (t
);
309 can_be_name_hashed_p (tree t
)
311 return (!in_lto_p
|| odr_type_p (t
));
314 /* Hash type by its ODR name. */
317 hash_odr_name (const_tree t
)
319 gcc_checking_assert (main_odr_variant (t
) == t
);
321 /* If not in LTO, all main variants are unique, so we can do
324 return htab_hash_pointer (t
);
326 /* Anonymous types are unique. */
327 if (type_with_linkage_p (t
) && type_in_anonymous_namespace_p (t
))
328 return htab_hash_pointer (t
);
330 gcc_checking_assert (TYPE_NAME (t
)
331 && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t
)));
332 return IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (TYPE_NAME (t
)));
335 /* Return the computed hashcode for ODR_TYPE. */
338 odr_name_hasher::hash (const odr_type_d
*odr_type
)
340 return hash_odr_name (odr_type
->type
);
344 can_be_vtable_hashed_p (tree t
)
346 /* vtable hashing can distinguish only main variants. */
347 if (TYPE_MAIN_VARIANT (t
) != t
)
349 /* Anonymous namespace types are always handled by name hash. */
350 if (type_with_linkage_p (t
) && type_in_anonymous_namespace_p (t
))
352 return (TREE_CODE (t
) == RECORD_TYPE
353 && TYPE_BINFO (t
) && BINFO_VTABLE (TYPE_BINFO (t
)));
356 /* Hash type by assembler name of its vtable. */
359 hash_odr_vtable (const_tree t
)
361 tree v
= BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
362 inchash::hash hstate
;
364 gcc_checking_assert (in_lto_p
);
365 gcc_checking_assert (!type_in_anonymous_namespace_p (t
));
366 gcc_checking_assert (TREE_CODE (t
) == RECORD_TYPE
367 && TYPE_BINFO (t
) && BINFO_VTABLE (TYPE_BINFO (t
)));
368 gcc_checking_assert (main_odr_variant (t
) == t
);
370 if (TREE_CODE (v
) == POINTER_PLUS_EXPR
)
372 add_expr (TREE_OPERAND (v
, 1), hstate
);
373 v
= TREE_OPERAND (TREE_OPERAND (v
, 0), 0);
376 hstate
.add_hwi (IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (v
)));
377 return hstate
.end ();
380 /* Return the computed hashcode for ODR_TYPE. */
383 odr_vtable_hasher::hash (const odr_type_d
*odr_type
)
385 return hash_odr_vtable (odr_type
->type
);
388 /* For languages with One Definition Rule, work out if
389 types are the same based on their name.
391 This is non-trivial for LTO where minor differences in
392 the type representation may have prevented type merging
393 to merge two copies of otherwise equivalent type.
395 Until we start streaming mangled type names, this function works
396 only for polymorphic types.
398 When STRICT is true, we compare types by their names for purposes of
399 ODR violation warnings. When strict is false, we consider variants
400 equivalent, because it is all that matters for devirtualization machinery.
404 types_same_for_odr (const_tree type1
, const_tree type2
, bool strict
)
406 gcc_checking_assert (TYPE_P (type1
) && TYPE_P (type2
));
408 type1
= main_odr_variant (type1
);
409 type2
= main_odr_variant (type2
);
412 type1
= TYPE_MAIN_VARIANT (type1
);
413 type2
= TYPE_MAIN_VARIANT (type2
);
422 /* Check for anonymous namespaces. Those have !TREE_PUBLIC
423 on the corresponding TYPE_STUB_DECL. */
424 if ((type_with_linkage_p (type1
) && type_in_anonymous_namespace_p (type1
))
425 || (type_with_linkage_p (type2
) && type_in_anonymous_namespace_p (type2
)))
429 /* ODR name of the type is set in DECL_ASSEMBLER_NAME of its TYPE_NAME.
431 Ideally we should never need types without ODR names here. It can however
434 1) for builtin types that are not streamed but rebuilt in lto/lto-lang.c
435 Here testing for equivalence is safe, since their MAIN_VARIANTs are
437 2) for units streamed with -fno-lto-odr-type-merging. Here we can't
438 establish precise ODR equivalency, but for correctness we care only
439 about equivalency on complete polymorphic types. For these we can
440 compare assembler names of their virtual tables. */
441 if ((!TYPE_NAME (type1
) || !DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (type1
)))
442 || (!TYPE_NAME (type2
) || !DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (type2
))))
444 /* See if types are obviously different (i.e. different codes
445 or polymorphic wrt non-polymorphic). This is not strictly correct
446 for ODR violating programs, but we can't do better without streaming
448 if (TREE_CODE (type1
) != TREE_CODE (type2
))
450 if (TREE_CODE (type1
) == RECORD_TYPE
451 && (TYPE_BINFO (type1
) == NULL_TREE
)
452 != (TYPE_BINFO (type2
) == NULL_TREE
))
454 if (TREE_CODE (type1
) == RECORD_TYPE
&& TYPE_BINFO (type1
)
455 && (BINFO_VTABLE (TYPE_BINFO (type1
)) == NULL_TREE
)
456 != (BINFO_VTABLE (TYPE_BINFO (type2
)) == NULL_TREE
))
459 /* At the moment we have no way to establish ODR equivalence at LTO
460 other than comparing virtual table pointers of polymorphic types.
461 Eventually we should start saving mangled names in TYPE_NAME.
462 Then this condition will become non-trivial. */
464 if (TREE_CODE (type1
) == RECORD_TYPE
465 && TYPE_BINFO (type1
) && TYPE_BINFO (type2
)
466 && BINFO_VTABLE (TYPE_BINFO (type1
))
467 && BINFO_VTABLE (TYPE_BINFO (type2
)))
469 tree v1
= BINFO_VTABLE (TYPE_BINFO (type1
));
470 tree v2
= BINFO_VTABLE (TYPE_BINFO (type2
));
471 gcc_assert (TREE_CODE (v1
) == POINTER_PLUS_EXPR
472 && TREE_CODE (v2
) == POINTER_PLUS_EXPR
);
473 return (operand_equal_p (TREE_OPERAND (v1
, 1),
474 TREE_OPERAND (v2
, 1), 0)
475 && DECL_ASSEMBLER_NAME
476 (TREE_OPERAND (TREE_OPERAND (v1
, 0), 0))
477 == DECL_ASSEMBLER_NAME
478 (TREE_OPERAND (TREE_OPERAND (v2
, 0), 0)));
482 return (DECL_ASSEMBLER_NAME (TYPE_NAME (type1
))
483 == DECL_ASSEMBLER_NAME (TYPE_NAME (type2
)));
486 /* Return true if we can decide on ODR equivalency.
488 In non-LTO it is always decide, in LTO however it depends in the type has
491 When STRICT is false, compare main variants. */
494 types_odr_comparable (tree t1
, tree t2
, bool strict
)
497 || (strict
? (main_odr_variant (t1
) == main_odr_variant (t2
)
498 && main_odr_variant (t1
))
499 : TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
500 || (odr_type_p (t1
) && odr_type_p (t2
))
501 || (TREE_CODE (t1
) == RECORD_TYPE
&& TREE_CODE (t2
) == RECORD_TYPE
502 && TYPE_BINFO (t1
) && TYPE_BINFO (t2
)
503 && polymorphic_type_binfo_p (TYPE_BINFO (t1
))
504 && polymorphic_type_binfo_p (TYPE_BINFO (t2
))));
507 /* Return true if T1 and T2 are ODR equivalent. If ODR equivalency is not
508 known, be conservative and return false. */
511 types_must_be_same_for_odr (tree t1
, tree t2
)
513 if (types_odr_comparable (t1
, t2
))
514 return types_same_for_odr (t1
, t2
);
516 return TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
);
519 /* If T is compound type, return type it is based on. */
522 compound_type_base (const_tree t
)
524 if (TREE_CODE (t
) == ARRAY_TYPE
525 || POINTER_TYPE_P (t
)
526 || TREE_CODE (t
) == COMPLEX_TYPE
527 || VECTOR_TYPE_P (t
))
528 return TREE_TYPE (t
);
529 if (TREE_CODE (t
) == METHOD_TYPE
)
530 return TYPE_METHOD_BASETYPE (t
);
531 if (TREE_CODE (t
) == OFFSET_TYPE
)
532 return TYPE_OFFSET_BASETYPE (t
);
536 /* Return true if T is either ODR type or compound type based from it.
537 If the function return true, we know that T is a type originating from C++
538 source even at link-time. */
541 odr_or_derived_type_p (const_tree t
)
547 /* Function type is a tricky one. Basically we can consider it
548 ODR derived if return type or any of the parameters is.
549 We need to check all parameters because LTO streaming merges
550 common types (such as void) and they are not considered ODR then. */
551 if (TREE_CODE (t
) == FUNCTION_TYPE
)
553 if (TYPE_METHOD_BASETYPE (t
))
554 t
= TYPE_METHOD_BASETYPE (t
);
557 if (TREE_TYPE (t
) && odr_or_derived_type_p (TREE_TYPE (t
)))
559 for (t
= TYPE_ARG_TYPES (t
); t
; t
= TREE_CHAIN (t
))
560 if (odr_or_derived_type_p (TREE_VALUE (t
)))
566 t
= compound_type_base (t
);
572 /* Compare types T1 and T2 and return true if they are
576 odr_name_hasher::equal (const odr_type_d
*o1
, const tree_node
*t2
)
580 gcc_checking_assert (main_odr_variant (t2
) == t2
);
581 gcc_checking_assert (main_odr_variant (t1
) == t1
);
586 /* Check for anonymous namespaces. Those have !TREE_PUBLIC
587 on the corresponding TYPE_STUB_DECL. */
588 if ((type_with_linkage_p (t1
) && type_in_anonymous_namespace_p (t1
))
589 || (type_with_linkage_p (t2
) && type_in_anonymous_namespace_p (t2
)))
591 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t1
)));
592 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t2
)));
593 return (DECL_ASSEMBLER_NAME (TYPE_NAME (t1
))
594 == DECL_ASSEMBLER_NAME (TYPE_NAME (t2
)));
597 /* Compare types T1 and T2 and return true if they are
601 odr_vtable_hasher::equal (const odr_type_d
*o1
, const tree_node
*t2
)
605 gcc_checking_assert (main_odr_variant (t2
) == t2
);
606 gcc_checking_assert (main_odr_variant (t1
) == t1
);
607 gcc_checking_assert (in_lto_p
);
608 t1
= TYPE_MAIN_VARIANT (t1
);
609 t2
= TYPE_MAIN_VARIANT (t2
);
612 tree v1
= BINFO_VTABLE (TYPE_BINFO (t1
));
613 tree v2
= BINFO_VTABLE (TYPE_BINFO (t2
));
614 return (operand_equal_p (TREE_OPERAND (v1
, 1),
615 TREE_OPERAND (v2
, 1), 0)
616 && DECL_ASSEMBLER_NAME
617 (TREE_OPERAND (TREE_OPERAND (v1
, 0), 0))
618 == DECL_ASSEMBLER_NAME
619 (TREE_OPERAND (TREE_OPERAND (v2
, 0), 0)));
622 /* Free ODR type V. */
625 odr_name_hasher::remove (odr_type_d
*v
)
628 v
->derived_types
.release ();
634 /* ODR type hash used to look up ODR type based on tree type node. */
636 typedef hash_table
<odr_name_hasher
> odr_hash_type
;
637 static odr_hash_type
*odr_hash
;
638 typedef hash_table
<odr_vtable_hasher
> odr_vtable_hash_type
;
639 static odr_vtable_hash_type
*odr_vtable_hash
;
641 /* ODR types are also stored into ODR_TYPE vector to allow consistent
642 walking. Bases appear before derived types. Vector is garbage collected
643 so we won't end up visiting empty types. */
645 static GTY(()) vec
<odr_type
, va_gc
> *odr_types_ptr
;
646 #define odr_types (*odr_types_ptr)
648 /* Set TYPE_BINFO of TYPE and its variants to BINFO. */
650 set_type_binfo (tree type
, tree binfo
)
652 for (; type
; type
= TYPE_NEXT_VARIANT (type
))
653 if (COMPLETE_TYPE_P (type
))
654 TYPE_BINFO (type
) = binfo
;
656 gcc_assert (!TYPE_BINFO (type
));
659 /* Compare T2 and T2 based on name or structure. */
662 odr_subtypes_equivalent_p (tree t1
, tree t2
,
663 hash_set
<type_pair
> *visited
,
664 location_t loc1
, location_t loc2
)
667 /* This can happen in incomplete types that should be handled earlier. */
668 gcc_assert (t1
&& t2
);
670 t1
= main_odr_variant (t1
);
671 t2
= main_odr_variant (t2
);
675 /* Anonymous namespace types must match exactly. */
676 if ((type_with_linkage_p (t1
) && type_in_anonymous_namespace_p (t1
))
677 || (type_with_linkage_p (t2
) && type_in_anonymous_namespace_p (t2
)))
680 /* For ODR types be sure to compare their names.
681 To support -wno-odr-type-merging we allow one type to be non-ODR
682 and other ODR even though it is a violation. */
683 if (types_odr_comparable (t1
, t2
, true))
685 if (!types_same_for_odr (t1
, t2
, true))
687 /* Limit recursion: if subtypes are ODR types and we know that they are
688 same, be happy. We need to call get_odr_type on both subtypes since
689 we don't know which among t1 and t2 defines the common ODR type and
690 therefore which call will report the ODR violation, if any. */
693 || (!get_odr_type (t1
, true)->odr_violated
694 && !get_odr_type (t2
, true)->odr_violated
))
698 /* Component types, builtins and possibly violating ODR types
699 have to be compared structurally. */
700 if (TREE_CODE (t1
) != TREE_CODE (t2
))
702 if (AGGREGATE_TYPE_P (t1
)
703 && (TYPE_NAME (t1
) == NULL_TREE
) != (TYPE_NAME (t2
) == NULL_TREE
))
706 type_pair pair
={t1
,t2
};
707 if (TYPE_UID (t1
) > TYPE_UID (t2
))
712 if (visited
->add (pair
))
714 return odr_types_equivalent_p (t1
, t2
, false, NULL
, visited
, loc1
, loc2
);
717 /* Return true if DECL1 and DECL2 are identical methods. Consider
718 name equivalent to name.localalias.xyz. */
721 methods_equal_p (tree decl1
, tree decl2
)
723 if (DECL_ASSEMBLER_NAME (decl1
) == DECL_ASSEMBLER_NAME (decl2
))
725 const char sep
= symbol_table::symbol_suffix_separator ();
727 const char *name1
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl1
));
728 const char *ptr1
= strchr (name1
, sep
);
729 int len1
= ptr1
? ptr1
- name1
: strlen (name1
);
731 const char *name2
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl2
));
732 const char *ptr2
= strchr (name2
, sep
);
733 int len2
= ptr2
? ptr2
- name2
: strlen (name2
);
737 return !strncmp (name1
, name2
, len1
);
740 /* Compare two virtual tables, PREVAILING and VTABLE and output ODR
741 violation warnings. */
744 compare_virtual_tables (varpool_node
*prevailing
, varpool_node
*vtable
)
748 if (DECL_VIRTUAL_P (prevailing
->decl
) != DECL_VIRTUAL_P (vtable
->decl
))
750 odr_violation_reported
= true;
751 if (DECL_VIRTUAL_P (prevailing
->decl
))
753 varpool_node
*tmp
= prevailing
;
757 if (warning_at (DECL_SOURCE_LOCATION
758 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
760 "virtual table of type %qD violates one definition rule",
761 DECL_CONTEXT (vtable
->decl
)))
762 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
763 "variable of same assembler name as the virtual table is "
764 "defined in another translation unit");
767 if (!prevailing
->definition
|| !vtable
->definition
)
770 /* If we do not stream ODR type info, do not bother to do useful compare. */
771 if (!TYPE_BINFO (DECL_CONTEXT (vtable
->decl
))
772 || !polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (vtable
->decl
))))
775 odr_type class_type
= get_odr_type (DECL_CONTEXT (vtable
->decl
), true);
777 if (class_type
->odr_violated
)
780 for (n1
= 0, n2
= 0; true; n1
++, n2
++)
782 struct ipa_ref
*ref1
, *ref2
;
785 end1
= !prevailing
->iterate_reference (n1
, ref1
);
786 end2
= !vtable
->iterate_reference (n2
, ref2
);
788 /* !DECL_VIRTUAL_P means RTTI entry;
789 We warn when RTTI is lost because non-RTTI previals; we silently
790 accept the other case. */
793 || (methods_equal_p (ref1
->referred
->decl
,
794 ref2
->referred
->decl
)
795 && TREE_CODE (ref1
->referred
->decl
) == FUNCTION_DECL
))
796 && TREE_CODE (ref2
->referred
->decl
) != FUNCTION_DECL
)
798 if (!class_type
->rtti_broken
799 && warning_at (DECL_SOURCE_LOCATION
800 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
802 "virtual table of type %qD contains RTTI "
804 DECL_CONTEXT (vtable
->decl
)))
806 inform (DECL_SOURCE_LOCATION
807 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
808 "but is prevailed by one without from other translation "
810 inform (DECL_SOURCE_LOCATION
811 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
812 "RTTI will not work on this type");
813 class_type
->rtti_broken
= true;
816 end2
= !vtable
->iterate_reference (n2
, ref2
);
820 || (methods_equal_p (ref2
->referred
->decl
, ref1
->referred
->decl
)
821 && TREE_CODE (ref2
->referred
->decl
) == FUNCTION_DECL
))
822 && TREE_CODE (ref1
->referred
->decl
) != FUNCTION_DECL
)
825 end1
= !prevailing
->iterate_reference (n1
, ref1
);
831 /* Extra paranoia; compare the sizes. We do not have information
832 about virtual inheritance offsets, so just be sure that these
834 Do this as very last check so the not very informative error
835 is not output too often. */
836 if (DECL_SIZE (prevailing
->decl
) != DECL_SIZE (vtable
->decl
))
838 class_type
->odr_violated
= true;
839 if (warning_at (DECL_SOURCE_LOCATION
840 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
842 "virtual table of type %qD violates "
843 "one definition rule ",
844 DECL_CONTEXT (vtable
->decl
)))
846 inform (DECL_SOURCE_LOCATION
847 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
848 "the conflicting type defined in another translation "
849 "unit has virtual table of different size");
857 if (methods_equal_p (ref1
->referred
->decl
, ref2
->referred
->decl
))
860 class_type
->odr_violated
= true;
862 /* If the loops above stopped on non-virtual pointer, we have
863 mismatch in RTTI information mangling. */
864 if (TREE_CODE (ref1
->referred
->decl
) != FUNCTION_DECL
865 && TREE_CODE (ref2
->referred
->decl
) != FUNCTION_DECL
)
867 if (warning_at (DECL_SOURCE_LOCATION
868 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
870 "virtual table of type %qD violates "
871 "one definition rule ",
872 DECL_CONTEXT (vtable
->decl
)))
874 inform (DECL_SOURCE_LOCATION
875 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
876 "the conflicting type defined in another translation "
877 "unit with different RTTI information");
881 /* At this point both REF1 and REF2 points either to virtual table
882 or virtual method. If one points to virtual table and other to
883 method we can complain the same way as if one table was shorter
884 than other pointing out the extra method. */
885 if (TREE_CODE (ref1
->referred
->decl
)
886 != TREE_CODE (ref2
->referred
->decl
))
888 if (VAR_P (ref1
->referred
->decl
))
890 else if (VAR_P (ref2
->referred
->decl
))
895 class_type
->odr_violated
= true;
897 /* Complain about size mismatch. Either we have too many virutal
898 functions or too many virtual table pointers. */
903 varpool_node
*tmp
= prevailing
;
908 if (warning_at (DECL_SOURCE_LOCATION
909 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
911 "virtual table of type %qD violates "
912 "one definition rule",
913 DECL_CONTEXT (vtable
->decl
)))
915 if (TREE_CODE (ref1
->referring
->decl
) == FUNCTION_DECL
)
917 inform (DECL_SOURCE_LOCATION
918 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
919 "the conflicting type defined in another translation "
921 inform (DECL_SOURCE_LOCATION
922 (TYPE_NAME (DECL_CONTEXT (ref1
->referring
->decl
))),
923 "contains additional virtual method %qD",
924 ref1
->referred
->decl
);
928 inform (DECL_SOURCE_LOCATION
929 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
930 "the conflicting type defined in another translation "
931 "unit has virtual table with more entries");
937 /* And in the last case we have either mistmatch in between two virtual
938 methods or two virtual table pointers. */
939 if (warning_at (DECL_SOURCE_LOCATION
940 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))), OPT_Wodr
,
941 "virtual table of type %qD violates "
942 "one definition rule ",
943 DECL_CONTEXT (vtable
->decl
)))
945 if (TREE_CODE (ref1
->referred
->decl
) == FUNCTION_DECL
)
947 inform (DECL_SOURCE_LOCATION
948 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
949 "the conflicting type defined in another translation "
951 gcc_assert (TREE_CODE (ref2
->referred
->decl
)
953 inform (DECL_SOURCE_LOCATION
954 (ref1
->referred
->ultimate_alias_target ()->decl
),
955 "virtual method %qD",
956 ref1
->referred
->ultimate_alias_target ()->decl
);
957 inform (DECL_SOURCE_LOCATION
958 (ref2
->referred
->ultimate_alias_target ()->decl
),
959 "ought to match virtual method %qD but does not",
960 ref2
->referred
->ultimate_alias_target ()->decl
);
963 inform (DECL_SOURCE_LOCATION
964 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
965 "the conflicting type defined in another translation "
966 "unit has virtual table with different contents");
972 /* Output ODR violation warning about T1 and T2 with REASON.
973 Display location of ST1 and ST2 if REASON speaks about field or
975 If WARN is false, do nothing. Set WARNED if warning was indeed
979 warn_odr (tree t1
, tree t2
, tree st1
, tree st2
,
980 bool warn
, bool *warned
, const char *reason
)
982 tree decl2
= TYPE_NAME (t2
);
986 if (!warn
|| !TYPE_NAME(t1
))
989 /* ODR warnings are output druing LTO streaming; we must apply location
990 cache for potential warnings to be output correctly. */
991 if (lto_location_cache::current_cache
)
992 lto_location_cache::current_cache
->apply_location_cache ();
994 if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (t1
)), OPT_Wodr
,
995 "type %qT violates the C++ One Definition Rule",
1000 /* For FIELD_DECL support also case where one of fields is
1001 NULL - this is used when the structures have mismatching number of
1003 else if (!st1
|| TREE_CODE (st1
) == FIELD_DECL
)
1005 inform (DECL_SOURCE_LOCATION (decl2
),
1006 "a different type is defined in another translation unit");
1012 inform (DECL_SOURCE_LOCATION (st1
),
1013 "the first difference of corresponding definitions is field %qD",
1018 else if (TREE_CODE (st1
) == FUNCTION_DECL
)
1020 inform (DECL_SOURCE_LOCATION (decl2
),
1021 "a different type is defined in another translation unit");
1022 inform (DECL_SOURCE_LOCATION (st1
),
1023 "the first difference of corresponding definitions is method %qD",
1029 inform (DECL_SOURCE_LOCATION (decl2
), reason
);
1035 /* Return ture if T1 and T2 are incompatible and we want to recusively
1036 dive into them from warn_type_mismatch to give sensible answer. */
1039 type_mismatch_p (tree t1
, tree t2
)
1041 if (odr_or_derived_type_p (t1
) && odr_or_derived_type_p (t2
)
1042 && !odr_types_equivalent_p (t1
, t2
))
1044 return !types_compatible_p (t1
, t2
);
1048 /* Types T1 and T2 was found to be incompatible in a context they can't
1049 (either used to declare a symbol of same assembler name or unified by
1050 ODR rule). We already output warning about this, but if possible, output
1051 extra information on how the types mismatch.
1053 This is hard to do in general. We basically handle the common cases.
1055 If LOC1 and LOC2 are meaningful locations, use it in the case the types
1056 themselves do no thave one.*/
1059 warn_types_mismatch (tree t1
, tree t2
, location_t loc1
, location_t loc2
)
1061 /* Location of type is known only if it has TYPE_NAME and the name is
1063 location_t loc_t1
= TYPE_NAME (t1
) && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
1064 ? DECL_SOURCE_LOCATION (TYPE_NAME (t1
))
1066 location_t loc_t2
= TYPE_NAME (t2
) && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
1067 ? DECL_SOURCE_LOCATION (TYPE_NAME (t2
))
1069 bool loc_t2_useful
= false;
1071 /* With LTO it is a common case that the location of both types match.
1072 See if T2 has a location that is different from T1. If so, we will
1073 inform user about the location.
1074 Do not consider the location passed to us in LOC1/LOC2 as those are
1076 if (loc_t2
> BUILTINS_LOCATION
&& loc_t2
!= loc_t1
)
1078 if (loc_t1
<= BUILTINS_LOCATION
)
1079 loc_t2_useful
= true;
1082 expanded_location xloc1
= expand_location (loc_t1
);
1083 expanded_location xloc2
= expand_location (loc_t2
);
1085 if (strcmp (xloc1
.file
, xloc2
.file
)
1086 || xloc1
.line
!= xloc2
.line
1087 || xloc1
.column
!= xloc2
.column
)
1088 loc_t2_useful
= true;
1092 if (loc_t1
<= BUILTINS_LOCATION
)
1094 if (loc_t2
<= BUILTINS_LOCATION
)
1097 location_t loc
= loc_t1
<= BUILTINS_LOCATION
? loc_t2
: loc_t1
;
1099 /* It is a quite common bug to reference anonymous namespace type in
1100 non-anonymous namespace class. */
1101 if ((type_with_linkage_p (t1
) && type_in_anonymous_namespace_p (t1
))
1102 || (type_with_linkage_p (t2
) && type_in_anonymous_namespace_p (t2
)))
1104 if (type_with_linkage_p (t1
) && !type_in_anonymous_namespace_p (t1
))
1107 std::swap (loc_t1
, loc_t2
);
1109 gcc_assert (TYPE_NAME (t1
) && TYPE_NAME (t2
)
1110 && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
1111 && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
);
1112 /* Most of the time, the type names will match, do not be unnecesarily
1114 if (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t1
)))
1115 != IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t2
))))
1117 "type %qT defined in anonymous namespace can not match "
1118 "type %qT across the translation unit boundary",
1122 "type %qT defined in anonymous namespace can not match "
1123 "across the translation unit boundary",
1127 "the incompatible type defined in another translation unit");
1130 /* If types have mangled ODR names and they are different, it is most
1131 informative to output those.
1132 This also covers types defined in different namespaces. */
1133 if (TYPE_NAME (t1
) && TYPE_NAME (t2
)
1134 && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
1135 && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
1136 && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t1
))
1137 && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t2
))
1138 && DECL_ASSEMBLER_NAME (TYPE_NAME (t1
))
1139 != DECL_ASSEMBLER_NAME (TYPE_NAME (t2
)))
1141 char *name1
= xstrdup (cplus_demangle
1142 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (t1
))),
1143 DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
));
1144 char *name2
= cplus_demangle
1145 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (t2
))),
1146 DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
);
1147 if (name1
&& name2
&& strcmp (name1
, name2
))
1150 "type name %qs should match type name %qs",
1154 "the incompatible type is defined here");
1160 /* A tricky case are compound types. Often they appear the same in source
1161 code and the mismatch is dragged in by type they are build from.
1162 Look for those differences in subtypes and try to be informative. In other
1163 cases just output nothing because the source code is probably different
1164 and in this case we already output a all necessary info. */
1165 if (!TYPE_NAME (t1
) || !TYPE_NAME (t2
))
1167 if (TREE_CODE (t1
) == TREE_CODE (t2
))
1169 if (TREE_CODE (t1
) == ARRAY_TYPE
1170 && COMPLETE_TYPE_P (t1
) && COMPLETE_TYPE_P (t2
))
1172 tree i1
= TYPE_DOMAIN (t1
);
1173 tree i2
= TYPE_DOMAIN (t2
);
1176 && TYPE_MAX_VALUE (i1
)
1177 && TYPE_MAX_VALUE (i2
)
1178 && !operand_equal_p (TYPE_MAX_VALUE (i1
),
1179 TYPE_MAX_VALUE (i2
), 0))
1182 "array types have different bounds");
1186 if ((POINTER_TYPE_P (t1
) || TREE_CODE (t1
) == ARRAY_TYPE
)
1187 && type_mismatch_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1188 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc_t1
, loc_t2
);
1189 else if (TREE_CODE (t1
) == METHOD_TYPE
1190 || TREE_CODE (t1
) == FUNCTION_TYPE
)
1192 tree parms1
= NULL
, parms2
= NULL
;
1195 if (type_mismatch_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1197 inform (loc
, "return value type mismatch");
1198 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc_t1
,
1202 if (prototype_p (t1
) && prototype_p (t2
))
1203 for (parms1
= TYPE_ARG_TYPES (t1
), parms2
= TYPE_ARG_TYPES (t2
);
1205 parms1
= TREE_CHAIN (parms1
), parms2
= TREE_CHAIN (parms2
),
1208 if (type_mismatch_p (TREE_VALUE (parms1
), TREE_VALUE (parms2
)))
1210 if (count
== 1 && TREE_CODE (t1
) == METHOD_TYPE
)
1212 "implicit this pointer type mismatch");
1215 "type mismatch in parameter %i",
1216 count
- (TREE_CODE (t1
) == METHOD_TYPE
));
1217 warn_types_mismatch (TREE_VALUE (parms1
),
1218 TREE_VALUE (parms2
),
1223 if (parms1
|| parms2
)
1226 "types have different parameter counts");
1234 if (types_odr_comparable (t1
, t2
, true)
1235 && types_same_for_odr (t1
, t2
, true))
1237 "type %qT itself violates the C++ One Definition Rule", t1
);
1238 /* Prevent pointless warnings like "struct aa" should match "struct aa". */
1239 else if (TYPE_NAME (t1
) == TYPE_NAME (t2
)
1240 && TREE_CODE (t1
) == TREE_CODE (t2
) && !loc_t2_useful
)
1243 inform (loc_t1
, "type %qT should match type %qT",
1246 inform (loc_t2
, "the incompatible type is defined here");
1249 /* Compare T1 and T2, report ODR violations if WARN is true and set
1250 WARNED to true if anything is reported. Return true if types match.
1251 If true is returned, the types are also compatible in the sense of
1252 gimple_canonical_types_compatible_p.
1253 If LOC1 and LOC2 is not UNKNOWN_LOCATION it may be used to output a warning
1254 about the type if the type itself do not have location. */
1257 odr_types_equivalent_p (tree t1
, tree t2
, bool warn
, bool *warned
,
1258 hash_set
<type_pair
> *visited
,
1259 location_t loc1
, location_t loc2
)
1261 /* Check first for the obvious case of pointer identity. */
1264 gcc_assert (!type_with_linkage_p (t1
) || !type_in_anonymous_namespace_p (t1
));
1265 gcc_assert (!type_with_linkage_p (t2
) || !type_in_anonymous_namespace_p (t2
));
1267 /* Can't be the same type if the types don't have the same code. */
1268 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1270 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1271 G_("a different type is defined in another translation unit"));
1275 if (TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
1277 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1278 G_("a type with different qualifiers is defined in another "
1279 "translation unit"));
1283 if ((type_with_linkage_p (t1
) && type_in_anonymous_namespace_p (t1
))
1284 || (type_with_linkage_p (t2
) && type_in_anonymous_namespace_p (t2
)))
1286 /* We can not trip this when comparing ODR types, only when trying to
1287 match different ODR derivations from different declarations.
1288 So WARN should be always false. */
1293 if (comp_type_attributes (t1
, t2
) != 1)
1295 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1296 G_("a type with different attributes "
1297 "is defined in another translation unit"));
1301 if (TREE_CODE (t1
) == ENUMERAL_TYPE
1302 && TYPE_VALUES (t1
) && TYPE_VALUES (t2
))
1305 for (v1
= TYPE_VALUES (t1
), v2
= TYPE_VALUES (t2
);
1306 v1
&& v2
; v1
= TREE_CHAIN (v1
), v2
= TREE_CHAIN (v2
))
1308 if (TREE_PURPOSE (v1
) != TREE_PURPOSE (v2
))
1310 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1311 G_("an enum with different value name"
1312 " is defined in another translation unit"));
1315 if (TREE_VALUE (v1
) != TREE_VALUE (v2
)
1316 && !operand_equal_p (DECL_INITIAL (TREE_VALUE (v1
)),
1317 DECL_INITIAL (TREE_VALUE (v2
)), 0))
1319 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1320 G_("an enum with different values is defined"
1321 " in another translation unit"));
1327 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1328 G_("an enum with mismatching number of values "
1329 "is defined in another translation unit"));
1334 /* Non-aggregate types can be handled cheaply. */
1335 if (INTEGRAL_TYPE_P (t1
)
1336 || SCALAR_FLOAT_TYPE_P (t1
)
1337 || FIXED_POINT_TYPE_P (t1
)
1338 || TREE_CODE (t1
) == VECTOR_TYPE
1339 || TREE_CODE (t1
) == COMPLEX_TYPE
1340 || TREE_CODE (t1
) == OFFSET_TYPE
1341 || POINTER_TYPE_P (t1
))
1343 if (TYPE_PRECISION (t1
) != TYPE_PRECISION (t2
))
1345 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1346 G_("a type with different precision is defined "
1347 "in another translation unit"));
1350 if (TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
))
1352 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1353 G_("a type with different signedness is defined "
1354 "in another translation unit"));
1358 if (TREE_CODE (t1
) == INTEGER_TYPE
1359 && TYPE_STRING_FLAG (t1
) != TYPE_STRING_FLAG (t2
))
1361 /* char WRT uint_8? */
1362 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1363 G_("a different type is defined in another "
1364 "translation unit"));
1368 /* For canonical type comparisons we do not want to build SCCs
1369 so we cannot compare pointed-to types. But we can, for now,
1370 require the same pointed-to type kind and match what
1371 useless_type_conversion_p would do. */
1372 if (POINTER_TYPE_P (t1
))
1374 if (TYPE_ADDR_SPACE (TREE_TYPE (t1
))
1375 != TYPE_ADDR_SPACE (TREE_TYPE (t2
)))
1377 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1378 G_("it is defined as a pointer in different address "
1379 "space in another translation unit"));
1383 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
1384 visited
, loc1
, loc2
))
1386 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1387 G_("it is defined as a pointer to different type "
1388 "in another translation unit"));
1390 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
),
1396 if ((TREE_CODE (t1
) == VECTOR_TYPE
|| TREE_CODE (t1
) == COMPLEX_TYPE
)
1397 && !odr_subtypes_equivalent_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
1398 visited
, loc1
, loc2
))
1400 /* Probably specific enough. */
1401 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1402 G_("a different type is defined "
1403 "in another translation unit"));
1405 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc1
, loc2
);
1409 /* Do type-specific comparisons. */
1410 else switch (TREE_CODE (t1
))
1414 /* Array types are the same if the element types are the same and
1415 the number of elements are the same. */
1416 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
1417 visited
, loc1
, loc2
))
1419 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1420 G_("a different type is defined in another "
1421 "translation unit"));
1423 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc1
, loc2
);
1425 gcc_assert (TYPE_STRING_FLAG (t1
) == TYPE_STRING_FLAG (t2
));
1426 gcc_assert (TYPE_NONALIASED_COMPONENT (t1
)
1427 == TYPE_NONALIASED_COMPONENT (t2
));
1429 tree i1
= TYPE_DOMAIN (t1
);
1430 tree i2
= TYPE_DOMAIN (t2
);
1432 /* For an incomplete external array, the type domain can be
1433 NULL_TREE. Check this condition also. */
1434 if (i1
== NULL_TREE
|| i2
== NULL_TREE
)
1437 tree min1
= TYPE_MIN_VALUE (i1
);
1438 tree min2
= TYPE_MIN_VALUE (i2
);
1439 tree max1
= TYPE_MAX_VALUE (i1
);
1440 tree max2
= TYPE_MAX_VALUE (i2
);
1442 /* In C++, minimums should be always 0. */
1443 gcc_assert (min1
== min2
);
1444 if (!operand_equal_p (max1
, max2
, 0))
1446 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1447 G_("an array of different size is defined "
1448 "in another translation unit"));
1456 /* Function types are the same if the return type and arguments types
1458 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
1459 visited
, loc1
, loc2
))
1461 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1462 G_("has different return value "
1463 "in another translation unit"));
1465 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc1
, loc2
);
1469 if (TYPE_ARG_TYPES (t1
) == TYPE_ARG_TYPES (t2
)
1470 || !prototype_p (t1
) || !prototype_p (t2
))
1474 tree parms1
, parms2
;
1476 for (parms1
= TYPE_ARG_TYPES (t1
), parms2
= TYPE_ARG_TYPES (t2
);
1478 parms1
= TREE_CHAIN (parms1
), parms2
= TREE_CHAIN (parms2
))
1480 if (!odr_subtypes_equivalent_p
1481 (TREE_VALUE (parms1
), TREE_VALUE (parms2
), visited
,
1484 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1485 G_("has different parameters in another "
1486 "translation unit"));
1488 warn_types_mismatch (TREE_VALUE (parms1
),
1489 TREE_VALUE (parms2
), loc1
, loc2
);
1494 if (parms1
|| parms2
)
1496 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1497 G_("has different parameters "
1498 "in another translation unit"));
1507 case QUAL_UNION_TYPE
:
1511 /* For aggregate types, all the fields must be the same. */
1512 if (COMPLETE_TYPE_P (t1
) && COMPLETE_TYPE_P (t2
))
1514 if (TYPE_BINFO (t1
) && TYPE_BINFO (t2
)
1515 && polymorphic_type_binfo_p (TYPE_BINFO (t1
))
1516 != polymorphic_type_binfo_p (TYPE_BINFO (t2
)))
1518 if (polymorphic_type_binfo_p (TYPE_BINFO (t1
)))
1519 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1520 G_("a type defined in another translation unit "
1521 "is not polymorphic"));
1523 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1524 G_("a type defined in another translation unit "
1528 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1530 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1532 /* Skip non-fields. */
1533 while (f1
&& TREE_CODE (f1
) != FIELD_DECL
)
1534 f1
= TREE_CHAIN (f1
);
1535 while (f2
&& TREE_CODE (f2
) != FIELD_DECL
)
1536 f2
= TREE_CHAIN (f2
);
1539 if (DECL_VIRTUAL_P (f1
) != DECL_VIRTUAL_P (f2
))
1541 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1542 G_("a type with different virtual table pointers"
1543 " is defined in another translation unit"));
1546 if (DECL_ARTIFICIAL (f1
) != DECL_ARTIFICIAL (f2
))
1548 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1549 G_("a type with different bases is defined "
1550 "in another translation unit"));
1553 if (DECL_NAME (f1
) != DECL_NAME (f2
)
1554 && !DECL_ARTIFICIAL (f1
))
1556 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1557 G_("a field with different name is defined "
1558 "in another translation unit"));
1561 if (!odr_subtypes_equivalent_p (TREE_TYPE (f1
),
1562 TREE_TYPE (f2
), visited
,
1565 /* Do not warn about artificial fields and just go into
1566 generic field mismatch warning. */
1567 if (DECL_ARTIFICIAL (f1
))
1570 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1571 G_("a field of same name but different type "
1572 "is defined in another translation unit"));
1574 warn_types_mismatch (TREE_TYPE (f1
), TREE_TYPE (f2
), loc1
, loc2
);
1577 if (!gimple_compare_field_offset (f1
, f2
))
1579 /* Do not warn about artificial fields and just go into
1580 generic field mismatch warning. */
1581 if (DECL_ARTIFICIAL (f1
))
1583 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1584 G_("fields have different layout "
1585 "in another translation unit"));
1588 gcc_assert (DECL_NONADDRESSABLE_P (f1
)
1589 == DECL_NONADDRESSABLE_P (f2
));
1592 /* If one aggregate has more fields than the other, they
1593 are not the same. */
1596 if ((f1
&& DECL_VIRTUAL_P (f1
)) || (f2
&& DECL_VIRTUAL_P (f2
)))
1597 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1598 G_("a type with different virtual table pointers"
1599 " is defined in another translation unit"));
1600 else if ((f1
&& DECL_ARTIFICIAL (f1
))
1601 || (f2
&& DECL_ARTIFICIAL (f2
)))
1602 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1603 G_("a type with different bases is defined "
1604 "in another translation unit"));
1606 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1607 G_("a type with different number of fields "
1608 "is defined in another translation unit"));
1624 /* Those are better to come last as they are utterly uninformative. */
1625 if (TYPE_SIZE (t1
) && TYPE_SIZE (t2
)
1626 && !operand_equal_p (TYPE_SIZE (t1
), TYPE_SIZE (t2
), 0))
1628 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1629 G_("a type with different size "
1630 "is defined in another translation unit"));
1633 if (COMPLETE_TYPE_P (t1
) && COMPLETE_TYPE_P (t2
)
1634 && TYPE_ALIGN (t1
) != TYPE_ALIGN (t2
))
1636 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1637 G_("a type with different alignment "
1638 "is defined in another translation unit"));
1641 gcc_assert (!TYPE_SIZE_UNIT (t1
) || !TYPE_SIZE_UNIT (t2
)
1642 || operand_equal_p (TYPE_SIZE_UNIT (t1
),
1643 TYPE_SIZE_UNIT (t2
), 0));
1647 /* Return true if TYPE1 and TYPE2 are equivalent for One Definition Rule. */
1650 odr_types_equivalent_p (tree type1
, tree type2
)
1652 gcc_checking_assert (odr_or_derived_type_p (type1
)
1653 && odr_or_derived_type_p (type2
));
1655 hash_set
<type_pair
> visited
;
1656 return odr_types_equivalent_p (type1
, type2
, false, NULL
,
1657 &visited
, UNKNOWN_LOCATION
, UNKNOWN_LOCATION
);
1660 /* TYPE is equivalent to VAL by ODR, but its tree representation differs
1661 from VAL->type. This may happen in LTO where tree merging did not merge
1662 all variants of the same type or due to ODR violation.
1664 Analyze and report ODR violations and add type to duplicate list.
1665 If TYPE is more specified than VAL->type, prevail VAL->type. Also if
1666 this is first time we see definition of a class return true so the
1667 base types are analyzed. */
1670 add_type_duplicate (odr_type val
, tree type
)
1672 bool build_bases
= false;
1673 bool prevail
= false;
1674 bool odr_must_violate
= false;
1676 if (!val
->types_set
)
1677 val
->types_set
= new hash_set
<tree
>;
1679 /* Chose polymorphic type as leader (this happens only in case of ODR
1681 if ((TREE_CODE (type
) == RECORD_TYPE
&& TYPE_BINFO (type
)
1682 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
1683 && (TREE_CODE (val
->type
) != RECORD_TYPE
|| !TYPE_BINFO (val
->type
)
1684 || !polymorphic_type_binfo_p (TYPE_BINFO (val
->type
))))
1689 /* Always prefer complete type to be the leader. */
1690 else if (!COMPLETE_TYPE_P (val
->type
) && COMPLETE_TYPE_P (type
))
1693 build_bases
= TYPE_BINFO (type
);
1695 else if (COMPLETE_TYPE_P (val
->type
) && !COMPLETE_TYPE_P (type
))
1697 else if (TREE_CODE (val
->type
) == ENUMERAL_TYPE
1698 && TREE_CODE (type
) == ENUMERAL_TYPE
1699 && !TYPE_VALUES (val
->type
) && TYPE_VALUES (type
))
1701 else if (TREE_CODE (val
->type
) == RECORD_TYPE
1702 && TREE_CODE (type
) == RECORD_TYPE
1703 && TYPE_BINFO (type
) && !TYPE_BINFO (val
->type
))
1705 gcc_assert (!val
->bases
.length ());
1711 std::swap (val
->type
, type
);
1713 val
->types_set
->add (type
);
1715 /* If we now have a mangled name, be sure to record it to val->type
1716 so ODR hash can work. */
1718 if (can_be_name_hashed_p (type
) && !can_be_name_hashed_p (val
->type
))
1719 SET_DECL_ASSEMBLER_NAME (TYPE_NAME (val
->type
),
1720 DECL_ASSEMBLER_NAME (TYPE_NAME (type
)));
1723 bool base_mismatch
= false;
1725 bool warned
= false;
1726 hash_set
<type_pair
> visited
;
1728 gcc_assert (in_lto_p
);
1729 vec_safe_push (val
->types
, type
);
1731 /* If both are class types, compare the bases. */
1732 if (COMPLETE_TYPE_P (type
) && COMPLETE_TYPE_P (val
->type
)
1733 && TREE_CODE (val
->type
) == RECORD_TYPE
1734 && TREE_CODE (type
) == RECORD_TYPE
1735 && TYPE_BINFO (val
->type
) && TYPE_BINFO (type
))
1737 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (type
))
1738 != BINFO_N_BASE_BINFOS (TYPE_BINFO (val
->type
)))
1740 if (!flag_ltrans
&& !warned
&& !val
->odr_violated
)
1743 warn_odr (type
, val
->type
, NULL
, NULL
, !warned
, &warned
,
1744 "a type with the same name but different "
1745 "number of polymorphic bases is "
1746 "defined in another translation unit");
1749 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (type
))
1750 > BINFO_N_BASE_BINFOS (TYPE_BINFO (val
->type
)))
1751 extra_base
= BINFO_BASE_BINFO
1753 BINFO_N_BASE_BINFOS (TYPE_BINFO (val
->type
)));
1755 extra_base
= BINFO_BASE_BINFO
1756 (TYPE_BINFO (val
->type
),
1757 BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1758 tree extra_base_type
= BINFO_TYPE (extra_base
);
1759 inform (DECL_SOURCE_LOCATION (TYPE_NAME (extra_base_type
)),
1760 "the extra base is defined here");
1763 base_mismatch
= true;
1766 for (i
= 0; i
< BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)); i
++)
1768 tree base1
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1769 tree base2
= BINFO_BASE_BINFO (TYPE_BINFO (val
->type
), i
);
1770 tree type1
= BINFO_TYPE (base1
);
1771 tree type2
= BINFO_TYPE (base2
);
1773 if (types_odr_comparable (type1
, type2
))
1775 if (!types_same_for_odr (type1
, type2
))
1776 base_mismatch
= true;
1779 if (!odr_types_equivalent_p (type1
, type2
))
1780 base_mismatch
= true;
1783 if (!warned
&& !val
->odr_violated
)
1785 warn_odr (type
, val
->type
, NULL
, NULL
,
1787 "a type with the same name but different base "
1788 "type is defined in another translation unit");
1790 warn_types_mismatch (type1
, type2
,
1791 UNKNOWN_LOCATION
, UNKNOWN_LOCATION
);
1795 if (BINFO_OFFSET (base1
) != BINFO_OFFSET (base2
))
1797 base_mismatch
= true;
1798 if (!warned
&& !val
->odr_violated
)
1799 warn_odr (type
, val
->type
, NULL
, NULL
,
1801 "a type with the same name but different base "
1802 "layout is defined in another translation unit");
1805 /* One of bases is not of complete type. */
1806 if (!TYPE_BINFO (type1
) != !TYPE_BINFO (type2
))
1808 /* If we have a polymorphic type info specified for TYPE1
1809 but not for TYPE2 we possibly missed a base when recording
1811 Be sure this does not happen. */
1812 if (TYPE_BINFO (type1
)
1813 && polymorphic_type_binfo_p (TYPE_BINFO (type1
))
1815 odr_must_violate
= true;
1818 /* One base is polymorphic and the other not.
1819 This ought to be diagnosed earlier, but do not ICE in the
1821 else if (TYPE_BINFO (type1
)
1822 && polymorphic_type_binfo_p (TYPE_BINFO (type1
))
1823 != polymorphic_type_binfo_p (TYPE_BINFO (type2
)))
1825 if (!warned
&& !val
->odr_violated
)
1826 warn_odr (type
, val
->type
, NULL
, NULL
,
1828 "a base of the type is polymorphic only in one "
1829 "translation unit");
1830 base_mismatch
= true;
1837 odr_violation_reported
= true;
1838 val
->odr_violated
= true;
1840 if (symtab
->dump_file
)
1842 fprintf (symtab
->dump_file
, "ODR base violation\n");
1844 print_node (symtab
->dump_file
, "", val
->type
, 0);
1845 putc ('\n',symtab
->dump_file
);
1846 print_node (symtab
->dump_file
, "", type
, 0);
1847 putc ('\n',symtab
->dump_file
);
1852 /* Next compare memory layout.
1853 The DECL_SOURCE_LOCATIONs in this invocation came from LTO streaming.
1854 We must apply the location cache to ensure that they are valid
1855 before we can pass them to odr_types_equivalent_p (PR lto/83121). */
1856 if (lto_location_cache::current_cache
)
1857 lto_location_cache::current_cache
->apply_location_cache ();
1858 if (!odr_types_equivalent_p (val
->type
, type
,
1859 !flag_ltrans
&& !val
->odr_violated
&& !warned
,
1861 DECL_SOURCE_LOCATION (TYPE_NAME (val
->type
)),
1862 DECL_SOURCE_LOCATION (TYPE_NAME (type
))))
1865 odr_violation_reported
= true;
1866 val
->odr_violated
= true;
1868 gcc_assert (val
->odr_violated
|| !odr_must_violate
);
1869 /* Sanity check that all bases will be build same way again. */
1871 && COMPLETE_TYPE_P (type
) && COMPLETE_TYPE_P (val
->type
)
1872 && TREE_CODE (val
->type
) == RECORD_TYPE
1873 && TREE_CODE (type
) == RECORD_TYPE
1874 && TYPE_BINFO (val
->type
) && TYPE_BINFO (type
)
1875 && !val
->odr_violated
1876 && !base_mismatch
&& val
->bases
.length ())
1878 unsigned int num_poly_bases
= 0;
1881 for (i
= 0; i
< BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)); i
++)
1882 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO
1883 (TYPE_BINFO (type
), i
)))
1885 gcc_assert (num_poly_bases
== val
->bases
.length ());
1886 for (j
= 0, i
= 0; i
< BINFO_N_BASE_BINFOS (TYPE_BINFO (type
));
1888 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO
1889 (TYPE_BINFO (type
), i
)))
1891 odr_type base
= get_odr_type
1893 (BINFO_BASE_BINFO (TYPE_BINFO (type
),
1896 gcc_assert (val
->bases
[j
] == base
);
1902 /* Regularize things a little. During LTO same types may come with
1903 different BINFOs. Either because their virtual table was
1904 not merged by tree merging and only later at decl merging or
1905 because one type comes with external vtable, while other
1906 with internal. We want to merge equivalent binfos to conserve
1907 memory and streaming overhead.
1909 The external vtables are more harmful: they contain references
1910 to external declarations of methods that may be defined in the
1911 merged LTO unit. For this reason we absolutely need to remove
1912 them and replace by internal variants. Not doing so will lead
1913 to incomplete answers from possible_polymorphic_call_targets.
1915 FIXME: disable for now; because ODR types are now build during
1916 streaming in, the variants do not need to be linked to the type,
1917 yet. We need to do the merging in cleanup pass to be implemented
1919 if (!flag_ltrans
&& merge
1921 && TREE_CODE (val
->type
) == RECORD_TYPE
1922 && TREE_CODE (type
) == RECORD_TYPE
1923 && TYPE_BINFO (val
->type
) && TYPE_BINFO (type
)
1924 && TYPE_MAIN_VARIANT (type
) == type
1925 && TYPE_MAIN_VARIANT (val
->type
) == val
->type
1926 && BINFO_VTABLE (TYPE_BINFO (val
->type
))
1927 && BINFO_VTABLE (TYPE_BINFO (type
)))
1929 tree master_binfo
= TYPE_BINFO (val
->type
);
1930 tree v1
= BINFO_VTABLE (master_binfo
);
1931 tree v2
= BINFO_VTABLE (TYPE_BINFO (type
));
1933 if (TREE_CODE (v1
) == POINTER_PLUS_EXPR
)
1935 gcc_assert (TREE_CODE (v2
) == POINTER_PLUS_EXPR
1936 && operand_equal_p (TREE_OPERAND (v1
, 1),
1937 TREE_OPERAND (v2
, 1), 0));
1938 v1
= TREE_OPERAND (TREE_OPERAND (v1
, 0), 0);
1939 v2
= TREE_OPERAND (TREE_OPERAND (v2
, 0), 0);
1941 gcc_assert (DECL_ASSEMBLER_NAME (v1
)
1942 == DECL_ASSEMBLER_NAME (v2
));
1944 if (DECL_EXTERNAL (v1
) && !DECL_EXTERNAL (v2
))
1948 set_type_binfo (val
->type
, TYPE_BINFO (type
));
1949 for (i
= 0; i
< val
->types
->length (); i
++)
1951 if (TYPE_BINFO ((*val
->types
)[i
])
1953 set_type_binfo ((*val
->types
)[i
], TYPE_BINFO (type
));
1955 BINFO_TYPE (TYPE_BINFO (type
)) = val
->type
;
1958 set_type_binfo (type
, master_binfo
);
1963 /* Get ODR type hash entry for TYPE. If INSERT is true, create
1964 possibly new entry. */
1967 get_odr_type (tree type
, bool insert
)
1969 odr_type_d
**slot
= NULL
;
1970 odr_type_d
**vtable_slot
= NULL
;
1971 odr_type val
= NULL
;
1973 bool build_bases
= false;
1974 bool insert_to_odr_array
= false;
1977 type
= main_odr_variant (type
);
1979 gcc_checking_assert (can_be_name_hashed_p (type
)
1980 || can_be_vtable_hashed_p (type
));
1982 /* Lookup entry, first try name hash, fallback to vtable hash. */
1983 if (can_be_name_hashed_p (type
))
1985 hash
= hash_odr_name (type
);
1986 slot
= odr_hash
->find_slot_with_hash (type
, hash
,
1987 insert
? INSERT
: NO_INSERT
);
1989 if ((!slot
|| !*slot
) && in_lto_p
&& can_be_vtable_hashed_p (type
))
1991 hash
= hash_odr_vtable (type
);
1992 vtable_slot
= odr_vtable_hash
->find_slot_with_hash (type
, hash
,
1993 insert
? INSERT
: NO_INSERT
);
1996 if (!slot
&& !vtable_slot
)
1999 /* See if we already have entry for type. */
2000 if ((slot
&& *slot
) || (vtable_slot
&& *vtable_slot
))
2006 && in_lto_p
&& can_be_vtable_hashed_p (type
))
2008 hash
= hash_odr_vtable (type
);
2009 vtable_slot
= odr_vtable_hash
->find_slot_with_hash (type
, hash
,
2011 gcc_assert (!vtable_slot
|| *vtable_slot
== *slot
);
2015 else if (*vtable_slot
)
2018 if (val
->type
!= type
2019 && (!val
->types_set
|| !val
->types_set
->add (type
)))
2021 gcc_assert (insert
);
2022 /* We have type duplicate, but it may introduce vtable name or
2023 mangled name; be sure to keep hashes in sync. */
2024 if (in_lto_p
&& can_be_vtable_hashed_p (type
)
2025 && (!vtable_slot
|| !*vtable_slot
))
2029 hash
= hash_odr_vtable (type
);
2030 vtable_slot
= odr_vtable_hash
->find_slot_with_hash
2031 (type
, hash
, INSERT
);
2032 gcc_checking_assert (!*vtable_slot
|| *vtable_slot
== val
);
2038 build_bases
= add_type_duplicate (val
, type
);
2043 val
= ggc_cleared_alloc
<odr_type_d
> ();
2046 val
->derived_types
= vNULL
;
2047 if (type_with_linkage_p (type
))
2048 val
->anonymous_namespace
= type_in_anonymous_namespace_p (type
);
2050 val
->anonymous_namespace
= 0;
2051 build_bases
= COMPLETE_TYPE_P (val
->type
);
2052 insert_to_odr_array
= true;
2059 if (build_bases
&& TREE_CODE (type
) == RECORD_TYPE
&& TYPE_BINFO (type
)
2060 && type_with_linkage_p (type
)
2061 && type
== TYPE_MAIN_VARIANT (type
))
2063 tree binfo
= TYPE_BINFO (type
);
2066 gcc_assert (BINFO_TYPE (TYPE_BINFO (val
->type
)) == type
);
2068 val
->all_derivations_known
= type_all_derivations_known_p (type
);
2069 for (i
= 0; i
< BINFO_N_BASE_BINFOS (binfo
); i
++)
2070 /* For now record only polymorphic types. other are
2071 pointless for devirtualization and we can not precisely
2072 determine ODR equivalency of these during LTO. */
2073 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (binfo
, i
)))
2075 tree base_type
= BINFO_TYPE (BINFO_BASE_BINFO (binfo
, i
));
2076 odr_type base
= get_odr_type (base_type
, true);
2077 gcc_assert (TYPE_MAIN_VARIANT (base_type
) == base_type
);
2078 base
->derived_types
.safe_push (val
);
2079 val
->bases
.safe_push (base
);
2080 if (base
->id
> base_id
)
2084 /* Ensure that type always appears after bases. */
2085 if (insert_to_odr_array
)
2088 val
->id
= odr_types
.length ();
2089 vec_safe_push (odr_types_ptr
, val
);
2091 else if (base_id
> val
->id
)
2093 odr_types
[val
->id
] = 0;
2094 /* Be sure we did not recorded any derived types; these may need
2096 gcc_assert (val
->derived_types
.length() == 0);
2097 val
->id
= odr_types
.length ();
2098 vec_safe_push (odr_types_ptr
, val
);
2103 /* Add TYPE od ODR type hash. */
2106 register_odr_type (tree type
)
2110 odr_hash
= new odr_hash_type (23);
2112 odr_vtable_hash
= new odr_vtable_hash_type (23);
2114 /* Arrange things to be nicer and insert main variants first.
2115 ??? fundamental prerecorded types do not have mangled names; this
2116 makes it possible that non-ODR type is main_odr_variant of ODR type.
2117 Things may get smoother if LTO FE set mangled name of those types same
2118 way as C++ FE does. */
2119 if (odr_type_p (main_odr_variant (TYPE_MAIN_VARIANT (type
)))
2120 && odr_type_p (TYPE_MAIN_VARIANT (type
)))
2121 get_odr_type (TYPE_MAIN_VARIANT (type
), true);
2122 if (TYPE_MAIN_VARIANT (type
) != type
&& odr_type_p (main_odr_variant (type
)))
2123 get_odr_type (type
, true);
2126 /* Return true if type is known to have no derivations. */
2129 type_known_to_have_no_derivations_p (tree t
)
2131 return (type_all_derivations_known_p (t
)
2132 && (TYPE_FINAL_P (t
)
2134 && !get_odr_type (t
, true)->derived_types
.length())));
2137 /* Dump ODR type T and all its derived types. INDENT specifies indentation for
2138 recursive printing. */
2141 dump_odr_type (FILE *f
, odr_type t
, int indent
=0)
2144 fprintf (f
, "%*s type %i: ", indent
* 2, "", t
->id
);
2145 print_generic_expr (f
, t
->type
, TDF_SLIM
);
2146 fprintf (f
, "%s", t
->anonymous_namespace
? " (anonymous namespace)":"");
2147 fprintf (f
, "%s\n", t
->all_derivations_known
? " (derivations known)":"");
2148 if (TYPE_NAME (t
->type
))
2150 /*fprintf (f, "%*s defined at: %s:%i\n", indent * 2, "",
2151 DECL_SOURCE_FILE (TYPE_NAME (t->type)),
2152 DECL_SOURCE_LINE (TYPE_NAME (t->type)));*/
2153 if (DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t
->type
)))
2154 fprintf (f
, "%*s mangled name: %s\n", indent
* 2, "",
2156 (DECL_ASSEMBLER_NAME (TYPE_NAME (t
->type
))));
2158 if (t
->bases
.length ())
2160 fprintf (f
, "%*s base odr type ids: ", indent
* 2, "");
2161 for (i
= 0; i
< t
->bases
.length (); i
++)
2162 fprintf (f
, " %i", t
->bases
[i
]->id
);
2165 if (t
->derived_types
.length ())
2167 fprintf (f
, "%*s derived types:\n", indent
* 2, "");
2168 for (i
= 0; i
< t
->derived_types
.length (); i
++)
2169 dump_odr_type (f
, t
->derived_types
[i
], indent
+ 1);
2174 /* Dump the type inheritance graph. */
2177 dump_type_inheritance_graph (FILE *f
)
2182 fprintf (f
, "\n\nType inheritance graph:\n");
2183 for (i
= 0; i
< odr_types
.length (); i
++)
2185 if (odr_types
[i
] && odr_types
[i
]->bases
.length () == 0)
2186 dump_odr_type (f
, odr_types
[i
]);
2188 for (i
= 0; i
< odr_types
.length (); i
++)
2190 if (odr_types
[i
] && odr_types
[i
]->types
&& odr_types
[i
]->types
->length ())
2193 fprintf (f
, "Duplicate tree types for odr type %i\n", i
);
2194 print_node (f
, "", odr_types
[i
]->type
, 0);
2195 for (j
= 0; j
< odr_types
[i
]->types
->length (); j
++)
2198 fprintf (f
, "duplicate #%i\n", j
);
2199 print_node (f
, "", (*odr_types
[i
]->types
)[j
], 0);
2200 t
= (*odr_types
[i
]->types
)[j
];
2201 while (TYPE_P (t
) && TYPE_CONTEXT (t
))
2203 t
= TYPE_CONTEXT (t
);
2204 print_node (f
, "", t
, 0);
2212 /* Initialize IPA devirt and build inheritance tree graph. */
2215 build_type_inheritance_graph (void)
2217 struct symtab_node
*n
;
2218 FILE *inheritance_dump_file
;
2223 timevar_push (TV_IPA_INHERITANCE
);
2224 inheritance_dump_file
= dump_begin (TDI_inheritance
, &flags
);
2225 odr_hash
= new odr_hash_type (23);
2227 odr_vtable_hash
= new odr_vtable_hash_type (23);
2229 /* We reconstruct the graph starting of types of all methods seen in the
2232 if (is_a
<cgraph_node
*> (n
)
2233 && DECL_VIRTUAL_P (n
->decl
)
2234 && n
->real_symbol_p ())
2235 get_odr_type (TYPE_METHOD_BASETYPE (TREE_TYPE (n
->decl
)), true);
2237 /* Look also for virtual tables of types that do not define any methods.
2239 We need it in a case where class B has virtual base of class A
2240 re-defining its virtual method and there is class C with no virtual
2241 methods with B as virtual base.
2243 Here we output B's virtual method in two variant - for non-virtual
2244 and virtual inheritance. B's virtual table has non-virtual version,
2245 while C's has virtual.
2247 For this reason we need to know about C in order to include both
2248 variants of B. More correctly, record_target_from_binfo should
2249 add both variants of the method when walking B, but we have no
2250 link in between them.
2252 We rely on fact that either the method is exported and thus we
2253 assume it is called externally or C is in anonymous namespace and
2254 thus we will see the vtable. */
2256 else if (is_a
<varpool_node
*> (n
)
2257 && DECL_VIRTUAL_P (n
->decl
)
2258 && TREE_CODE (DECL_CONTEXT (n
->decl
)) == RECORD_TYPE
2259 && TYPE_BINFO (DECL_CONTEXT (n
->decl
))
2260 && polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (n
->decl
))))
2261 get_odr_type (TYPE_MAIN_VARIANT (DECL_CONTEXT (n
->decl
)), true);
2262 if (inheritance_dump_file
)
2264 dump_type_inheritance_graph (inheritance_dump_file
);
2265 dump_end (TDI_inheritance
, inheritance_dump_file
);
2267 timevar_pop (TV_IPA_INHERITANCE
);
2270 /* Return true if N has reference from live virtual table
2271 (and thus can be a destination of polymorphic call).
2272 Be conservatively correct when callgraph is not built or
2273 if the method may be referred externally. */
2276 referenced_from_vtable_p (struct cgraph_node
*node
)
2279 struct ipa_ref
*ref
;
2282 if (node
->externally_visible
2283 || DECL_EXTERNAL (node
->decl
)
2284 || node
->used_from_other_partition
)
2287 /* Keep this test constant time.
2288 It is unlikely this can happen except for the case where speculative
2289 devirtualization introduced many speculative edges to this node.
2290 In this case the target is very likely alive anyway. */
2291 if (node
->ref_list
.referring
.length () > 100)
2294 /* We need references built. */
2295 if (symtab
->state
<= CONSTRUCTION
)
2298 for (i
= 0; node
->iterate_referring (i
, ref
); i
++)
2299 if ((ref
->use
== IPA_REF_ALIAS
2300 && referenced_from_vtable_p (dyn_cast
<cgraph_node
*> (ref
->referring
)))
2301 || (ref
->use
== IPA_REF_ADDR
2302 && VAR_P (ref
->referring
->decl
)
2303 && DECL_VIRTUAL_P (ref
->referring
->decl
)))
2311 /* Return if TARGET is cxa_pure_virtual. */
2314 is_cxa_pure_virtual_p (tree target
)
2316 return target
&& TREE_CODE (TREE_TYPE (target
)) != METHOD_TYPE
2317 && DECL_NAME (target
)
2318 && id_equal (DECL_NAME (target
),
2319 "__cxa_pure_virtual");
2322 /* If TARGET has associated node, record it in the NODES array.
2323 CAN_REFER specify if program can refer to the target directly.
2324 if TARGET is unknown (NULL) or it can not be inserted (for example because
2325 its body was already removed and there is no way to refer to it), clear
2329 maybe_record_node (vec
<cgraph_node
*> &nodes
,
2330 tree target
, hash_set
<tree
> *inserted
,
2334 struct cgraph_node
*target_node
, *alias_target
;
2335 enum availability avail
;
2336 bool pure_virtual
= is_cxa_pure_virtual_p (target
);
2338 /* __builtin_unreachable do not need to be added into
2339 list of targets; the runtime effect of calling them is undefined.
2340 Only "real" virtual methods should be accounted. */
2341 if (target
&& TREE_CODE (TREE_TYPE (target
)) != METHOD_TYPE
&& !pure_virtual
)
2346 /* The only case when method of anonymous namespace becomes unreferable
2347 is when we completely optimized it out. */
2350 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target
)))
2358 target_node
= cgraph_node::get (target
);
2360 /* Prefer alias target over aliases, so we do not get confused by
2364 alias_target
= target_node
->ultimate_alias_target (&avail
);
2365 if (target_node
!= alias_target
2366 && avail
>= AVAIL_AVAILABLE
2367 && target_node
->get_availability ())
2368 target_node
= alias_target
;
2371 /* Method can only be called by polymorphic call if any
2372 of vtables referring to it are alive.
2374 While this holds for non-anonymous functions, too, there are
2375 cases where we want to keep them in the list; for example
2376 inline functions with -fno-weak are static, but we still
2377 may devirtualize them when instance comes from other unit.
2378 The same holds for LTO.
2380 Currently we ignore these functions in speculative devirtualization.
2381 ??? Maybe it would make sense to be more aggressive for LTO even
2385 && type_in_anonymous_namespace_p (DECL_CONTEXT (target
))
2387 || !referenced_from_vtable_p (target_node
)))
2389 /* See if TARGET is useful function we can deal with. */
2390 else if (target_node
!= NULL
2391 && (TREE_PUBLIC (target
)
2392 || DECL_EXTERNAL (target
)
2393 || target_node
->definition
)
2394 && target_node
->real_symbol_p ())
2396 gcc_assert (!target_node
->global
.inlined_to
);
2397 gcc_assert (target_node
->real_symbol_p ());
2398 /* When sanitizing, do not assume that __cxa_pure_virtual is not called
2399 by valid program. */
2400 if (flag_sanitize
& SANITIZE_UNREACHABLE
)
2402 /* Only add pure virtual if it is the only possible target. This way
2403 we will preserve the diagnostics about pure virtual called in many
2404 cases without disabling optimization in other. */
2405 else if (pure_virtual
)
2407 if (nodes
.length ())
2410 /* If we found a real target, take away cxa_pure_virtual. */
2411 else if (!pure_virtual
&& nodes
.length () == 1
2412 && is_cxa_pure_virtual_p (nodes
[0]->decl
))
2414 if (pure_virtual
&& nodes
.length ())
2416 if (!inserted
->add (target
))
2418 cached_polymorphic_call_targets
->add (target_node
);
2419 nodes
.safe_push (target_node
);
2422 else if (!completep
)
2424 /* We have definition of __cxa_pure_virtual that is not accessible (it is
2425 optimized out or partitioned to other unit) so we can not add it. When
2426 not sanitizing, there is nothing to do.
2427 Otherwise declare the list incomplete. */
2428 else if (pure_virtual
)
2430 if (flag_sanitize
& SANITIZE_UNREACHABLE
)
2433 else if (flag_ltrans
2434 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target
)))
2438 /* See if BINFO's type matches OUTER_TYPE. If so, look up
2439 BINFO of subtype of OTR_TYPE at OFFSET and in that BINFO find
2440 method in vtable and insert method to NODES array
2441 or BASES_TO_CONSIDER if this array is non-NULL.
2442 Otherwise recurse to base BINFOs.
2443 This matches what get_binfo_at_offset does, but with offset
2446 TYPE_BINFOS is a stack of BINFOS of types with defined
2447 virtual table seen on way from class type to BINFO.
2449 MATCHED_VTABLES tracks virtual tables we already did lookup
2450 for virtual function in. INSERTED tracks nodes we already
2453 ANONYMOUS is true if BINFO is part of anonymous namespace.
2455 Clear COMPLETEP when we hit unreferable target.
2459 record_target_from_binfo (vec
<cgraph_node
*> &nodes
,
2460 vec
<tree
> *bases_to_consider
,
2463 vec
<tree
> &type_binfos
,
2464 HOST_WIDE_INT otr_token
,
2466 HOST_WIDE_INT offset
,
2467 hash_set
<tree
> *inserted
,
2468 hash_set
<tree
> *matched_vtables
,
2472 tree type
= BINFO_TYPE (binfo
);
2477 if (BINFO_VTABLE (binfo
))
2478 type_binfos
.safe_push (binfo
);
2479 if (types_same_for_odr (type
, outer_type
))
2482 tree type_binfo
= NULL
;
2484 /* Look up BINFO with virtual table. For normal types it is always last
2486 for (i
= type_binfos
.length () - 1; i
>= 0; i
--)
2487 if (BINFO_OFFSET (type_binfos
[i
]) == BINFO_OFFSET (binfo
))
2489 type_binfo
= type_binfos
[i
];
2492 if (BINFO_VTABLE (binfo
))
2494 /* If this is duplicated BINFO for base shared by virtual inheritance,
2495 we may not have its associated vtable. This is not a problem, since
2496 we will walk it on the other path. */
2499 tree inner_binfo
= get_binfo_at_offset (type_binfo
,
2503 gcc_assert (odr_violation_reported
);
2506 /* For types in anonymous namespace first check if the respective vtable
2507 is alive. If not, we know the type can't be called. */
2508 if (!flag_ltrans
&& anonymous
)
2510 tree vtable
= BINFO_VTABLE (inner_binfo
);
2511 varpool_node
*vnode
;
2513 if (TREE_CODE (vtable
) == POINTER_PLUS_EXPR
)
2514 vtable
= TREE_OPERAND (TREE_OPERAND (vtable
, 0), 0);
2515 vnode
= varpool_node::get (vtable
);
2516 if (!vnode
|| !vnode
->definition
)
2519 gcc_assert (inner_binfo
);
2520 if (bases_to_consider
2521 ? !matched_vtables
->contains (BINFO_VTABLE (inner_binfo
))
2522 : !matched_vtables
->add (BINFO_VTABLE (inner_binfo
)))
2525 tree target
= gimple_get_virt_method_for_binfo (otr_token
,
2528 if (!bases_to_consider
)
2529 maybe_record_node (nodes
, target
, inserted
, can_refer
, completep
);
2530 /* Destructors are never called via construction vtables. */
2531 else if (!target
|| !DECL_CXX_DESTRUCTOR_P (target
))
2532 bases_to_consider
->safe_push (target
);
2538 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2539 /* Walking bases that have no virtual method is pointless exercise. */
2540 if (polymorphic_type_binfo_p (base_binfo
))
2541 record_target_from_binfo (nodes
, bases_to_consider
, base_binfo
, otr_type
,
2543 otr_token
, outer_type
, offset
, inserted
,
2544 matched_vtables
, anonymous
, completep
);
2545 if (BINFO_VTABLE (binfo
))
2549 /* Look up virtual methods matching OTR_TYPE (with OFFSET and OTR_TOKEN)
2550 of TYPE, insert them to NODES, recurse into derived nodes.
2551 INSERTED is used to avoid duplicate insertions of methods into NODES.
2552 MATCHED_VTABLES are used to avoid duplicate walking vtables.
2553 Clear COMPLETEP if unreferable target is found.
2555 If CONSIDER_CONSTRUCTION is true, record to BASES_TO_CONSIDER
2556 all cases where BASE_SKIPPED is true (because the base is abstract
2560 possible_polymorphic_call_targets_1 (vec
<cgraph_node
*> &nodes
,
2561 hash_set
<tree
> *inserted
,
2562 hash_set
<tree
> *matched_vtables
,
2565 HOST_WIDE_INT otr_token
,
2567 HOST_WIDE_INT offset
,
2569 vec
<tree
> &bases_to_consider
,
2570 bool consider_construction
)
2572 tree binfo
= TYPE_BINFO (type
->type
);
2574 auto_vec
<tree
, 8> type_binfos
;
2575 bool possibly_instantiated
= type_possibly_instantiated_p (type
->type
);
2577 /* We may need to consider types w/o instances because of possible derived
2578 types using their methods either directly or via construction vtables.
2579 We are safe to skip them when all derivations are known, since we will
2581 This is done by recording them to BASES_TO_CONSIDER array. */
2582 if (possibly_instantiated
|| consider_construction
)
2584 record_target_from_binfo (nodes
,
2585 (!possibly_instantiated
2586 && type_all_derivations_known_p (type
->type
))
2587 ? &bases_to_consider
: NULL
,
2588 binfo
, otr_type
, type_binfos
, otr_token
,
2590 inserted
, matched_vtables
,
2591 type
->anonymous_namespace
, completep
);
2593 for (i
= 0; i
< type
->derived_types
.length (); i
++)
2594 possible_polymorphic_call_targets_1 (nodes
, inserted
,
2597 type
->derived_types
[i
],
2598 otr_token
, outer_type
, offset
, completep
,
2599 bases_to_consider
, consider_construction
);
2602 /* Cache of queries for polymorphic call targets.
2604 Enumerating all call targets may get expensive when there are many
2605 polymorphic calls in the program, so we memoize all the previous
2606 queries and avoid duplicated work. */
2608 struct polymorphic_call_target_d
2610 HOST_WIDE_INT otr_token
;
2611 ipa_polymorphic_call_context context
;
2613 vec
<cgraph_node
*> targets
;
2620 /* Polymorphic call target cache helpers. */
2622 struct polymorphic_call_target_hasher
2623 : pointer_hash
<polymorphic_call_target_d
>
2625 static inline hashval_t
hash (const polymorphic_call_target_d
*);
2626 static inline bool equal (const polymorphic_call_target_d
*,
2627 const polymorphic_call_target_d
*);
2628 static inline void remove (polymorphic_call_target_d
*);
2631 /* Return the computed hashcode for ODR_QUERY. */
2634 polymorphic_call_target_hasher::hash (const polymorphic_call_target_d
*odr_query
)
2636 inchash::hash
hstate (odr_query
->otr_token
);
2638 hstate
.add_hwi (odr_query
->type
->id
);
2639 hstate
.merge_hash (TYPE_UID (odr_query
->context
.outer_type
));
2640 hstate
.add_hwi (odr_query
->context
.offset
);
2642 if (odr_query
->context
.speculative_outer_type
)
2644 hstate
.merge_hash (TYPE_UID (odr_query
->context
.speculative_outer_type
));
2645 hstate
.add_hwi (odr_query
->context
.speculative_offset
);
2647 hstate
.add_flag (odr_query
->speculative
);
2648 hstate
.add_flag (odr_query
->context
.maybe_in_construction
);
2649 hstate
.add_flag (odr_query
->context
.maybe_derived_type
);
2650 hstate
.add_flag (odr_query
->context
.speculative_maybe_derived_type
);
2651 hstate
.commit_flag ();
2652 return hstate
.end ();
2655 /* Compare cache entries T1 and T2. */
2658 polymorphic_call_target_hasher::equal (const polymorphic_call_target_d
*t1
,
2659 const polymorphic_call_target_d
*t2
)
2661 return (t1
->type
== t2
->type
&& t1
->otr_token
== t2
->otr_token
2662 && t1
->speculative
== t2
->speculative
2663 && t1
->context
.offset
== t2
->context
.offset
2664 && t1
->context
.speculative_offset
== t2
->context
.speculative_offset
2665 && t1
->context
.outer_type
== t2
->context
.outer_type
2666 && t1
->context
.speculative_outer_type
== t2
->context
.speculative_outer_type
2667 && t1
->context
.maybe_in_construction
2668 == t2
->context
.maybe_in_construction
2669 && t1
->context
.maybe_derived_type
== t2
->context
.maybe_derived_type
2670 && (t1
->context
.speculative_maybe_derived_type
2671 == t2
->context
.speculative_maybe_derived_type
));
2674 /* Remove entry in polymorphic call target cache hash. */
2677 polymorphic_call_target_hasher::remove (polymorphic_call_target_d
*v
)
2679 v
->targets
.release ();
2683 /* Polymorphic call target query cache. */
2685 typedef hash_table
<polymorphic_call_target_hasher
>
2686 polymorphic_call_target_hash_type
;
2687 static polymorphic_call_target_hash_type
*polymorphic_call_target_hash
;
2689 /* Destroy polymorphic call target query cache. */
2692 free_polymorphic_call_targets_hash ()
2694 if (cached_polymorphic_call_targets
)
2696 delete polymorphic_call_target_hash
;
2697 polymorphic_call_target_hash
= NULL
;
2698 delete cached_polymorphic_call_targets
;
2699 cached_polymorphic_call_targets
= NULL
;
2703 /* When virtual function is removed, we may need to flush the cache. */
2706 devirt_node_removal_hook (struct cgraph_node
*n
, void *d ATTRIBUTE_UNUSED
)
2708 if (cached_polymorphic_call_targets
2709 && cached_polymorphic_call_targets
->contains (n
))
2710 free_polymorphic_call_targets_hash ();
2713 /* Look up base of BINFO that has virtual table VTABLE with OFFSET. */
2716 subbinfo_with_vtable_at_offset (tree binfo
, unsigned HOST_WIDE_INT offset
,
2719 tree v
= BINFO_VTABLE (binfo
);
2722 unsigned HOST_WIDE_INT this_offset
;
2726 if (!vtable_pointer_value_to_vtable (v
, &v
, &this_offset
))
2729 if (offset
== this_offset
2730 && DECL_ASSEMBLER_NAME (v
) == DECL_ASSEMBLER_NAME (vtable
))
2734 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2735 if (polymorphic_type_binfo_p (base_binfo
))
2737 base_binfo
= subbinfo_with_vtable_at_offset (base_binfo
, offset
, vtable
);
2744 /* T is known constant value of virtual table pointer.
2745 Store virtual table to V and its offset to OFFSET.
2746 Return false if T does not look like virtual table reference. */
2749 vtable_pointer_value_to_vtable (const_tree t
, tree
*v
,
2750 unsigned HOST_WIDE_INT
*offset
)
2752 /* We expect &MEM[(void *)&virtual_table + 16B].
2753 We obtain object's BINFO from the context of the virtual table.
2754 This one contains pointer to virtual table represented via
2755 POINTER_PLUS_EXPR. Verify that this pointer matches what
2756 we propagated through.
2758 In the case of virtual inheritance, the virtual tables may
2759 be nested, i.e. the offset may be different from 16 and we may
2760 need to dive into the type representation. */
2761 if (TREE_CODE (t
) == ADDR_EXPR
2762 && TREE_CODE (TREE_OPERAND (t
, 0)) == MEM_REF
2763 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)) == ADDR_EXPR
2764 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 1)) == INTEGER_CST
2765 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 0))
2767 && DECL_VIRTUAL_P (TREE_OPERAND (TREE_OPERAND
2768 (TREE_OPERAND (t
, 0), 0), 0)))
2770 *v
= TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 0);
2771 *offset
= tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (t
, 0), 1));
2775 /* Alternative representation, used by C++ frontend is POINTER_PLUS_EXPR.
2776 We need to handle it when T comes from static variable initializer or
2778 if (TREE_CODE (t
) == POINTER_PLUS_EXPR
)
2780 *offset
= tree_to_uhwi (TREE_OPERAND (t
, 1));
2781 t
= TREE_OPERAND (t
, 0);
2786 if (TREE_CODE (t
) != ADDR_EXPR
)
2788 *v
= TREE_OPERAND (t
, 0);
2792 /* T is known constant value of virtual table pointer. Return BINFO of the
2796 vtable_pointer_value_to_binfo (const_tree t
)
2799 unsigned HOST_WIDE_INT offset
;
2801 if (!vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
2804 /* FIXME: for stores of construction vtables we return NULL,
2805 because we do not have BINFO for those. Eventually we should fix
2806 our representation to allow this case to be handled, too.
2807 In the case we see store of BINFO we however may assume
2808 that standard folding will be able to cope with it. */
2809 return subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable
)),
2813 /* Walk bases of OUTER_TYPE that contain OTR_TYPE at OFFSET.
2814 Look up their respective virtual methods for OTR_TOKEN and OTR_TYPE
2815 and insert them in NODES.
2817 MATCHED_VTABLES and INSERTED is used to avoid duplicated work. */
2820 record_targets_from_bases (tree otr_type
,
2821 HOST_WIDE_INT otr_token
,
2823 HOST_WIDE_INT offset
,
2824 vec
<cgraph_node
*> &nodes
,
2825 hash_set
<tree
> *inserted
,
2826 hash_set
<tree
> *matched_vtables
,
2831 HOST_WIDE_INT pos
, size
;
2835 if (types_same_for_odr (outer_type
, otr_type
))
2838 for (fld
= TYPE_FIELDS (outer_type
); fld
; fld
= DECL_CHAIN (fld
))
2840 if (TREE_CODE (fld
) != FIELD_DECL
)
2843 pos
= int_bit_position (fld
);
2844 size
= tree_to_shwi (DECL_SIZE (fld
));
2845 if (pos
<= offset
&& (pos
+ size
) > offset
2846 /* Do not get confused by zero sized bases. */
2847 && polymorphic_type_binfo_p (TYPE_BINFO (TREE_TYPE (fld
))))
2850 /* Within a class type we should always find corresponding fields. */
2851 gcc_assert (fld
&& TREE_CODE (TREE_TYPE (fld
)) == RECORD_TYPE
);
2853 /* Nonbase types should have been stripped by outer_class_type. */
2854 gcc_assert (DECL_ARTIFICIAL (fld
));
2856 outer_type
= TREE_TYPE (fld
);
2859 base_binfo
= get_binfo_at_offset (TYPE_BINFO (outer_type
),
2863 gcc_assert (odr_violation_reported
);
2866 gcc_assert (base_binfo
);
2867 if (!matched_vtables
->add (BINFO_VTABLE (base_binfo
)))
2870 tree target
= gimple_get_virt_method_for_binfo (otr_token
,
2873 if (!target
|| ! DECL_CXX_DESTRUCTOR_P (target
))
2874 maybe_record_node (nodes
, target
, inserted
, can_refer
, completep
);
2875 matched_vtables
->add (BINFO_VTABLE (base_binfo
));
2880 /* When virtual table is removed, we may need to flush the cache. */
2883 devirt_variable_node_removal_hook (varpool_node
*n
,
2884 void *d ATTRIBUTE_UNUSED
)
2886 if (cached_polymorphic_call_targets
2887 && DECL_VIRTUAL_P (n
->decl
)
2888 && type_in_anonymous_namespace_p (DECL_CONTEXT (n
->decl
)))
2889 free_polymorphic_call_targets_hash ();
2892 /* Record about how many calls would benefit from given type to be final. */
2894 struct odr_type_warn_count
2898 profile_count dyn_count
;
2901 /* Record about how many calls would benefit from given method to be final. */
2903 struct decl_warn_count
2907 profile_count dyn_count
;
2910 /* Information about type and decl warnings. */
2912 struct final_warning_record
2914 /* If needed grow type_warnings vector and initialize new decl_warn_count
2915 to have dyn_count set to profile_count::zero (). */
2916 void grow_type_warnings (unsigned newlen
);
2918 profile_count dyn_count
;
2919 auto_vec
<odr_type_warn_count
> type_warnings
;
2920 hash_map
<tree
, decl_warn_count
> decl_warnings
;
2924 final_warning_record::grow_type_warnings (unsigned newlen
)
2926 unsigned len
= type_warnings
.length ();
2929 type_warnings
.safe_grow_cleared (newlen
);
2930 for (unsigned i
= len
; i
< newlen
; i
++)
2931 type_warnings
[i
].dyn_count
= profile_count::zero ();
2935 struct final_warning_record
*final_warning_records
;
2937 /* Return vector containing possible targets of polymorphic call of type
2938 OTR_TYPE calling method OTR_TOKEN within type of OTR_OUTER_TYPE and OFFSET.
2939 If INCLUDE_BASES is true, walk also base types of OUTER_TYPES containing
2940 OTR_TYPE and include their virtual method. This is useful for types
2941 possibly in construction or destruction where the virtual table may
2942 temporarily change to one of base types. INCLUDE_DERIVER_TYPES make
2943 us to walk the inheritance graph for all derivations.
2945 If COMPLETEP is non-NULL, store true if the list is complete.
2946 CACHE_TOKEN (if non-NULL) will get stored to an unique ID of entry
2947 in the target cache. If user needs to visit every target list
2948 just once, it can memoize them.
2950 If SPECULATIVE is set, the list will not contain targets that
2951 are not speculatively taken.
2953 Returned vector is placed into cache. It is NOT caller's responsibility
2954 to free it. The vector can be freed on cgraph_remove_node call if
2955 the particular node is a virtual function present in the cache. */
2958 possible_polymorphic_call_targets (tree otr_type
,
2959 HOST_WIDE_INT otr_token
,
2960 ipa_polymorphic_call_context context
,
2965 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
2966 vec
<cgraph_node
*> nodes
= vNULL
;
2967 auto_vec
<tree
, 8> bases_to_consider
;
2968 odr_type type
, outer_type
;
2969 polymorphic_call_target_d key
;
2970 polymorphic_call_target_d
**slot
;
2974 bool can_refer
= false;
2975 bool skipped
= false;
2977 otr_type
= TYPE_MAIN_VARIANT (otr_type
);
2979 /* If ODR is not initialized or the context is invalid, return empty
2981 if (!odr_hash
|| context
.invalid
|| !TYPE_BINFO (otr_type
))
2984 *completep
= context
.invalid
;
2986 *cache_token
= NULL
;
2990 /* Do not bother to compute speculative info when user do not asks for it. */
2991 if (!speculative
|| !context
.speculative_outer_type
)
2992 context
.clear_speculation ();
2994 type
= get_odr_type (otr_type
, true);
2996 /* Recording type variants would waste results cache. */
2997 gcc_assert (!context
.outer_type
2998 || TYPE_MAIN_VARIANT (context
.outer_type
) == context
.outer_type
);
3000 /* Look up the outer class type we want to walk.
3001 If we fail to do so, the context is invalid. */
3002 if ((context
.outer_type
|| context
.speculative_outer_type
)
3003 && !context
.restrict_to_inner_class (otr_type
))
3008 *cache_token
= NULL
;
3011 gcc_assert (!context
.invalid
);
3013 /* Check that restrict_to_inner_class kept the main variant. */
3014 gcc_assert (!context
.outer_type
3015 || TYPE_MAIN_VARIANT (context
.outer_type
) == context
.outer_type
);
3017 /* We canonicalize our query, so we do not need extra hashtable entries. */
3019 /* Without outer type, we have no use for offset. Just do the
3020 basic search from inner type. */
3021 if (!context
.outer_type
)
3022 context
.clear_outer_type (otr_type
);
3023 /* We need to update our hierarchy if the type does not exist. */
3024 outer_type
= get_odr_type (context
.outer_type
, true);
3025 /* If the type is complete, there are no derivations. */
3026 if (TYPE_FINAL_P (outer_type
->type
))
3027 context
.maybe_derived_type
= false;
3029 /* Initialize query cache. */
3030 if (!cached_polymorphic_call_targets
)
3032 cached_polymorphic_call_targets
= new hash_set
<cgraph_node
*>;
3033 polymorphic_call_target_hash
3034 = new polymorphic_call_target_hash_type (23);
3035 if (!node_removal_hook_holder
)
3037 node_removal_hook_holder
=
3038 symtab
->add_cgraph_removal_hook (&devirt_node_removal_hook
, NULL
);
3039 symtab
->add_varpool_removal_hook (&devirt_variable_node_removal_hook
,
3046 if (context
.outer_type
!= otr_type
)
3048 = get_odr_type (context
.outer_type
, true)->type
;
3049 if (context
.speculative_outer_type
)
3050 context
.speculative_outer_type
3051 = get_odr_type (context
.speculative_outer_type
, true)->type
;
3054 /* Look up cached answer. */
3056 key
.otr_token
= otr_token
;
3057 key
.speculative
= speculative
;
3058 key
.context
= context
;
3059 slot
= polymorphic_call_target_hash
->find_slot (&key
, INSERT
);
3061 *cache_token
= (void *)*slot
;
3065 *completep
= (*slot
)->complete
;
3066 if ((*slot
)->type_warning
&& final_warning_records
)
3068 final_warning_records
->type_warnings
[(*slot
)->type_warning
- 1].count
++;
3069 if (!final_warning_records
->type_warnings
3070 [(*slot
)->type_warning
- 1].dyn_count
.initialized_p ())
3071 final_warning_records
->type_warnings
3072 [(*slot
)->type_warning
- 1].dyn_count
= profile_count::zero ();
3073 if (final_warning_records
->dyn_count
> 0)
3074 final_warning_records
->type_warnings
[(*slot
)->type_warning
- 1].dyn_count
3075 = final_warning_records
->type_warnings
[(*slot
)->type_warning
- 1].dyn_count
3076 + final_warning_records
->dyn_count
;
3078 if (!speculative
&& (*slot
)->decl_warning
&& final_warning_records
)
3080 struct decl_warn_count
*c
=
3081 final_warning_records
->decl_warnings
.get ((*slot
)->decl_warning
);
3083 if (final_warning_records
->dyn_count
> 0)
3084 c
->dyn_count
+= final_warning_records
->dyn_count
;
3086 return (*slot
)->targets
;
3091 /* Do actual search. */
3092 timevar_push (TV_IPA_VIRTUAL_CALL
);
3093 *slot
= XCNEW (polymorphic_call_target_d
);
3095 *cache_token
= (void *)*slot
;
3096 (*slot
)->type
= type
;
3097 (*slot
)->otr_token
= otr_token
;
3098 (*slot
)->context
= context
;
3099 (*slot
)->speculative
= speculative
;
3101 hash_set
<tree
> inserted
;
3102 hash_set
<tree
> matched_vtables
;
3104 /* First insert targets we speculatively identified as likely. */
3105 if (context
.speculative_outer_type
)
3107 odr_type speculative_outer_type
;
3108 bool speculation_complete
= true;
3110 /* First insert target from type itself and check if it may have
3112 speculative_outer_type
= get_odr_type (context
.speculative_outer_type
, true);
3113 if (TYPE_FINAL_P (speculative_outer_type
->type
))
3114 context
.speculative_maybe_derived_type
= false;
3115 binfo
= get_binfo_at_offset (TYPE_BINFO (speculative_outer_type
->type
),
3116 context
.speculative_offset
, otr_type
);
3118 target
= gimple_get_virt_method_for_binfo (otr_token
, binfo
,
3123 /* In the case we get complete method, we don't need
3124 to walk derivations. */
3125 if (target
&& DECL_FINAL_P (target
))
3126 context
.speculative_maybe_derived_type
= false;
3127 if (type_possibly_instantiated_p (speculative_outer_type
->type
))
3128 maybe_record_node (nodes
, target
, &inserted
, can_refer
, &speculation_complete
);
3130 matched_vtables
.add (BINFO_VTABLE (binfo
));
3133 /* Next walk recursively all derived types. */
3134 if (context
.speculative_maybe_derived_type
)
3135 for (i
= 0; i
< speculative_outer_type
->derived_types
.length(); i
++)
3136 possible_polymorphic_call_targets_1 (nodes
, &inserted
,
3139 speculative_outer_type
->derived_types
[i
],
3140 otr_token
, speculative_outer_type
->type
,
3141 context
.speculative_offset
,
3142 &speculation_complete
,
3147 if (!speculative
|| !nodes
.length ())
3149 /* First see virtual method of type itself. */
3150 binfo
= get_binfo_at_offset (TYPE_BINFO (outer_type
->type
),
3151 context
.offset
, otr_type
);
3153 target
= gimple_get_virt_method_for_binfo (otr_token
, binfo
,
3157 gcc_assert (odr_violation_reported
);
3161 /* Destructors are never called through construction virtual tables,
3162 because the type is always known. */
3163 if (target
&& DECL_CXX_DESTRUCTOR_P (target
))
3164 context
.maybe_in_construction
= false;
3168 /* In the case we get complete method, we don't need
3169 to walk derivations. */
3170 if (DECL_FINAL_P (target
))
3171 context
.maybe_derived_type
= false;
3174 /* If OUTER_TYPE is abstract, we know we are not seeing its instance. */
3175 if (type_possibly_instantiated_p (outer_type
->type
))
3176 maybe_record_node (nodes
, target
, &inserted
, can_refer
, &complete
);
3181 matched_vtables
.add (BINFO_VTABLE (binfo
));
3183 /* Next walk recursively all derived types. */
3184 if (context
.maybe_derived_type
)
3186 for (i
= 0; i
< outer_type
->derived_types
.length(); i
++)
3187 possible_polymorphic_call_targets_1 (nodes
, &inserted
,
3190 outer_type
->derived_types
[i
],
3191 otr_token
, outer_type
->type
,
3192 context
.offset
, &complete
,
3194 context
.maybe_in_construction
);
3196 if (!outer_type
->all_derivations_known
)
3198 if (!speculative
&& final_warning_records
3199 && nodes
.length () == 1
3200 && TREE_CODE (TREE_TYPE (nodes
[0]->decl
)) == METHOD_TYPE
)
3203 && warn_suggest_final_types
3204 && !outer_type
->derived_types
.length ())
3206 final_warning_records
->grow_type_warnings
3208 final_warning_records
->type_warnings
[outer_type
->id
].count
++;
3209 if (!final_warning_records
->type_warnings
3210 [outer_type
->id
].dyn_count
.initialized_p ())
3211 final_warning_records
->type_warnings
3212 [outer_type
->id
].dyn_count
= profile_count::zero ();
3213 final_warning_records
->type_warnings
[outer_type
->id
].dyn_count
3214 += final_warning_records
->dyn_count
;
3215 final_warning_records
->type_warnings
[outer_type
->id
].type
3217 (*slot
)->type_warning
= outer_type
->id
+ 1;
3220 && warn_suggest_final_methods
3221 && types_same_for_odr (DECL_CONTEXT (nodes
[0]->decl
),
3225 struct decl_warn_count
&c
=
3226 final_warning_records
->decl_warnings
.get_or_insert
3227 (nodes
[0]->decl
, &existed
);
3232 c
.dyn_count
+= final_warning_records
->dyn_count
;
3237 c
.dyn_count
= final_warning_records
->dyn_count
;
3238 c
.decl
= nodes
[0]->decl
;
3240 (*slot
)->decl_warning
= nodes
[0]->decl
;
3249 /* Destructors are never called through construction virtual tables,
3250 because the type is always known. One of entries may be
3251 cxa_pure_virtual so look to at least two of them. */
3252 if (context
.maybe_in_construction
)
3253 for (i
=0 ; i
< MIN (nodes
.length (), 2); i
++)
3254 if (DECL_CXX_DESTRUCTOR_P (nodes
[i
]->decl
))
3255 context
.maybe_in_construction
= false;
3256 if (context
.maybe_in_construction
)
3258 if (type
!= outer_type
3260 || (context
.maybe_derived_type
3261 && !type_all_derivations_known_p (outer_type
->type
))))
3262 record_targets_from_bases (otr_type
, otr_token
, outer_type
->type
,
3263 context
.offset
, nodes
, &inserted
,
3264 &matched_vtables
, &complete
);
3266 maybe_record_node (nodes
, target
, &inserted
, can_refer
, &complete
);
3267 for (i
= 0; i
< bases_to_consider
.length(); i
++)
3268 maybe_record_node (nodes
, bases_to_consider
[i
], &inserted
, can_refer
, &complete
);
3273 (*slot
)->targets
= nodes
;
3274 (*slot
)->complete
= complete
;
3276 *completep
= complete
;
3278 timevar_pop (TV_IPA_VIRTUAL_CALL
);
3283 add_decl_warning (const tree
&key ATTRIBUTE_UNUSED
, const decl_warn_count
&value
,
3284 vec
<const decl_warn_count
*> *vec
)
3286 vec
->safe_push (&value
);
3290 /* Dump target list TARGETS into FILE. */
3293 dump_targets (FILE *f
, vec
<cgraph_node
*> targets
)
3297 for (i
= 0; i
< targets
.length (); i
++)
3301 name
= cplus_demangle_v3 (targets
[i
]->asm_name (), 0);
3302 fprintf (f
, " %s/%i", name
? name
: targets
[i
]->name (),
3306 if (!targets
[i
]->definition
)
3307 fprintf (f
, " (no definition%s)",
3308 DECL_DECLARED_INLINE_P (targets
[i
]->decl
)
3314 /* Dump all possible targets of a polymorphic call. */
3317 dump_possible_polymorphic_call_targets (FILE *f
,
3319 HOST_WIDE_INT otr_token
,
3320 const ipa_polymorphic_call_context
&ctx
)
3322 vec
<cgraph_node
*> targets
;
3324 odr_type type
= get_odr_type (TYPE_MAIN_VARIANT (otr_type
), false);
3329 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
,
3331 &final
, NULL
, false);
3332 fprintf (f
, " Targets of polymorphic call of type %i:", type
->id
);
3333 print_generic_expr (f
, type
->type
, TDF_SLIM
);
3334 fprintf (f
, " token %i\n", (int)otr_token
);
3338 fprintf (f
, " %s%s%s%s\n ",
3339 final
? "This is a complete list." :
3340 "This is partial list; extra targets may be defined in other units.",
3341 ctx
.maybe_in_construction
? " (base types included)" : "",
3342 ctx
.maybe_derived_type
? " (derived types included)" : "",
3343 ctx
.speculative_maybe_derived_type
? " (speculative derived types included)" : "");
3344 len
= targets
.length ();
3345 dump_targets (f
, targets
);
3347 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
,
3349 &final
, NULL
, true);
3350 if (targets
.length () != len
)
3352 fprintf (f
, " Speculative targets:");
3353 dump_targets (f
, targets
);
3355 /* Ugly: during callgraph construction the target cache may get populated
3356 before all targets are found. While this is harmless (because all local
3357 types are discovered and only in those case we devirtualize fully and we
3358 don't do speculative devirtualization before IPA stage) it triggers
3359 assert here when dumping at that stage also populates the case with
3360 speculative targets. Quietly ignore this. */
3361 gcc_assert (symtab
->state
< IPA_SSA
|| targets
.length () <= len
);
3366 /* Return true if N can be possibly target of a polymorphic call of
3367 OTR_TYPE/OTR_TOKEN. */
3370 possible_polymorphic_call_target_p (tree otr_type
,
3371 HOST_WIDE_INT otr_token
,
3372 const ipa_polymorphic_call_context
&ctx
,
3373 struct cgraph_node
*n
)
3375 vec
<cgraph_node
*> targets
;
3377 enum built_in_function fcode
;
3380 if (TREE_CODE (TREE_TYPE (n
->decl
)) == FUNCTION_TYPE
3381 && ((fcode
= DECL_FUNCTION_CODE (n
->decl
)) == BUILT_IN_UNREACHABLE
3382 || fcode
== BUILT_IN_TRAP
))
3385 if (is_cxa_pure_virtual_p (n
->decl
))
3390 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
, ctx
, &final
);
3391 for (i
= 0; i
< targets
.length (); i
++)
3392 if (n
->semantically_equivalent_p (targets
[i
]))
3395 /* At a moment we allow middle end to dig out new external declarations
3396 as a targets of polymorphic calls. */
3397 if (!final
&& !n
->definition
)
3404 /* Return true if N can be possibly target of a polymorphic call of
3405 OBJ_TYPE_REF expression REF in STMT. */
3408 possible_polymorphic_call_target_p (tree ref
,
3410 struct cgraph_node
*n
)
3412 ipa_polymorphic_call_context
context (current_function_decl
, ref
, stmt
);
3413 tree call_fn
= gimple_call_fn (stmt
);
3415 return possible_polymorphic_call_target_p (obj_type_ref_class (call_fn
),
3417 (OBJ_TYPE_REF_TOKEN (call_fn
)),
3423 /* After callgraph construction new external nodes may appear.
3424 Add them into the graph. */
3427 update_type_inheritance_graph (void)
3429 struct cgraph_node
*n
;
3433 free_polymorphic_call_targets_hash ();
3434 timevar_push (TV_IPA_INHERITANCE
);
3435 /* We reconstruct the graph starting from types of all methods seen in the
3437 FOR_EACH_FUNCTION (n
)
3438 if (DECL_VIRTUAL_P (n
->decl
)
3440 && n
->real_symbol_p ())
3441 get_odr_type (TYPE_METHOD_BASETYPE (TREE_TYPE (n
->decl
)), true);
3442 timevar_pop (TV_IPA_INHERITANCE
);
3446 /* Return true if N looks like likely target of a polymorphic call.
3447 Rule out cxa_pure_virtual, noreturns, function declared cold and
3448 other obvious cases. */
3451 likely_target_p (struct cgraph_node
*n
)
3454 /* cxa_pure_virtual and similar things are not likely. */
3455 if (TREE_CODE (TREE_TYPE (n
->decl
)) != METHOD_TYPE
)
3457 flags
= flags_from_decl_or_type (n
->decl
);
3458 if (flags
& ECF_NORETURN
)
3460 if (lookup_attribute ("cold",
3461 DECL_ATTRIBUTES (n
->decl
)))
3463 if (n
->frequency
< NODE_FREQUENCY_NORMAL
)
3465 /* If there are no live virtual tables referring the target,
3466 the only way the target can be called is an instance coming from other
3467 compilation unit; speculative devirtualization is built around an
3468 assumption that won't happen. */
3469 if (!referenced_from_vtable_p (n
))
3474 /* Compare type warning records P1 and P2 and choose one with larger count;
3475 helper for qsort. */
3478 type_warning_cmp (const void *p1
, const void *p2
)
3480 const odr_type_warn_count
*t1
= (const odr_type_warn_count
*)p1
;
3481 const odr_type_warn_count
*t2
= (const odr_type_warn_count
*)p2
;
3483 if (t1
->dyn_count
< t2
->dyn_count
)
3485 if (t1
->dyn_count
> t2
->dyn_count
)
3487 return t2
->count
- t1
->count
;
3490 /* Compare decl warning records P1 and P2 and choose one with larger count;
3491 helper for qsort. */
3494 decl_warning_cmp (const void *p1
, const void *p2
)
3496 const decl_warn_count
*t1
= *(const decl_warn_count
* const *)p1
;
3497 const decl_warn_count
*t2
= *(const decl_warn_count
* const *)p2
;
3499 if (t1
->dyn_count
< t2
->dyn_count
)
3501 if (t1
->dyn_count
> t2
->dyn_count
)
3503 return t2
->count
- t1
->count
;
3507 /* Try to speculatively devirtualize call to OTR_TYPE with OTR_TOKEN with
3510 struct cgraph_node
*
3511 try_speculative_devirtualization (tree otr_type
, HOST_WIDE_INT otr_token
,
3512 ipa_polymorphic_call_context ctx
)
3514 vec
<cgraph_node
*>targets
3515 = possible_polymorphic_call_targets
3516 (otr_type
, otr_token
, ctx
, NULL
, NULL
, true);
3518 struct cgraph_node
*likely_target
= NULL
;
3520 for (i
= 0; i
< targets
.length (); i
++)
3521 if (likely_target_p (targets
[i
]))
3525 likely_target
= targets
[i
];
3528 ||!likely_target
->definition
3529 || DECL_EXTERNAL (likely_target
->decl
))
3532 /* Don't use an implicitly-declared destructor (c++/58678). */
3533 struct cgraph_node
*non_thunk_target
3534 = likely_target
->function_symbol ();
3535 if (DECL_ARTIFICIAL (non_thunk_target
->decl
))
3537 if (likely_target
->get_availability () <= AVAIL_INTERPOSABLE
3538 && likely_target
->can_be_discarded_p ())
3540 return likely_target
;
3543 /* The ipa-devirt pass.
3544 When polymorphic call has only one likely target in the unit,
3545 turn it into a speculative call. */
3550 struct cgraph_node
*n
;
3551 hash_set
<void *> bad_call_targets
;
3552 struct cgraph_edge
*e
;
3554 int npolymorphic
= 0, nspeculated
= 0, nconverted
= 0, ncold
= 0;
3555 int nmultiple
= 0, noverwritable
= 0, ndevirtualized
= 0, nnotdefined
= 0;
3556 int nwrong
= 0, nok
= 0, nexternal
= 0, nartificial
= 0;
3563 dump_type_inheritance_graph (dump_file
);
3565 /* We can output -Wsuggest-final-methods and -Wsuggest-final-types warnings.
3566 This is implemented by setting up final_warning_records that are updated
3567 by get_polymorphic_call_targets.
3568 We need to clear cache in this case to trigger recomputation of all
3570 if (warn_suggest_final_methods
|| warn_suggest_final_types
)
3572 final_warning_records
= new (final_warning_record
);
3573 final_warning_records
->dyn_count
= profile_count::zero ();
3574 final_warning_records
->grow_type_warnings (odr_types
.length ());
3575 free_polymorphic_call_targets_hash ();
3578 FOR_EACH_DEFINED_FUNCTION (n
)
3580 bool update
= false;
3581 if (!opt_for_fn (n
->decl
, flag_devirtualize
))
3583 if (dump_file
&& n
->indirect_calls
)
3584 fprintf (dump_file
, "\n\nProcesing function %s\n",
3586 for (e
= n
->indirect_calls
; e
; e
= e
->next_callee
)
3587 if (e
->indirect_info
->polymorphic
)
3589 struct cgraph_node
*likely_target
= NULL
;
3593 if (final_warning_records
)
3594 final_warning_records
->dyn_count
= e
->count
.ipa ();
3596 vec
<cgraph_node
*>targets
3597 = possible_polymorphic_call_targets
3598 (e
, &final
, &cache_token
, true);
3601 /* Trigger warnings by calculating non-speculative targets. */
3602 if (warn_suggest_final_methods
|| warn_suggest_final_types
)
3603 possible_polymorphic_call_targets (e
);
3606 dump_possible_polymorphic_call_targets
3611 /* See if the call can be devirtualized by means of ipa-prop's
3612 polymorphic call context propagation. If not, we can just
3613 forget about this call being polymorphic and avoid some heavy
3614 lifting in remove_unreachable_nodes that will otherwise try to
3615 keep all possible targets alive until inlining and in the inliner
3618 This may need to be revisited once we add further ways to use
3619 the may edges, but it is a resonable thing to do right now. */
3621 if ((e
->indirect_info
->param_index
== -1
3622 || (!opt_for_fn (n
->decl
, flag_devirtualize_speculatively
)
3623 && e
->indirect_info
->vptr_changed
))
3624 && !flag_ltrans_devirtualize
)
3626 e
->indirect_info
->polymorphic
= false;
3629 fprintf (dump_file
, "Dropping polymorphic call info;"
3630 " it can not be used by ipa-prop\n");
3633 if (!opt_for_fn (n
->decl
, flag_devirtualize_speculatively
))
3636 if (!e
->maybe_hot_p ())
3639 fprintf (dump_file
, "Call is cold\n\n");
3646 fprintf (dump_file
, "Call is already speculated\n\n");
3649 /* When dumping see if we agree with speculation. */
3653 if (bad_call_targets
.contains (cache_token
))
3656 fprintf (dump_file
, "Target list is known to be useless\n\n");
3660 for (i
= 0; i
< targets
.length (); i
++)
3661 if (likely_target_p (targets
[i
]))
3665 likely_target
= NULL
;
3667 fprintf (dump_file
, "More than one likely target\n\n");
3671 likely_target
= targets
[i
];
3675 bad_call_targets
.add (cache_token
);
3678 /* This is reached only when dumping; check if we agree or disagree
3679 with the speculation. */
3682 struct cgraph_edge
*e2
;
3683 struct ipa_ref
*ref
;
3684 e
->speculative_call_info (e2
, e
, ref
);
3685 if (e2
->callee
->ultimate_alias_target ()
3686 == likely_target
->ultimate_alias_target ())
3688 fprintf (dump_file
, "We agree with speculation\n\n");
3693 fprintf (dump_file
, "We disagree with speculation\n\n");
3698 if (!likely_target
->definition
)
3701 fprintf (dump_file
, "Target is not a definition\n\n");
3705 /* Do not introduce new references to external symbols. While we
3706 can handle these just well, it is common for programs to
3707 incorrectly with headers defining methods they are linked
3709 if (DECL_EXTERNAL (likely_target
->decl
))
3712 fprintf (dump_file
, "Target is external\n\n");
3716 /* Don't use an implicitly-declared destructor (c++/58678). */
3717 struct cgraph_node
*non_thunk_target
3718 = likely_target
->function_symbol ();
3719 if (DECL_ARTIFICIAL (non_thunk_target
->decl
))
3722 fprintf (dump_file
, "Target is artificial\n\n");
3726 if (likely_target
->get_availability () <= AVAIL_INTERPOSABLE
3727 && likely_target
->can_be_discarded_p ())
3730 fprintf (dump_file
, "Target is overwritable\n\n");
3734 else if (dbg_cnt (devirt
))
3736 if (dump_enabled_p ())
3738 location_t locus
= gimple_location_safe (e
->call_stmt
);
3739 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, locus
,
3740 "speculatively devirtualizing call "
3743 likely_target
->dump_name ());
3745 if (!likely_target
->can_be_discarded_p ())
3748 alias
= dyn_cast
<cgraph_node
*> (likely_target
->noninterposable_alias ());
3750 likely_target
= alias
;
3755 (likely_target
, e
->count
.apply_scale (8, 10));
3759 ipa_update_overall_fn_summary (n
);
3761 if (warn_suggest_final_methods
|| warn_suggest_final_types
)
3763 if (warn_suggest_final_types
)
3765 final_warning_records
->type_warnings
.qsort (type_warning_cmp
);
3766 for (unsigned int i
= 0;
3767 i
< final_warning_records
->type_warnings
.length (); i
++)
3768 if (final_warning_records
->type_warnings
[i
].count
)
3770 tree type
= final_warning_records
->type_warnings
[i
].type
;
3771 int count
= final_warning_records
->type_warnings
[i
].count
;
3772 profile_count dyn_count
3773 = final_warning_records
->type_warnings
[i
].dyn_count
;
3775 if (!(dyn_count
> 0))
3776 warning_n (DECL_SOURCE_LOCATION (TYPE_NAME (type
)),
3777 OPT_Wsuggest_final_types
, count
,
3778 "Declaring type %qD final "
3779 "would enable devirtualization of %i call",
3780 "Declaring type %qD final "
3781 "would enable devirtualization of %i calls",
3785 warning_n (DECL_SOURCE_LOCATION (TYPE_NAME (type
)),
3786 OPT_Wsuggest_final_types
, count
,
3787 "Declaring type %qD final "
3788 "would enable devirtualization of %i call "
3789 "executed %lli times",
3790 "Declaring type %qD final "
3791 "would enable devirtualization of %i calls "
3792 "executed %lli times",
3795 (long long) dyn_count
.to_gcov_type ());
3799 if (warn_suggest_final_methods
)
3801 auto_vec
<const decl_warn_count
*> decl_warnings_vec
;
3803 final_warning_records
->decl_warnings
.traverse
3804 <vec
<const decl_warn_count
*> *, add_decl_warning
> (&decl_warnings_vec
);
3805 decl_warnings_vec
.qsort (decl_warning_cmp
);
3806 for (unsigned int i
= 0; i
< decl_warnings_vec
.length (); i
++)
3808 tree decl
= decl_warnings_vec
[i
]->decl
;
3809 int count
= decl_warnings_vec
[i
]->count
;
3810 profile_count dyn_count
3811 = decl_warnings_vec
[i
]->dyn_count
;
3813 if (!(dyn_count
> 0))
3814 if (DECL_CXX_DESTRUCTOR_P (decl
))
3815 warning_n (DECL_SOURCE_LOCATION (decl
),
3816 OPT_Wsuggest_final_methods
, count
,
3817 "Declaring virtual destructor of %qD final "
3818 "would enable devirtualization of %i call",
3819 "Declaring virtual destructor of %qD final "
3820 "would enable devirtualization of %i calls",
3821 DECL_CONTEXT (decl
), count
);
3823 warning_n (DECL_SOURCE_LOCATION (decl
),
3824 OPT_Wsuggest_final_methods
, count
,
3825 "Declaring method %qD final "
3826 "would enable devirtualization of %i call",
3827 "Declaring method %qD final "
3828 "would enable devirtualization of %i calls",
3830 else if (DECL_CXX_DESTRUCTOR_P (decl
))
3831 warning_n (DECL_SOURCE_LOCATION (decl
),
3832 OPT_Wsuggest_final_methods
, count
,
3833 "Declaring virtual destructor of %qD final "
3834 "would enable devirtualization of %i call "
3835 "executed %lli times",
3836 "Declaring virtual destructor of %qD final "
3837 "would enable devirtualization of %i calls "
3838 "executed %lli times",
3839 DECL_CONTEXT (decl
), count
,
3840 (long long)dyn_count
.to_gcov_type ());
3842 warning_n (DECL_SOURCE_LOCATION (decl
),
3843 OPT_Wsuggest_final_methods
, count
,
3844 "Declaring method %qD final "
3845 "would enable devirtualization of %i call "
3846 "executed %lli times",
3847 "Declaring method %qD final "
3848 "would enable devirtualization of %i calls "
3849 "executed %lli times",
3851 (long long)dyn_count
.to_gcov_type ());
3855 delete (final_warning_records
);
3856 final_warning_records
= 0;
3861 "%i polymorphic calls, %i devirtualized,"
3862 " %i speculatively devirtualized, %i cold\n"
3863 "%i have multiple targets, %i overwritable,"
3864 " %i already speculated (%i agree, %i disagree),"
3865 " %i external, %i not defined, %i artificial, %i infos dropped\n",
3866 npolymorphic
, ndevirtualized
, nconverted
, ncold
,
3867 nmultiple
, noverwritable
, nspeculated
, nok
, nwrong
,
3868 nexternal
, nnotdefined
, nartificial
, ndropped
);
3869 return ndevirtualized
|| ndropped
? TODO_remove_functions
: 0;
3874 const pass_data pass_data_ipa_devirt
=
3876 IPA_PASS
, /* type */
3877 "devirt", /* name */
3878 OPTGROUP_NONE
, /* optinfo_flags */
3879 TV_IPA_DEVIRT
, /* tv_id */
3880 0, /* properties_required */
3881 0, /* properties_provided */
3882 0, /* properties_destroyed */
3883 0, /* todo_flags_start */
3884 ( TODO_dump_symtab
), /* todo_flags_finish */
3887 class pass_ipa_devirt
: public ipa_opt_pass_d
3890 pass_ipa_devirt (gcc::context
*ctxt
)
3891 : ipa_opt_pass_d (pass_data_ipa_devirt
, ctxt
,
3892 NULL
, /* generate_summary */
3893 NULL
, /* write_summary */
3894 NULL
, /* read_summary */
3895 NULL
, /* write_optimization_summary */
3896 NULL
, /* read_optimization_summary */
3897 NULL
, /* stmt_fixup */
3898 0, /* function_transform_todo_flags_start */
3899 NULL
, /* function_transform */
3900 NULL
) /* variable_transform */
3903 /* opt_pass methods: */
3904 virtual bool gate (function
*)
3906 /* In LTO, always run the IPA passes and decide on function basis if the
3910 return (flag_devirtualize
3911 && (flag_devirtualize_speculatively
3912 || (warn_suggest_final_methods
3913 || warn_suggest_final_types
))
3917 virtual unsigned int execute (function
*) { return ipa_devirt (); }
3919 }; // class pass_ipa_devirt
3924 make_pass_ipa_devirt (gcc::context
*ctxt
)
3926 return new pass_ipa_devirt (ctxt
);
3929 #include "gt-ipa-devirt.h"