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
);
178 static void warn_odr (tree t1
, tree t2
, tree st1
, tree st2
,
179 bool warn
, bool *warned
, const char *reason
);
181 static bool odr_violation_reported
= false;
184 /* Pointer set of all call targets appearing in the cache. */
185 static hash_set
<cgraph_node
*> *cached_polymorphic_call_targets
;
187 /* The node of type inheritance graph. For each type unique in
188 One Definition Rule (ODR) sense, we produce one node linking all
189 main variants of types equivalent to it, bases and derived types. */
191 struct GTY(()) odr_type_d
195 /* All bases; built only for main variants of types. */
196 vec
<odr_type
> GTY((skip
)) bases
;
197 /* All derived types with virtual methods seen in unit;
198 built only for main variants of types. */
199 vec
<odr_type
> GTY((skip
)) derived_types
;
201 /* All equivalent types, if more than one. */
202 vec
<tree
, va_gc
> *types
;
203 /* Set of all equivalent types, if NON-NULL. */
204 hash_set
<tree
> * GTY((skip
)) types_set
;
206 /* Unique ID indexing the type in odr_types array. */
208 /* Is it in anonymous namespace? */
209 bool anonymous_namespace
;
210 /* Do we know about all derivations of given type? */
211 bool all_derivations_known
;
212 /* Did we report ODR violation here? */
214 /* Set when virtual table without RTTI previaled table with. */
218 /* Return TRUE if all derived types of T are known and thus
219 we may consider the walk of derived type complete.
221 This is typically true only for final anonymous namespace types and types
222 defined within functions (that may be COMDAT and thus shared across units,
223 but with the same set of derived types). */
226 type_all_derivations_known_p (const_tree t
)
228 if (TYPE_FINAL_P (t
))
232 /* Non-C++ types may have IDENTIFIER_NODE here, do not crash. */
233 if (!TYPE_NAME (t
) || TREE_CODE (TYPE_NAME (t
)) != TYPE_DECL
)
235 if (type_in_anonymous_namespace_p (t
))
237 return (decl_function_context (TYPE_NAME (t
)) != NULL
);
240 /* Return TRUE if type's constructors are all visible. */
243 type_all_ctors_visible_p (tree t
)
246 && symtab
->state
>= CONSTRUCTION
247 /* We can not always use type_all_derivations_known_p.
248 For function local types we must assume case where
249 the function is COMDAT and shared in between units.
251 TODO: These cases are quite easy to get, but we need
252 to keep track of C++ privatizing via -Wno-weak
253 as well as the IPA privatizing. */
254 && type_in_anonymous_namespace_p (t
);
257 /* Return TRUE if type may have instance. */
260 type_possibly_instantiated_p (tree t
)
265 /* TODO: Add abstract types here. */
266 if (!type_all_ctors_visible_p (t
))
269 vtable
= BINFO_VTABLE (TYPE_BINFO (t
));
270 if (TREE_CODE (vtable
) == POINTER_PLUS_EXPR
)
271 vtable
= TREE_OPERAND (TREE_OPERAND (vtable
, 0), 0);
272 vnode
= varpool_node::get (vtable
);
273 return vnode
&& vnode
->definition
;
276 /* Hash used to unify ODR types based on their mangled name and for anonymous
279 struct odr_name_hasher
: pointer_hash
<odr_type_d
>
281 typedef union tree_node
*compare_type
;
282 static inline hashval_t
hash (const odr_type_d
*);
283 static inline bool equal (const odr_type_d
*, const tree_node
*);
284 static inline void remove (odr_type_d
*);
287 /* Has used to unify ODR types based on their associated virtual table.
288 This hash is needed to keep -fno-lto-odr-type-merging to work and contains
289 only polymorphic types. Types with mangled names are inserted to both. */
291 struct odr_vtable_hasher
:odr_name_hasher
293 static inline hashval_t
hash (const odr_type_d
*);
294 static inline bool equal (const odr_type_d
*, const tree_node
*);
298 can_be_name_hashed_p (tree t
)
300 return (!in_lto_p
|| odr_type_p (t
));
303 /* Hash type by its ODR name. */
306 hash_odr_name (const_tree t
)
308 gcc_checking_assert (TYPE_MAIN_VARIANT (t
) == t
);
310 /* If not in LTO, all main variants are unique, so we can do
313 return htab_hash_pointer (t
);
315 /* Anonymous types are unique. */
316 if (type_with_linkage_p (t
) && type_in_anonymous_namespace_p (t
))
317 return htab_hash_pointer (t
);
319 gcc_checking_assert (TYPE_NAME (t
)
320 && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t
)));
321 return IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (TYPE_NAME (t
)));
324 /* Return the computed hashcode for ODR_TYPE. */
327 odr_name_hasher::hash (const odr_type_d
*odr_type
)
329 return hash_odr_name (odr_type
->type
);
333 can_be_vtable_hashed_p (tree t
)
335 /* vtable hashing can distinguish only main variants. */
336 if (TYPE_MAIN_VARIANT (t
) != t
)
338 /* Anonymous namespace types are always handled by name hash. */
339 if (type_with_linkage_p (t
) && type_in_anonymous_namespace_p (t
))
341 return (TREE_CODE (t
) == RECORD_TYPE
342 && TYPE_BINFO (t
) && BINFO_VTABLE (TYPE_BINFO (t
)));
345 /* Hash type by assembler name of its vtable. */
348 hash_odr_vtable (const_tree t
)
350 tree v
= BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
351 inchash::hash hstate
;
353 gcc_checking_assert (in_lto_p
);
354 gcc_checking_assert (!type_in_anonymous_namespace_p (t
));
355 gcc_checking_assert (TREE_CODE (t
) == RECORD_TYPE
356 && TYPE_BINFO (t
) && BINFO_VTABLE (TYPE_BINFO (t
)));
357 gcc_checking_assert (TYPE_MAIN_VARIANT (t
) == t
);
359 if (TREE_CODE (v
) == POINTER_PLUS_EXPR
)
361 add_expr (TREE_OPERAND (v
, 1), hstate
);
362 v
= TREE_OPERAND (TREE_OPERAND (v
, 0), 0);
365 hstate
.add_hwi (IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (v
)));
366 return hstate
.end ();
369 /* Return the computed hashcode for ODR_TYPE. */
372 odr_vtable_hasher::hash (const odr_type_d
*odr_type
)
374 return hash_odr_vtable (odr_type
->type
);
377 /* For languages with One Definition Rule, work out if
378 types are the same based on their name.
380 This is non-trivial for LTO where minor differences in
381 the type representation may have prevented type merging
382 to merge two copies of otherwise equivalent type.
384 Until we start streaming mangled type names, this function works
385 only for polymorphic types.
389 types_same_for_odr (const_tree type1
, const_tree type2
)
391 gcc_checking_assert (TYPE_P (type1
) && TYPE_P (type2
));
393 type1
= TYPE_MAIN_VARIANT (type1
);
394 type2
= TYPE_MAIN_VARIANT (type2
);
402 /* Anonymous namespace types are never duplicated. */
403 if ((type_with_linkage_p (type1
) && type_in_anonymous_namespace_p (type1
))
404 || (type_with_linkage_p (type2
) && type_in_anonymous_namespace_p (type2
)))
408 /* ODR name of the type is set in DECL_ASSEMBLER_NAME of its TYPE_NAME.
410 Ideally we should never need types without ODR names here. It can however
413 1) for builtin types that are not streamed but rebuilt in lto/lto-lang.c
414 Here testing for equivalence is safe, since their MAIN_VARIANTs are
416 2) for units streamed with -fno-lto-odr-type-merging. Here we can't
417 establish precise ODR equivalency, but for correctness we care only
418 about equivalency on complete polymorphic types. For these we can
419 compare assembler names of their virtual tables. */
420 if ((!TYPE_NAME (type1
) || !DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (type1
)))
421 || (!TYPE_NAME (type2
) || !DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (type2
))))
423 /* See if types are obviously different (i.e. different codes
424 or polymorphic wrt non-polymorphic). This is not strictly correct
425 for ODR violating programs, but we can't do better without streaming
427 if (TREE_CODE (type1
) != TREE_CODE (type2
))
429 if (TREE_CODE (type1
) == RECORD_TYPE
430 && (TYPE_BINFO (type1
) == NULL_TREE
)
431 != (TYPE_BINFO (type2
) == NULL_TREE
))
433 if (TREE_CODE (type1
) == RECORD_TYPE
&& TYPE_BINFO (type1
)
434 && (BINFO_VTABLE (TYPE_BINFO (type1
)) == NULL_TREE
)
435 != (BINFO_VTABLE (TYPE_BINFO (type2
)) == NULL_TREE
))
438 /* At the moment we have no way to establish ODR equivalence at LTO
439 other than comparing virtual table pointers of polymorphic types.
440 Eventually we should start saving mangled names in TYPE_NAME.
441 Then this condition will become non-trivial. */
443 if (TREE_CODE (type1
) == RECORD_TYPE
444 && TYPE_BINFO (type1
) && TYPE_BINFO (type2
)
445 && BINFO_VTABLE (TYPE_BINFO (type1
))
446 && BINFO_VTABLE (TYPE_BINFO (type2
)))
448 tree v1
= BINFO_VTABLE (TYPE_BINFO (type1
));
449 tree v2
= BINFO_VTABLE (TYPE_BINFO (type2
));
450 gcc_assert (TREE_CODE (v1
) == POINTER_PLUS_EXPR
451 && TREE_CODE (v2
) == POINTER_PLUS_EXPR
);
452 return (operand_equal_p (TREE_OPERAND (v1
, 1),
453 TREE_OPERAND (v2
, 1), 0)
454 && DECL_ASSEMBLER_NAME
455 (TREE_OPERAND (TREE_OPERAND (v1
, 0), 0))
456 == DECL_ASSEMBLER_NAME
457 (TREE_OPERAND (TREE_OPERAND (v2
, 0), 0)));
461 return (DECL_ASSEMBLER_NAME (TYPE_NAME (type1
))
462 == DECL_ASSEMBLER_NAME (TYPE_NAME (type2
)));
465 /* Return true if we can decide on ODR equivalency.
467 In non-LTO it is always decide, in LTO however it depends in the type has
468 ODR info attached. */
471 types_odr_comparable (tree t1
, tree t2
)
474 || TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
)
475 || (odr_type_p (TYPE_MAIN_VARIANT (t1
))
476 && odr_type_p (TYPE_MAIN_VARIANT (t2
)))
477 || (TREE_CODE (t1
) == RECORD_TYPE
&& TREE_CODE (t2
) == RECORD_TYPE
478 && TYPE_BINFO (t1
) && TYPE_BINFO (t2
)
479 && polymorphic_type_binfo_p (TYPE_BINFO (t1
))
480 && polymorphic_type_binfo_p (TYPE_BINFO (t2
))));
483 /* Return true if T1 and T2 are ODR equivalent. If ODR equivalency is not
484 known, be conservative and return false. */
487 types_must_be_same_for_odr (tree t1
, tree t2
)
489 if (types_odr_comparable (t1
, t2
))
490 return types_same_for_odr (t1
, t2
);
492 return TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
);
495 /* If T is compound type, return type it is based on. */
498 compound_type_base (const_tree t
)
500 if (TREE_CODE (t
) == ARRAY_TYPE
501 || POINTER_TYPE_P (t
)
502 || TREE_CODE (t
) == COMPLEX_TYPE
503 || VECTOR_TYPE_P (t
))
504 return TREE_TYPE (t
);
505 if (TREE_CODE (t
) == METHOD_TYPE
)
506 return TYPE_METHOD_BASETYPE (t
);
507 if (TREE_CODE (t
) == OFFSET_TYPE
)
508 return TYPE_OFFSET_BASETYPE (t
);
512 /* Return true if T is either ODR type or compound type based from it.
513 If the function return true, we know that T is a type originating from C++
514 source even at link-time. */
517 odr_or_derived_type_p (const_tree t
)
521 if (odr_type_p (TYPE_MAIN_VARIANT (t
)))
523 /* Function type is a tricky one. Basically we can consider it
524 ODR derived if return type or any of the parameters is.
525 We need to check all parameters because LTO streaming merges
526 common types (such as void) and they are not considered ODR then. */
527 if (TREE_CODE (t
) == FUNCTION_TYPE
)
529 if (TYPE_METHOD_BASETYPE (t
))
530 t
= TYPE_METHOD_BASETYPE (t
);
533 if (TREE_TYPE (t
) && odr_or_derived_type_p (TREE_TYPE (t
)))
535 for (t
= TYPE_ARG_TYPES (t
); t
; t
= TREE_CHAIN (t
))
536 if (odr_or_derived_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (t
))))
542 t
= compound_type_base (t
);
548 /* Compare types T1 and T2 and return true if they are
552 odr_name_hasher::equal (const odr_type_d
*o1
, const tree_node
*t2
)
556 gcc_checking_assert (TYPE_MAIN_VARIANT (t2
) == t2
);
557 gcc_checking_assert (TYPE_MAIN_VARIANT (t1
) == t1
);
562 /* Check for anonymous namespaces. */
563 if ((type_with_linkage_p (t1
) && type_in_anonymous_namespace_p (t1
))
564 || (type_with_linkage_p (t2
) && type_in_anonymous_namespace_p (t2
)))
566 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t1
)));
567 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t2
)));
568 return (DECL_ASSEMBLER_NAME (TYPE_NAME (t1
))
569 == DECL_ASSEMBLER_NAME (TYPE_NAME (t2
)));
572 /* Compare types T1 and T2 and return true if they are
576 odr_vtable_hasher::equal (const odr_type_d
*o1
, const tree_node
*t2
)
580 gcc_checking_assert (TYPE_MAIN_VARIANT (t2
) == t2
);
581 gcc_checking_assert (TYPE_MAIN_VARIANT (t1
) == t1
);
582 gcc_checking_assert (in_lto_p
);
583 t1
= TYPE_MAIN_VARIANT (t1
);
584 t2
= TYPE_MAIN_VARIANT (t2
);
587 tree v1
= BINFO_VTABLE (TYPE_BINFO (t1
));
588 tree v2
= BINFO_VTABLE (TYPE_BINFO (t2
));
589 return (operand_equal_p (TREE_OPERAND (v1
, 1),
590 TREE_OPERAND (v2
, 1), 0)
591 && DECL_ASSEMBLER_NAME
592 (TREE_OPERAND (TREE_OPERAND (v1
, 0), 0))
593 == DECL_ASSEMBLER_NAME
594 (TREE_OPERAND (TREE_OPERAND (v2
, 0), 0)));
597 /* Free ODR type V. */
600 odr_name_hasher::remove (odr_type_d
*v
)
603 v
->derived_types
.release ();
609 /* ODR type hash used to look up ODR type based on tree type node. */
611 typedef hash_table
<odr_name_hasher
> odr_hash_type
;
612 static odr_hash_type
*odr_hash
;
613 typedef hash_table
<odr_vtable_hasher
> odr_vtable_hash_type
;
614 static odr_vtable_hash_type
*odr_vtable_hash
;
616 /* ODR types are also stored into ODR_TYPE vector to allow consistent
617 walking. Bases appear before derived types. Vector is garbage collected
618 so we won't end up visiting empty types. */
620 static GTY(()) vec
<odr_type
, va_gc
> *odr_types_ptr
;
621 #define odr_types (*odr_types_ptr)
623 /* Set TYPE_BINFO of TYPE and its variants to BINFO. */
625 set_type_binfo (tree type
, tree binfo
)
627 for (; type
; type
= TYPE_NEXT_VARIANT (type
))
628 if (COMPLETE_TYPE_P (type
))
629 TYPE_BINFO (type
) = binfo
;
631 gcc_assert (!TYPE_BINFO (type
));
634 /* Return true if type variants match.
635 This assumes that we already verified that T1 and T2 are variants of the
639 type_variants_equivalent_p (tree t1
, tree t2
, bool warn
, bool *warned
)
641 if (TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
643 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
644 G_("a type with different qualifiers is defined in another "
645 "translation unit"));
649 if (comp_type_attributes (t1
, t2
) != 1)
651 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
652 G_("a type with different attributes "
653 "is defined in another translation unit"));
657 if (COMPLETE_TYPE_P (t1
) && COMPLETE_TYPE_P (t2
)
658 && TYPE_ALIGN (t1
) != TYPE_ALIGN (t2
))
660 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
661 G_("a type with different alignment "
662 "is defined in another translation unit"));
669 /* Compare T1 and T2 based on name or structure. */
672 odr_subtypes_equivalent_p (tree t1
, tree t2
, bool warn
, bool *warned
,
673 hash_set
<type_pair
> *visited
,
674 location_t loc1
, location_t loc2
)
677 /* This can happen in incomplete types that should be handled earlier. */
678 gcc_assert (t1
&& t2
);
683 /* Anonymous namespace types must match exactly. */
684 if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1
))
685 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1
)))
686 || (type_with_linkage_p (TYPE_MAIN_VARIANT (t2
))
687 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2
))))
690 /* For ODR types be sure to compare their names.
691 To support -Wno-odr-type-merging we allow one type to be non-ODR
692 and other ODR even though it is a violation. */
693 if (types_odr_comparable (t1
, t2
))
695 if (!types_same_for_odr (t1
, t2
))
697 if (!type_variants_equivalent_p (t1
, t2
, warn
, warned
))
699 /* Limit recursion: If subtypes are ODR types and we know
700 that they are same, be happy. */
701 if (!odr_type_p (TYPE_MAIN_VARIANT (t1
))
702 || !get_odr_type (TYPE_MAIN_VARIANT (t1
), true)->odr_violated
)
706 /* Component types, builtins and possibly violating ODR types
707 have to be compared structurally. */
708 if (TREE_CODE (t1
) != TREE_CODE (t2
))
710 if (AGGREGATE_TYPE_P (t1
)
711 && (TYPE_NAME (t1
) == NULL_TREE
) != (TYPE_NAME (t2
) == NULL_TREE
))
714 type_pair pair
={TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
)};
715 if (TYPE_UID (TYPE_MAIN_VARIANT (t1
)) > TYPE_UID (TYPE_MAIN_VARIANT (t2
)))
717 pair
.first
= TYPE_MAIN_VARIANT (t2
);
718 pair
.second
= TYPE_MAIN_VARIANT (t1
);
720 if (visited
->add (pair
))
722 if (!odr_types_equivalent_p (TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
),
723 false, NULL
, visited
, loc1
, loc2
))
725 if (!type_variants_equivalent_p (t1
, t2
, warn
, warned
))
730 /* Return true if DECL1 and DECL2 are identical methods. Consider
731 name equivalent to name.localalias.xyz. */
734 methods_equal_p (tree decl1
, tree decl2
)
736 if (DECL_ASSEMBLER_NAME (decl1
) == DECL_ASSEMBLER_NAME (decl2
))
738 const char sep
= symbol_table::symbol_suffix_separator ();
740 const char *name1
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl1
));
741 const char *ptr1
= strchr (name1
, sep
);
742 int len1
= ptr1
? ptr1
- name1
: strlen (name1
);
744 const char *name2
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl2
));
745 const char *ptr2
= strchr (name2
, sep
);
746 int len2
= ptr2
? ptr2
- name2
: strlen (name2
);
750 return !strncmp (name1
, name2
, len1
);
753 /* Compare two virtual tables, PREVAILING and VTABLE and output ODR
754 violation warnings. */
757 compare_virtual_tables (varpool_node
*prevailing
, varpool_node
*vtable
)
761 if (DECL_VIRTUAL_P (prevailing
->decl
) != DECL_VIRTUAL_P (vtable
->decl
))
763 odr_violation_reported
= true;
764 if (DECL_VIRTUAL_P (prevailing
->decl
))
766 varpool_node
*tmp
= prevailing
;
770 auto_diagnostic_group d
;
771 if (warning_at (DECL_SOURCE_LOCATION
772 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
774 "virtual table of type %qD violates one definition rule",
775 DECL_CONTEXT (vtable
->decl
)))
776 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
777 "variable of same assembler name as the virtual table is "
778 "defined in another translation unit");
781 if (!prevailing
->definition
|| !vtable
->definition
)
784 /* If we do not stream ODR type info, do not bother to do useful compare. */
785 if (!TYPE_BINFO (DECL_CONTEXT (vtable
->decl
))
786 || !polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (vtable
->decl
))))
789 odr_type class_type
= get_odr_type (DECL_CONTEXT (vtable
->decl
), true);
791 if (class_type
->odr_violated
)
794 for (n1
= 0, n2
= 0; true; n1
++, n2
++)
796 struct ipa_ref
*ref1
, *ref2
;
799 end1
= !prevailing
->iterate_reference (n1
, ref1
);
800 end2
= !vtable
->iterate_reference (n2
, ref2
);
802 /* !DECL_VIRTUAL_P means RTTI entry;
803 We warn when RTTI is lost because non-RTTI previals; we silently
804 accept the other case. */
807 || (methods_equal_p (ref1
->referred
->decl
,
808 ref2
->referred
->decl
)
809 && TREE_CODE (ref1
->referred
->decl
) == FUNCTION_DECL
))
810 && TREE_CODE (ref2
->referred
->decl
) != FUNCTION_DECL
)
812 if (!class_type
->rtti_broken
)
814 auto_diagnostic_group d
;
815 if (warning_at (DECL_SOURCE_LOCATION
816 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
818 "virtual table of type %qD contains RTTI "
820 DECL_CONTEXT (vtable
->decl
)))
822 inform (DECL_SOURCE_LOCATION
823 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
824 "but is prevailed by one without from other"
825 " translation unit");
826 inform (DECL_SOURCE_LOCATION
827 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
828 "RTTI will not work on this type");
829 class_type
->rtti_broken
= true;
833 end2
= !vtable
->iterate_reference (n2
, ref2
);
837 || (methods_equal_p (ref2
->referred
->decl
, ref1
->referred
->decl
)
838 && TREE_CODE (ref2
->referred
->decl
) == FUNCTION_DECL
))
839 && TREE_CODE (ref1
->referred
->decl
) != FUNCTION_DECL
)
842 end1
= !prevailing
->iterate_reference (n1
, ref1
);
848 /* Extra paranoia; compare the sizes. We do not have information
849 about virtual inheritance offsets, so just be sure that these
851 Do this as very last check so the not very informative error
852 is not output too often. */
853 if (DECL_SIZE (prevailing
->decl
) != DECL_SIZE (vtable
->decl
))
855 class_type
->odr_violated
= true;
856 auto_diagnostic_group d
;
857 if (warning_at (DECL_SOURCE_LOCATION
858 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
860 "virtual table of type %qD violates "
861 "one definition rule ",
862 DECL_CONTEXT (vtable
->decl
)))
864 inform (DECL_SOURCE_LOCATION
865 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
866 "the conflicting type defined in another translation "
867 "unit has virtual table of different size");
875 if (methods_equal_p (ref1
->referred
->decl
, ref2
->referred
->decl
))
878 class_type
->odr_violated
= true;
880 /* If the loops above stopped on non-virtual pointer, we have
881 mismatch in RTTI information mangling. */
882 if (TREE_CODE (ref1
->referred
->decl
) != FUNCTION_DECL
883 && TREE_CODE (ref2
->referred
->decl
) != FUNCTION_DECL
)
885 auto_diagnostic_group d
;
886 if (warning_at (DECL_SOURCE_LOCATION
887 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
889 "virtual table of type %qD violates "
890 "one definition rule ",
891 DECL_CONTEXT (vtable
->decl
)))
893 inform (DECL_SOURCE_LOCATION
894 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
895 "the conflicting type defined in another translation "
896 "unit with different RTTI information");
900 /* At this point both REF1 and REF2 points either to virtual table
901 or virtual method. If one points to virtual table and other to
902 method we can complain the same way as if one table was shorter
903 than other pointing out the extra method. */
904 if (TREE_CODE (ref1
->referred
->decl
)
905 != TREE_CODE (ref2
->referred
->decl
))
907 if (VAR_P (ref1
->referred
->decl
))
909 else if (VAR_P (ref2
->referred
->decl
))
914 class_type
->odr_violated
= true;
916 /* Complain about size mismatch. Either we have too many virutal
917 functions or too many virtual table pointers. */
922 varpool_node
*tmp
= prevailing
;
927 auto_diagnostic_group d
;
928 if (warning_at (DECL_SOURCE_LOCATION
929 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))),
931 "virtual table of type %qD violates "
932 "one definition rule",
933 DECL_CONTEXT (vtable
->decl
)))
935 if (TREE_CODE (ref1
->referring
->decl
) == FUNCTION_DECL
)
937 inform (DECL_SOURCE_LOCATION
938 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
939 "the conflicting type defined in another translation "
941 inform (DECL_SOURCE_LOCATION
942 (TYPE_NAME (DECL_CONTEXT (ref1
->referring
->decl
))),
943 "contains additional virtual method %qD",
944 ref1
->referred
->decl
);
948 inform (DECL_SOURCE_LOCATION
949 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
950 "the conflicting type defined in another translation "
951 "unit has virtual table with more entries");
957 /* And in the last case we have either mistmatch in between two virtual
958 methods or two virtual table pointers. */
959 auto_diagnostic_group d
;
960 if (warning_at (DECL_SOURCE_LOCATION
961 (TYPE_NAME (DECL_CONTEXT (vtable
->decl
))), OPT_Wodr
,
962 "virtual table of type %qD violates "
963 "one definition rule ",
964 DECL_CONTEXT (vtable
->decl
)))
966 if (TREE_CODE (ref1
->referred
->decl
) == FUNCTION_DECL
)
968 inform (DECL_SOURCE_LOCATION
969 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
970 "the conflicting type defined in another translation "
972 gcc_assert (TREE_CODE (ref2
->referred
->decl
)
974 inform (DECL_SOURCE_LOCATION
975 (ref1
->referred
->ultimate_alias_target ()->decl
),
976 "virtual method %qD",
977 ref1
->referred
->ultimate_alias_target ()->decl
);
978 inform (DECL_SOURCE_LOCATION
979 (ref2
->referred
->ultimate_alias_target ()->decl
),
980 "ought to match virtual method %qD but does not",
981 ref2
->referred
->ultimate_alias_target ()->decl
);
984 inform (DECL_SOURCE_LOCATION
985 (TYPE_NAME (DECL_CONTEXT (prevailing
->decl
))),
986 "the conflicting type defined in another translation "
987 "unit has virtual table with different contents");
993 /* Output ODR violation warning about T1 and T2 with REASON.
994 Display location of ST1 and ST2 if REASON speaks about field or
996 If WARN is false, do nothing. Set WARNED if warning was indeed
1000 warn_odr (tree t1
, tree t2
, tree st1
, tree st2
,
1001 bool warn
, bool *warned
, const char *reason
)
1003 tree decl2
= TYPE_NAME (t2
);
1007 if (!warn
|| !TYPE_NAME(t1
))
1010 /* ODR warnings are output druing LTO streaming; we must apply location
1011 cache for potential warnings to be output correctly. */
1012 if (lto_location_cache::current_cache
)
1013 lto_location_cache::current_cache
->apply_location_cache ();
1015 auto_diagnostic_group d
;
1016 if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (t1
)), OPT_Wodr
,
1017 "type %qT violates the C++ One Definition Rule",
1022 /* For FIELD_DECL support also case where one of fields is
1023 NULL - this is used when the structures have mismatching number of
1025 else if (!st1
|| TREE_CODE (st1
) == FIELD_DECL
)
1027 inform (DECL_SOURCE_LOCATION (decl2
),
1028 "a different type is defined in another translation unit");
1034 inform (DECL_SOURCE_LOCATION (st1
),
1035 "the first difference of corresponding definitions is field %qD",
1040 else if (TREE_CODE (st1
) == FUNCTION_DECL
)
1042 inform (DECL_SOURCE_LOCATION (decl2
),
1043 "a different type is defined in another translation unit");
1044 inform (DECL_SOURCE_LOCATION (st1
),
1045 "the first difference of corresponding definitions is method %qD",
1051 inform (DECL_SOURCE_LOCATION (decl2
), reason
);
1057 /* Return ture if T1 and T2 are incompatible and we want to recusively
1058 dive into them from warn_type_mismatch to give sensible answer. */
1061 type_mismatch_p (tree t1
, tree t2
)
1063 if (odr_or_derived_type_p (t1
) && odr_or_derived_type_p (t2
)
1064 && !odr_types_equivalent_p (t1
, t2
))
1066 return !types_compatible_p (t1
, t2
);
1070 /* Types T1 and T2 was found to be incompatible in a context they can't
1071 (either used to declare a symbol of same assembler name or unified by
1072 ODR rule). We already output warning about this, but if possible, output
1073 extra information on how the types mismatch.
1075 This is hard to do in general. We basically handle the common cases.
1077 If LOC1 and LOC2 are meaningful locations, use it in the case the types
1078 themselves do no thave one.*/
1081 warn_types_mismatch (tree t1
, tree t2
, location_t loc1
, location_t loc2
)
1083 /* Location of type is known only if it has TYPE_NAME and the name is
1085 location_t loc_t1
= TYPE_NAME (t1
) && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
1086 ? DECL_SOURCE_LOCATION (TYPE_NAME (t1
))
1088 location_t loc_t2
= TYPE_NAME (t2
) && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
1089 ? DECL_SOURCE_LOCATION (TYPE_NAME (t2
))
1091 bool loc_t2_useful
= false;
1093 /* With LTO it is a common case that the location of both types match.
1094 See if T2 has a location that is different from T1. If so, we will
1095 inform user about the location.
1096 Do not consider the location passed to us in LOC1/LOC2 as those are
1098 if (loc_t2
> BUILTINS_LOCATION
&& loc_t2
!= loc_t1
)
1100 if (loc_t1
<= BUILTINS_LOCATION
)
1101 loc_t2_useful
= true;
1104 expanded_location xloc1
= expand_location (loc_t1
);
1105 expanded_location xloc2
= expand_location (loc_t2
);
1107 if (strcmp (xloc1
.file
, xloc2
.file
)
1108 || xloc1
.line
!= xloc2
.line
1109 || xloc1
.column
!= xloc2
.column
)
1110 loc_t2_useful
= true;
1114 if (loc_t1
<= BUILTINS_LOCATION
)
1116 if (loc_t2
<= BUILTINS_LOCATION
)
1119 location_t loc
= loc_t1
<= BUILTINS_LOCATION
? loc_t2
: loc_t1
;
1121 /* It is a quite common bug to reference anonymous namespace type in
1122 non-anonymous namespace class. */
1123 if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1
))
1124 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1
)))
1125 || (type_with_linkage_p (TYPE_MAIN_VARIANT (t2
))
1126 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2
))))
1128 if (type_with_linkage_p (TYPE_MAIN_VARIANT (t1
))
1129 && !type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1
)))
1132 std::swap (loc_t1
, loc_t2
);
1134 gcc_assert (TYPE_NAME (t1
) && TYPE_NAME (t2
)
1135 && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
1136 && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
);
1137 tree n1
= TYPE_NAME (t1
);
1138 tree n2
= TYPE_NAME (t2
);
1139 if (TREE_CODE (n1
) == TYPE_DECL
)
1140 n1
= DECL_NAME (n1
);
1141 if (TREE_CODE (n2
) == TYPE_DECL
)
1142 n2
= DECL_NAME (n2
);
1143 /* Most of the time, the type names will match, do not be unnecesarily
1145 if (IDENTIFIER_POINTER (n1
) != IDENTIFIER_POINTER (n2
))
1147 "type %qT defined in anonymous namespace can not match "
1148 "type %qT across the translation unit boundary",
1152 "type %qT defined in anonymous namespace can not match "
1153 "across the translation unit boundary",
1157 "the incompatible type defined in another translation unit");
1160 tree mt1
= TYPE_MAIN_VARIANT (t1
);
1161 tree mt2
= TYPE_MAIN_VARIANT (t2
);
1162 /* If types have mangled ODR names and they are different, it is most
1163 informative to output those.
1164 This also covers types defined in different namespaces. */
1165 if (TYPE_NAME (mt1
) && TYPE_NAME (mt2
)
1166 && TREE_CODE (TYPE_NAME (mt1
)) == TYPE_DECL
1167 && TREE_CODE (TYPE_NAME (mt2
)) == TYPE_DECL
1168 && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (mt1
))
1169 && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (mt2
))
1170 && DECL_ASSEMBLER_NAME (TYPE_NAME (mt1
))
1171 != DECL_ASSEMBLER_NAME (TYPE_NAME (mt2
)))
1173 char *name1
= xstrdup (cplus_demangle
1174 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (mt1
))),
1175 DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
));
1176 char *name2
= cplus_demangle
1177 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (mt2
))),
1178 DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
);
1179 if (name1
&& name2
&& strcmp (name1
, name2
))
1182 "type name %qs should match type name %qs",
1186 "the incompatible type is defined here");
1192 /* A tricky case are compound types. Often they appear the same in source
1193 code and the mismatch is dragged in by type they are build from.
1194 Look for those differences in subtypes and try to be informative. In other
1195 cases just output nothing because the source code is probably different
1196 and in this case we already output a all necessary info. */
1197 if (!TYPE_NAME (t1
) || !TYPE_NAME (t2
))
1199 if (TREE_CODE (t1
) == TREE_CODE (t2
))
1201 if (TREE_CODE (t1
) == ARRAY_TYPE
1202 && COMPLETE_TYPE_P (t1
) && COMPLETE_TYPE_P (t2
))
1204 tree i1
= TYPE_DOMAIN (t1
);
1205 tree i2
= TYPE_DOMAIN (t2
);
1208 && TYPE_MAX_VALUE (i1
)
1209 && TYPE_MAX_VALUE (i2
)
1210 && !operand_equal_p (TYPE_MAX_VALUE (i1
),
1211 TYPE_MAX_VALUE (i2
), 0))
1214 "array types have different bounds");
1218 if ((POINTER_TYPE_P (t1
) || TREE_CODE (t1
) == ARRAY_TYPE
)
1219 && type_mismatch_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1220 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc_t1
, loc_t2
);
1221 else if (TREE_CODE (t1
) == METHOD_TYPE
1222 || TREE_CODE (t1
) == FUNCTION_TYPE
)
1224 tree parms1
= NULL
, parms2
= NULL
;
1227 if (type_mismatch_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1229 inform (loc
, "return value type mismatch");
1230 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc_t1
,
1234 if (prototype_p (t1
) && prototype_p (t2
))
1235 for (parms1
= TYPE_ARG_TYPES (t1
), parms2
= TYPE_ARG_TYPES (t2
);
1237 parms1
= TREE_CHAIN (parms1
), parms2
= TREE_CHAIN (parms2
),
1240 if (type_mismatch_p (TREE_VALUE (parms1
), TREE_VALUE (parms2
)))
1242 if (count
== 1 && TREE_CODE (t1
) == METHOD_TYPE
)
1244 "implicit this pointer type mismatch");
1247 "type mismatch in parameter %i",
1248 count
- (TREE_CODE (t1
) == METHOD_TYPE
));
1249 warn_types_mismatch (TREE_VALUE (parms1
),
1250 TREE_VALUE (parms2
),
1255 if (parms1
|| parms2
)
1258 "types have different parameter counts");
1266 if (types_odr_comparable (t1
, t2
)
1267 && types_same_for_odr (t1
, t2
))
1269 "type %qT itself violates the C++ One Definition Rule", t1
);
1270 /* Prevent pointless warnings like "struct aa" should match "struct aa". */
1271 else if (TYPE_NAME (t1
) == TYPE_NAME (t2
)
1272 && TREE_CODE (t1
) == TREE_CODE (t2
) && !loc_t2_useful
)
1275 inform (loc_t1
, "type %qT should match type %qT",
1278 inform (loc_t2
, "the incompatible type is defined here");
1281 /* Compare T1 and T2, report ODR violations if WARN is true and set
1282 WARNED to true if anything is reported. Return true if types match.
1283 If true is returned, the types are also compatible in the sense of
1284 gimple_canonical_types_compatible_p.
1285 If LOC1 and LOC2 is not UNKNOWN_LOCATION it may be used to output a warning
1286 about the type if the type itself do not have location. */
1289 odr_types_equivalent_p (tree t1
, tree t2
, bool warn
, bool *warned
,
1290 hash_set
<type_pair
> *visited
,
1291 location_t loc1
, location_t loc2
)
1293 /* Check first for the obvious case of pointer identity. */
1297 /* Can't be the same type if the types don't have the same code. */
1298 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1300 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1301 G_("a different type is defined in another translation unit"));
1305 if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1
))
1306 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1
)))
1307 || (type_with_linkage_p (TYPE_MAIN_VARIANT (t2
))
1308 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2
))))
1310 /* We can not trip this when comparing ODR types, only when trying to
1311 match different ODR derivations from different declarations.
1312 So WARN should be always false. */
1317 if (TREE_CODE (t1
) == ENUMERAL_TYPE
1318 && TYPE_VALUES (t1
) && TYPE_VALUES (t2
))
1321 for (v1
= TYPE_VALUES (t1
), v2
= TYPE_VALUES (t2
);
1322 v1
&& v2
; v1
= TREE_CHAIN (v1
), v2
= TREE_CHAIN (v2
))
1324 if (TREE_PURPOSE (v1
) != TREE_PURPOSE (v2
))
1326 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1327 G_("an enum with different value name"
1328 " is defined in another translation unit"));
1331 if (TREE_VALUE (v1
) != TREE_VALUE (v2
)
1332 && !operand_equal_p (DECL_INITIAL (TREE_VALUE (v1
)),
1333 DECL_INITIAL (TREE_VALUE (v2
)), 0))
1335 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1336 G_("an enum with different values is defined"
1337 " in another translation unit"));
1343 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1344 G_("an enum with mismatching number of values "
1345 "is defined in another translation unit"));
1350 /* Non-aggregate types can be handled cheaply. */
1351 if (INTEGRAL_TYPE_P (t1
)
1352 || SCALAR_FLOAT_TYPE_P (t1
)
1353 || FIXED_POINT_TYPE_P (t1
)
1354 || TREE_CODE (t1
) == VECTOR_TYPE
1355 || TREE_CODE (t1
) == COMPLEX_TYPE
1356 || TREE_CODE (t1
) == OFFSET_TYPE
1357 || POINTER_TYPE_P (t1
))
1359 if (TYPE_PRECISION (t1
) != TYPE_PRECISION (t2
))
1361 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1362 G_("a type with different precision is defined "
1363 "in another translation unit"));
1366 if (TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
))
1368 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1369 G_("a type with different signedness is defined "
1370 "in another translation unit"));
1374 if (TREE_CODE (t1
) == INTEGER_TYPE
1375 && TYPE_STRING_FLAG (t1
) != TYPE_STRING_FLAG (t2
))
1377 /* char WRT uint_8? */
1378 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1379 G_("a different type is defined in another "
1380 "translation unit"));
1384 /* For canonical type comparisons we do not want to build SCCs
1385 so we cannot compare pointed-to types. But we can, for now,
1386 require the same pointed-to type kind and match what
1387 useless_type_conversion_p would do. */
1388 if (POINTER_TYPE_P (t1
))
1390 if (TYPE_ADDR_SPACE (TREE_TYPE (t1
))
1391 != TYPE_ADDR_SPACE (TREE_TYPE (t2
)))
1393 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1394 G_("it is defined as a pointer in different address "
1395 "space in another translation unit"));
1399 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
1400 warn
, warned
, visited
, loc1
, loc2
))
1402 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1403 G_("it is defined as a pointer to different type "
1404 "in another translation unit"));
1406 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
),
1412 if ((TREE_CODE (t1
) == VECTOR_TYPE
|| TREE_CODE (t1
) == COMPLEX_TYPE
)
1413 && !odr_subtypes_equivalent_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
1415 visited
, loc1
, loc2
))
1417 /* Probably specific enough. */
1418 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1419 G_("a different type is defined "
1420 "in another translation unit"));
1422 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc1
, loc2
);
1426 /* Do type-specific comparisons. */
1427 else switch (TREE_CODE (t1
))
1431 /* Array types are the same if the element types are the same and
1432 the number of elements are the same. */
1433 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
1434 warn
, warned
, visited
, loc1
, loc2
))
1436 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1437 G_("a different type is defined in another "
1438 "translation unit"));
1440 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc1
, loc2
);
1442 gcc_assert (TYPE_STRING_FLAG (t1
) == TYPE_STRING_FLAG (t2
));
1443 gcc_assert (TYPE_NONALIASED_COMPONENT (t1
)
1444 == TYPE_NONALIASED_COMPONENT (t2
));
1446 tree i1
= TYPE_DOMAIN (t1
);
1447 tree i2
= TYPE_DOMAIN (t2
);
1449 /* For an incomplete external array, the type domain can be
1450 NULL_TREE. Check this condition also. */
1451 if (i1
== NULL_TREE
|| i2
== NULL_TREE
)
1452 return type_variants_equivalent_p (t1
, t2
, warn
, warned
);
1454 tree min1
= TYPE_MIN_VALUE (i1
);
1455 tree min2
= TYPE_MIN_VALUE (i2
);
1456 tree max1
= TYPE_MAX_VALUE (i1
);
1457 tree max2
= TYPE_MAX_VALUE (i2
);
1459 /* In C++, minimums should be always 0. */
1460 gcc_assert (min1
== min2
);
1461 if (!operand_equal_p (max1
, max2
, 0))
1463 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1464 G_("an array of different size is defined "
1465 "in another translation unit"));
1473 /* Function types are the same if the return type and arguments types
1475 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1
), TREE_TYPE (t2
),
1476 warn
, warned
, visited
, loc1
, loc2
))
1478 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1479 G_("has different return value "
1480 "in another translation unit"));
1482 warn_types_mismatch (TREE_TYPE (t1
), TREE_TYPE (t2
), loc1
, loc2
);
1486 if (TYPE_ARG_TYPES (t1
) == TYPE_ARG_TYPES (t2
)
1487 || !prototype_p (t1
) || !prototype_p (t2
))
1488 return type_variants_equivalent_p (t1
, t2
, warn
, warned
);
1491 tree parms1
, parms2
;
1493 for (parms1
= TYPE_ARG_TYPES (t1
), parms2
= TYPE_ARG_TYPES (t2
);
1495 parms1
= TREE_CHAIN (parms1
), parms2
= TREE_CHAIN (parms2
))
1497 if (!odr_subtypes_equivalent_p
1498 (TREE_VALUE (parms1
), TREE_VALUE (parms2
), warn
, warned
,
1499 visited
, loc1
, loc2
))
1501 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1502 G_("has different parameters in another "
1503 "translation unit"));
1505 warn_types_mismatch (TREE_VALUE (parms1
),
1506 TREE_VALUE (parms2
), loc1
, loc2
);
1511 if (parms1
|| parms2
)
1513 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1514 G_("has different parameters "
1515 "in another translation unit"));
1519 return type_variants_equivalent_p (t1
, t2
, warn
, warned
);
1524 case QUAL_UNION_TYPE
:
1528 /* For aggregate types, all the fields must be the same. */
1529 if (COMPLETE_TYPE_P (t1
) && COMPLETE_TYPE_P (t2
))
1531 if (TYPE_BINFO (t1
) && TYPE_BINFO (t2
)
1532 && polymorphic_type_binfo_p (TYPE_BINFO (t1
))
1533 != polymorphic_type_binfo_p (TYPE_BINFO (t2
)))
1535 if (polymorphic_type_binfo_p (TYPE_BINFO (t1
)))
1536 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1537 G_("a type defined in another translation unit "
1538 "is not polymorphic"));
1540 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1541 G_("a type defined in another translation unit "
1545 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1547 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1549 /* Skip non-fields. */
1550 while (f1
&& TREE_CODE (f1
) != FIELD_DECL
)
1551 f1
= TREE_CHAIN (f1
);
1552 while (f2
&& TREE_CODE (f2
) != FIELD_DECL
)
1553 f2
= TREE_CHAIN (f2
);
1556 if (DECL_VIRTUAL_P (f1
) != DECL_VIRTUAL_P (f2
))
1558 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1559 G_("a type with different virtual table pointers"
1560 " is defined in another translation unit"));
1563 if (DECL_ARTIFICIAL (f1
) != DECL_ARTIFICIAL (f2
))
1565 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1566 G_("a type with different bases is defined "
1567 "in another translation unit"));
1570 if (DECL_NAME (f1
) != DECL_NAME (f2
)
1571 && !DECL_ARTIFICIAL (f1
))
1573 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1574 G_("a field with different name is defined "
1575 "in another translation unit"));
1578 if (!odr_subtypes_equivalent_p (TREE_TYPE (f1
),
1579 TREE_TYPE (f2
), warn
, warned
,
1580 visited
, loc1
, loc2
))
1582 /* Do not warn about artificial fields and just go into
1583 generic field mismatch warning. */
1584 if (DECL_ARTIFICIAL (f1
))
1587 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1588 G_("a field of same name but different type "
1589 "is defined in another translation unit"));
1591 warn_types_mismatch (TREE_TYPE (f1
), TREE_TYPE (f2
), loc1
, loc2
);
1594 if (!gimple_compare_field_offset (f1
, f2
))
1596 /* Do not warn about artificial fields and just go into
1597 generic field mismatch warning. */
1598 if (DECL_ARTIFICIAL (f1
))
1600 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1601 G_("fields have different layout "
1602 "in another translation unit"));
1605 if (DECL_BIT_FIELD (f1
) != DECL_BIT_FIELD (f2
))
1607 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1608 G_("one field is bitfield while other is not"));
1612 gcc_assert (DECL_NONADDRESSABLE_P (f1
)
1613 == DECL_NONADDRESSABLE_P (f2
));
1616 /* If one aggregate has more fields than the other, they
1617 are not the same. */
1620 if ((f1
&& DECL_VIRTUAL_P (f1
)) || (f2
&& DECL_VIRTUAL_P (f2
)))
1621 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1622 G_("a type with different virtual table pointers"
1623 " is defined in another translation unit"));
1624 else if ((f1
&& DECL_ARTIFICIAL (f1
))
1625 || (f2
&& DECL_ARTIFICIAL (f2
)))
1626 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1627 G_("a type with different bases is defined "
1628 "in another translation unit"));
1630 warn_odr (t1
, t2
, f1
, f2
, warn
, warned
,
1631 G_("a type with different number of fields "
1632 "is defined in another translation unit"));
1648 /* Those are better to come last as they are utterly uninformative. */
1649 if (TYPE_SIZE (t1
) && TYPE_SIZE (t2
)
1650 && !operand_equal_p (TYPE_SIZE (t1
), TYPE_SIZE (t2
), 0))
1652 warn_odr (t1
, t2
, NULL
, NULL
, warn
, warned
,
1653 G_("a type with different size "
1654 "is defined in another translation unit"));
1658 gcc_assert (!TYPE_SIZE_UNIT (t1
) || !TYPE_SIZE_UNIT (t2
)
1659 || operand_equal_p (TYPE_SIZE_UNIT (t1
),
1660 TYPE_SIZE_UNIT (t2
), 0));
1661 return type_variants_equivalent_p (t1
, t2
, warn
, warned
);
1664 /* Return true if TYPE1 and TYPE2 are equivalent for One Definition Rule. */
1667 odr_types_equivalent_p (tree type1
, tree type2
)
1669 gcc_checking_assert (odr_or_derived_type_p (type1
)
1670 && odr_or_derived_type_p (type2
));
1672 hash_set
<type_pair
> visited
;
1673 return odr_types_equivalent_p (type1
, type2
, false, NULL
,
1674 &visited
, UNKNOWN_LOCATION
, UNKNOWN_LOCATION
);
1677 /* TYPE is equivalent to VAL by ODR, but its tree representation differs
1678 from VAL->type. This may happen in LTO where tree merging did not merge
1679 all variants of the same type or due to ODR violation.
1681 Analyze and report ODR violations and add type to duplicate list.
1682 If TYPE is more specified than VAL->type, prevail VAL->type. Also if
1683 this is first time we see definition of a class return true so the
1684 base types are analyzed. */
1687 add_type_duplicate (odr_type val
, tree type
)
1689 bool build_bases
= false;
1690 bool prevail
= false;
1691 bool odr_must_violate
= false;
1693 if (!val
->types_set
)
1694 val
->types_set
= new hash_set
<tree
>;
1696 /* Chose polymorphic type as leader (this happens only in case of ODR
1698 if ((TREE_CODE (type
) == RECORD_TYPE
&& TYPE_BINFO (type
)
1699 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
1700 && (TREE_CODE (val
->type
) != RECORD_TYPE
|| !TYPE_BINFO (val
->type
)
1701 || !polymorphic_type_binfo_p (TYPE_BINFO (val
->type
))))
1706 /* Always prefer complete type to be the leader. */
1707 else if (!COMPLETE_TYPE_P (val
->type
) && COMPLETE_TYPE_P (type
))
1710 build_bases
= TYPE_BINFO (type
);
1712 else if (COMPLETE_TYPE_P (val
->type
) && !COMPLETE_TYPE_P (type
))
1714 else if (TREE_CODE (val
->type
) == ENUMERAL_TYPE
1715 && TREE_CODE (type
) == ENUMERAL_TYPE
1716 && !TYPE_VALUES (val
->type
) && TYPE_VALUES (type
))
1718 else if (TREE_CODE (val
->type
) == RECORD_TYPE
1719 && TREE_CODE (type
) == RECORD_TYPE
1720 && TYPE_BINFO (type
) && !TYPE_BINFO (val
->type
))
1722 gcc_assert (!val
->bases
.length ());
1728 std::swap (val
->type
, type
);
1730 val
->types_set
->add (type
);
1732 /* If we now have a mangled name, be sure to record it to val->type
1733 so ODR hash can work. */
1735 if (can_be_name_hashed_p (type
) && !can_be_name_hashed_p (val
->type
))
1736 SET_DECL_ASSEMBLER_NAME (TYPE_NAME (val
->type
),
1737 DECL_ASSEMBLER_NAME (TYPE_NAME (type
)));
1740 bool base_mismatch
= false;
1742 bool warned
= false;
1743 hash_set
<type_pair
> visited
;
1745 gcc_assert (in_lto_p
);
1746 vec_safe_push (val
->types
, type
);
1748 /* If both are class types, compare the bases. */
1749 if (COMPLETE_TYPE_P (type
) && COMPLETE_TYPE_P (val
->type
)
1750 && TREE_CODE (val
->type
) == RECORD_TYPE
1751 && TREE_CODE (type
) == RECORD_TYPE
1752 && TYPE_BINFO (val
->type
) && TYPE_BINFO (type
))
1754 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (type
))
1755 != BINFO_N_BASE_BINFOS (TYPE_BINFO (val
->type
)))
1757 if (!flag_ltrans
&& !warned
&& !val
->odr_violated
)
1760 warn_odr (type
, val
->type
, NULL
, NULL
, !warned
, &warned
,
1761 "a type with the same name but different "
1762 "number of polymorphic bases is "
1763 "defined in another translation unit");
1766 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (type
))
1767 > BINFO_N_BASE_BINFOS (TYPE_BINFO (val
->type
)))
1768 extra_base
= BINFO_BASE_BINFO
1770 BINFO_N_BASE_BINFOS (TYPE_BINFO (val
->type
)));
1772 extra_base
= BINFO_BASE_BINFO
1773 (TYPE_BINFO (val
->type
),
1774 BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1775 tree extra_base_type
= BINFO_TYPE (extra_base
);
1776 inform (DECL_SOURCE_LOCATION (TYPE_NAME (extra_base_type
)),
1777 "the extra base is defined here");
1780 base_mismatch
= true;
1783 for (i
= 0; i
< BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)); i
++)
1785 tree base1
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1786 tree base2
= BINFO_BASE_BINFO (TYPE_BINFO (val
->type
), i
);
1787 tree type1
= BINFO_TYPE (base1
);
1788 tree type2
= BINFO_TYPE (base2
);
1790 if (types_odr_comparable (type1
, type2
))
1792 if (!types_same_for_odr (type1
, type2
))
1793 base_mismatch
= true;
1796 if (!odr_types_equivalent_p (type1
, type2
))
1797 base_mismatch
= true;
1800 if (!warned
&& !val
->odr_violated
)
1802 warn_odr (type
, val
->type
, NULL
, NULL
,
1804 "a type with the same name but different base "
1805 "type is defined in another translation unit");
1807 warn_types_mismatch (type1
, type2
,
1808 UNKNOWN_LOCATION
, UNKNOWN_LOCATION
);
1812 if (BINFO_OFFSET (base1
) != BINFO_OFFSET (base2
))
1814 base_mismatch
= true;
1815 if (!warned
&& !val
->odr_violated
)
1816 warn_odr (type
, val
->type
, NULL
, NULL
,
1818 "a type with the same name but different base "
1819 "layout is defined in another translation unit");
1822 /* One of bases is not of complete type. */
1823 if (!TYPE_BINFO (type1
) != !TYPE_BINFO (type2
))
1825 /* If we have a polymorphic type info specified for TYPE1
1826 but not for TYPE2 we possibly missed a base when recording
1828 Be sure this does not happen. */
1829 if (TYPE_BINFO (type1
)
1830 && polymorphic_type_binfo_p (TYPE_BINFO (type1
))
1832 odr_must_violate
= true;
1835 /* One base is polymorphic and the other not.
1836 This ought to be diagnosed earlier, but do not ICE in the
1838 else if (TYPE_BINFO (type1
)
1839 && polymorphic_type_binfo_p (TYPE_BINFO (type1
))
1840 != polymorphic_type_binfo_p (TYPE_BINFO (type2
)))
1842 if (!warned
&& !val
->odr_violated
)
1843 warn_odr (type
, val
->type
, NULL
, NULL
,
1845 "a base of the type is polymorphic only in one "
1846 "translation unit");
1847 base_mismatch
= true;
1854 odr_violation_reported
= true;
1855 val
->odr_violated
= true;
1857 if (symtab
->dump_file
)
1859 fprintf (symtab
->dump_file
, "ODR base violation\n");
1861 print_node (symtab
->dump_file
, "", val
->type
, 0);
1862 putc ('\n',symtab
->dump_file
);
1863 print_node (symtab
->dump_file
, "", type
, 0);
1864 putc ('\n',symtab
->dump_file
);
1869 /* Next compare memory layout.
1870 The DECL_SOURCE_LOCATIONs in this invocation came from LTO streaming.
1871 We must apply the location cache to ensure that they are valid
1872 before we can pass them to odr_types_equivalent_p (PR lto/83121). */
1873 if (lto_location_cache::current_cache
)
1874 lto_location_cache::current_cache
->apply_location_cache ();
1875 /* As a special case we stream mangles names of integer types so we can see
1876 if they are believed to be same even though they have different
1877 representation. Avoid bogus warning on mismatches in these. */
1878 if (TREE_CODE (type
) != INTEGER_TYPE
1879 && TREE_CODE (val
->type
) != INTEGER_TYPE
1880 && !odr_types_equivalent_p (val
->type
, type
,
1881 !flag_ltrans
&& !val
->odr_violated
&& !warned
,
1883 DECL_SOURCE_LOCATION (TYPE_NAME (val
->type
)),
1884 DECL_SOURCE_LOCATION (TYPE_NAME (type
))))
1887 odr_violation_reported
= true;
1888 val
->odr_violated
= true;
1890 gcc_assert (val
->odr_violated
|| !odr_must_violate
);
1891 /* Sanity check that all bases will be build same way again. */
1893 && COMPLETE_TYPE_P (type
) && COMPLETE_TYPE_P (val
->type
)
1894 && TREE_CODE (val
->type
) == RECORD_TYPE
1895 && TREE_CODE (type
) == RECORD_TYPE
1896 && TYPE_BINFO (val
->type
) && TYPE_BINFO (type
)
1897 && !val
->odr_violated
1898 && !base_mismatch
&& val
->bases
.length ())
1900 unsigned int num_poly_bases
= 0;
1903 for (i
= 0; i
< BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)); i
++)
1904 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO
1905 (TYPE_BINFO (type
), i
)))
1907 gcc_assert (num_poly_bases
== val
->bases
.length ());
1908 for (j
= 0, i
= 0; i
< BINFO_N_BASE_BINFOS (TYPE_BINFO (type
));
1910 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO
1911 (TYPE_BINFO (type
), i
)))
1913 odr_type base
= get_odr_type
1915 (BINFO_BASE_BINFO (TYPE_BINFO (type
),
1918 gcc_assert (val
->bases
[j
] == base
);
1924 /* Regularize things a little. During LTO same types may come with
1925 different BINFOs. Either because their virtual table was
1926 not merged by tree merging and only later at decl merging or
1927 because one type comes with external vtable, while other
1928 with internal. We want to merge equivalent binfos to conserve
1929 memory and streaming overhead.
1931 The external vtables are more harmful: they contain references
1932 to external declarations of methods that may be defined in the
1933 merged LTO unit. For this reason we absolutely need to remove
1934 them and replace by internal variants. Not doing so will lead
1935 to incomplete answers from possible_polymorphic_call_targets.
1937 FIXME: disable for now; because ODR types are now build during
1938 streaming in, the variants do not need to be linked to the type,
1939 yet. We need to do the merging in cleanup pass to be implemented
1941 if (!flag_ltrans
&& merge
1943 && TREE_CODE (val
->type
) == RECORD_TYPE
1944 && TREE_CODE (type
) == RECORD_TYPE
1945 && TYPE_BINFO (val
->type
) && TYPE_BINFO (type
)
1946 && TYPE_MAIN_VARIANT (type
) == type
1947 && TYPE_MAIN_VARIANT (val
->type
) == val
->type
1948 && BINFO_VTABLE (TYPE_BINFO (val
->type
))
1949 && BINFO_VTABLE (TYPE_BINFO (type
)))
1951 tree master_binfo
= TYPE_BINFO (val
->type
);
1952 tree v1
= BINFO_VTABLE (master_binfo
);
1953 tree v2
= BINFO_VTABLE (TYPE_BINFO (type
));
1955 if (TREE_CODE (v1
) == POINTER_PLUS_EXPR
)
1957 gcc_assert (TREE_CODE (v2
) == POINTER_PLUS_EXPR
1958 && operand_equal_p (TREE_OPERAND (v1
, 1),
1959 TREE_OPERAND (v2
, 1), 0));
1960 v1
= TREE_OPERAND (TREE_OPERAND (v1
, 0), 0);
1961 v2
= TREE_OPERAND (TREE_OPERAND (v2
, 0), 0);
1963 gcc_assert (DECL_ASSEMBLER_NAME (v1
)
1964 == DECL_ASSEMBLER_NAME (v2
));
1966 if (DECL_EXTERNAL (v1
) && !DECL_EXTERNAL (v2
))
1970 set_type_binfo (val
->type
, TYPE_BINFO (type
));
1971 for (i
= 0; i
< val
->types
->length (); i
++)
1973 if (TYPE_BINFO ((*val
->types
)[i
])
1975 set_type_binfo ((*val
->types
)[i
], TYPE_BINFO (type
));
1977 BINFO_TYPE (TYPE_BINFO (type
)) = val
->type
;
1980 set_type_binfo (type
, master_binfo
);
1985 /* Get ODR type hash entry for TYPE. If INSERT is true, create
1986 possibly new entry. */
1989 get_odr_type (tree type
, bool insert
)
1991 odr_type_d
**slot
= NULL
;
1992 odr_type_d
**vtable_slot
= NULL
;
1993 odr_type val
= NULL
;
1995 bool build_bases
= false;
1996 bool insert_to_odr_array
= false;
1999 type
= TYPE_MAIN_VARIANT (type
);
2001 gcc_checking_assert (can_be_name_hashed_p (type
)
2002 || can_be_vtable_hashed_p (type
));
2004 /* Lookup entry, first try name hash, fallback to vtable hash. */
2005 if (can_be_name_hashed_p (type
))
2007 hash
= hash_odr_name (type
);
2008 slot
= odr_hash
->find_slot_with_hash (type
, hash
,
2009 insert
? INSERT
: NO_INSERT
);
2011 if ((!slot
|| !*slot
) && in_lto_p
&& can_be_vtable_hashed_p (type
))
2013 hash
= hash_odr_vtable (type
);
2014 vtable_slot
= odr_vtable_hash
->find_slot_with_hash (type
, hash
,
2015 insert
? INSERT
: NO_INSERT
);
2018 if (!slot
&& !vtable_slot
)
2021 /* See if we already have entry for type. */
2022 if ((slot
&& *slot
) || (vtable_slot
&& *vtable_slot
))
2028 && in_lto_p
&& can_be_vtable_hashed_p (type
))
2030 hash
= hash_odr_vtable (type
);
2031 vtable_slot
= odr_vtable_hash
->find_slot_with_hash (type
, hash
,
2033 gcc_assert (!vtable_slot
|| *vtable_slot
== *slot
);
2037 else if (*vtable_slot
)
2040 if (val
->type
!= type
2041 && (!val
->types_set
|| !val
->types_set
->add (type
)))
2043 gcc_assert (insert
);
2044 /* We have type duplicate, but it may introduce vtable name or
2045 mangled name; be sure to keep hashes in sync. */
2046 if (in_lto_p
&& can_be_vtable_hashed_p (type
)
2047 && (!vtable_slot
|| !*vtable_slot
))
2051 hash
= hash_odr_vtable (type
);
2052 vtable_slot
= odr_vtable_hash
->find_slot_with_hash
2053 (type
, hash
, INSERT
);
2054 gcc_checking_assert (!*vtable_slot
|| *vtable_slot
== val
);
2060 build_bases
= add_type_duplicate (val
, type
);
2065 val
= ggc_cleared_alloc
<odr_type_d
> ();
2068 val
->derived_types
= vNULL
;
2069 if (type_with_linkage_p (type
))
2070 val
->anonymous_namespace
= type_in_anonymous_namespace_p (type
);
2072 val
->anonymous_namespace
= 0;
2073 build_bases
= COMPLETE_TYPE_P (val
->type
);
2074 insert_to_odr_array
= true;
2081 if (build_bases
&& TREE_CODE (type
) == RECORD_TYPE
&& TYPE_BINFO (type
)
2082 && type_with_linkage_p (type
)
2083 && type
== TYPE_MAIN_VARIANT (type
))
2085 tree binfo
= TYPE_BINFO (type
);
2088 gcc_assert (BINFO_TYPE (TYPE_BINFO (val
->type
)) == type
);
2090 val
->all_derivations_known
= type_all_derivations_known_p (type
);
2091 for (i
= 0; i
< BINFO_N_BASE_BINFOS (binfo
); i
++)
2092 /* For now record only polymorphic types. other are
2093 pointless for devirtualization and we can not precisely
2094 determine ODR equivalency of these during LTO. */
2095 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (binfo
, i
)))
2097 tree base_type
= BINFO_TYPE (BINFO_BASE_BINFO (binfo
, i
));
2098 odr_type base
= get_odr_type (base_type
, true);
2099 gcc_assert (TYPE_MAIN_VARIANT (base_type
) == base_type
);
2100 base
->derived_types
.safe_push (val
);
2101 val
->bases
.safe_push (base
);
2102 if (base
->id
> base_id
)
2106 /* Ensure that type always appears after bases. */
2107 if (insert_to_odr_array
)
2110 val
->id
= odr_types
.length ();
2111 vec_safe_push (odr_types_ptr
, val
);
2113 else if (base_id
> val
->id
)
2115 odr_types
[val
->id
] = 0;
2116 /* Be sure we did not recorded any derived types; these may need
2118 gcc_assert (val
->derived_types
.length() == 0);
2119 val
->id
= odr_types
.length ();
2120 vec_safe_push (odr_types_ptr
, val
);
2125 /* Add TYPE od ODR type hash. */
2128 register_odr_type (tree type
)
2132 odr_hash
= new odr_hash_type (23);
2134 odr_vtable_hash
= new odr_vtable_hash_type (23);
2136 if (type
== TYPE_MAIN_VARIANT (type
))
2137 get_odr_type (type
, true);
2140 /* Return true if type is known to have no derivations. */
2143 type_known_to_have_no_derivations_p (tree t
)
2145 return (type_all_derivations_known_p (t
)
2146 && (TYPE_FINAL_P (t
)
2148 && !get_odr_type (t
, true)->derived_types
.length())));
2151 /* Dump ODR type T and all its derived types. INDENT specifies indentation for
2152 recursive printing. */
2155 dump_odr_type (FILE *f
, odr_type t
, int indent
=0)
2158 fprintf (f
, "%*s type %i: ", indent
* 2, "", t
->id
);
2159 print_generic_expr (f
, t
->type
, TDF_SLIM
);
2160 fprintf (f
, "%s", t
->anonymous_namespace
? " (anonymous namespace)":"");
2161 fprintf (f
, "%s\n", t
->all_derivations_known
? " (derivations known)":"");
2162 if (TYPE_NAME (t
->type
))
2164 /*fprintf (f, "%*s defined at: %s:%i\n", indent * 2, "",
2165 DECL_SOURCE_FILE (TYPE_NAME (t->type)),
2166 DECL_SOURCE_LINE (TYPE_NAME (t->type)));*/
2167 if (DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t
->type
)))
2168 fprintf (f
, "%*s mangled name: %s\n", indent
* 2, "",
2170 (DECL_ASSEMBLER_NAME (TYPE_NAME (t
->type
))));
2172 if (t
->bases
.length ())
2174 fprintf (f
, "%*s base odr type ids: ", indent
* 2, "");
2175 for (i
= 0; i
< t
->bases
.length (); i
++)
2176 fprintf (f
, " %i", t
->bases
[i
]->id
);
2179 if (t
->derived_types
.length ())
2181 fprintf (f
, "%*s derived types:\n", indent
* 2, "");
2182 for (i
= 0; i
< t
->derived_types
.length (); i
++)
2183 dump_odr_type (f
, t
->derived_types
[i
], indent
+ 1);
2188 /* Dump the type inheritance graph. */
2191 dump_type_inheritance_graph (FILE *f
)
2196 fprintf (f
, "\n\nType inheritance graph:\n");
2197 for (i
= 0; i
< odr_types
.length (); i
++)
2199 if (odr_types
[i
] && odr_types
[i
]->bases
.length () == 0)
2200 dump_odr_type (f
, odr_types
[i
]);
2202 for (i
= 0; i
< odr_types
.length (); i
++)
2204 if (odr_types
[i
] && odr_types
[i
]->types
&& odr_types
[i
]->types
->length ())
2207 fprintf (f
, "Duplicate tree types for odr type %i\n", i
);
2208 print_node (f
, "", odr_types
[i
]->type
, 0);
2209 for (j
= 0; j
< odr_types
[i
]->types
->length (); j
++)
2212 fprintf (f
, "duplicate #%i\n", j
);
2213 print_node (f
, "", (*odr_types
[i
]->types
)[j
], 0);
2214 t
= (*odr_types
[i
]->types
)[j
];
2215 while (TYPE_P (t
) && TYPE_CONTEXT (t
))
2217 t
= TYPE_CONTEXT (t
);
2218 print_node (f
, "", t
, 0);
2226 /* Initialize IPA devirt and build inheritance tree graph. */
2229 build_type_inheritance_graph (void)
2231 struct symtab_node
*n
;
2232 FILE *inheritance_dump_file
;
2237 timevar_push (TV_IPA_INHERITANCE
);
2238 inheritance_dump_file
= dump_begin (TDI_inheritance
, &flags
);
2239 odr_hash
= new odr_hash_type (23);
2241 odr_vtable_hash
= new odr_vtable_hash_type (23);
2243 /* We reconstruct the graph starting of types of all methods seen in the
2246 if (is_a
<cgraph_node
*> (n
)
2247 && DECL_VIRTUAL_P (n
->decl
)
2248 && n
->real_symbol_p ())
2249 get_odr_type (TYPE_METHOD_BASETYPE (TREE_TYPE (n
->decl
)), true);
2251 /* Look also for virtual tables of types that do not define any methods.
2253 We need it in a case where class B has virtual base of class A
2254 re-defining its virtual method and there is class C with no virtual
2255 methods with B as virtual base.
2257 Here we output B's virtual method in two variant - for non-virtual
2258 and virtual inheritance. B's virtual table has non-virtual version,
2259 while C's has virtual.
2261 For this reason we need to know about C in order to include both
2262 variants of B. More correctly, record_target_from_binfo should
2263 add both variants of the method when walking B, but we have no
2264 link in between them.
2266 We rely on fact that either the method is exported and thus we
2267 assume it is called externally or C is in anonymous namespace and
2268 thus we will see the vtable. */
2270 else if (is_a
<varpool_node
*> (n
)
2271 && DECL_VIRTUAL_P (n
->decl
)
2272 && TREE_CODE (DECL_CONTEXT (n
->decl
)) == RECORD_TYPE
2273 && TYPE_BINFO (DECL_CONTEXT (n
->decl
))
2274 && polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (n
->decl
))))
2275 get_odr_type (TYPE_MAIN_VARIANT (DECL_CONTEXT (n
->decl
)), true);
2276 if (inheritance_dump_file
)
2278 dump_type_inheritance_graph (inheritance_dump_file
);
2279 dump_end (TDI_inheritance
, inheritance_dump_file
);
2281 timevar_pop (TV_IPA_INHERITANCE
);
2284 /* Return true if N has reference from live virtual table
2285 (and thus can be a destination of polymorphic call).
2286 Be conservatively correct when callgraph is not built or
2287 if the method may be referred externally. */
2290 referenced_from_vtable_p (struct cgraph_node
*node
)
2293 struct ipa_ref
*ref
;
2296 if (node
->externally_visible
2297 || DECL_EXTERNAL (node
->decl
)
2298 || node
->used_from_other_partition
)
2301 /* Keep this test constant time.
2302 It is unlikely this can happen except for the case where speculative
2303 devirtualization introduced many speculative edges to this node.
2304 In this case the target is very likely alive anyway. */
2305 if (node
->ref_list
.referring
.length () > 100)
2308 /* We need references built. */
2309 if (symtab
->state
<= CONSTRUCTION
)
2312 for (i
= 0; node
->iterate_referring (i
, ref
); i
++)
2313 if ((ref
->use
== IPA_REF_ALIAS
2314 && referenced_from_vtable_p (dyn_cast
<cgraph_node
*> (ref
->referring
)))
2315 || (ref
->use
== IPA_REF_ADDR
2316 && VAR_P (ref
->referring
->decl
)
2317 && DECL_VIRTUAL_P (ref
->referring
->decl
)))
2325 /* Return if TARGET is cxa_pure_virtual. */
2328 is_cxa_pure_virtual_p (tree target
)
2330 return target
&& TREE_CODE (TREE_TYPE (target
)) != METHOD_TYPE
2331 && DECL_NAME (target
)
2332 && id_equal (DECL_NAME (target
),
2333 "__cxa_pure_virtual");
2336 /* If TARGET has associated node, record it in the NODES array.
2337 CAN_REFER specify if program can refer to the target directly.
2338 if TARGET is unknown (NULL) or it can not be inserted (for example because
2339 its body was already removed and there is no way to refer to it), clear
2343 maybe_record_node (vec
<cgraph_node
*> &nodes
,
2344 tree target
, hash_set
<tree
> *inserted
,
2348 struct cgraph_node
*target_node
, *alias_target
;
2349 enum availability avail
;
2350 bool pure_virtual
= is_cxa_pure_virtual_p (target
);
2352 /* __builtin_unreachable do not need to be added into
2353 list of targets; the runtime effect of calling them is undefined.
2354 Only "real" virtual methods should be accounted. */
2355 if (target
&& TREE_CODE (TREE_TYPE (target
)) != METHOD_TYPE
&& !pure_virtual
)
2360 /* The only case when method of anonymous namespace becomes unreferable
2361 is when we completely optimized it out. */
2364 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target
)))
2372 target_node
= cgraph_node::get (target
);
2374 /* Prefer alias target over aliases, so we do not get confused by
2378 alias_target
= target_node
->ultimate_alias_target (&avail
);
2379 if (target_node
!= alias_target
2380 && avail
>= AVAIL_AVAILABLE
2381 && target_node
->get_availability ())
2382 target_node
= alias_target
;
2385 /* Method can only be called by polymorphic call if any
2386 of vtables referring to it are alive.
2388 While this holds for non-anonymous functions, too, there are
2389 cases where we want to keep them in the list; for example
2390 inline functions with -fno-weak are static, but we still
2391 may devirtualize them when instance comes from other unit.
2392 The same holds for LTO.
2394 Currently we ignore these functions in speculative devirtualization.
2395 ??? Maybe it would make sense to be more aggressive for LTO even
2399 && type_in_anonymous_namespace_p (DECL_CONTEXT (target
))
2401 || !referenced_from_vtable_p (target_node
)))
2403 /* See if TARGET is useful function we can deal with. */
2404 else if (target_node
!= NULL
2405 && (TREE_PUBLIC (target
)
2406 || DECL_EXTERNAL (target
)
2407 || target_node
->definition
)
2408 && target_node
->real_symbol_p ())
2410 gcc_assert (!target_node
->global
.inlined_to
);
2411 gcc_assert (target_node
->real_symbol_p ());
2412 /* When sanitizing, do not assume that __cxa_pure_virtual is not called
2413 by valid program. */
2414 if (flag_sanitize
& SANITIZE_UNREACHABLE
)
2416 /* Only add pure virtual if it is the only possible target. This way
2417 we will preserve the diagnostics about pure virtual called in many
2418 cases without disabling optimization in other. */
2419 else if (pure_virtual
)
2421 if (nodes
.length ())
2424 /* If we found a real target, take away cxa_pure_virtual. */
2425 else if (!pure_virtual
&& nodes
.length () == 1
2426 && is_cxa_pure_virtual_p (nodes
[0]->decl
))
2428 if (pure_virtual
&& nodes
.length ())
2430 if (!inserted
->add (target
))
2432 cached_polymorphic_call_targets
->add (target_node
);
2433 nodes
.safe_push (target_node
);
2436 else if (!completep
)
2438 /* We have definition of __cxa_pure_virtual that is not accessible (it is
2439 optimized out or partitioned to other unit) so we can not add it. When
2440 not sanitizing, there is nothing to do.
2441 Otherwise declare the list incomplete. */
2442 else if (pure_virtual
)
2444 if (flag_sanitize
& SANITIZE_UNREACHABLE
)
2447 else if (flag_ltrans
2448 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target
)))
2452 /* See if BINFO's type matches OUTER_TYPE. If so, look up
2453 BINFO of subtype of OTR_TYPE at OFFSET and in that BINFO find
2454 method in vtable and insert method to NODES array
2455 or BASES_TO_CONSIDER if this array is non-NULL.
2456 Otherwise recurse to base BINFOs.
2457 This matches what get_binfo_at_offset does, but with offset
2460 TYPE_BINFOS is a stack of BINFOS of types with defined
2461 virtual table seen on way from class type to BINFO.
2463 MATCHED_VTABLES tracks virtual tables we already did lookup
2464 for virtual function in. INSERTED tracks nodes we already
2467 ANONYMOUS is true if BINFO is part of anonymous namespace.
2469 Clear COMPLETEP when we hit unreferable target.
2473 record_target_from_binfo (vec
<cgraph_node
*> &nodes
,
2474 vec
<tree
> *bases_to_consider
,
2477 vec
<tree
> &type_binfos
,
2478 HOST_WIDE_INT otr_token
,
2480 HOST_WIDE_INT offset
,
2481 hash_set
<tree
> *inserted
,
2482 hash_set
<tree
> *matched_vtables
,
2486 tree type
= BINFO_TYPE (binfo
);
2491 if (BINFO_VTABLE (binfo
))
2492 type_binfos
.safe_push (binfo
);
2493 if (types_same_for_odr (type
, outer_type
))
2496 tree type_binfo
= NULL
;
2498 /* Look up BINFO with virtual table. For normal types it is always last
2500 for (i
= type_binfos
.length () - 1; i
>= 0; i
--)
2501 if (BINFO_OFFSET (type_binfos
[i
]) == BINFO_OFFSET (binfo
))
2503 type_binfo
= type_binfos
[i
];
2506 if (BINFO_VTABLE (binfo
))
2508 /* If this is duplicated BINFO for base shared by virtual inheritance,
2509 we may not have its associated vtable. This is not a problem, since
2510 we will walk it on the other path. */
2513 tree inner_binfo
= get_binfo_at_offset (type_binfo
,
2517 gcc_assert (odr_violation_reported
);
2520 /* For types in anonymous namespace first check if the respective vtable
2521 is alive. If not, we know the type can't be called. */
2522 if (!flag_ltrans
&& anonymous
)
2524 tree vtable
= BINFO_VTABLE (inner_binfo
);
2525 varpool_node
*vnode
;
2527 if (TREE_CODE (vtable
) == POINTER_PLUS_EXPR
)
2528 vtable
= TREE_OPERAND (TREE_OPERAND (vtable
, 0), 0);
2529 vnode
= varpool_node::get (vtable
);
2530 if (!vnode
|| !vnode
->definition
)
2533 gcc_assert (inner_binfo
);
2534 if (bases_to_consider
2535 ? !matched_vtables
->contains (BINFO_VTABLE (inner_binfo
))
2536 : !matched_vtables
->add (BINFO_VTABLE (inner_binfo
)))
2539 tree target
= gimple_get_virt_method_for_binfo (otr_token
,
2542 if (!bases_to_consider
)
2543 maybe_record_node (nodes
, target
, inserted
, can_refer
, completep
);
2544 /* Destructors are never called via construction vtables. */
2545 else if (!target
|| !DECL_CXX_DESTRUCTOR_P (target
))
2546 bases_to_consider
->safe_push (target
);
2552 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2553 /* Walking bases that have no virtual method is pointless exercise. */
2554 if (polymorphic_type_binfo_p (base_binfo
))
2555 record_target_from_binfo (nodes
, bases_to_consider
, base_binfo
, otr_type
,
2557 otr_token
, outer_type
, offset
, inserted
,
2558 matched_vtables
, anonymous
, completep
);
2559 if (BINFO_VTABLE (binfo
))
2563 /* Look up virtual methods matching OTR_TYPE (with OFFSET and OTR_TOKEN)
2564 of TYPE, insert them to NODES, recurse into derived nodes.
2565 INSERTED is used to avoid duplicate insertions of methods into NODES.
2566 MATCHED_VTABLES are used to avoid duplicate walking vtables.
2567 Clear COMPLETEP if unreferable target is found.
2569 If CONSIDER_CONSTRUCTION is true, record to BASES_TO_CONSIDER
2570 all cases where BASE_SKIPPED is true (because the base is abstract
2574 possible_polymorphic_call_targets_1 (vec
<cgraph_node
*> &nodes
,
2575 hash_set
<tree
> *inserted
,
2576 hash_set
<tree
> *matched_vtables
,
2579 HOST_WIDE_INT otr_token
,
2581 HOST_WIDE_INT offset
,
2583 vec
<tree
> &bases_to_consider
,
2584 bool consider_construction
)
2586 tree binfo
= TYPE_BINFO (type
->type
);
2588 auto_vec
<tree
, 8> type_binfos
;
2589 bool possibly_instantiated
= type_possibly_instantiated_p (type
->type
);
2591 /* We may need to consider types w/o instances because of possible derived
2592 types using their methods either directly or via construction vtables.
2593 We are safe to skip them when all derivations are known, since we will
2595 This is done by recording them to BASES_TO_CONSIDER array. */
2596 if (possibly_instantiated
|| consider_construction
)
2598 record_target_from_binfo (nodes
,
2599 (!possibly_instantiated
2600 && type_all_derivations_known_p (type
->type
))
2601 ? &bases_to_consider
: NULL
,
2602 binfo
, otr_type
, type_binfos
, otr_token
,
2604 inserted
, matched_vtables
,
2605 type
->anonymous_namespace
, completep
);
2607 for (i
= 0; i
< type
->derived_types
.length (); i
++)
2608 possible_polymorphic_call_targets_1 (nodes
, inserted
,
2611 type
->derived_types
[i
],
2612 otr_token
, outer_type
, offset
, completep
,
2613 bases_to_consider
, consider_construction
);
2616 /* Cache of queries for polymorphic call targets.
2618 Enumerating all call targets may get expensive when there are many
2619 polymorphic calls in the program, so we memoize all the previous
2620 queries and avoid duplicated work. */
2622 struct polymorphic_call_target_d
2624 HOST_WIDE_INT otr_token
;
2625 ipa_polymorphic_call_context context
;
2627 vec
<cgraph_node
*> targets
;
2634 /* Polymorphic call target cache helpers. */
2636 struct polymorphic_call_target_hasher
2637 : pointer_hash
<polymorphic_call_target_d
>
2639 static inline hashval_t
hash (const polymorphic_call_target_d
*);
2640 static inline bool equal (const polymorphic_call_target_d
*,
2641 const polymorphic_call_target_d
*);
2642 static inline void remove (polymorphic_call_target_d
*);
2645 /* Return the computed hashcode for ODR_QUERY. */
2648 polymorphic_call_target_hasher::hash (const polymorphic_call_target_d
*odr_query
)
2650 inchash::hash
hstate (odr_query
->otr_token
);
2652 hstate
.add_hwi (odr_query
->type
->id
);
2653 hstate
.merge_hash (TYPE_UID (odr_query
->context
.outer_type
));
2654 hstate
.add_hwi (odr_query
->context
.offset
);
2656 if (odr_query
->context
.speculative_outer_type
)
2658 hstate
.merge_hash (TYPE_UID (odr_query
->context
.speculative_outer_type
));
2659 hstate
.add_hwi (odr_query
->context
.speculative_offset
);
2661 hstate
.add_flag (odr_query
->speculative
);
2662 hstate
.add_flag (odr_query
->context
.maybe_in_construction
);
2663 hstate
.add_flag (odr_query
->context
.maybe_derived_type
);
2664 hstate
.add_flag (odr_query
->context
.speculative_maybe_derived_type
);
2665 hstate
.commit_flag ();
2666 return hstate
.end ();
2669 /* Compare cache entries T1 and T2. */
2672 polymorphic_call_target_hasher::equal (const polymorphic_call_target_d
*t1
,
2673 const polymorphic_call_target_d
*t2
)
2675 return (t1
->type
== t2
->type
&& t1
->otr_token
== t2
->otr_token
2676 && t1
->speculative
== t2
->speculative
2677 && t1
->context
.offset
== t2
->context
.offset
2678 && t1
->context
.speculative_offset
== t2
->context
.speculative_offset
2679 && t1
->context
.outer_type
== t2
->context
.outer_type
2680 && t1
->context
.speculative_outer_type
== t2
->context
.speculative_outer_type
2681 && t1
->context
.maybe_in_construction
2682 == t2
->context
.maybe_in_construction
2683 && t1
->context
.maybe_derived_type
== t2
->context
.maybe_derived_type
2684 && (t1
->context
.speculative_maybe_derived_type
2685 == t2
->context
.speculative_maybe_derived_type
));
2688 /* Remove entry in polymorphic call target cache hash. */
2691 polymorphic_call_target_hasher::remove (polymorphic_call_target_d
*v
)
2693 v
->targets
.release ();
2697 /* Polymorphic call target query cache. */
2699 typedef hash_table
<polymorphic_call_target_hasher
>
2700 polymorphic_call_target_hash_type
;
2701 static polymorphic_call_target_hash_type
*polymorphic_call_target_hash
;
2703 /* Destroy polymorphic call target query cache. */
2706 free_polymorphic_call_targets_hash ()
2708 if (cached_polymorphic_call_targets
)
2710 delete polymorphic_call_target_hash
;
2711 polymorphic_call_target_hash
= NULL
;
2712 delete cached_polymorphic_call_targets
;
2713 cached_polymorphic_call_targets
= NULL
;
2717 /* Force rebuilding type inheritance graph from scratch.
2718 This is use to make sure that we do not keep references to types
2719 which was not visible to free_lang_data. */
2722 rebuild_type_inheritance_graph ()
2728 delete odr_vtable_hash
;
2730 odr_vtable_hash
= NULL
;
2731 odr_types_ptr
= NULL
;
2732 free_polymorphic_call_targets_hash ();
2735 /* When virtual function is removed, we may need to flush the cache. */
2738 devirt_node_removal_hook (struct cgraph_node
*n
, void *d ATTRIBUTE_UNUSED
)
2740 if (cached_polymorphic_call_targets
2741 && cached_polymorphic_call_targets
->contains (n
))
2742 free_polymorphic_call_targets_hash ();
2745 /* Look up base of BINFO that has virtual table VTABLE with OFFSET. */
2748 subbinfo_with_vtable_at_offset (tree binfo
, unsigned HOST_WIDE_INT offset
,
2751 tree v
= BINFO_VTABLE (binfo
);
2754 unsigned HOST_WIDE_INT this_offset
;
2758 if (!vtable_pointer_value_to_vtable (v
, &v
, &this_offset
))
2761 if (offset
== this_offset
2762 && DECL_ASSEMBLER_NAME (v
) == DECL_ASSEMBLER_NAME (vtable
))
2766 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
2767 if (polymorphic_type_binfo_p (base_binfo
))
2769 base_binfo
= subbinfo_with_vtable_at_offset (base_binfo
, offset
, vtable
);
2776 /* T is known constant value of virtual table pointer.
2777 Store virtual table to V and its offset to OFFSET.
2778 Return false if T does not look like virtual table reference. */
2781 vtable_pointer_value_to_vtable (const_tree t
, tree
*v
,
2782 unsigned HOST_WIDE_INT
*offset
)
2784 /* We expect &MEM[(void *)&virtual_table + 16B].
2785 We obtain object's BINFO from the context of the virtual table.
2786 This one contains pointer to virtual table represented via
2787 POINTER_PLUS_EXPR. Verify that this pointer matches what
2788 we propagated through.
2790 In the case of virtual inheritance, the virtual tables may
2791 be nested, i.e. the offset may be different from 16 and we may
2792 need to dive into the type representation. */
2793 if (TREE_CODE (t
) == ADDR_EXPR
2794 && TREE_CODE (TREE_OPERAND (t
, 0)) == MEM_REF
2795 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)) == ADDR_EXPR
2796 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 1)) == INTEGER_CST
2797 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 0))
2799 && DECL_VIRTUAL_P (TREE_OPERAND (TREE_OPERAND
2800 (TREE_OPERAND (t
, 0), 0), 0)))
2802 *v
= TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 0);
2803 *offset
= tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (t
, 0), 1));
2807 /* Alternative representation, used by C++ frontend is POINTER_PLUS_EXPR.
2808 We need to handle it when T comes from static variable initializer or
2810 if (TREE_CODE (t
) == POINTER_PLUS_EXPR
)
2812 *offset
= tree_to_uhwi (TREE_OPERAND (t
, 1));
2813 t
= TREE_OPERAND (t
, 0);
2818 if (TREE_CODE (t
) != ADDR_EXPR
)
2820 *v
= TREE_OPERAND (t
, 0);
2824 /* T is known constant value of virtual table pointer. Return BINFO of the
2828 vtable_pointer_value_to_binfo (const_tree t
)
2831 unsigned HOST_WIDE_INT offset
;
2833 if (!vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
2836 /* FIXME: for stores of construction vtables we return NULL,
2837 because we do not have BINFO for those. Eventually we should fix
2838 our representation to allow this case to be handled, too.
2839 In the case we see store of BINFO we however may assume
2840 that standard folding will be able to cope with it. */
2841 return subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable
)),
2845 /* Walk bases of OUTER_TYPE that contain OTR_TYPE at OFFSET.
2846 Look up their respective virtual methods for OTR_TOKEN and OTR_TYPE
2847 and insert them in NODES.
2849 MATCHED_VTABLES and INSERTED is used to avoid duplicated work. */
2852 record_targets_from_bases (tree otr_type
,
2853 HOST_WIDE_INT otr_token
,
2855 HOST_WIDE_INT offset
,
2856 vec
<cgraph_node
*> &nodes
,
2857 hash_set
<tree
> *inserted
,
2858 hash_set
<tree
> *matched_vtables
,
2863 HOST_WIDE_INT pos
, size
;
2867 if (types_same_for_odr (outer_type
, otr_type
))
2870 for (fld
= TYPE_FIELDS (outer_type
); fld
; fld
= DECL_CHAIN (fld
))
2872 if (TREE_CODE (fld
) != FIELD_DECL
)
2875 pos
= int_bit_position (fld
);
2876 size
= tree_to_shwi (DECL_SIZE (fld
));
2877 if (pos
<= offset
&& (pos
+ size
) > offset
2878 /* Do not get confused by zero sized bases. */
2879 && polymorphic_type_binfo_p (TYPE_BINFO (TREE_TYPE (fld
))))
2882 /* Within a class type we should always find corresponding fields. */
2883 gcc_assert (fld
&& TREE_CODE (TREE_TYPE (fld
)) == RECORD_TYPE
);
2885 /* Nonbase types should have been stripped by outer_class_type. */
2886 gcc_assert (DECL_ARTIFICIAL (fld
));
2888 outer_type
= TREE_TYPE (fld
);
2891 base_binfo
= get_binfo_at_offset (TYPE_BINFO (outer_type
),
2895 gcc_assert (odr_violation_reported
);
2898 gcc_assert (base_binfo
);
2899 if (!matched_vtables
->add (BINFO_VTABLE (base_binfo
)))
2902 tree target
= gimple_get_virt_method_for_binfo (otr_token
,
2905 if (!target
|| ! DECL_CXX_DESTRUCTOR_P (target
))
2906 maybe_record_node (nodes
, target
, inserted
, can_refer
, completep
);
2907 matched_vtables
->add (BINFO_VTABLE (base_binfo
));
2912 /* When virtual table is removed, we may need to flush the cache. */
2915 devirt_variable_node_removal_hook (varpool_node
*n
,
2916 void *d ATTRIBUTE_UNUSED
)
2918 if (cached_polymorphic_call_targets
2919 && DECL_VIRTUAL_P (n
->decl
)
2920 && type_in_anonymous_namespace_p (DECL_CONTEXT (n
->decl
)))
2921 free_polymorphic_call_targets_hash ();
2924 /* Record about how many calls would benefit from given type to be final. */
2926 struct odr_type_warn_count
2930 profile_count dyn_count
;
2933 /* Record about how many calls would benefit from given method to be final. */
2935 struct decl_warn_count
2939 profile_count dyn_count
;
2942 /* Information about type and decl warnings. */
2944 struct final_warning_record
2946 /* If needed grow type_warnings vector and initialize new decl_warn_count
2947 to have dyn_count set to profile_count::zero (). */
2948 void grow_type_warnings (unsigned newlen
);
2950 profile_count dyn_count
;
2951 auto_vec
<odr_type_warn_count
> type_warnings
;
2952 hash_map
<tree
, decl_warn_count
> decl_warnings
;
2956 final_warning_record::grow_type_warnings (unsigned newlen
)
2958 unsigned len
= type_warnings
.length ();
2961 type_warnings
.safe_grow_cleared (newlen
);
2962 for (unsigned i
= len
; i
< newlen
; i
++)
2963 type_warnings
[i
].dyn_count
= profile_count::zero ();
2967 struct final_warning_record
*final_warning_records
;
2969 /* Return vector containing possible targets of polymorphic call of type
2970 OTR_TYPE calling method OTR_TOKEN within type of OTR_OUTER_TYPE and OFFSET.
2971 If INCLUDE_BASES is true, walk also base types of OUTER_TYPES containing
2972 OTR_TYPE and include their virtual method. This is useful for types
2973 possibly in construction or destruction where the virtual table may
2974 temporarily change to one of base types. INCLUDE_DERIVER_TYPES make
2975 us to walk the inheritance graph for all derivations.
2977 If COMPLETEP is non-NULL, store true if the list is complete.
2978 CACHE_TOKEN (if non-NULL) will get stored to an unique ID of entry
2979 in the target cache. If user needs to visit every target list
2980 just once, it can memoize them.
2982 If SPECULATIVE is set, the list will not contain targets that
2983 are not speculatively taken.
2985 Returned vector is placed into cache. It is NOT caller's responsibility
2986 to free it. The vector can be freed on cgraph_remove_node call if
2987 the particular node is a virtual function present in the cache. */
2990 possible_polymorphic_call_targets (tree otr_type
,
2991 HOST_WIDE_INT otr_token
,
2992 ipa_polymorphic_call_context context
,
2997 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
2998 vec
<cgraph_node
*> nodes
= vNULL
;
2999 auto_vec
<tree
, 8> bases_to_consider
;
3000 odr_type type
, outer_type
;
3001 polymorphic_call_target_d key
;
3002 polymorphic_call_target_d
**slot
;
3006 bool can_refer
= false;
3007 bool skipped
= false;
3009 otr_type
= TYPE_MAIN_VARIANT (otr_type
);
3011 /* If ODR is not initialized or the context is invalid, return empty
3013 if (!odr_hash
|| context
.invalid
|| !TYPE_BINFO (otr_type
))
3016 *completep
= context
.invalid
;
3018 *cache_token
= NULL
;
3022 /* Do not bother to compute speculative info when user do not asks for it. */
3023 if (!speculative
|| !context
.speculative_outer_type
)
3024 context
.clear_speculation ();
3026 type
= get_odr_type (otr_type
, true);
3028 /* Recording type variants would waste results cache. */
3029 gcc_assert (!context
.outer_type
3030 || TYPE_MAIN_VARIANT (context
.outer_type
) == context
.outer_type
);
3032 /* Look up the outer class type we want to walk.
3033 If we fail to do so, the context is invalid. */
3034 if ((context
.outer_type
|| context
.speculative_outer_type
)
3035 && !context
.restrict_to_inner_class (otr_type
))
3040 *cache_token
= NULL
;
3043 gcc_assert (!context
.invalid
);
3045 /* Check that restrict_to_inner_class kept the main variant. */
3046 gcc_assert (!context
.outer_type
3047 || TYPE_MAIN_VARIANT (context
.outer_type
) == context
.outer_type
);
3049 /* We canonicalize our query, so we do not need extra hashtable entries. */
3051 /* Without outer type, we have no use for offset. Just do the
3052 basic search from inner type. */
3053 if (!context
.outer_type
)
3054 context
.clear_outer_type (otr_type
);
3055 /* We need to update our hierarchy if the type does not exist. */
3056 outer_type
= get_odr_type (context
.outer_type
, true);
3057 /* If the type is complete, there are no derivations. */
3058 if (TYPE_FINAL_P (outer_type
->type
))
3059 context
.maybe_derived_type
= false;
3061 /* Initialize query cache. */
3062 if (!cached_polymorphic_call_targets
)
3064 cached_polymorphic_call_targets
= new hash_set
<cgraph_node
*>;
3065 polymorphic_call_target_hash
3066 = new polymorphic_call_target_hash_type (23);
3067 if (!node_removal_hook_holder
)
3069 node_removal_hook_holder
=
3070 symtab
->add_cgraph_removal_hook (&devirt_node_removal_hook
, NULL
);
3071 symtab
->add_varpool_removal_hook (&devirt_variable_node_removal_hook
,
3078 if (context
.outer_type
!= otr_type
)
3080 = get_odr_type (context
.outer_type
, true)->type
;
3081 if (context
.speculative_outer_type
)
3082 context
.speculative_outer_type
3083 = get_odr_type (context
.speculative_outer_type
, true)->type
;
3086 /* Look up cached answer. */
3088 key
.otr_token
= otr_token
;
3089 key
.speculative
= speculative
;
3090 key
.context
= context
;
3091 slot
= polymorphic_call_target_hash
->find_slot (&key
, INSERT
);
3093 *cache_token
= (void *)*slot
;
3097 *completep
= (*slot
)->complete
;
3098 if ((*slot
)->type_warning
&& final_warning_records
)
3100 final_warning_records
->type_warnings
[(*slot
)->type_warning
- 1].count
++;
3101 if (!final_warning_records
->type_warnings
3102 [(*slot
)->type_warning
- 1].dyn_count
.initialized_p ())
3103 final_warning_records
->type_warnings
3104 [(*slot
)->type_warning
- 1].dyn_count
= profile_count::zero ();
3105 if (final_warning_records
->dyn_count
> 0)
3106 final_warning_records
->type_warnings
[(*slot
)->type_warning
- 1].dyn_count
3107 = final_warning_records
->type_warnings
[(*slot
)->type_warning
- 1].dyn_count
3108 + final_warning_records
->dyn_count
;
3110 if (!speculative
&& (*slot
)->decl_warning
&& final_warning_records
)
3112 struct decl_warn_count
*c
=
3113 final_warning_records
->decl_warnings
.get ((*slot
)->decl_warning
);
3115 if (final_warning_records
->dyn_count
> 0)
3116 c
->dyn_count
+= final_warning_records
->dyn_count
;
3118 return (*slot
)->targets
;
3123 /* Do actual search. */
3124 timevar_push (TV_IPA_VIRTUAL_CALL
);
3125 *slot
= XCNEW (polymorphic_call_target_d
);
3127 *cache_token
= (void *)*slot
;
3128 (*slot
)->type
= type
;
3129 (*slot
)->otr_token
= otr_token
;
3130 (*slot
)->context
= context
;
3131 (*slot
)->speculative
= speculative
;
3133 hash_set
<tree
> inserted
;
3134 hash_set
<tree
> matched_vtables
;
3136 /* First insert targets we speculatively identified as likely. */
3137 if (context
.speculative_outer_type
)
3139 odr_type speculative_outer_type
;
3140 bool speculation_complete
= true;
3142 /* First insert target from type itself and check if it may have
3144 speculative_outer_type
= get_odr_type (context
.speculative_outer_type
, true);
3145 if (TYPE_FINAL_P (speculative_outer_type
->type
))
3146 context
.speculative_maybe_derived_type
= false;
3147 binfo
= get_binfo_at_offset (TYPE_BINFO (speculative_outer_type
->type
),
3148 context
.speculative_offset
, otr_type
);
3150 target
= gimple_get_virt_method_for_binfo (otr_token
, binfo
,
3155 /* In the case we get complete method, we don't need
3156 to walk derivations. */
3157 if (target
&& DECL_FINAL_P (target
))
3158 context
.speculative_maybe_derived_type
= false;
3159 if (type_possibly_instantiated_p (speculative_outer_type
->type
))
3160 maybe_record_node (nodes
, target
, &inserted
, can_refer
, &speculation_complete
);
3162 matched_vtables
.add (BINFO_VTABLE (binfo
));
3165 /* Next walk recursively all derived types. */
3166 if (context
.speculative_maybe_derived_type
)
3167 for (i
= 0; i
< speculative_outer_type
->derived_types
.length(); i
++)
3168 possible_polymorphic_call_targets_1 (nodes
, &inserted
,
3171 speculative_outer_type
->derived_types
[i
],
3172 otr_token
, speculative_outer_type
->type
,
3173 context
.speculative_offset
,
3174 &speculation_complete
,
3179 if (!speculative
|| !nodes
.length ())
3181 /* First see virtual method of type itself. */
3182 binfo
= get_binfo_at_offset (TYPE_BINFO (outer_type
->type
),
3183 context
.offset
, otr_type
);
3185 target
= gimple_get_virt_method_for_binfo (otr_token
, binfo
,
3189 gcc_assert (odr_violation_reported
);
3193 /* Destructors are never called through construction virtual tables,
3194 because the type is always known. */
3195 if (target
&& DECL_CXX_DESTRUCTOR_P (target
))
3196 context
.maybe_in_construction
= false;
3200 /* In the case we get complete method, we don't need
3201 to walk derivations. */
3202 if (DECL_FINAL_P (target
))
3203 context
.maybe_derived_type
= false;
3206 /* If OUTER_TYPE is abstract, we know we are not seeing its instance. */
3207 if (type_possibly_instantiated_p (outer_type
->type
))
3208 maybe_record_node (nodes
, target
, &inserted
, can_refer
, &complete
);
3213 matched_vtables
.add (BINFO_VTABLE (binfo
));
3215 /* Next walk recursively all derived types. */
3216 if (context
.maybe_derived_type
)
3218 for (i
= 0; i
< outer_type
->derived_types
.length(); i
++)
3219 possible_polymorphic_call_targets_1 (nodes
, &inserted
,
3222 outer_type
->derived_types
[i
],
3223 otr_token
, outer_type
->type
,
3224 context
.offset
, &complete
,
3226 context
.maybe_in_construction
);
3228 if (!outer_type
->all_derivations_known
)
3230 if (!speculative
&& final_warning_records
3231 && nodes
.length () == 1
3232 && TREE_CODE (TREE_TYPE (nodes
[0]->decl
)) == METHOD_TYPE
)
3235 && warn_suggest_final_types
3236 && !outer_type
->derived_types
.length ())
3238 final_warning_records
->grow_type_warnings
3240 final_warning_records
->type_warnings
[outer_type
->id
].count
++;
3241 if (!final_warning_records
->type_warnings
3242 [outer_type
->id
].dyn_count
.initialized_p ())
3243 final_warning_records
->type_warnings
3244 [outer_type
->id
].dyn_count
= profile_count::zero ();
3245 final_warning_records
->type_warnings
[outer_type
->id
].dyn_count
3246 += final_warning_records
->dyn_count
;
3247 final_warning_records
->type_warnings
[outer_type
->id
].type
3249 (*slot
)->type_warning
= outer_type
->id
+ 1;
3252 && warn_suggest_final_methods
3253 && types_same_for_odr (DECL_CONTEXT (nodes
[0]->decl
),
3257 struct decl_warn_count
&c
=
3258 final_warning_records
->decl_warnings
.get_or_insert
3259 (nodes
[0]->decl
, &existed
);
3264 c
.dyn_count
+= final_warning_records
->dyn_count
;
3269 c
.dyn_count
= final_warning_records
->dyn_count
;
3270 c
.decl
= nodes
[0]->decl
;
3272 (*slot
)->decl_warning
= nodes
[0]->decl
;
3281 /* Destructors are never called through construction virtual tables,
3282 because the type is always known. One of entries may be
3283 cxa_pure_virtual so look to at least two of them. */
3284 if (context
.maybe_in_construction
)
3285 for (i
=0 ; i
< MIN (nodes
.length (), 2); i
++)
3286 if (DECL_CXX_DESTRUCTOR_P (nodes
[i
]->decl
))
3287 context
.maybe_in_construction
= false;
3288 if (context
.maybe_in_construction
)
3290 if (type
!= outer_type
3292 || (context
.maybe_derived_type
3293 && !type_all_derivations_known_p (outer_type
->type
))))
3294 record_targets_from_bases (otr_type
, otr_token
, outer_type
->type
,
3295 context
.offset
, nodes
, &inserted
,
3296 &matched_vtables
, &complete
);
3298 maybe_record_node (nodes
, target
, &inserted
, can_refer
, &complete
);
3299 for (i
= 0; i
< bases_to_consider
.length(); i
++)
3300 maybe_record_node (nodes
, bases_to_consider
[i
], &inserted
, can_refer
, &complete
);
3305 (*slot
)->targets
= nodes
;
3306 (*slot
)->complete
= complete
;
3308 *completep
= complete
;
3310 timevar_pop (TV_IPA_VIRTUAL_CALL
);
3315 add_decl_warning (const tree
&key ATTRIBUTE_UNUSED
, const decl_warn_count
&value
,
3316 vec
<const decl_warn_count
*> *vec
)
3318 vec
->safe_push (&value
);
3322 /* Dump target list TARGETS into FILE. */
3325 dump_targets (FILE *f
, vec
<cgraph_node
*> targets
)
3329 for (i
= 0; i
< targets
.length (); i
++)
3333 name
= cplus_demangle_v3 (targets
[i
]->asm_name (), 0);
3334 fprintf (f
, " %s/%i", name
? name
: targets
[i
]->name (),
3338 if (!targets
[i
]->definition
)
3339 fprintf (f
, " (no definition%s)",
3340 DECL_DECLARED_INLINE_P (targets
[i
]->decl
)
3346 /* Dump all possible targets of a polymorphic call. */
3349 dump_possible_polymorphic_call_targets (FILE *f
,
3351 HOST_WIDE_INT otr_token
,
3352 const ipa_polymorphic_call_context
&ctx
)
3354 vec
<cgraph_node
*> targets
;
3356 odr_type type
= get_odr_type (TYPE_MAIN_VARIANT (otr_type
), false);
3361 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
,
3363 &final
, NULL
, false);
3364 fprintf (f
, " Targets of polymorphic call of type %i:", type
->id
);
3365 print_generic_expr (f
, type
->type
, TDF_SLIM
);
3366 fprintf (f
, " token %i\n", (int)otr_token
);
3370 fprintf (f
, " %s%s%s%s\n ",
3371 final
? "This is a complete list." :
3372 "This is partial list; extra targets may be defined in other units.",
3373 ctx
.maybe_in_construction
? " (base types included)" : "",
3374 ctx
.maybe_derived_type
? " (derived types included)" : "",
3375 ctx
.speculative_maybe_derived_type
? " (speculative derived types included)" : "");
3376 len
= targets
.length ();
3377 dump_targets (f
, targets
);
3379 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
,
3381 &final
, NULL
, true);
3382 if (targets
.length () != len
)
3384 fprintf (f
, " Speculative targets:");
3385 dump_targets (f
, targets
);
3387 /* Ugly: during callgraph construction the target cache may get populated
3388 before all targets are found. While this is harmless (because all local
3389 types are discovered and only in those case we devirtualize fully and we
3390 don't do speculative devirtualization before IPA stage) it triggers
3391 assert here when dumping at that stage also populates the case with
3392 speculative targets. Quietly ignore this. */
3393 gcc_assert (symtab
->state
< IPA_SSA
|| targets
.length () <= len
);
3398 /* Return true if N can be possibly target of a polymorphic call of
3399 OTR_TYPE/OTR_TOKEN. */
3402 possible_polymorphic_call_target_p (tree otr_type
,
3403 HOST_WIDE_INT otr_token
,
3404 const ipa_polymorphic_call_context
&ctx
,
3405 struct cgraph_node
*n
)
3407 vec
<cgraph_node
*> targets
;
3409 enum built_in_function fcode
;
3412 if (TREE_CODE (TREE_TYPE (n
->decl
)) == FUNCTION_TYPE
3413 && ((fcode
= DECL_FUNCTION_CODE (n
->decl
)) == BUILT_IN_UNREACHABLE
3414 || fcode
== BUILT_IN_TRAP
))
3417 if (is_cxa_pure_virtual_p (n
->decl
))
3422 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
, ctx
, &final
);
3423 for (i
= 0; i
< targets
.length (); i
++)
3424 if (n
->semantically_equivalent_p (targets
[i
]))
3427 /* At a moment we allow middle end to dig out new external declarations
3428 as a targets of polymorphic calls. */
3429 if (!final
&& !n
->definition
)
3436 /* Return true if N can be possibly target of a polymorphic call of
3437 OBJ_TYPE_REF expression REF in STMT. */
3440 possible_polymorphic_call_target_p (tree ref
,
3442 struct cgraph_node
*n
)
3444 ipa_polymorphic_call_context
context (current_function_decl
, ref
, stmt
);
3445 tree call_fn
= gimple_call_fn (stmt
);
3447 return possible_polymorphic_call_target_p (obj_type_ref_class (call_fn
),
3449 (OBJ_TYPE_REF_TOKEN (call_fn
)),
3455 /* After callgraph construction new external nodes may appear.
3456 Add them into the graph. */
3459 update_type_inheritance_graph (void)
3461 struct cgraph_node
*n
;
3465 free_polymorphic_call_targets_hash ();
3466 timevar_push (TV_IPA_INHERITANCE
);
3467 /* We reconstruct the graph starting from types of all methods seen in the
3469 FOR_EACH_FUNCTION (n
)
3470 if (DECL_VIRTUAL_P (n
->decl
)
3472 && n
->real_symbol_p ())
3473 get_odr_type (TYPE_METHOD_BASETYPE (TREE_TYPE (n
->decl
)), true);
3474 timevar_pop (TV_IPA_INHERITANCE
);
3478 /* Return true if N looks like likely target of a polymorphic call.
3479 Rule out cxa_pure_virtual, noreturns, function declared cold and
3480 other obvious cases. */
3483 likely_target_p (struct cgraph_node
*n
)
3486 /* cxa_pure_virtual and similar things are not likely. */
3487 if (TREE_CODE (TREE_TYPE (n
->decl
)) != METHOD_TYPE
)
3489 flags
= flags_from_decl_or_type (n
->decl
);
3490 if (flags
& ECF_NORETURN
)
3492 if (lookup_attribute ("cold",
3493 DECL_ATTRIBUTES (n
->decl
)))
3495 if (n
->frequency
< NODE_FREQUENCY_NORMAL
)
3497 /* If there are no live virtual tables referring the target,
3498 the only way the target can be called is an instance coming from other
3499 compilation unit; speculative devirtualization is built around an
3500 assumption that won't happen. */
3501 if (!referenced_from_vtable_p (n
))
3506 /* Compare type warning records P1 and P2 and choose one with larger count;
3507 helper for qsort. */
3510 type_warning_cmp (const void *p1
, const void *p2
)
3512 const odr_type_warn_count
*t1
= (const odr_type_warn_count
*)p1
;
3513 const odr_type_warn_count
*t2
= (const odr_type_warn_count
*)p2
;
3515 if (t1
->dyn_count
< t2
->dyn_count
)
3517 if (t1
->dyn_count
> t2
->dyn_count
)
3519 return t2
->count
- t1
->count
;
3522 /* Compare decl warning records P1 and P2 and choose one with larger count;
3523 helper for qsort. */
3526 decl_warning_cmp (const void *p1
, const void *p2
)
3528 const decl_warn_count
*t1
= *(const decl_warn_count
* const *)p1
;
3529 const decl_warn_count
*t2
= *(const decl_warn_count
* const *)p2
;
3531 if (t1
->dyn_count
< t2
->dyn_count
)
3533 if (t1
->dyn_count
> t2
->dyn_count
)
3535 return t2
->count
- t1
->count
;
3539 /* Try to speculatively devirtualize call to OTR_TYPE with OTR_TOKEN with
3542 struct cgraph_node
*
3543 try_speculative_devirtualization (tree otr_type
, HOST_WIDE_INT otr_token
,
3544 ipa_polymorphic_call_context ctx
)
3546 vec
<cgraph_node
*>targets
3547 = possible_polymorphic_call_targets
3548 (otr_type
, otr_token
, ctx
, NULL
, NULL
, true);
3550 struct cgraph_node
*likely_target
= NULL
;
3552 for (i
= 0; i
< targets
.length (); i
++)
3553 if (likely_target_p (targets
[i
]))
3557 likely_target
= targets
[i
];
3560 ||!likely_target
->definition
3561 || DECL_EXTERNAL (likely_target
->decl
))
3564 /* Don't use an implicitly-declared destructor (c++/58678). */
3565 struct cgraph_node
*non_thunk_target
3566 = likely_target
->function_symbol ();
3567 if (DECL_ARTIFICIAL (non_thunk_target
->decl
))
3569 if (likely_target
->get_availability () <= AVAIL_INTERPOSABLE
3570 && likely_target
->can_be_discarded_p ())
3572 return likely_target
;
3575 /* The ipa-devirt pass.
3576 When polymorphic call has only one likely target in the unit,
3577 turn it into a speculative call. */
3582 struct cgraph_node
*n
;
3583 hash_set
<void *> bad_call_targets
;
3584 struct cgraph_edge
*e
;
3586 int npolymorphic
= 0, nspeculated
= 0, nconverted
= 0, ncold
= 0;
3587 int nmultiple
= 0, noverwritable
= 0, ndevirtualized
= 0, nnotdefined
= 0;
3588 int nwrong
= 0, nok
= 0, nexternal
= 0, nartificial
= 0;
3595 dump_type_inheritance_graph (dump_file
);
3597 /* We can output -Wsuggest-final-methods and -Wsuggest-final-types warnings.
3598 This is implemented by setting up final_warning_records that are updated
3599 by get_polymorphic_call_targets.
3600 We need to clear cache in this case to trigger recomputation of all
3602 if (warn_suggest_final_methods
|| warn_suggest_final_types
)
3604 final_warning_records
= new (final_warning_record
);
3605 final_warning_records
->dyn_count
= profile_count::zero ();
3606 final_warning_records
->grow_type_warnings (odr_types
.length ());
3607 free_polymorphic_call_targets_hash ();
3610 FOR_EACH_DEFINED_FUNCTION (n
)
3612 bool update
= false;
3613 if (!opt_for_fn (n
->decl
, flag_devirtualize
))
3615 if (dump_file
&& n
->indirect_calls
)
3616 fprintf (dump_file
, "\n\nProcesing function %s\n",
3618 for (e
= n
->indirect_calls
; e
; e
= e
->next_callee
)
3619 if (e
->indirect_info
->polymorphic
)
3621 struct cgraph_node
*likely_target
= NULL
;
3625 if (final_warning_records
)
3626 final_warning_records
->dyn_count
= e
->count
.ipa ();
3628 vec
<cgraph_node
*>targets
3629 = possible_polymorphic_call_targets
3630 (e
, &final
, &cache_token
, true);
3633 /* Trigger warnings by calculating non-speculative targets. */
3634 if (warn_suggest_final_methods
|| warn_suggest_final_types
)
3635 possible_polymorphic_call_targets (e
);
3638 dump_possible_polymorphic_call_targets
3643 /* See if the call can be devirtualized by means of ipa-prop's
3644 polymorphic call context propagation. If not, we can just
3645 forget about this call being polymorphic and avoid some heavy
3646 lifting in remove_unreachable_nodes that will otherwise try to
3647 keep all possible targets alive until inlining and in the inliner
3650 This may need to be revisited once we add further ways to use
3651 the may edges, but it is a resonable thing to do right now. */
3653 if ((e
->indirect_info
->param_index
== -1
3654 || (!opt_for_fn (n
->decl
, flag_devirtualize_speculatively
)
3655 && e
->indirect_info
->vptr_changed
))
3656 && !flag_ltrans_devirtualize
)
3658 e
->indirect_info
->polymorphic
= false;
3661 fprintf (dump_file
, "Dropping polymorphic call info;"
3662 " it can not be used by ipa-prop\n");
3665 if (!opt_for_fn (n
->decl
, flag_devirtualize_speculatively
))
3668 if (!e
->maybe_hot_p ())
3671 fprintf (dump_file
, "Call is cold\n\n");
3678 fprintf (dump_file
, "Call is already speculated\n\n");
3681 /* When dumping see if we agree with speculation. */
3685 if (bad_call_targets
.contains (cache_token
))
3688 fprintf (dump_file
, "Target list is known to be useless\n\n");
3692 for (i
= 0; i
< targets
.length (); i
++)
3693 if (likely_target_p (targets
[i
]))
3697 likely_target
= NULL
;
3699 fprintf (dump_file
, "More than one likely target\n\n");
3703 likely_target
= targets
[i
];
3707 bad_call_targets
.add (cache_token
);
3710 /* This is reached only when dumping; check if we agree or disagree
3711 with the speculation. */
3714 struct cgraph_edge
*e2
;
3715 struct ipa_ref
*ref
;
3716 e
->speculative_call_info (e2
, e
, ref
);
3717 if (e2
->callee
->ultimate_alias_target ()
3718 == likely_target
->ultimate_alias_target ())
3720 fprintf (dump_file
, "We agree with speculation\n\n");
3725 fprintf (dump_file
, "We disagree with speculation\n\n");
3730 if (!likely_target
->definition
)
3733 fprintf (dump_file
, "Target is not a definition\n\n");
3737 /* Do not introduce new references to external symbols. While we
3738 can handle these just well, it is common for programs to
3739 incorrectly with headers defining methods they are linked
3741 if (DECL_EXTERNAL (likely_target
->decl
))
3744 fprintf (dump_file
, "Target is external\n\n");
3748 /* Don't use an implicitly-declared destructor (c++/58678). */
3749 struct cgraph_node
*non_thunk_target
3750 = likely_target
->function_symbol ();
3751 if (DECL_ARTIFICIAL (non_thunk_target
->decl
))
3754 fprintf (dump_file
, "Target is artificial\n\n");
3758 if (likely_target
->get_availability () <= AVAIL_INTERPOSABLE
3759 && likely_target
->can_be_discarded_p ())
3762 fprintf (dump_file
, "Target is overwritable\n\n");
3766 else if (dbg_cnt (devirt
))
3768 if (dump_enabled_p ())
3770 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, e
->call_stmt
,
3771 "speculatively devirtualizing call "
3774 likely_target
->dump_name ());
3776 if (!likely_target
->can_be_discarded_p ())
3779 alias
= dyn_cast
<cgraph_node
*> (likely_target
->noninterposable_alias ());
3781 likely_target
= alias
;
3786 (likely_target
, e
->count
.apply_scale (8, 10));
3790 ipa_update_overall_fn_summary (n
);
3792 if (warn_suggest_final_methods
|| warn_suggest_final_types
)
3794 if (warn_suggest_final_types
)
3796 final_warning_records
->type_warnings
.qsort (type_warning_cmp
);
3797 for (unsigned int i
= 0;
3798 i
< final_warning_records
->type_warnings
.length (); i
++)
3799 if (final_warning_records
->type_warnings
[i
].count
)
3801 tree type
= final_warning_records
->type_warnings
[i
].type
;
3802 int count
= final_warning_records
->type_warnings
[i
].count
;
3803 profile_count dyn_count
3804 = final_warning_records
->type_warnings
[i
].dyn_count
;
3806 if (!(dyn_count
> 0))
3807 warning_n (DECL_SOURCE_LOCATION (TYPE_NAME (type
)),
3808 OPT_Wsuggest_final_types
, count
,
3809 "Declaring type %qD final "
3810 "would enable devirtualization of %i call",
3811 "Declaring type %qD final "
3812 "would enable devirtualization of %i calls",
3816 warning_n (DECL_SOURCE_LOCATION (TYPE_NAME (type
)),
3817 OPT_Wsuggest_final_types
, count
,
3818 "Declaring type %qD final "
3819 "would enable devirtualization of %i call "
3820 "executed %lli times",
3821 "Declaring type %qD final "
3822 "would enable devirtualization of %i calls "
3823 "executed %lli times",
3826 (long long) dyn_count
.to_gcov_type ());
3830 if (warn_suggest_final_methods
)
3832 auto_vec
<const decl_warn_count
*> decl_warnings_vec
;
3834 final_warning_records
->decl_warnings
.traverse
3835 <vec
<const decl_warn_count
*> *, add_decl_warning
> (&decl_warnings_vec
);
3836 decl_warnings_vec
.qsort (decl_warning_cmp
);
3837 for (unsigned int i
= 0; i
< decl_warnings_vec
.length (); i
++)
3839 tree decl
= decl_warnings_vec
[i
]->decl
;
3840 int count
= decl_warnings_vec
[i
]->count
;
3841 profile_count dyn_count
3842 = decl_warnings_vec
[i
]->dyn_count
;
3844 if (!(dyn_count
> 0))
3845 if (DECL_CXX_DESTRUCTOR_P (decl
))
3846 warning_n (DECL_SOURCE_LOCATION (decl
),
3847 OPT_Wsuggest_final_methods
, count
,
3848 "Declaring virtual destructor of %qD final "
3849 "would enable devirtualization of %i call",
3850 "Declaring virtual destructor of %qD final "
3851 "would enable devirtualization of %i calls",
3852 DECL_CONTEXT (decl
), count
);
3854 warning_n (DECL_SOURCE_LOCATION (decl
),
3855 OPT_Wsuggest_final_methods
, count
,
3856 "Declaring method %qD final "
3857 "would enable devirtualization of %i call",
3858 "Declaring method %qD final "
3859 "would enable devirtualization of %i calls",
3861 else if (DECL_CXX_DESTRUCTOR_P (decl
))
3862 warning_n (DECL_SOURCE_LOCATION (decl
),
3863 OPT_Wsuggest_final_methods
, count
,
3864 "Declaring virtual destructor of %qD final "
3865 "would enable devirtualization of %i call "
3866 "executed %lli times",
3867 "Declaring virtual destructor of %qD final "
3868 "would enable devirtualization of %i calls "
3869 "executed %lli times",
3870 DECL_CONTEXT (decl
), count
,
3871 (long long)dyn_count
.to_gcov_type ());
3873 warning_n (DECL_SOURCE_LOCATION (decl
),
3874 OPT_Wsuggest_final_methods
, count
,
3875 "Declaring method %qD final "
3876 "would enable devirtualization of %i call "
3877 "executed %lli times",
3878 "Declaring method %qD final "
3879 "would enable devirtualization of %i calls "
3880 "executed %lli times",
3882 (long long)dyn_count
.to_gcov_type ());
3886 delete (final_warning_records
);
3887 final_warning_records
= 0;
3892 "%i polymorphic calls, %i devirtualized,"
3893 " %i speculatively devirtualized, %i cold\n"
3894 "%i have multiple targets, %i overwritable,"
3895 " %i already speculated (%i agree, %i disagree),"
3896 " %i external, %i not defined, %i artificial, %i infos dropped\n",
3897 npolymorphic
, ndevirtualized
, nconverted
, ncold
,
3898 nmultiple
, noverwritable
, nspeculated
, nok
, nwrong
,
3899 nexternal
, nnotdefined
, nartificial
, ndropped
);
3900 return ndevirtualized
|| ndropped
? TODO_remove_functions
: 0;
3905 const pass_data pass_data_ipa_devirt
=
3907 IPA_PASS
, /* type */
3908 "devirt", /* name */
3909 OPTGROUP_NONE
, /* optinfo_flags */
3910 TV_IPA_DEVIRT
, /* tv_id */
3911 0, /* properties_required */
3912 0, /* properties_provided */
3913 0, /* properties_destroyed */
3914 0, /* todo_flags_start */
3915 ( TODO_dump_symtab
), /* todo_flags_finish */
3918 class pass_ipa_devirt
: public ipa_opt_pass_d
3921 pass_ipa_devirt (gcc::context
*ctxt
)
3922 : ipa_opt_pass_d (pass_data_ipa_devirt
, ctxt
,
3923 NULL
, /* generate_summary */
3924 NULL
, /* write_summary */
3925 NULL
, /* read_summary */
3926 NULL
, /* write_optimization_summary */
3927 NULL
, /* read_optimization_summary */
3928 NULL
, /* stmt_fixup */
3929 0, /* function_transform_todo_flags_start */
3930 NULL
, /* function_transform */
3931 NULL
) /* variable_transform */
3934 /* opt_pass methods: */
3935 virtual bool gate (function
*)
3937 /* In LTO, always run the IPA passes and decide on function basis if the
3941 return (flag_devirtualize
3942 && (flag_devirtualize_speculatively
3943 || (warn_suggest_final_methods
3944 || warn_suggest_final_types
))
3948 virtual unsigned int execute (function
*) { return ipa_devirt (); }
3950 }; // class pass_ipa_devirt
3955 make_pass_ipa_devirt (gcc::context
*ctxt
)
3957 return new pass_ipa_devirt (ctxt
);
3960 #include "gt-ipa-devirt.h"