mklog: add subject line skeleton
[official-gcc.git] / gcc / ipa-devirt.c
blob8cd1100aba986234f563a22366d0ef876919c97f
1 /* Basic IPA utilities for type inheritance graph construction and
2 devirtualization.
3 Copyright (C) 2013-2021 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
11 version.
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
16 for more details.
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/>. */
22 /* Brief vocabulary:
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.
39 OTR = OBJ_TYPE_REF
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.
45 BINFO
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
52 BINFO_VTABLE.
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
70 base type.
72 token
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.
82 What we do here:
84 build_type_inheritance_graph triggers a construction of the type inheritance
85 graph.
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.
100 Adding this is easy.
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.
108 #include "config.h"
109 #include "system.h"
110 #include "coretypes.h"
111 #include "backend.h"
112 #include "rtl.h"
113 #include "tree.h"
114 #include "gimple.h"
115 #include "alloc-pool.h"
116 #include "tree-pass.h"
117 #include "cgraph.h"
118 #include "lto-streamer.h"
119 #include "fold-const.h"
120 #include "print-tree.h"
121 #include "calls.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"
129 #include "dbgcnt.h"
130 #include "gimple-pretty-print.h"
131 #include "intl.h"
132 #include "stringpool.h"
133 #include "attribs.h"
134 #include "data-streamer.h"
135 #include "lto-streamer.h"
136 #include "streamer-hooks.h"
138 /* Hash based set of pairs of types. */
139 struct type_pair
141 tree first;
142 tree second;
145 template <>
146 struct default_hash_traits <type_pair>
147 : typed_noop_remove <type_pair>
149 GTY((skip)) typedef type_pair value_type;
150 GTY((skip)) typedef type_pair compare_type;
151 static hashval_t
152 hash (type_pair p)
154 return TYPE_UID (p.first) ^ TYPE_UID (p.second);
156 static const bool empty_zero_p = true;
157 static bool
158 is_empty (type_pair p)
160 return p.first == NULL;
162 static bool
163 is_deleted (type_pair p ATTRIBUTE_UNUSED)
165 return false;
167 static bool
168 equal (const type_pair &a, const type_pair &b)
170 return a.first==b.first && a.second == b.second;
172 static void
173 mark_empty (type_pair &e)
175 e.first = NULL;
179 /* HACK alert: this is used to communicate with ipa-inline-transform that
180 thunk is being expanded and there is no need to clear the polymorphic
181 call target cache. */
182 bool thunk_expansion;
184 static bool odr_types_equivalent_p (tree, tree, bool, bool *,
185 hash_set<type_pair> *,
186 location_t, location_t);
187 static void warn_odr (tree t1, tree t2, tree st1, tree st2,
188 bool warn, bool *warned, const char *reason);
190 static bool odr_violation_reported = false;
193 /* Pointer set of all call targets appearing in the cache. */
194 static hash_set<cgraph_node *> *cached_polymorphic_call_targets;
196 /* The node of type inheritance graph. For each type unique in
197 One Definition Rule (ODR) sense, we produce one node linking all
198 main variants of types equivalent to it, bases and derived types. */
200 struct GTY(()) odr_type_d
202 /* leader type. */
203 tree type;
204 /* All bases; built only for main variants of types. */
205 vec<odr_type> GTY((skip)) bases;
206 /* All derived types with virtual methods seen in unit;
207 built only for main variants of types. */
208 vec<odr_type> GTY((skip)) derived_types;
210 /* All equivalent types, if more than one. */
211 vec<tree, va_gc> *types;
212 /* Set of all equivalent types, if NON-NULL. */
213 hash_set<tree> * GTY((skip)) types_set;
215 /* Unique ID indexing the type in odr_types array. */
216 int id;
217 /* Is it in anonymous namespace? */
218 bool anonymous_namespace;
219 /* Do we know about all derivations of given type? */
220 bool all_derivations_known;
221 /* Did we report ODR violation here? */
222 bool odr_violated;
223 /* Set when virtual table without RTTI prevailed table with. */
224 bool rtti_broken;
225 /* Set when the canonical type is determined using the type name. */
226 bool tbaa_enabled;
229 /* Return TRUE if all derived types of T are known and thus
230 we may consider the walk of derived type complete.
232 This is typically true only for final anonymous namespace types and types
233 defined within functions (that may be COMDAT and thus shared across units,
234 but with the same set of derived types). */
236 bool
237 type_all_derivations_known_p (const_tree t)
239 if (TYPE_FINAL_P (t))
240 return true;
241 if (flag_ltrans)
242 return false;
243 /* Non-C++ types may have IDENTIFIER_NODE here, do not crash. */
244 if (!TYPE_NAME (t) || TREE_CODE (TYPE_NAME (t)) != TYPE_DECL)
245 return true;
246 if (type_in_anonymous_namespace_p (t))
247 return true;
248 return (decl_function_context (TYPE_NAME (t)) != NULL);
251 /* Return TRUE if type's constructors are all visible. */
253 static bool
254 type_all_ctors_visible_p (tree t)
256 return !flag_ltrans
257 && symtab->state >= CONSTRUCTION
258 /* We cannot always use type_all_derivations_known_p.
259 For function local types we must assume case where
260 the function is COMDAT and shared in between units.
262 TODO: These cases are quite easy to get, but we need
263 to keep track of C++ privatizing via -Wno-weak
264 as well as the IPA privatizing. */
265 && type_in_anonymous_namespace_p (t);
268 /* Return TRUE if type may have instance. */
270 static bool
271 type_possibly_instantiated_p (tree t)
273 tree vtable;
274 varpool_node *vnode;
276 /* TODO: Add abstract types here. */
277 if (!type_all_ctors_visible_p (t))
278 return true;
280 vtable = BINFO_VTABLE (TYPE_BINFO (t));
281 if (TREE_CODE (vtable) == POINTER_PLUS_EXPR)
282 vtable = TREE_OPERAND (TREE_OPERAND (vtable, 0), 0);
283 vnode = varpool_node::get (vtable);
284 return vnode && vnode->definition;
287 /* Hash used to unify ODR types based on their mangled name and for anonymous
288 namespace types. */
290 struct odr_name_hasher : pointer_hash <odr_type_d>
292 typedef union tree_node *compare_type;
293 static inline hashval_t hash (const odr_type_d *);
294 static inline bool equal (const odr_type_d *, const tree_node *);
295 static inline void remove (odr_type_d *);
298 static bool
299 can_be_name_hashed_p (tree t)
301 return (!in_lto_p || odr_type_p (t));
304 /* Hash type by its ODR name. */
306 static hashval_t
307 hash_odr_name (const_tree t)
309 gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);
311 /* If not in LTO, all main variants are unique, so we can do
312 pointer hash. */
313 if (!in_lto_p)
314 return htab_hash_pointer (t);
316 /* Anonymous types are unique. */
317 if (type_with_linkage_p (t) && type_in_anonymous_namespace_p (t))
318 return htab_hash_pointer (t);
320 gcc_checking_assert (TYPE_NAME (t)
321 && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t)));
322 return IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (TYPE_NAME (t)));
325 /* Return the computed hashcode for ODR_TYPE. */
327 inline hashval_t
328 odr_name_hasher::hash (const odr_type_d *odr_type)
330 return hash_odr_name (odr_type->type);
333 /* For languages with One Definition Rule, work out if
334 types are the same based on their name.
336 This is non-trivial for LTO where minor differences in
337 the type representation may have prevented type merging
338 to merge two copies of otherwise equivalent type.
340 Until we start streaming mangled type names, this function works
341 only for polymorphic types.
344 bool
345 types_same_for_odr (const_tree type1, const_tree type2)
347 gcc_checking_assert (TYPE_P (type1) && TYPE_P (type2));
349 type1 = TYPE_MAIN_VARIANT (type1);
350 type2 = TYPE_MAIN_VARIANT (type2);
352 if (type1 == type2)
353 return true;
355 if (!in_lto_p)
356 return false;
358 /* Anonymous namespace types are never duplicated. */
359 if ((type_with_linkage_p (type1) && type_in_anonymous_namespace_p (type1))
360 || (type_with_linkage_p (type2) && type_in_anonymous_namespace_p (type2)))
361 return false;
363 /* If both type has mangled defined check if they are same.
364 Watch for anonymous types which are all mangled as "<anon">. */
365 if (!type_with_linkage_p (type1) || !type_with_linkage_p (type2))
366 return false;
367 if (type_in_anonymous_namespace_p (type1)
368 || type_in_anonymous_namespace_p (type2))
369 return false;
370 return (DECL_ASSEMBLER_NAME (TYPE_NAME (type1))
371 == DECL_ASSEMBLER_NAME (TYPE_NAME (type2)));
374 /* Return true if we can decide on ODR equivalency.
376 In non-LTO it is always decide, in LTO however it depends in the type has
377 ODR info attached. */
379 bool
380 types_odr_comparable (tree t1, tree t2)
382 return (!in_lto_p
383 || TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)
384 || (odr_type_p (TYPE_MAIN_VARIANT (t1))
385 && odr_type_p (TYPE_MAIN_VARIANT (t2))));
388 /* Return true if T1 and T2 are ODR equivalent. If ODR equivalency is not
389 known, be conservative and return false. */
391 bool
392 types_must_be_same_for_odr (tree t1, tree t2)
394 if (types_odr_comparable (t1, t2))
395 return types_same_for_odr (t1, t2);
396 else
397 return TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2);
400 /* If T is compound type, return type it is based on. */
402 static tree
403 compound_type_base (const_tree t)
405 if (TREE_CODE (t) == ARRAY_TYPE
406 || POINTER_TYPE_P (t)
407 || TREE_CODE (t) == COMPLEX_TYPE
408 || VECTOR_TYPE_P (t))
409 return TREE_TYPE (t);
410 if (TREE_CODE (t) == METHOD_TYPE)
411 return TYPE_METHOD_BASETYPE (t);
412 if (TREE_CODE (t) == OFFSET_TYPE)
413 return TYPE_OFFSET_BASETYPE (t);
414 return NULL_TREE;
417 /* Return true if T is either ODR type or compound type based from it.
418 If the function return true, we know that T is a type originating from C++
419 source even at link-time. */
421 bool
422 odr_or_derived_type_p (const_tree t)
426 if (odr_type_p (TYPE_MAIN_VARIANT (t)))
427 return true;
428 /* Function type is a tricky one. Basically we can consider it
429 ODR derived if return type or any of the parameters is.
430 We need to check all parameters because LTO streaming merges
431 common types (such as void) and they are not considered ODR then. */
432 if (TREE_CODE (t) == FUNCTION_TYPE)
434 if (TYPE_METHOD_BASETYPE (t))
435 t = TYPE_METHOD_BASETYPE (t);
436 else
438 if (TREE_TYPE (t) && odr_or_derived_type_p (TREE_TYPE (t)))
439 return true;
440 for (t = TYPE_ARG_TYPES (t); t; t = TREE_CHAIN (t))
441 if (odr_or_derived_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (t))))
442 return true;
443 return false;
446 else
447 t = compound_type_base (t);
449 while (t);
450 return t;
453 /* Compare types T1 and T2 and return true if they are
454 equivalent. */
456 inline bool
457 odr_name_hasher::equal (const odr_type_d *o1, const tree_node *t2)
459 tree t1 = o1->type;
461 gcc_checking_assert (TYPE_MAIN_VARIANT (t2) == t2);
462 gcc_checking_assert (TYPE_MAIN_VARIANT (t1) == t1);
463 if (t1 == t2)
464 return true;
465 if (!in_lto_p)
466 return false;
467 /* Check for anonymous namespaces. */
468 if ((type_with_linkage_p (t1) && type_in_anonymous_namespace_p (t1))
469 || (type_with_linkage_p (t2) && type_in_anonymous_namespace_p (t2)))
470 return false;
471 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t1)));
472 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t2)));
473 return (DECL_ASSEMBLER_NAME (TYPE_NAME (t1))
474 == DECL_ASSEMBLER_NAME (TYPE_NAME (t2)));
477 /* Free ODR type V. */
479 inline void
480 odr_name_hasher::remove (odr_type_d *v)
482 v->bases.release ();
483 v->derived_types.release ();
484 if (v->types_set)
485 delete v->types_set;
486 ggc_free (v);
489 /* ODR type hash used to look up ODR type based on tree type node. */
491 typedef hash_table<odr_name_hasher> odr_hash_type;
492 static odr_hash_type *odr_hash;
494 /* ODR types are also stored into ODR_TYPE vector to allow consistent
495 walking. Bases appear before derived types. Vector is garbage collected
496 so we won't end up visiting empty types. */
498 static GTY(()) vec <odr_type, va_gc> *odr_types_ptr;
499 #define odr_types (*odr_types_ptr)
501 /* All enums defined and accessible for the unit. */
502 static GTY(()) vec <tree, va_gc> *odr_enums;
504 /* Information we hold about value defined by an enum type. */
505 struct odr_enum_val
507 const char *name;
508 wide_int val;
509 location_t locus;
512 /* Information about enum values. */
513 struct odr_enum
515 location_t locus;
516 auto_vec<odr_enum_val, 0> vals;
517 bool warned;
520 /* A table of all ODR enum definitions. */
521 static hash_map <nofree_string_hash, odr_enum> *odr_enum_map = NULL;
522 static struct obstack odr_enum_obstack;
524 /* Set TYPE_BINFO of TYPE and its variants to BINFO. */
525 void
526 set_type_binfo (tree type, tree binfo)
528 for (; type; type = TYPE_NEXT_VARIANT (type))
529 if (COMPLETE_TYPE_P (type))
530 TYPE_BINFO (type) = binfo;
531 else
532 gcc_assert (!TYPE_BINFO (type));
535 /* Return true if type variants match.
536 This assumes that we already verified that T1 and T2 are variants of the
537 same type. */
539 static bool
540 type_variants_equivalent_p (tree t1, tree t2)
542 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
543 return false;
545 if (comp_type_attributes (t1, t2) != 1)
546 return false;
548 if (COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2)
549 && TYPE_ALIGN (t1) != TYPE_ALIGN (t2))
550 return false;
552 return true;
555 /* Compare T1 and T2 based on name or structure. */
557 static bool
558 odr_subtypes_equivalent_p (tree t1, tree t2,
559 hash_set<type_pair> *visited,
560 location_t loc1, location_t loc2)
563 /* This can happen in incomplete types that should be handled earlier. */
564 gcc_assert (t1 && t2);
566 if (t1 == t2)
567 return true;
569 /* Anonymous namespace types must match exactly. */
570 if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1))
571 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1)))
572 || (type_with_linkage_p (TYPE_MAIN_VARIANT (t2))
573 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2))))
574 return false;
576 /* For ODR types be sure to compare their names.
577 To support -Wno-odr-type-merging we allow one type to be non-ODR
578 and other ODR even though it is a violation. */
579 if (types_odr_comparable (t1, t2))
581 if (t1 != t2
582 && odr_type_p (TYPE_MAIN_VARIANT (t1))
583 && get_odr_type (TYPE_MAIN_VARIANT (t1), true)->odr_violated)
584 return false;
585 if (!types_same_for_odr (t1, t2))
586 return false;
587 if (!type_variants_equivalent_p (t1, t2))
588 return false;
589 /* Limit recursion: If subtypes are ODR types and we know
590 that they are same, be happy. */
591 if (odr_type_p (TYPE_MAIN_VARIANT (t1)))
592 return true;
595 /* Component types, builtins and possibly violating ODR types
596 have to be compared structurally. */
597 if (TREE_CODE (t1) != TREE_CODE (t2))
598 return false;
599 if (AGGREGATE_TYPE_P (t1)
600 && (TYPE_NAME (t1) == NULL_TREE) != (TYPE_NAME (t2) == NULL_TREE))
601 return false;
603 type_pair pair={TYPE_MAIN_VARIANT (t1), TYPE_MAIN_VARIANT (t2)};
604 if (TYPE_UID (TYPE_MAIN_VARIANT (t1)) > TYPE_UID (TYPE_MAIN_VARIANT (t2)))
606 pair.first = TYPE_MAIN_VARIANT (t2);
607 pair.second = TYPE_MAIN_VARIANT (t1);
609 if (visited->add (pair))
610 return true;
611 if (!odr_types_equivalent_p (TYPE_MAIN_VARIANT (t1), TYPE_MAIN_VARIANT (t2),
612 false, NULL, visited, loc1, loc2))
613 return false;
614 if (!type_variants_equivalent_p (t1, t2))
615 return false;
616 return true;
619 /* Return true if DECL1 and DECL2 are identical methods. Consider
620 name equivalent to name.localalias.xyz. */
622 static bool
623 methods_equal_p (tree decl1, tree decl2)
625 if (DECL_ASSEMBLER_NAME (decl1) == DECL_ASSEMBLER_NAME (decl2))
626 return true;
627 const char sep = symbol_table::symbol_suffix_separator ();
629 const char *name1 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl1));
630 const char *ptr1 = strchr (name1, sep);
631 int len1 = ptr1 ? ptr1 - name1 : strlen (name1);
633 const char *name2 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl2));
634 const char *ptr2 = strchr (name2, sep);
635 int len2 = ptr2 ? ptr2 - name2 : strlen (name2);
637 if (len1 != len2)
638 return false;
639 return !strncmp (name1, name2, len1);
642 /* Compare two virtual tables, PREVAILING and VTABLE and output ODR
643 violation warnings. */
645 void
646 compare_virtual_tables (varpool_node *prevailing, varpool_node *vtable)
648 int n1, n2;
650 if (DECL_VIRTUAL_P (prevailing->decl) != DECL_VIRTUAL_P (vtable->decl))
652 odr_violation_reported = true;
653 if (DECL_VIRTUAL_P (prevailing->decl))
655 varpool_node *tmp = prevailing;
656 prevailing = vtable;
657 vtable = tmp;
659 auto_diagnostic_group d;
660 if (warning_at (DECL_SOURCE_LOCATION
661 (TYPE_NAME (DECL_CONTEXT (vtable->decl))),
662 OPT_Wodr,
663 "virtual table of type %qD violates one definition rule",
664 DECL_CONTEXT (vtable->decl)))
665 inform (DECL_SOURCE_LOCATION (prevailing->decl),
666 "variable of same assembler name as the virtual table is "
667 "defined in another translation unit");
668 return;
670 if (!prevailing->definition || !vtable->definition)
671 return;
673 /* If we do not stream ODR type info, do not bother to do useful compare. */
674 if (!TYPE_BINFO (DECL_CONTEXT (vtable->decl))
675 || !polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (vtable->decl))))
676 return;
678 odr_type class_type = get_odr_type (DECL_CONTEXT (vtable->decl), true);
680 if (class_type->odr_violated)
681 return;
683 for (n1 = 0, n2 = 0; true; n1++, n2++)
685 struct ipa_ref *ref1, *ref2;
686 bool end1, end2;
688 end1 = !prevailing->iterate_reference (n1, ref1);
689 end2 = !vtable->iterate_reference (n2, ref2);
691 /* !DECL_VIRTUAL_P means RTTI entry;
692 We warn when RTTI is lost because non-RTTI prevails; we silently
693 accept the other case. */
694 while (!end2
695 && (end1
696 || (methods_equal_p (ref1->referred->decl,
697 ref2->referred->decl)
698 && TREE_CODE (ref1->referred->decl) == FUNCTION_DECL))
699 && TREE_CODE (ref2->referred->decl) != FUNCTION_DECL)
701 if (!class_type->rtti_broken)
703 auto_diagnostic_group d;
704 if (warning_at (DECL_SOURCE_LOCATION
705 (TYPE_NAME (DECL_CONTEXT (vtable->decl))),
706 OPT_Wodr,
707 "virtual table of type %qD contains RTTI "
708 "information",
709 DECL_CONTEXT (vtable->decl)))
711 inform (DECL_SOURCE_LOCATION
712 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
713 "but is prevailed by one without from other"
714 " translation unit");
715 inform (DECL_SOURCE_LOCATION
716 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
717 "RTTI will not work on this type");
718 class_type->rtti_broken = true;
721 n2++;
722 end2 = !vtable->iterate_reference (n2, ref2);
724 while (!end1
725 && (end2
726 || (methods_equal_p (ref2->referred->decl, ref1->referred->decl)
727 && TREE_CODE (ref2->referred->decl) == FUNCTION_DECL))
728 && TREE_CODE (ref1->referred->decl) != FUNCTION_DECL)
730 n1++;
731 end1 = !prevailing->iterate_reference (n1, ref1);
734 /* Finished? */
735 if (end1 && end2)
737 /* Extra paranoia; compare the sizes. We do not have information
738 about virtual inheritance offsets, so just be sure that these
739 match.
740 Do this as very last check so the not very informative error
741 is not output too often. */
742 if (DECL_SIZE (prevailing->decl) != DECL_SIZE (vtable->decl))
744 class_type->odr_violated = true;
745 auto_diagnostic_group d;
746 tree ctx = TYPE_NAME (DECL_CONTEXT (vtable->decl));
747 if (warning_at (DECL_SOURCE_LOCATION (ctx), OPT_Wodr,
748 "virtual table of type %qD violates "
749 "one definition rule",
750 DECL_CONTEXT (vtable->decl)))
752 ctx = TYPE_NAME (DECL_CONTEXT (prevailing->decl));
753 inform (DECL_SOURCE_LOCATION (ctx),
754 "the conflicting type defined in another translation"
755 " unit has virtual table of different size");
758 return;
761 if (!end1 && !end2)
763 if (methods_equal_p (ref1->referred->decl, ref2->referred->decl))
764 continue;
766 class_type->odr_violated = true;
768 /* If the loops above stopped on non-virtual pointer, we have
769 mismatch in RTTI information mangling. */
770 if (TREE_CODE (ref1->referred->decl) != FUNCTION_DECL
771 && TREE_CODE (ref2->referred->decl) != FUNCTION_DECL)
773 auto_diagnostic_group d;
774 if (warning_at (DECL_SOURCE_LOCATION
775 (TYPE_NAME (DECL_CONTEXT (vtable->decl))),
776 OPT_Wodr,
777 "virtual table of type %qD violates "
778 "one definition rule",
779 DECL_CONTEXT (vtable->decl)))
781 inform (DECL_SOURCE_LOCATION
782 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
783 "the conflicting type defined in another translation "
784 "unit with different RTTI information");
786 return;
788 /* At this point both REF1 and REF2 points either to virtual table
789 or virtual method. If one points to virtual table and other to
790 method we can complain the same way as if one table was shorter
791 than other pointing out the extra method. */
792 if (TREE_CODE (ref1->referred->decl)
793 != TREE_CODE (ref2->referred->decl))
795 if (VAR_P (ref1->referred->decl))
796 end1 = true;
797 else if (VAR_P (ref2->referred->decl))
798 end2 = true;
802 class_type->odr_violated = true;
804 /* Complain about size mismatch. Either we have too many virtual
805 functions or too many virtual table pointers. */
806 if (end1 || end2)
808 if (end1)
810 varpool_node *tmp = prevailing;
811 prevailing = vtable;
812 vtable = tmp;
813 ref1 = ref2;
815 auto_diagnostic_group d;
816 if (warning_at (DECL_SOURCE_LOCATION
817 (TYPE_NAME (DECL_CONTEXT (vtable->decl))),
818 OPT_Wodr,
819 "virtual table of type %qD violates "
820 "one definition rule",
821 DECL_CONTEXT (vtable->decl)))
823 if (TREE_CODE (ref1->referring->decl) == FUNCTION_DECL)
825 inform (DECL_SOURCE_LOCATION
826 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
827 "the conflicting type defined in another translation "
828 "unit");
829 inform (DECL_SOURCE_LOCATION
830 (TYPE_NAME (DECL_CONTEXT (ref1->referring->decl))),
831 "contains additional virtual method %qD",
832 ref1->referred->decl);
834 else
836 inform (DECL_SOURCE_LOCATION
837 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
838 "the conflicting type defined in another translation "
839 "unit has virtual table with more entries");
842 return;
845 /* And in the last case we have either mismatch in between two virtual
846 methods or two virtual table pointers. */
847 auto_diagnostic_group d;
848 if (warning_at (DECL_SOURCE_LOCATION
849 (TYPE_NAME (DECL_CONTEXT (vtable->decl))), OPT_Wodr,
850 "virtual table of type %qD violates "
851 "one definition rule",
852 DECL_CONTEXT (vtable->decl)))
854 if (TREE_CODE (ref1->referred->decl) == FUNCTION_DECL)
856 inform (DECL_SOURCE_LOCATION
857 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
858 "the conflicting type defined in another translation "
859 "unit");
860 gcc_assert (TREE_CODE (ref2->referred->decl)
861 == FUNCTION_DECL);
862 inform (DECL_SOURCE_LOCATION
863 (ref1->referred->ultimate_alias_target ()->decl),
864 "virtual method %qD",
865 ref1->referred->ultimate_alias_target ()->decl);
866 inform (DECL_SOURCE_LOCATION
867 (ref2->referred->ultimate_alias_target ()->decl),
868 "ought to match virtual method %qD but does not",
869 ref2->referred->ultimate_alias_target ()->decl);
871 else
872 inform (DECL_SOURCE_LOCATION
873 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
874 "the conflicting type defined in another translation "
875 "unit has virtual table with different contents");
876 return;
881 /* Output ODR violation warning about T1 and T2 with REASON.
882 Display location of ST1 and ST2 if REASON speaks about field or
883 method of the type.
884 If WARN is false, do nothing. Set WARNED if warning was indeed
885 output. */
887 static void
888 warn_odr (tree t1, tree t2, tree st1, tree st2,
889 bool warn, bool *warned, const char *reason)
891 tree decl2 = TYPE_NAME (TYPE_MAIN_VARIANT (t2));
892 if (warned)
893 *warned = false;
895 if (!warn || !TYPE_NAME(TYPE_MAIN_VARIANT (t1)))
896 return;
898 /* ODR warnings are output during LTO streaming; we must apply location
899 cache for potential warnings to be output correctly. */
900 if (lto_location_cache::current_cache)
901 lto_location_cache::current_cache->apply_location_cache ();
903 auto_diagnostic_group d;
904 if (t1 != TYPE_MAIN_VARIANT (t1)
905 && TYPE_NAME (t1) != TYPE_NAME (TYPE_MAIN_VARIANT (t1)))
907 if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (TYPE_MAIN_VARIANT (t1))),
908 OPT_Wodr, "type %qT (typedef of %qT) violates the "
909 "C++ One Definition Rule",
910 t1, TYPE_MAIN_VARIANT (t1)))
911 return;
913 else
915 if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (TYPE_MAIN_VARIANT (t1))),
916 OPT_Wodr, "type %qT violates the C++ One Definition Rule",
917 t1))
918 return;
920 if (!st1 && !st2)
922 /* For FIELD_DECL support also case where one of fields is
923 NULL - this is used when the structures have mismatching number of
924 elements. */
925 else if (!st1 || TREE_CODE (st1) == FIELD_DECL)
927 inform (DECL_SOURCE_LOCATION (decl2),
928 "a different type is defined in another translation unit");
929 if (!st1)
931 st1 = st2;
932 st2 = NULL;
934 inform (DECL_SOURCE_LOCATION (st1),
935 "the first difference of corresponding definitions is field %qD",
936 st1);
937 if (st2)
938 decl2 = st2;
940 else if (TREE_CODE (st1) == FUNCTION_DECL)
942 inform (DECL_SOURCE_LOCATION (decl2),
943 "a different type is defined in another translation unit");
944 inform (DECL_SOURCE_LOCATION (st1),
945 "the first difference of corresponding definitions is method %qD",
946 st1);
947 decl2 = st2;
949 else
950 return;
951 inform (DECL_SOURCE_LOCATION (decl2), reason);
953 if (warned)
954 *warned = true;
957 /* Return true if T1 and T2 are incompatible and we want to recursively
958 dive into them from warn_type_mismatch to give sensible answer. */
960 static bool
961 type_mismatch_p (tree t1, tree t2)
963 if (odr_or_derived_type_p (t1) && odr_or_derived_type_p (t2)
964 && !odr_types_equivalent_p (t1, t2))
965 return true;
966 return !types_compatible_p (t1, t2);
970 /* Types T1 and T2 was found to be incompatible in a context they can't
971 (either used to declare a symbol of same assembler name or unified by
972 ODR rule). We already output warning about this, but if possible, output
973 extra information on how the types mismatch.
975 This is hard to do in general. We basically handle the common cases.
977 If LOC1 and LOC2 are meaningful locations, use it in the case the types
978 themselves do not have one. */
980 void
981 warn_types_mismatch (tree t1, tree t2, location_t loc1, location_t loc2)
983 /* Location of type is known only if it has TYPE_NAME and the name is
984 TYPE_DECL. */
985 location_t loc_t1 = TYPE_NAME (t1) && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
986 ? DECL_SOURCE_LOCATION (TYPE_NAME (t1))
987 : UNKNOWN_LOCATION;
988 location_t loc_t2 = TYPE_NAME (t2) && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
989 ? DECL_SOURCE_LOCATION (TYPE_NAME (t2))
990 : UNKNOWN_LOCATION;
991 bool loc_t2_useful = false;
993 /* With LTO it is a common case that the location of both types match.
994 See if T2 has a location that is different from T1. If so, we will
995 inform user about the location.
996 Do not consider the location passed to us in LOC1/LOC2 as those are
997 already output. */
998 if (loc_t2 > BUILTINS_LOCATION && loc_t2 != loc_t1)
1000 if (loc_t1 <= BUILTINS_LOCATION)
1001 loc_t2_useful = true;
1002 else
1004 expanded_location xloc1 = expand_location (loc_t1);
1005 expanded_location xloc2 = expand_location (loc_t2);
1007 if (strcmp (xloc1.file, xloc2.file)
1008 || xloc1.line != xloc2.line
1009 || xloc1.column != xloc2.column)
1010 loc_t2_useful = true;
1014 if (loc_t1 <= BUILTINS_LOCATION)
1015 loc_t1 = loc1;
1016 if (loc_t2 <= BUILTINS_LOCATION)
1017 loc_t2 = loc2;
1019 location_t loc = loc_t1 <= BUILTINS_LOCATION ? loc_t2 : loc_t1;
1021 /* It is a quite common bug to reference anonymous namespace type in
1022 non-anonymous namespace class. */
1023 tree mt1 = TYPE_MAIN_VARIANT (t1);
1024 tree mt2 = TYPE_MAIN_VARIANT (t2);
1025 if ((type_with_linkage_p (mt1)
1026 && type_in_anonymous_namespace_p (mt1))
1027 || (type_with_linkage_p (mt2)
1028 && type_in_anonymous_namespace_p (mt2)))
1030 if (!type_with_linkage_p (mt1)
1031 || !type_in_anonymous_namespace_p (mt1))
1033 std::swap (t1, t2);
1034 std::swap (mt1, mt2);
1035 std::swap (loc_t1, loc_t2);
1037 gcc_assert (TYPE_NAME (mt1)
1038 && TREE_CODE (TYPE_NAME (mt1)) == TYPE_DECL);
1039 tree n1 = TYPE_NAME (mt1);
1040 tree n2 = TYPE_NAME (mt2) ? TYPE_NAME (mt2) : NULL;
1042 if (TREE_CODE (n1) == TYPE_DECL)
1043 n1 = DECL_NAME (n1);
1044 if (n2 && TREE_CODE (n2) == TYPE_DECL)
1045 n2 = DECL_NAME (n2);
1046 /* Most of the time, the type names will match, do not be unnecessarily
1047 verbose. */
1048 if (n1 != n2)
1049 inform (loc_t1,
1050 "type %qT defined in anonymous namespace cannot match "
1051 "type %qT across the translation unit boundary",
1052 t1, t2);
1053 else
1054 inform (loc_t1,
1055 "type %qT defined in anonymous namespace cannot match "
1056 "across the translation unit boundary",
1057 t1);
1058 if (loc_t2_useful)
1059 inform (loc_t2,
1060 "the incompatible type defined in another translation unit");
1061 return;
1063 /* If types have mangled ODR names and they are different, it is most
1064 informative to output those.
1065 This also covers types defined in different namespaces. */
1066 const char *odr1 = get_odr_name_for_type (mt1);
1067 const char *odr2 = get_odr_name_for_type (mt2);
1068 if (odr1 != NULL && odr2 != NULL && odr1 != odr2)
1070 const int opts = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
1071 char *name1 = xstrdup (cplus_demangle (odr1, opts));
1072 char *name2 = cplus_demangle (odr2, opts);
1073 if (name1 && name2 && strcmp (name1, name2))
1075 inform (loc_t1,
1076 "type name %qs should match type name %qs",
1077 name1, name2);
1078 if (loc_t2_useful)
1079 inform (loc_t2,
1080 "the incompatible type is defined here");
1081 free (name1);
1082 return;
1084 free (name1);
1086 /* A tricky case are compound types. Often they appear the same in source
1087 code and the mismatch is dragged in by type they are build from.
1088 Look for those differences in subtypes and try to be informative. In other
1089 cases just output nothing because the source code is probably different
1090 and in this case we already output a all necessary info. */
1091 if (!TYPE_NAME (t1) || !TYPE_NAME (t2))
1093 if (TREE_CODE (t1) == TREE_CODE (t2))
1095 if (TREE_CODE (t1) == ARRAY_TYPE
1096 && COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2))
1098 tree i1 = TYPE_DOMAIN (t1);
1099 tree i2 = TYPE_DOMAIN (t2);
1101 if (i1 && i2
1102 && TYPE_MAX_VALUE (i1)
1103 && TYPE_MAX_VALUE (i2)
1104 && !operand_equal_p (TYPE_MAX_VALUE (i1),
1105 TYPE_MAX_VALUE (i2), 0))
1107 inform (loc,
1108 "array types have different bounds");
1109 return;
1112 if ((POINTER_TYPE_P (t1) || TREE_CODE (t1) == ARRAY_TYPE)
1113 && type_mismatch_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1114 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc_t1, loc_t2);
1115 else if (TREE_CODE (t1) == METHOD_TYPE
1116 || TREE_CODE (t1) == FUNCTION_TYPE)
1118 tree parms1 = NULL, parms2 = NULL;
1119 int count = 1;
1121 if (type_mismatch_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1123 inform (loc, "return value type mismatch");
1124 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc_t1,
1125 loc_t2);
1126 return;
1128 if (prototype_p (t1) && prototype_p (t2))
1129 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
1130 parms1 && parms2;
1131 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2),
1132 count++)
1134 if (type_mismatch_p (TREE_VALUE (parms1), TREE_VALUE (parms2)))
1136 if (count == 1 && TREE_CODE (t1) == METHOD_TYPE)
1137 inform (loc,
1138 "implicit this pointer type mismatch");
1139 else
1140 inform (loc,
1141 "type mismatch in parameter %i",
1142 count - (TREE_CODE (t1) == METHOD_TYPE));
1143 warn_types_mismatch (TREE_VALUE (parms1),
1144 TREE_VALUE (parms2),
1145 loc_t1, loc_t2);
1146 return;
1149 if (parms1 || parms2)
1151 inform (loc,
1152 "types have different parameter counts");
1153 return;
1157 return;
1160 if (types_odr_comparable (t1, t2)
1161 /* We make assign integers mangled names to be able to handle
1162 signed/unsigned chars. Accepting them here would however lead to
1163 confusing message like
1164 "type ‘const int’ itself violates the C++ One Definition Rule" */
1165 && TREE_CODE (t1) != INTEGER_TYPE
1166 && types_same_for_odr (t1, t2))
1167 inform (loc_t1,
1168 "type %qT itself violates the C++ One Definition Rule", t1);
1169 /* Prevent pointless warnings like "struct aa" should match "struct aa". */
1170 else if (TYPE_NAME (t1) == TYPE_NAME (t2)
1171 && TREE_CODE (t1) == TREE_CODE (t2) && !loc_t2_useful)
1172 return;
1173 else
1174 inform (loc_t1, "type %qT should match type %qT",
1175 t1, t2);
1176 if (loc_t2_useful)
1177 inform (loc_t2, "the incompatible type is defined here");
1180 /* Return true if T should be ignored in TYPE_FIELDS for ODR comparison. */
1182 static bool
1183 skip_in_fields_list_p (tree t)
1185 if (TREE_CODE (t) != FIELD_DECL)
1186 return true;
1187 /* C++ FE introduces zero sized fields depending on -std setting, see
1188 PR89358. */
1189 if (DECL_SIZE (t)
1190 && integer_zerop (DECL_SIZE (t))
1191 && DECL_ARTIFICIAL (t)
1192 && DECL_IGNORED_P (t)
1193 && !DECL_NAME (t))
1194 return true;
1195 return false;
1198 /* Compare T1 and T2, report ODR violations if WARN is true and set
1199 WARNED to true if anything is reported. Return true if types match.
1200 If true is returned, the types are also compatible in the sense of
1201 gimple_canonical_types_compatible_p.
1202 If LOC1 and LOC2 is not UNKNOWN_LOCATION it may be used to output a warning
1203 about the type if the type itself do not have location. */
1205 static bool
1206 odr_types_equivalent_p (tree t1, tree t2, bool warn, bool *warned,
1207 hash_set<type_pair> *visited,
1208 location_t loc1, location_t loc2)
1210 /* Check first for the obvious case of pointer identity. */
1211 if (t1 == t2)
1212 return true;
1214 /* Can't be the same type if the types don't have the same code. */
1215 if (TREE_CODE (t1) != TREE_CODE (t2))
1217 warn_odr (t1, t2, NULL, NULL, warn, warned,
1218 G_("a different type is defined in another translation unit"));
1219 return false;
1222 if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1))
1223 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1)))
1224 || (type_with_linkage_p (TYPE_MAIN_VARIANT (t2))
1225 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2))))
1227 /* We cannot trip this when comparing ODR types, only when trying to
1228 match different ODR derivations from different declarations.
1229 So WARN should be always false. */
1230 gcc_assert (!warn);
1231 return false;
1234 /* Non-aggregate types can be handled cheaply. */
1235 if (INTEGRAL_TYPE_P (t1)
1236 || SCALAR_FLOAT_TYPE_P (t1)
1237 || FIXED_POINT_TYPE_P (t1)
1238 || TREE_CODE (t1) == VECTOR_TYPE
1239 || TREE_CODE (t1) == COMPLEX_TYPE
1240 || TREE_CODE (t1) == OFFSET_TYPE
1241 || POINTER_TYPE_P (t1))
1243 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2))
1245 warn_odr (t1, t2, NULL, NULL, warn, warned,
1246 G_("a type with different precision is defined "
1247 "in another translation unit"));
1248 return false;
1250 if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
1252 warn_odr (t1, t2, NULL, NULL, warn, warned,
1253 G_("a type with different signedness is defined "
1254 "in another translation unit"));
1255 return false;
1258 if (TREE_CODE (t1) == INTEGER_TYPE
1259 && TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2))
1261 /* char WRT uint_8? */
1262 warn_odr (t1, t2, NULL, NULL, warn, warned,
1263 G_("a different type is defined in another "
1264 "translation unit"));
1265 return false;
1268 /* For canonical type comparisons we do not want to build SCCs
1269 so we cannot compare pointed-to types. But we can, for now,
1270 require the same pointed-to type kind and match what
1271 useless_type_conversion_p would do. */
1272 if (POINTER_TYPE_P (t1))
1274 if (TYPE_ADDR_SPACE (TREE_TYPE (t1))
1275 != TYPE_ADDR_SPACE (TREE_TYPE (t2)))
1277 warn_odr (t1, t2, NULL, NULL, warn, warned,
1278 G_("it is defined as a pointer in different address "
1279 "space in another translation unit"));
1280 return false;
1283 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2),
1284 visited, loc1, loc2))
1286 warn_odr (t1, t2, NULL, NULL, warn, warned,
1287 G_("it is defined as a pointer to different type "
1288 "in another translation unit"));
1289 if (warn && warned)
1290 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2),
1291 loc1, loc2);
1292 return false;
1296 if ((TREE_CODE (t1) == VECTOR_TYPE || TREE_CODE (t1) == COMPLEX_TYPE)
1297 && !odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2),
1298 visited, loc1, loc2))
1300 /* Probably specific enough. */
1301 warn_odr (t1, t2, NULL, NULL, warn, warned,
1302 G_("a different type is defined "
1303 "in another translation unit"));
1304 if (warn && warned)
1305 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc1, loc2);
1306 return false;
1309 /* Do type-specific comparisons. */
1310 else switch (TREE_CODE (t1))
1312 case ARRAY_TYPE:
1314 /* Array types are the same if the element types are the same and
1315 the number of elements are the same. */
1316 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2),
1317 visited, loc1, loc2))
1319 warn_odr (t1, t2, NULL, NULL, warn, warned,
1320 G_("a different type is defined in another "
1321 "translation unit"));
1322 if (warn && warned)
1323 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc1, loc2);
1325 gcc_assert (TYPE_STRING_FLAG (t1) == TYPE_STRING_FLAG (t2));
1326 gcc_assert (TYPE_NONALIASED_COMPONENT (t1)
1327 == TYPE_NONALIASED_COMPONENT (t2));
1329 tree i1 = TYPE_DOMAIN (t1);
1330 tree i2 = TYPE_DOMAIN (t2);
1332 /* For an incomplete external array, the type domain can be
1333 NULL_TREE. Check this condition also. */
1334 if (i1 == NULL_TREE || i2 == NULL_TREE)
1335 return type_variants_equivalent_p (t1, t2);
1337 tree min1 = TYPE_MIN_VALUE (i1);
1338 tree min2 = TYPE_MIN_VALUE (i2);
1339 tree max1 = TYPE_MAX_VALUE (i1);
1340 tree max2 = TYPE_MAX_VALUE (i2);
1342 /* In C++, minimums should be always 0. */
1343 gcc_assert (min1 == min2);
1344 if (!operand_equal_p (max1, max2, 0))
1346 warn_odr (t1, t2, NULL, NULL, warn, warned,
1347 G_("an array of different size is defined "
1348 "in another translation unit"));
1349 return false;
1352 break;
1354 case METHOD_TYPE:
1355 case FUNCTION_TYPE:
1356 /* Function types are the same if the return type and arguments types
1357 are the same. */
1358 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2),
1359 visited, loc1, loc2))
1361 warn_odr (t1, t2, NULL, NULL, warn, warned,
1362 G_("has different return value "
1363 "in another translation unit"));
1364 if (warn && warned)
1365 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc1, loc2);
1366 return false;
1369 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2)
1370 || !prototype_p (t1) || !prototype_p (t2))
1371 return type_variants_equivalent_p (t1, t2);
1372 else
1374 tree parms1, parms2;
1376 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
1377 parms1 && parms2;
1378 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
1380 if (!odr_subtypes_equivalent_p
1381 (TREE_VALUE (parms1), TREE_VALUE (parms2),
1382 visited, loc1, loc2))
1384 warn_odr (t1, t2, NULL, NULL, warn, warned,
1385 G_("has different parameters in another "
1386 "translation unit"));
1387 if (warn && warned)
1388 warn_types_mismatch (TREE_VALUE (parms1),
1389 TREE_VALUE (parms2), loc1, loc2);
1390 return false;
1394 if (parms1 || parms2)
1396 warn_odr (t1, t2, NULL, NULL, warn, warned,
1397 G_("has different parameters "
1398 "in another translation unit"));
1399 return false;
1402 return type_variants_equivalent_p (t1, t2);
1405 case RECORD_TYPE:
1406 case UNION_TYPE:
1407 case QUAL_UNION_TYPE:
1409 tree f1, f2;
1411 /* For aggregate types, all the fields must be the same. */
1412 if (COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2))
1414 if (TYPE_BINFO (t1) && TYPE_BINFO (t2)
1415 && polymorphic_type_binfo_p (TYPE_BINFO (t1))
1416 != polymorphic_type_binfo_p (TYPE_BINFO (t2)))
1418 if (polymorphic_type_binfo_p (TYPE_BINFO (t1)))
1419 warn_odr (t1, t2, NULL, NULL, warn, warned,
1420 G_("a type defined in another translation unit "
1421 "is not polymorphic"));
1422 else
1423 warn_odr (t1, t2, NULL, NULL, warn, warned,
1424 G_("a type defined in another translation unit "
1425 "is polymorphic"));
1426 return false;
1428 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
1429 f1 || f2;
1430 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
1432 /* Skip non-fields. */
1433 while (f1 && skip_in_fields_list_p (f1))
1434 f1 = TREE_CHAIN (f1);
1435 while (f2 && skip_in_fields_list_p (f2))
1436 f2 = TREE_CHAIN (f2);
1437 if (!f1 || !f2)
1438 break;
1439 if (DECL_VIRTUAL_P (f1) != DECL_VIRTUAL_P (f2))
1441 warn_odr (t1, t2, NULL, NULL, warn, warned,
1442 G_("a type with different virtual table pointers"
1443 " is defined in another translation unit"));
1444 return false;
1446 if (DECL_ARTIFICIAL (f1) != DECL_ARTIFICIAL (f2))
1448 warn_odr (t1, t2, NULL, NULL, warn, warned,
1449 G_("a type with different bases is defined "
1450 "in another translation unit"));
1451 return false;
1453 if (DECL_NAME (f1) != DECL_NAME (f2)
1454 && !DECL_ARTIFICIAL (f1))
1456 warn_odr (t1, t2, f1, f2, warn, warned,
1457 G_("a field with different name is defined "
1458 "in another translation unit"));
1459 return false;
1461 if (!odr_subtypes_equivalent_p (TREE_TYPE (f1),
1462 TREE_TYPE (f2),
1463 visited, loc1, loc2))
1465 /* Do not warn about artificial fields and just go into
1466 generic field mismatch warning. */
1467 if (DECL_ARTIFICIAL (f1))
1468 break;
1470 warn_odr (t1, t2, f1, f2, warn, warned,
1471 G_("a field of same name but different type "
1472 "is defined in another translation unit"));
1473 if (warn && warned)
1474 warn_types_mismatch (TREE_TYPE (f1), TREE_TYPE (f2), loc1, loc2);
1475 return false;
1477 if (!gimple_compare_field_offset (f1, f2))
1479 /* Do not warn about artificial fields and just go into
1480 generic field mismatch warning. */
1481 if (DECL_ARTIFICIAL (f1))
1482 break;
1483 warn_odr (t1, t2, f1, f2, warn, warned,
1484 G_("fields have different layout "
1485 "in another translation unit"));
1486 return false;
1488 if (DECL_BIT_FIELD (f1) != DECL_BIT_FIELD (f2))
1490 warn_odr (t1, t2, f1, f2, warn, warned,
1491 G_("one field is a bitfield while the other "
1492 "is not"));
1493 return false;
1495 else
1496 gcc_assert (DECL_NONADDRESSABLE_P (f1)
1497 == DECL_NONADDRESSABLE_P (f2));
1500 /* If one aggregate has more fields than the other, they
1501 are not the same. */
1502 if (f1 || f2)
1504 if ((f1 && DECL_VIRTUAL_P (f1)) || (f2 && DECL_VIRTUAL_P (f2)))
1505 warn_odr (t1, t2, NULL, NULL, warn, warned,
1506 G_("a type with different virtual table pointers"
1507 " is defined in another translation unit"));
1508 else if ((f1 && DECL_ARTIFICIAL (f1))
1509 || (f2 && DECL_ARTIFICIAL (f2)))
1510 warn_odr (t1, t2, NULL, NULL, warn, warned,
1511 G_("a type with different bases is defined "
1512 "in another translation unit"));
1513 else
1514 warn_odr (t1, t2, f1, f2, warn, warned,
1515 G_("a type with different number of fields "
1516 "is defined in another translation unit"));
1518 return false;
1521 break;
1523 case VOID_TYPE:
1524 case OPAQUE_TYPE:
1525 case NULLPTR_TYPE:
1526 break;
1528 default:
1529 debug_tree (t1);
1530 gcc_unreachable ();
1533 /* Those are better to come last as they are utterly uninformative. */
1534 if (TYPE_SIZE (t1) && TYPE_SIZE (t2)
1535 && !operand_equal_p (TYPE_SIZE (t1), TYPE_SIZE (t2), 0))
1537 warn_odr (t1, t2, NULL, NULL, warn, warned,
1538 G_("a type with different size "
1539 "is defined in another translation unit"));
1540 return false;
1543 if (TREE_ADDRESSABLE (t1) != TREE_ADDRESSABLE (t2)
1544 && COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2))
1546 warn_odr (t1, t2, NULL, NULL, warn, warned,
1547 G_("one type needs to be constructed while the other does not"));
1548 gcc_checking_assert (RECORD_OR_UNION_TYPE_P (t1));
1549 return false;
1551 /* There is no really good user facing warning for this.
1552 Either the original reason for modes being different is lost during
1553 streaming or we should catch earlier warnings. We however must detect
1554 the mismatch to avoid type verifier from cmplaining on mismatched
1555 types between type and canonical type. See PR91576. */
1556 if (TYPE_MODE (t1) != TYPE_MODE (t2)
1557 && COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2))
1559 warn_odr (t1, t2, NULL, NULL, warn, warned,
1560 G_("memory layout mismatch"));
1561 return false;
1564 gcc_assert (!TYPE_SIZE_UNIT (t1) || !TYPE_SIZE_UNIT (t2)
1565 || operand_equal_p (TYPE_SIZE_UNIT (t1),
1566 TYPE_SIZE_UNIT (t2), 0));
1567 return type_variants_equivalent_p (t1, t2);
1570 /* Return true if TYPE1 and TYPE2 are equivalent for One Definition Rule. */
1572 bool
1573 odr_types_equivalent_p (tree type1, tree type2)
1575 gcc_checking_assert (odr_or_derived_type_p (type1)
1576 && odr_or_derived_type_p (type2));
1578 hash_set<type_pair> visited;
1579 return odr_types_equivalent_p (type1, type2, false, NULL,
1580 &visited, UNKNOWN_LOCATION, UNKNOWN_LOCATION);
1583 /* TYPE is equivalent to VAL by ODR, but its tree representation differs
1584 from VAL->type. This may happen in LTO where tree merging did not merge
1585 all variants of the same type or due to ODR violation.
1587 Analyze and report ODR violations and add type to duplicate list.
1588 If TYPE is more specified than VAL->type, prevail VAL->type. Also if
1589 this is first time we see definition of a class return true so the
1590 base types are analyzed. */
1592 static bool
1593 add_type_duplicate (odr_type val, tree type)
1595 bool build_bases = false;
1596 bool prevail = false;
1597 bool odr_must_violate = false;
1599 if (!val->types_set)
1600 val->types_set = new hash_set<tree>;
1602 /* Chose polymorphic type as leader (this happens only in case of ODR
1603 violations. */
1604 if ((TREE_CODE (type) == RECORD_TYPE && TYPE_BINFO (type)
1605 && polymorphic_type_binfo_p (TYPE_BINFO (type)))
1606 && (TREE_CODE (val->type) != RECORD_TYPE || !TYPE_BINFO (val->type)
1607 || !polymorphic_type_binfo_p (TYPE_BINFO (val->type))))
1609 prevail = true;
1610 build_bases = true;
1612 /* Always prefer complete type to be the leader. */
1613 else if (!COMPLETE_TYPE_P (val->type) && COMPLETE_TYPE_P (type))
1615 prevail = true;
1616 if (TREE_CODE (type) == RECORD_TYPE)
1617 build_bases = TYPE_BINFO (type);
1619 else if (COMPLETE_TYPE_P (val->type) && !COMPLETE_TYPE_P (type))
1621 else if (TREE_CODE (val->type) == RECORD_TYPE
1622 && TREE_CODE (type) == RECORD_TYPE
1623 && TYPE_BINFO (type) && !TYPE_BINFO (val->type))
1625 gcc_assert (!val->bases.length ());
1626 build_bases = true;
1627 prevail = true;
1630 if (prevail)
1631 std::swap (val->type, type);
1633 val->types_set->add (type);
1635 if (!odr_hash)
1636 return false;
1638 gcc_checking_assert (can_be_name_hashed_p (type)
1639 && can_be_name_hashed_p (val->type));
1641 bool merge = true;
1642 bool base_mismatch = false;
1643 unsigned int i;
1644 bool warned = false;
1645 hash_set<type_pair> visited;
1647 gcc_assert (in_lto_p);
1648 vec_safe_push (val->types, type);
1650 /* If both are class types, compare the bases. */
1651 if (COMPLETE_TYPE_P (type) && COMPLETE_TYPE_P (val->type)
1652 && TREE_CODE (val->type) == RECORD_TYPE
1653 && TREE_CODE (type) == RECORD_TYPE
1654 && TYPE_BINFO (val->type) && TYPE_BINFO (type))
1656 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (type))
1657 != BINFO_N_BASE_BINFOS (TYPE_BINFO (val->type)))
1659 if (!flag_ltrans && !warned && !val->odr_violated)
1661 tree extra_base;
1662 warn_odr (type, val->type, NULL, NULL, !warned, &warned,
1663 "a type with the same name but different "
1664 "number of polymorphic bases is "
1665 "defined in another translation unit");
1666 if (warned)
1668 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (type))
1669 > BINFO_N_BASE_BINFOS (TYPE_BINFO (val->type)))
1670 extra_base = BINFO_BASE_BINFO
1671 (TYPE_BINFO (type),
1672 BINFO_N_BASE_BINFOS (TYPE_BINFO (val->type)));
1673 else
1674 extra_base = BINFO_BASE_BINFO
1675 (TYPE_BINFO (val->type),
1676 BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1677 tree extra_base_type = BINFO_TYPE (extra_base);
1678 inform (DECL_SOURCE_LOCATION (TYPE_NAME (extra_base_type)),
1679 "the extra base is defined here");
1682 base_mismatch = true;
1684 else
1685 for (i = 0; i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); i++)
1687 tree base1 = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
1688 tree base2 = BINFO_BASE_BINFO (TYPE_BINFO (val->type), i);
1689 tree type1 = BINFO_TYPE (base1);
1690 tree type2 = BINFO_TYPE (base2);
1692 if (types_odr_comparable (type1, type2))
1694 if (!types_same_for_odr (type1, type2))
1695 base_mismatch = true;
1697 else
1698 if (!odr_types_equivalent_p (type1, type2))
1699 base_mismatch = true;
1700 if (base_mismatch)
1702 if (!warned && !val->odr_violated)
1704 warn_odr (type, val->type, NULL, NULL,
1705 !warned, &warned,
1706 "a type with the same name but different base "
1707 "type is defined in another translation unit");
1708 if (warned)
1709 warn_types_mismatch (type1, type2,
1710 UNKNOWN_LOCATION, UNKNOWN_LOCATION);
1712 break;
1714 if (BINFO_OFFSET (base1) != BINFO_OFFSET (base2))
1716 base_mismatch = true;
1717 if (!warned && !val->odr_violated)
1718 warn_odr (type, val->type, NULL, NULL,
1719 !warned, &warned,
1720 "a type with the same name but different base "
1721 "layout is defined in another translation unit");
1722 break;
1724 /* One of bases is not of complete type. */
1725 if (!TYPE_BINFO (type1) != !TYPE_BINFO (type2))
1727 /* If we have a polymorphic type info specified for TYPE1
1728 but not for TYPE2 we possibly missed a base when recording
1729 VAL->type earlier.
1730 Be sure this does not happen. */
1731 if (TYPE_BINFO (type1)
1732 && polymorphic_type_binfo_p (TYPE_BINFO (type1))
1733 && !build_bases)
1734 odr_must_violate = true;
1735 break;
1737 /* One base is polymorphic and the other not.
1738 This ought to be diagnosed earlier, but do not ICE in the
1739 checking bellow. */
1740 else if (TYPE_BINFO (type1)
1741 && polymorphic_type_binfo_p (TYPE_BINFO (type1))
1742 != polymorphic_type_binfo_p (TYPE_BINFO (type2)))
1744 if (!warned && !val->odr_violated)
1745 warn_odr (type, val->type, NULL, NULL,
1746 !warned, &warned,
1747 "a base of the type is polymorphic only in one "
1748 "translation unit");
1749 base_mismatch = true;
1750 break;
1753 if (base_mismatch)
1755 merge = false;
1756 odr_violation_reported = true;
1757 val->odr_violated = true;
1759 if (symtab->dump_file)
1761 fprintf (symtab->dump_file, "ODR base violation\n");
1763 print_node (symtab->dump_file, "", val->type, 0);
1764 putc ('\n',symtab->dump_file);
1765 print_node (symtab->dump_file, "", type, 0);
1766 putc ('\n',symtab->dump_file);
1771 /* Next compare memory layout.
1772 The DECL_SOURCE_LOCATIONs in this invocation came from LTO streaming.
1773 We must apply the location cache to ensure that they are valid
1774 before we can pass them to odr_types_equivalent_p (PR lto/83121). */
1775 if (lto_location_cache::current_cache)
1776 lto_location_cache::current_cache->apply_location_cache ();
1777 /* As a special case we stream mangles names of integer types so we can see
1778 if they are believed to be same even though they have different
1779 representation. Avoid bogus warning on mismatches in these. */
1780 if (TREE_CODE (type) != INTEGER_TYPE
1781 && TREE_CODE (val->type) != INTEGER_TYPE
1782 && !odr_types_equivalent_p (val->type, type,
1783 !flag_ltrans && !val->odr_violated && !warned,
1784 &warned, &visited,
1785 DECL_SOURCE_LOCATION (TYPE_NAME (val->type)),
1786 DECL_SOURCE_LOCATION (TYPE_NAME (type))))
1788 merge = false;
1789 odr_violation_reported = true;
1790 val->odr_violated = true;
1792 gcc_assert (val->odr_violated || !odr_must_violate);
1793 /* Sanity check that all bases will be build same way again. */
1794 if (flag_checking
1795 && COMPLETE_TYPE_P (type) && COMPLETE_TYPE_P (val->type)
1796 && TREE_CODE (val->type) == RECORD_TYPE
1797 && TREE_CODE (type) == RECORD_TYPE
1798 && TYPE_BINFO (val->type) && TYPE_BINFO (type)
1799 && !val->odr_violated
1800 && !base_mismatch && val->bases.length ())
1802 unsigned int num_poly_bases = 0;
1803 unsigned int j;
1805 for (i = 0; i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); i++)
1806 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO
1807 (TYPE_BINFO (type), i)))
1808 num_poly_bases++;
1809 gcc_assert (num_poly_bases == val->bases.length ());
1810 for (j = 0, i = 0; i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type));
1811 i++)
1812 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO
1813 (TYPE_BINFO (type), i)))
1815 odr_type base = get_odr_type
1816 (BINFO_TYPE
1817 (BINFO_BASE_BINFO (TYPE_BINFO (type),
1818 i)),
1819 true);
1820 gcc_assert (val->bases[j] == base);
1821 j++;
1826 /* Regularize things a little. During LTO same types may come with
1827 different BINFOs. Either because their virtual table was
1828 not merged by tree merging and only later at decl merging or
1829 because one type comes with external vtable, while other
1830 with internal. We want to merge equivalent binfos to conserve
1831 memory and streaming overhead.
1833 The external vtables are more harmful: they contain references
1834 to external declarations of methods that may be defined in the
1835 merged LTO unit. For this reason we absolutely need to remove
1836 them and replace by internal variants. Not doing so will lead
1837 to incomplete answers from possible_polymorphic_call_targets.
1839 FIXME: disable for now; because ODR types are now build during
1840 streaming in, the variants do not need to be linked to the type,
1841 yet. We need to do the merging in cleanup pass to be implemented
1842 soon. */
1843 if (!flag_ltrans && merge
1844 && 0
1845 && TREE_CODE (val->type) == RECORD_TYPE
1846 && TREE_CODE (type) == RECORD_TYPE
1847 && TYPE_BINFO (val->type) && TYPE_BINFO (type)
1848 && TYPE_MAIN_VARIANT (type) == type
1849 && TYPE_MAIN_VARIANT (val->type) == val->type
1850 && BINFO_VTABLE (TYPE_BINFO (val->type))
1851 && BINFO_VTABLE (TYPE_BINFO (type)))
1853 tree master_binfo = TYPE_BINFO (val->type);
1854 tree v1 = BINFO_VTABLE (master_binfo);
1855 tree v2 = BINFO_VTABLE (TYPE_BINFO (type));
1857 if (TREE_CODE (v1) == POINTER_PLUS_EXPR)
1859 gcc_assert (TREE_CODE (v2) == POINTER_PLUS_EXPR
1860 && operand_equal_p (TREE_OPERAND (v1, 1),
1861 TREE_OPERAND (v2, 1), 0));
1862 v1 = TREE_OPERAND (TREE_OPERAND (v1, 0), 0);
1863 v2 = TREE_OPERAND (TREE_OPERAND (v2, 0), 0);
1865 gcc_assert (DECL_ASSEMBLER_NAME (v1)
1866 == DECL_ASSEMBLER_NAME (v2));
1868 if (DECL_EXTERNAL (v1) && !DECL_EXTERNAL (v2))
1870 unsigned int i;
1872 set_type_binfo (val->type, TYPE_BINFO (type));
1873 for (i = 0; i < val->types->length (); i++)
1875 if (TYPE_BINFO ((*val->types)[i])
1876 == master_binfo)
1877 set_type_binfo ((*val->types)[i], TYPE_BINFO (type));
1879 BINFO_TYPE (TYPE_BINFO (type)) = val->type;
1881 else
1882 set_type_binfo (type, master_binfo);
1884 return build_bases;
1887 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to.
1888 FOR_DUMP_P is true when being called from the dump routines. */
1890 tree
1891 obj_type_ref_class (const_tree ref, bool for_dump_p)
1893 gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
1894 ref = TREE_TYPE (ref);
1895 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
1896 ref = TREE_TYPE (ref);
1897 /* We look for type THIS points to. ObjC also builds
1898 OBJ_TYPE_REF with non-method calls, Their first parameter
1899 ID however also corresponds to class type. */
1900 gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
1901 || TREE_CODE (ref) == FUNCTION_TYPE);
1902 ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
1903 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
1904 tree ret = TREE_TYPE (ref);
1905 if (!in_lto_p && !TYPE_STRUCTURAL_EQUALITY_P (ret))
1906 ret = TYPE_CANONICAL (ret);
1907 else if (odr_type ot = get_odr_type (ret, !for_dump_p))
1908 ret = ot->type;
1909 else
1910 gcc_assert (for_dump_p);
1911 return ret;
1914 /* Get ODR type hash entry for TYPE. If INSERT is true, create
1915 possibly new entry. */
1917 odr_type
1918 get_odr_type (tree type, bool insert)
1920 odr_type_d **slot = NULL;
1921 odr_type val = NULL;
1922 hashval_t hash;
1923 bool build_bases = false;
1924 bool insert_to_odr_array = false;
1925 int base_id = -1;
1927 type = TYPE_MAIN_VARIANT (type);
1928 if (!in_lto_p && !TYPE_STRUCTURAL_EQUALITY_P (type))
1929 type = TYPE_CANONICAL (type);
1931 gcc_checking_assert (can_be_name_hashed_p (type));
1933 hash = hash_odr_name (type);
1934 slot = odr_hash->find_slot_with_hash (type, hash,
1935 insert ? INSERT : NO_INSERT);
1937 if (!slot)
1938 return NULL;
1940 /* See if we already have entry for type. */
1941 if (*slot)
1943 val = *slot;
1945 if (val->type != type && insert
1946 && (!val->types_set || !val->types_set->add (type)))
1947 build_bases = add_type_duplicate (val, type);
1949 else
1951 val = ggc_cleared_alloc<odr_type_d> ();
1952 val->type = type;
1953 val->bases = vNULL;
1954 val->derived_types = vNULL;
1955 if (type_with_linkage_p (type))
1956 val->anonymous_namespace = type_in_anonymous_namespace_p (type);
1957 else
1958 val->anonymous_namespace = 0;
1959 build_bases = COMPLETE_TYPE_P (val->type);
1960 insert_to_odr_array = true;
1961 *slot = val;
1964 if (build_bases && TREE_CODE (type) == RECORD_TYPE && TYPE_BINFO (type)
1965 && type_with_linkage_p (type)
1966 && type == TYPE_MAIN_VARIANT (type))
1968 tree binfo = TYPE_BINFO (type);
1969 unsigned int i;
1971 gcc_assert (BINFO_TYPE (TYPE_BINFO (val->type)) == type);
1973 val->all_derivations_known = type_all_derivations_known_p (type);
1974 for (i = 0; i < BINFO_N_BASE_BINFOS (binfo); i++)
1975 /* For now record only polymorphic types. other are
1976 pointless for devirtualization and we cannot precisely
1977 determine ODR equivalency of these during LTO. */
1978 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (binfo, i)))
1980 tree base_type= BINFO_TYPE (BINFO_BASE_BINFO (binfo, i));
1981 odr_type base = get_odr_type (base_type, true);
1982 gcc_assert (TYPE_MAIN_VARIANT (base_type) == base_type);
1983 base->derived_types.safe_push (val);
1984 val->bases.safe_push (base);
1985 if (base->id > base_id)
1986 base_id = base->id;
1989 /* Ensure that type always appears after bases. */
1990 if (insert_to_odr_array)
1992 if (odr_types_ptr)
1993 val->id = odr_types.length ();
1994 vec_safe_push (odr_types_ptr, val);
1996 else if (base_id > val->id)
1998 odr_types[val->id] = 0;
1999 /* Be sure we did not recorded any derived types; these may need
2000 renumbering too. */
2001 gcc_assert (val->derived_types.length() == 0);
2002 val->id = odr_types.length ();
2003 vec_safe_push (odr_types_ptr, val);
2005 return val;
2008 /* Return type that in ODR type hash prevailed TYPE. Be careful and punt
2009 on ODR violations. */
2011 tree
2012 prevailing_odr_type (tree type)
2014 odr_type t = get_odr_type (type, false);
2015 if (!t || t->odr_violated)
2016 return type;
2017 return t->type;
2020 /* Set tbaa_enabled flag for TYPE. */
2022 void
2023 enable_odr_based_tbaa (tree type)
2025 odr_type t = get_odr_type (type, true);
2026 t->tbaa_enabled = true;
2029 /* True if canonical type of TYPE is determined using ODR name. */
2031 bool
2032 odr_based_tbaa_p (const_tree type)
2034 if (!RECORD_OR_UNION_TYPE_P (type))
2035 return false;
2036 if (!odr_hash)
2037 return false;
2038 odr_type t = get_odr_type (const_cast <tree> (type), false);
2039 if (!t || !t->tbaa_enabled)
2040 return false;
2041 return true;
2044 /* Set TYPE_CANONICAL of type and all its variants and duplicates
2045 to CANONICAL. */
2047 void
2048 set_type_canonical_for_odr_type (tree type, tree canonical)
2050 odr_type t = get_odr_type (type, false);
2051 unsigned int i;
2052 tree tt;
2054 for (tree t2 = t->type; t2; t2 = TYPE_NEXT_VARIANT (t2))
2055 TYPE_CANONICAL (t2) = canonical;
2056 if (t->types)
2057 FOR_EACH_VEC_ELT (*t->types, i, tt)
2058 for (tree t2 = tt; t2; t2 = TYPE_NEXT_VARIANT (t2))
2059 TYPE_CANONICAL (t2) = canonical;
2062 /* Return true if we reported some ODR violation on TYPE. */
2064 bool
2065 odr_type_violation_reported_p (tree type)
2067 return get_odr_type (type, false)->odr_violated;
2070 /* Add TYPE of ODR type hash. */
2072 void
2073 register_odr_type (tree type)
2075 if (!odr_hash)
2076 odr_hash = new odr_hash_type (23);
2077 if (type == TYPE_MAIN_VARIANT (type))
2079 /* To get ODR warnings right, first register all sub-types. */
2080 if (RECORD_OR_UNION_TYPE_P (type)
2081 && COMPLETE_TYPE_P (type))
2083 /* Limit recursion on types which are already registered. */
2084 odr_type ot = get_odr_type (type, false);
2085 if (ot
2086 && (ot->type == type
2087 || (ot->types_set
2088 && ot->types_set->contains (type))))
2089 return;
2090 for (tree f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f))
2091 if (TREE_CODE (f) == FIELD_DECL)
2093 tree subtype = TREE_TYPE (f);
2095 while (TREE_CODE (subtype) == ARRAY_TYPE)
2096 subtype = TREE_TYPE (subtype);
2097 if (type_with_linkage_p (TYPE_MAIN_VARIANT (subtype)))
2098 register_odr_type (TYPE_MAIN_VARIANT (subtype));
2100 if (TYPE_BINFO (type))
2101 for (unsigned int i = 0;
2102 i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); i++)
2103 register_odr_type (BINFO_TYPE (BINFO_BASE_BINFO
2104 (TYPE_BINFO (type), i)));
2106 get_odr_type (type, true);
2110 /* Return true if type is known to have no derivations. */
2112 bool
2113 type_known_to_have_no_derivations_p (tree t)
2115 return (type_all_derivations_known_p (t)
2116 && (TYPE_FINAL_P (t)
2117 || (odr_hash
2118 && !get_odr_type (t, true)->derived_types.length())));
2121 /* Dump ODR type T and all its derived types. INDENT specifies indentation for
2122 recursive printing. */
2124 static void
2125 dump_odr_type (FILE *f, odr_type t, int indent=0)
2127 unsigned int i;
2128 fprintf (f, "%*s type %i: ", indent * 2, "", t->id);
2129 print_generic_expr (f, t->type, TDF_SLIM);
2130 fprintf (f, "%s", t->anonymous_namespace ? " (anonymous namespace)":"");
2131 fprintf (f, "%s\n", t->all_derivations_known ? " (derivations known)":"");
2132 if (TYPE_NAME (t->type))
2134 if (DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t->type)))
2135 fprintf (f, "%*s mangled name: %s\n", indent * 2, "",
2136 IDENTIFIER_POINTER
2137 (DECL_ASSEMBLER_NAME (TYPE_NAME (t->type))));
2139 if (t->bases.length ())
2141 fprintf (f, "%*s base odr type ids: ", indent * 2, "");
2142 for (i = 0; i < t->bases.length (); i++)
2143 fprintf (f, " %i", t->bases[i]->id);
2144 fprintf (f, "\n");
2146 if (t->derived_types.length ())
2148 fprintf (f, "%*s derived types:\n", indent * 2, "");
2149 for (i = 0; i < t->derived_types.length (); i++)
2150 dump_odr_type (f, t->derived_types[i], indent + 1);
2152 fprintf (f, "\n");
2155 /* Dump the type inheritance graph. */
2157 static void
2158 dump_type_inheritance_graph (FILE *f)
2160 unsigned int i;
2161 unsigned int num_all_types = 0, num_types = 0, num_duplicates = 0;
2162 if (!odr_types_ptr)
2163 return;
2164 fprintf (f, "\n\nType inheritance graph:\n");
2165 for (i = 0; i < odr_types.length (); i++)
2167 if (odr_types[i] && odr_types[i]->bases.length () == 0)
2168 dump_odr_type (f, odr_types[i]);
2170 for (i = 0; i < odr_types.length (); i++)
2172 if (!odr_types[i])
2173 continue;
2175 num_all_types++;
2176 if (!odr_types[i]->types || !odr_types[i]->types->length ())
2177 continue;
2179 /* To aid ODR warnings we also mangle integer constants but do
2180 not consider duplicates there. */
2181 if (TREE_CODE (odr_types[i]->type) == INTEGER_TYPE)
2182 continue;
2184 /* It is normal to have one duplicate and one normal variant. */
2185 if (odr_types[i]->types->length () == 1
2186 && COMPLETE_TYPE_P (odr_types[i]->type)
2187 && !COMPLETE_TYPE_P ((*odr_types[i]->types)[0]))
2188 continue;
2190 num_types ++;
2192 unsigned int j;
2193 fprintf (f, "Duplicate tree types for odr type %i\n", i);
2194 print_node (f, "", odr_types[i]->type, 0);
2195 print_node (f, "", TYPE_NAME (odr_types[i]->type), 0);
2196 putc ('\n',f);
2197 for (j = 0; j < odr_types[i]->types->length (); j++)
2199 tree t;
2200 num_duplicates ++;
2201 fprintf (f, "duplicate #%i\n", j);
2202 print_node (f, "", (*odr_types[i]->types)[j], 0);
2203 t = (*odr_types[i]->types)[j];
2204 while (TYPE_P (t) && TYPE_CONTEXT (t))
2206 t = TYPE_CONTEXT (t);
2207 print_node (f, "", t, 0);
2209 print_node (f, "", TYPE_NAME ((*odr_types[i]->types)[j]), 0);
2210 putc ('\n',f);
2213 fprintf (f, "Out of %i types there are %i types with duplicates; "
2214 "%i duplicates overall\n", num_all_types, num_types, num_duplicates);
2217 /* Save some WPA->ltrans streaming by freeing stuff needed only for good
2218 ODR warnings.
2219 We make TYPE_DECLs to not point back
2220 to the type (which is needed to keep them in the same SCC and preserve
2221 location information to output warnings) and subsequently we make all
2222 TYPE_DECLS of same assembler name equivalent. */
2224 static void
2225 free_odr_warning_data ()
2227 static bool odr_data_freed = false;
2229 if (odr_data_freed || !flag_wpa || !odr_types_ptr)
2230 return;
2232 odr_data_freed = true;
2234 for (unsigned int i = 0; i < odr_types.length (); i++)
2235 if (odr_types[i])
2237 tree t = odr_types[i]->type;
2239 TREE_TYPE (TYPE_NAME (t)) = void_type_node;
2241 if (odr_types[i]->types)
2242 for (unsigned int j = 0; j < odr_types[i]->types->length (); j++)
2244 tree td = (*odr_types[i]->types)[j];
2246 TYPE_NAME (td) = TYPE_NAME (t);
2249 odr_data_freed = true;
2252 /* Initialize IPA devirt and build inheritance tree graph. */
2254 void
2255 build_type_inheritance_graph (void)
2257 struct symtab_node *n;
2258 FILE *inheritance_dump_file;
2259 dump_flags_t flags;
2261 if (odr_hash)
2263 free_odr_warning_data ();
2264 return;
2266 timevar_push (TV_IPA_INHERITANCE);
2267 inheritance_dump_file = dump_begin (TDI_inheritance, &flags);
2268 odr_hash = new odr_hash_type (23);
2270 /* We reconstruct the graph starting of types of all methods seen in the
2271 unit. */
2272 FOR_EACH_SYMBOL (n)
2273 if (is_a <cgraph_node *> (n)
2274 && DECL_VIRTUAL_P (n->decl)
2275 && n->real_symbol_p ())
2276 get_odr_type (TYPE_METHOD_BASETYPE (TREE_TYPE (n->decl)), true);
2278 /* Look also for virtual tables of types that do not define any methods.
2280 We need it in a case where class B has virtual base of class A
2281 re-defining its virtual method and there is class C with no virtual
2282 methods with B as virtual base.
2284 Here we output B's virtual method in two variant - for non-virtual
2285 and virtual inheritance. B's virtual table has non-virtual version,
2286 while C's has virtual.
2288 For this reason we need to know about C in order to include both
2289 variants of B. More correctly, record_target_from_binfo should
2290 add both variants of the method when walking B, but we have no
2291 link in between them.
2293 We rely on fact that either the method is exported and thus we
2294 assume it is called externally or C is in anonymous namespace and
2295 thus we will see the vtable. */
2297 else if (is_a <varpool_node *> (n)
2298 && DECL_VIRTUAL_P (n->decl)
2299 && TREE_CODE (DECL_CONTEXT (n->decl)) == RECORD_TYPE
2300 && TYPE_BINFO (DECL_CONTEXT (n->decl))
2301 && polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (n->decl))))
2302 get_odr_type (TYPE_MAIN_VARIANT (DECL_CONTEXT (n->decl)), true);
2303 if (inheritance_dump_file)
2305 dump_type_inheritance_graph (inheritance_dump_file);
2306 dump_end (TDI_inheritance, inheritance_dump_file);
2308 free_odr_warning_data ();
2309 timevar_pop (TV_IPA_INHERITANCE);
2312 /* Return true if N has reference from live virtual table
2313 (and thus can be a destination of polymorphic call).
2314 Be conservatively correct when callgraph is not built or
2315 if the method may be referred externally. */
2317 static bool
2318 referenced_from_vtable_p (struct cgraph_node *node)
2320 int i;
2321 struct ipa_ref *ref;
2322 bool found = false;
2324 if (node->externally_visible
2325 || DECL_EXTERNAL (node->decl)
2326 || node->used_from_other_partition)
2327 return true;
2329 /* Keep this test constant time.
2330 It is unlikely this can happen except for the case where speculative
2331 devirtualization introduced many speculative edges to this node.
2332 In this case the target is very likely alive anyway. */
2333 if (node->ref_list.referring.length () > 100)
2334 return true;
2336 /* We need references built. */
2337 if (symtab->state <= CONSTRUCTION)
2338 return true;
2340 for (i = 0; node->iterate_referring (i, ref); i++)
2341 if ((ref->use == IPA_REF_ALIAS
2342 && referenced_from_vtable_p (dyn_cast<cgraph_node *> (ref->referring)))
2343 || (ref->use == IPA_REF_ADDR
2344 && VAR_P (ref->referring->decl)
2345 && DECL_VIRTUAL_P (ref->referring->decl)))
2347 found = true;
2348 break;
2350 return found;
2353 /* Return if TARGET is cxa_pure_virtual. */
2355 static bool
2356 is_cxa_pure_virtual_p (tree target)
2358 return target && TREE_CODE (TREE_TYPE (target)) != METHOD_TYPE
2359 && DECL_NAME (target)
2360 && id_equal (DECL_NAME (target),
2361 "__cxa_pure_virtual");
2364 /* If TARGET has associated node, record it in the NODES array.
2365 CAN_REFER specify if program can refer to the target directly.
2366 if TARGET is unknown (NULL) or it cannot be inserted (for example because
2367 its body was already removed and there is no way to refer to it), clear
2368 COMPLETEP. */
2370 static void
2371 maybe_record_node (vec <cgraph_node *> &nodes,
2372 tree target, hash_set<tree> *inserted,
2373 bool can_refer,
2374 bool *completep)
2376 struct cgraph_node *target_node, *alias_target;
2377 enum availability avail;
2378 bool pure_virtual = is_cxa_pure_virtual_p (target);
2380 /* __builtin_unreachable do not need to be added into
2381 list of targets; the runtime effect of calling them is undefined.
2382 Only "real" virtual methods should be accounted. */
2383 if (target && TREE_CODE (TREE_TYPE (target)) != METHOD_TYPE && !pure_virtual)
2384 return;
2386 if (!can_refer)
2388 /* The only case when method of anonymous namespace becomes unreferable
2389 is when we completely optimized it out. */
2390 if (flag_ltrans
2391 || !target
2392 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target)))
2393 *completep = false;
2394 return;
2397 if (!target)
2398 return;
2400 target_node = cgraph_node::get (target);
2402 /* Prefer alias target over aliases, so we do not get confused by
2403 fake duplicates. */
2404 if (target_node)
2406 alias_target = target_node->ultimate_alias_target (&avail);
2407 if (target_node != alias_target
2408 && avail >= AVAIL_AVAILABLE
2409 && target_node->get_availability ())
2410 target_node = alias_target;
2413 /* Method can only be called by polymorphic call if any
2414 of vtables referring to it are alive.
2416 While this holds for non-anonymous functions, too, there are
2417 cases where we want to keep them in the list; for example
2418 inline functions with -fno-weak are static, but we still
2419 may devirtualize them when instance comes from other unit.
2420 The same holds for LTO.
2422 Currently we ignore these functions in speculative devirtualization.
2423 ??? Maybe it would make sense to be more aggressive for LTO even
2424 elsewhere. */
2425 if (!flag_ltrans
2426 && !pure_virtual
2427 && type_in_anonymous_namespace_p (DECL_CONTEXT (target))
2428 && (!target_node
2429 || !referenced_from_vtable_p (target_node)))
2431 /* See if TARGET is useful function we can deal with. */
2432 else if (target_node != NULL
2433 && (TREE_PUBLIC (target)
2434 || DECL_EXTERNAL (target)
2435 || target_node->definition)
2436 && target_node->real_symbol_p ())
2438 gcc_assert (!target_node->inlined_to);
2439 gcc_assert (target_node->real_symbol_p ());
2440 /* When sanitizing, do not assume that __cxa_pure_virtual is not called
2441 by valid program. */
2442 if (flag_sanitize & SANITIZE_UNREACHABLE)
2444 /* Only add pure virtual if it is the only possible target. This way
2445 we will preserve the diagnostics about pure virtual called in many
2446 cases without disabling optimization in other. */
2447 else if (pure_virtual)
2449 if (nodes.length ())
2450 return;
2452 /* If we found a real target, take away cxa_pure_virtual. */
2453 else if (!pure_virtual && nodes.length () == 1
2454 && is_cxa_pure_virtual_p (nodes[0]->decl))
2455 nodes.pop ();
2456 if (pure_virtual && nodes.length ())
2457 return;
2458 if (!inserted->add (target))
2460 cached_polymorphic_call_targets->add (target_node);
2461 nodes.safe_push (target_node);
2464 else if (!completep)
2466 /* We have definition of __cxa_pure_virtual that is not accessible (it is
2467 optimized out or partitioned to other unit) so we cannot add it. When
2468 not sanitizing, there is nothing to do.
2469 Otherwise declare the list incomplete. */
2470 else if (pure_virtual)
2472 if (flag_sanitize & SANITIZE_UNREACHABLE)
2473 *completep = false;
2475 else if (flag_ltrans
2476 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target)))
2477 *completep = false;
2480 /* See if BINFO's type matches OUTER_TYPE. If so, look up
2481 BINFO of subtype of OTR_TYPE at OFFSET and in that BINFO find
2482 method in vtable and insert method to NODES array
2483 or BASES_TO_CONSIDER if this array is non-NULL.
2484 Otherwise recurse to base BINFOs.
2485 This matches what get_binfo_at_offset does, but with offset
2486 being unknown.
2488 TYPE_BINFOS is a stack of BINFOS of types with defined
2489 virtual table seen on way from class type to BINFO.
2491 MATCHED_VTABLES tracks virtual tables we already did lookup
2492 for virtual function in. INSERTED tracks nodes we already
2493 inserted.
2495 ANONYMOUS is true if BINFO is part of anonymous namespace.
2497 Clear COMPLETEP when we hit unreferable target.
2500 static void
2501 record_target_from_binfo (vec <cgraph_node *> &nodes,
2502 vec <tree> *bases_to_consider,
2503 tree binfo,
2504 tree otr_type,
2505 vec <tree> &type_binfos,
2506 HOST_WIDE_INT otr_token,
2507 tree outer_type,
2508 HOST_WIDE_INT offset,
2509 hash_set<tree> *inserted,
2510 hash_set<tree> *matched_vtables,
2511 bool anonymous,
2512 bool *completep)
2514 tree type = BINFO_TYPE (binfo);
2515 int i;
2516 tree base_binfo;
2519 if (BINFO_VTABLE (binfo))
2520 type_binfos.safe_push (binfo);
2521 if (types_same_for_odr (type, outer_type))
2523 int i;
2524 tree type_binfo = NULL;
2526 /* Look up BINFO with virtual table. For normal types it is always last
2527 binfo on stack. */
2528 for (i = type_binfos.length () - 1; i >= 0; i--)
2529 if (BINFO_OFFSET (type_binfos[i]) == BINFO_OFFSET (binfo))
2531 type_binfo = type_binfos[i];
2532 break;
2534 if (BINFO_VTABLE (binfo))
2535 type_binfos.pop ();
2536 /* If this is duplicated BINFO for base shared by virtual inheritance,
2537 we may not have its associated vtable. This is not a problem, since
2538 we will walk it on the other path. */
2539 if (!type_binfo)
2540 return;
2541 tree inner_binfo = get_binfo_at_offset (type_binfo,
2542 offset, otr_type);
2543 if (!inner_binfo)
2545 gcc_assert (odr_violation_reported);
2546 return;
2548 /* For types in anonymous namespace first check if the respective vtable
2549 is alive. If not, we know the type can't be called. */
2550 if (!flag_ltrans && anonymous)
2552 tree vtable = BINFO_VTABLE (inner_binfo);
2553 varpool_node *vnode;
2555 if (TREE_CODE (vtable) == POINTER_PLUS_EXPR)
2556 vtable = TREE_OPERAND (TREE_OPERAND (vtable, 0), 0);
2557 vnode = varpool_node::get (vtable);
2558 if (!vnode || !vnode->definition)
2559 return;
2561 gcc_assert (inner_binfo);
2562 if (bases_to_consider
2563 ? !matched_vtables->contains (BINFO_VTABLE (inner_binfo))
2564 : !matched_vtables->add (BINFO_VTABLE (inner_binfo)))
2566 bool can_refer;
2567 tree target = gimple_get_virt_method_for_binfo (otr_token,
2568 inner_binfo,
2569 &can_refer);
2570 if (!bases_to_consider)
2571 maybe_record_node (nodes, target, inserted, can_refer, completep);
2572 /* Destructors are never called via construction vtables. */
2573 else if (!target || !DECL_CXX_DESTRUCTOR_P (target))
2574 bases_to_consider->safe_push (target);
2576 return;
2579 /* Walk bases. */
2580 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2581 /* Walking bases that have no virtual method is pointless exercise. */
2582 if (polymorphic_type_binfo_p (base_binfo))
2583 record_target_from_binfo (nodes, bases_to_consider, base_binfo, otr_type,
2584 type_binfos,
2585 otr_token, outer_type, offset, inserted,
2586 matched_vtables, anonymous, completep);
2587 if (BINFO_VTABLE (binfo))
2588 type_binfos.pop ();
2591 /* Look up virtual methods matching OTR_TYPE (with OFFSET and OTR_TOKEN)
2592 of TYPE, insert them to NODES, recurse into derived nodes.
2593 INSERTED is used to avoid duplicate insertions of methods into NODES.
2594 MATCHED_VTABLES are used to avoid duplicate walking vtables.
2595 Clear COMPLETEP if unreferable target is found.
2597 If CONSIDER_CONSTRUCTION is true, record to BASES_TO_CONSIDER
2598 all cases where BASE_SKIPPED is true (because the base is abstract
2599 class). */
2601 static void
2602 possible_polymorphic_call_targets_1 (vec <cgraph_node *> &nodes,
2603 hash_set<tree> *inserted,
2604 hash_set<tree> *matched_vtables,
2605 tree otr_type,
2606 odr_type type,
2607 HOST_WIDE_INT otr_token,
2608 tree outer_type,
2609 HOST_WIDE_INT offset,
2610 bool *completep,
2611 vec <tree> &bases_to_consider,
2612 bool consider_construction)
2614 tree binfo = TYPE_BINFO (type->type);
2615 unsigned int i;
2616 auto_vec <tree, 8> type_binfos;
2617 bool possibly_instantiated = type_possibly_instantiated_p (type->type);
2619 /* We may need to consider types w/o instances because of possible derived
2620 types using their methods either directly or via construction vtables.
2621 We are safe to skip them when all derivations are known, since we will
2622 handle them later.
2623 This is done by recording them to BASES_TO_CONSIDER array. */
2624 if (possibly_instantiated || consider_construction)
2626 record_target_from_binfo (nodes,
2627 (!possibly_instantiated
2628 && type_all_derivations_known_p (type->type))
2629 ? &bases_to_consider : NULL,
2630 binfo, otr_type, type_binfos, otr_token,
2631 outer_type, offset,
2632 inserted, matched_vtables,
2633 type->anonymous_namespace, completep);
2635 for (i = 0; i < type->derived_types.length (); i++)
2636 possible_polymorphic_call_targets_1 (nodes, inserted,
2637 matched_vtables,
2638 otr_type,
2639 type->derived_types[i],
2640 otr_token, outer_type, offset, completep,
2641 bases_to_consider, consider_construction);
2644 /* Cache of queries for polymorphic call targets.
2646 Enumerating all call targets may get expensive when there are many
2647 polymorphic calls in the program, so we memoize all the previous
2648 queries and avoid duplicated work. */
2650 class polymorphic_call_target_d
2652 public:
2653 HOST_WIDE_INT otr_token;
2654 ipa_polymorphic_call_context context;
2655 odr_type type;
2656 vec <cgraph_node *> targets;
2657 tree decl_warning;
2658 int type_warning;
2659 unsigned int n_odr_types;
2660 bool complete;
2661 bool speculative;
2664 /* Polymorphic call target cache helpers. */
2666 struct polymorphic_call_target_hasher
2667 : pointer_hash <polymorphic_call_target_d>
2669 static inline hashval_t hash (const polymorphic_call_target_d *);
2670 static inline bool equal (const polymorphic_call_target_d *,
2671 const polymorphic_call_target_d *);
2672 static inline void remove (polymorphic_call_target_d *);
2675 /* Return the computed hashcode for ODR_QUERY. */
2677 inline hashval_t
2678 polymorphic_call_target_hasher::hash (const polymorphic_call_target_d *odr_query)
2680 inchash::hash hstate (odr_query->otr_token);
2682 hstate.add_hwi (odr_query->type->id);
2683 hstate.merge_hash (TYPE_UID (odr_query->context.outer_type));
2684 hstate.add_hwi (odr_query->context.offset);
2685 hstate.add_hwi (odr_query->n_odr_types);
2687 if (odr_query->context.speculative_outer_type)
2689 hstate.merge_hash (TYPE_UID (odr_query->context.speculative_outer_type));
2690 hstate.add_hwi (odr_query->context.speculative_offset);
2692 hstate.add_flag (odr_query->speculative);
2693 hstate.add_flag (odr_query->context.maybe_in_construction);
2694 hstate.add_flag (odr_query->context.maybe_derived_type);
2695 hstate.add_flag (odr_query->context.speculative_maybe_derived_type);
2696 hstate.commit_flag ();
2697 return hstate.end ();
2700 /* Compare cache entries T1 and T2. */
2702 inline bool
2703 polymorphic_call_target_hasher::equal (const polymorphic_call_target_d *t1,
2704 const polymorphic_call_target_d *t2)
2706 return (t1->type == t2->type && t1->otr_token == t2->otr_token
2707 && t1->speculative == t2->speculative
2708 && t1->context.offset == t2->context.offset
2709 && t1->context.speculative_offset == t2->context.speculative_offset
2710 && t1->context.outer_type == t2->context.outer_type
2711 && t1->context.speculative_outer_type == t2->context.speculative_outer_type
2712 && t1->context.maybe_in_construction
2713 == t2->context.maybe_in_construction
2714 && t1->context.maybe_derived_type == t2->context.maybe_derived_type
2715 && (t1->context.speculative_maybe_derived_type
2716 == t2->context.speculative_maybe_derived_type)
2717 /* Adding new type may affect outcome of target search. */
2718 && t1->n_odr_types == t2->n_odr_types);
2721 /* Remove entry in polymorphic call target cache hash. */
2723 inline void
2724 polymorphic_call_target_hasher::remove (polymorphic_call_target_d *v)
2726 v->targets.release ();
2727 free (v);
2730 /* Polymorphic call target query cache. */
2732 typedef hash_table<polymorphic_call_target_hasher>
2733 polymorphic_call_target_hash_type;
2734 static polymorphic_call_target_hash_type *polymorphic_call_target_hash;
2736 /* Destroy polymorphic call target query cache. */
2738 static void
2739 free_polymorphic_call_targets_hash ()
2741 if (cached_polymorphic_call_targets)
2743 delete polymorphic_call_target_hash;
2744 polymorphic_call_target_hash = NULL;
2745 delete cached_polymorphic_call_targets;
2746 cached_polymorphic_call_targets = NULL;
2750 /* Force rebuilding type inheritance graph from scratch.
2751 This is use to make sure that we do not keep references to types
2752 which was not visible to free_lang_data. */
2754 void
2755 rebuild_type_inheritance_graph ()
2757 if (!odr_hash)
2758 return;
2759 delete odr_hash;
2760 odr_hash = NULL;
2761 odr_types_ptr = NULL;
2762 free_polymorphic_call_targets_hash ();
2765 /* When virtual function is removed, we may need to flush the cache. */
2767 static void
2768 devirt_node_removal_hook (struct cgraph_node *n, void *d ATTRIBUTE_UNUSED)
2770 if (cached_polymorphic_call_targets
2771 && !thunk_expansion
2772 && cached_polymorphic_call_targets->contains (n))
2773 free_polymorphic_call_targets_hash ();
2776 /* Look up base of BINFO that has virtual table VTABLE with OFFSET. */
2778 tree
2779 subbinfo_with_vtable_at_offset (tree binfo, unsigned HOST_WIDE_INT offset,
2780 tree vtable)
2782 tree v = BINFO_VTABLE (binfo);
2783 int i;
2784 tree base_binfo;
2785 unsigned HOST_WIDE_INT this_offset;
2787 if (v)
2789 if (!vtable_pointer_value_to_vtable (v, &v, &this_offset))
2790 gcc_unreachable ();
2792 if (offset == this_offset
2793 && DECL_ASSEMBLER_NAME (v) == DECL_ASSEMBLER_NAME (vtable))
2794 return binfo;
2797 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2798 if (polymorphic_type_binfo_p (base_binfo))
2800 base_binfo = subbinfo_with_vtable_at_offset (base_binfo, offset, vtable);
2801 if (base_binfo)
2802 return base_binfo;
2804 return NULL;
2807 /* T is known constant value of virtual table pointer.
2808 Store virtual table to V and its offset to OFFSET.
2809 Return false if T does not look like virtual table reference. */
2811 bool
2812 vtable_pointer_value_to_vtable (const_tree t, tree *v,
2813 unsigned HOST_WIDE_INT *offset)
2815 /* We expect &MEM[(void *)&virtual_table + 16B].
2816 We obtain object's BINFO from the context of the virtual table.
2817 This one contains pointer to virtual table represented via
2818 POINTER_PLUS_EXPR. Verify that this pointer matches what
2819 we propagated through.
2821 In the case of virtual inheritance, the virtual tables may
2822 be nested, i.e. the offset may be different from 16 and we may
2823 need to dive into the type representation. */
2824 if (TREE_CODE (t) == ADDR_EXPR
2825 && TREE_CODE (TREE_OPERAND (t, 0)) == MEM_REF
2826 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == ADDR_EXPR
2827 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 1)) == INTEGER_CST
2828 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 0))
2829 == VAR_DECL)
2830 && DECL_VIRTUAL_P (TREE_OPERAND (TREE_OPERAND
2831 (TREE_OPERAND (t, 0), 0), 0)))
2833 *v = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 0);
2834 *offset = tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (t, 0), 1));
2835 return true;
2838 /* Alternative representation, used by C++ frontend is POINTER_PLUS_EXPR.
2839 We need to handle it when T comes from static variable initializer or
2840 BINFO. */
2841 if (TREE_CODE (t) == POINTER_PLUS_EXPR)
2843 *offset = tree_to_uhwi (TREE_OPERAND (t, 1));
2844 t = TREE_OPERAND (t, 0);
2846 else
2847 *offset = 0;
2849 if (TREE_CODE (t) != ADDR_EXPR)
2850 return false;
2851 *v = TREE_OPERAND (t, 0);
2852 return true;
2855 /* T is known constant value of virtual table pointer. Return BINFO of the
2856 instance type. */
2858 tree
2859 vtable_pointer_value_to_binfo (const_tree t)
2861 tree vtable;
2862 unsigned HOST_WIDE_INT offset;
2864 if (!vtable_pointer_value_to_vtable (t, &vtable, &offset))
2865 return NULL_TREE;
2867 /* FIXME: for stores of construction vtables we return NULL,
2868 because we do not have BINFO for those. Eventually we should fix
2869 our representation to allow this case to be handled, too.
2870 In the case we see store of BINFO we however may assume
2871 that standard folding will be able to cope with it. */
2872 return subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable)),
2873 offset, vtable);
2876 /* Walk bases of OUTER_TYPE that contain OTR_TYPE at OFFSET.
2877 Look up their respective virtual methods for OTR_TOKEN and OTR_TYPE
2878 and insert them in NODES.
2880 MATCHED_VTABLES and INSERTED is used to avoid duplicated work. */
2882 static void
2883 record_targets_from_bases (tree otr_type,
2884 HOST_WIDE_INT otr_token,
2885 tree outer_type,
2886 HOST_WIDE_INT offset,
2887 vec <cgraph_node *> &nodes,
2888 hash_set<tree> *inserted,
2889 hash_set<tree> *matched_vtables,
2890 bool *completep)
2892 while (true)
2894 HOST_WIDE_INT pos, size;
2895 tree base_binfo;
2896 tree fld;
2898 if (types_same_for_odr (outer_type, otr_type))
2899 return;
2901 for (fld = TYPE_FIELDS (outer_type); fld; fld = DECL_CHAIN (fld))
2903 if (TREE_CODE (fld) != FIELD_DECL)
2904 continue;
2906 pos = int_bit_position (fld);
2907 size = tree_to_shwi (DECL_SIZE (fld));
2908 if (pos <= offset && (pos + size) > offset
2909 /* Do not get confused by zero sized bases. */
2910 && polymorphic_type_binfo_p (TYPE_BINFO (TREE_TYPE (fld))))
2911 break;
2913 /* Within a class type we should always find corresponding fields. */
2914 gcc_assert (fld && TREE_CODE (TREE_TYPE (fld)) == RECORD_TYPE);
2916 /* Nonbase types should have been stripped by outer_class_type. */
2917 gcc_assert (DECL_ARTIFICIAL (fld));
2919 outer_type = TREE_TYPE (fld);
2920 offset -= pos;
2922 base_binfo = get_binfo_at_offset (TYPE_BINFO (outer_type),
2923 offset, otr_type);
2924 if (!base_binfo)
2926 gcc_assert (odr_violation_reported);
2927 return;
2929 gcc_assert (base_binfo);
2930 if (!matched_vtables->add (BINFO_VTABLE (base_binfo)))
2932 bool can_refer;
2933 tree target = gimple_get_virt_method_for_binfo (otr_token,
2934 base_binfo,
2935 &can_refer);
2936 if (!target || ! DECL_CXX_DESTRUCTOR_P (target))
2937 maybe_record_node (nodes, target, inserted, can_refer, completep);
2938 matched_vtables->add (BINFO_VTABLE (base_binfo));
2943 /* When virtual table is removed, we may need to flush the cache. */
2945 static void
2946 devirt_variable_node_removal_hook (varpool_node *n,
2947 void *d ATTRIBUTE_UNUSED)
2949 if (cached_polymorphic_call_targets
2950 && DECL_VIRTUAL_P (n->decl)
2951 && type_in_anonymous_namespace_p (DECL_CONTEXT (n->decl)))
2952 free_polymorphic_call_targets_hash ();
2955 /* Record about how many calls would benefit from given type to be final. */
2957 struct odr_type_warn_count
2959 tree type;
2960 int count;
2961 profile_count dyn_count;
2964 /* Record about how many calls would benefit from given method to be final. */
2966 struct decl_warn_count
2968 tree decl;
2969 int count;
2970 profile_count dyn_count;
2973 /* Information about type and decl warnings. */
2975 class final_warning_record
2977 public:
2978 /* If needed grow type_warnings vector and initialize new decl_warn_count
2979 to have dyn_count set to profile_count::zero (). */
2980 void grow_type_warnings (unsigned newlen);
2982 profile_count dyn_count;
2983 auto_vec<odr_type_warn_count> type_warnings;
2984 hash_map<tree, decl_warn_count> decl_warnings;
2987 void
2988 final_warning_record::grow_type_warnings (unsigned newlen)
2990 unsigned len = type_warnings.length ();
2991 if (newlen > len)
2993 type_warnings.safe_grow_cleared (newlen, true);
2994 for (unsigned i = len; i < newlen; i++)
2995 type_warnings[i].dyn_count = profile_count::zero ();
2999 class final_warning_record *final_warning_records;
3001 /* Return vector containing possible targets of polymorphic call of type
3002 OTR_TYPE calling method OTR_TOKEN within type of OTR_OUTER_TYPE and OFFSET.
3003 If INCLUDE_BASES is true, walk also base types of OUTER_TYPES containing
3004 OTR_TYPE and include their virtual method. This is useful for types
3005 possibly in construction or destruction where the virtual table may
3006 temporarily change to one of base types. INCLUDE_DERIVED_TYPES make
3007 us to walk the inheritance graph for all derivations.
3009 If COMPLETEP is non-NULL, store true if the list is complete.
3010 CACHE_TOKEN (if non-NULL) will get stored to an unique ID of entry
3011 in the target cache. If user needs to visit every target list
3012 just once, it can memoize them.
3014 If SPECULATIVE is set, the list will not contain targets that
3015 are not speculatively taken.
3017 Returned vector is placed into cache. It is NOT caller's responsibility
3018 to free it. The vector can be freed on cgraph_remove_node call if
3019 the particular node is a virtual function present in the cache. */
3021 vec <cgraph_node *>
3022 possible_polymorphic_call_targets (tree otr_type,
3023 HOST_WIDE_INT otr_token,
3024 ipa_polymorphic_call_context context,
3025 bool *completep,
3026 void **cache_token,
3027 bool speculative)
3029 static struct cgraph_node_hook_list *node_removal_hook_holder;
3030 vec <cgraph_node *> nodes = vNULL;
3031 auto_vec <tree, 8> bases_to_consider;
3032 odr_type type, outer_type;
3033 polymorphic_call_target_d key;
3034 polymorphic_call_target_d **slot;
3035 unsigned int i;
3036 tree binfo, target;
3037 bool complete;
3038 bool can_refer = false;
3039 bool skipped = false;
3041 otr_type = TYPE_MAIN_VARIANT (otr_type);
3043 /* If ODR is not initialized or the context is invalid, return empty
3044 incomplete list. */
3045 if (!odr_hash || context.invalid || !TYPE_BINFO (otr_type))
3047 if (completep)
3048 *completep = context.invalid;
3049 if (cache_token)
3050 *cache_token = NULL;
3051 return nodes;
3054 /* Do not bother to compute speculative info when user do not asks for it. */
3055 if (!speculative || !context.speculative_outer_type)
3056 context.clear_speculation ();
3058 type = get_odr_type (otr_type, true);
3060 /* Recording type variants would waste results cache. */
3061 gcc_assert (!context.outer_type
3062 || TYPE_MAIN_VARIANT (context.outer_type) == context.outer_type);
3064 /* Look up the outer class type we want to walk.
3065 If we fail to do so, the context is invalid. */
3066 if ((context.outer_type || context.speculative_outer_type)
3067 && !context.restrict_to_inner_class (otr_type))
3069 if (completep)
3070 *completep = true;
3071 if (cache_token)
3072 *cache_token = NULL;
3073 return nodes;
3075 gcc_assert (!context.invalid);
3077 /* Check that restrict_to_inner_class kept the main variant. */
3078 gcc_assert (!context.outer_type
3079 || TYPE_MAIN_VARIANT (context.outer_type) == context.outer_type);
3081 /* We canonicalize our query, so we do not need extra hashtable entries. */
3083 /* Without outer type, we have no use for offset. Just do the
3084 basic search from inner type. */
3085 if (!context.outer_type)
3086 context.clear_outer_type (otr_type);
3087 /* We need to update our hierarchy if the type does not exist. */
3088 outer_type = get_odr_type (context.outer_type, true);
3089 /* If the type is complete, there are no derivations. */
3090 if (TYPE_FINAL_P (outer_type->type))
3091 context.maybe_derived_type = false;
3093 /* Initialize query cache. */
3094 if (!cached_polymorphic_call_targets)
3096 cached_polymorphic_call_targets = new hash_set<cgraph_node *>;
3097 polymorphic_call_target_hash
3098 = new polymorphic_call_target_hash_type (23);
3099 if (!node_removal_hook_holder)
3101 node_removal_hook_holder =
3102 symtab->add_cgraph_removal_hook (&devirt_node_removal_hook, NULL);
3103 symtab->add_varpool_removal_hook (&devirt_variable_node_removal_hook,
3104 NULL);
3108 if (in_lto_p)
3110 if (context.outer_type != otr_type)
3111 context.outer_type
3112 = get_odr_type (context.outer_type, true)->type;
3113 if (context.speculative_outer_type)
3114 context.speculative_outer_type
3115 = get_odr_type (context.speculative_outer_type, true)->type;
3118 /* Look up cached answer. */
3119 key.type = type;
3120 key.otr_token = otr_token;
3121 key.speculative = speculative;
3122 key.context = context;
3123 key.n_odr_types = odr_types.length ();
3124 slot = polymorphic_call_target_hash->find_slot (&key, INSERT);
3125 if (cache_token)
3126 *cache_token = (void *)*slot;
3127 if (*slot)
3129 if (completep)
3130 *completep = (*slot)->complete;
3131 if ((*slot)->type_warning && final_warning_records)
3133 final_warning_records->type_warnings[(*slot)->type_warning - 1].count++;
3134 if (!final_warning_records->type_warnings
3135 [(*slot)->type_warning - 1].dyn_count.initialized_p ())
3136 final_warning_records->type_warnings
3137 [(*slot)->type_warning - 1].dyn_count = profile_count::zero ();
3138 if (final_warning_records->dyn_count > 0)
3139 final_warning_records->type_warnings[(*slot)->type_warning - 1].dyn_count
3140 = final_warning_records->type_warnings[(*slot)->type_warning - 1].dyn_count
3141 + final_warning_records->dyn_count;
3143 if (!speculative && (*slot)->decl_warning && final_warning_records)
3145 struct decl_warn_count *c =
3146 final_warning_records->decl_warnings.get ((*slot)->decl_warning);
3147 c->count++;
3148 if (final_warning_records->dyn_count > 0)
3149 c->dyn_count += final_warning_records->dyn_count;
3151 return (*slot)->targets;
3154 complete = true;
3156 /* Do actual search. */
3157 timevar_push (TV_IPA_VIRTUAL_CALL);
3158 *slot = XCNEW (polymorphic_call_target_d);
3159 if (cache_token)
3160 *cache_token = (void *)*slot;
3161 (*slot)->type = type;
3162 (*slot)->otr_token = otr_token;
3163 (*slot)->context = context;
3164 (*slot)->speculative = speculative;
3166 hash_set<tree> inserted;
3167 hash_set<tree> matched_vtables;
3169 /* First insert targets we speculatively identified as likely. */
3170 if (context.speculative_outer_type)
3172 odr_type speculative_outer_type;
3173 bool speculation_complete = true;
3175 /* First insert target from type itself and check if it may have
3176 derived types. */
3177 speculative_outer_type = get_odr_type (context.speculative_outer_type, true);
3178 if (TYPE_FINAL_P (speculative_outer_type->type))
3179 context.speculative_maybe_derived_type = false;
3180 binfo = get_binfo_at_offset (TYPE_BINFO (speculative_outer_type->type),
3181 context.speculative_offset, otr_type);
3182 if (binfo)
3183 target = gimple_get_virt_method_for_binfo (otr_token, binfo,
3184 &can_refer);
3185 else
3186 target = NULL;
3188 /* In the case we get complete method, we don't need
3189 to walk derivations. */
3190 if (target && DECL_FINAL_P (target))
3191 context.speculative_maybe_derived_type = false;
3192 if (type_possibly_instantiated_p (speculative_outer_type->type))
3193 maybe_record_node (nodes, target, &inserted, can_refer, &speculation_complete);
3194 if (binfo)
3195 matched_vtables.add (BINFO_VTABLE (binfo));
3198 /* Next walk recursively all derived types. */
3199 if (context.speculative_maybe_derived_type)
3200 for (i = 0; i < speculative_outer_type->derived_types.length(); i++)
3201 possible_polymorphic_call_targets_1 (nodes, &inserted,
3202 &matched_vtables,
3203 otr_type,
3204 speculative_outer_type->derived_types[i],
3205 otr_token, speculative_outer_type->type,
3206 context.speculative_offset,
3207 &speculation_complete,
3208 bases_to_consider,
3209 false);
3212 if (!speculative || !nodes.length ())
3214 /* First see virtual method of type itself. */
3215 binfo = get_binfo_at_offset (TYPE_BINFO (outer_type->type),
3216 context.offset, otr_type);
3217 if (binfo)
3218 target = gimple_get_virt_method_for_binfo (otr_token, binfo,
3219 &can_refer);
3220 else
3222 gcc_assert (odr_violation_reported);
3223 target = NULL;
3226 /* Destructors are never called through construction virtual tables,
3227 because the type is always known. */
3228 if (target && DECL_CXX_DESTRUCTOR_P (target))
3229 context.maybe_in_construction = false;
3231 if (target)
3233 /* In the case we get complete method, we don't need
3234 to walk derivations. */
3235 if (DECL_FINAL_P (target))
3236 context.maybe_derived_type = false;
3239 /* If OUTER_TYPE is abstract, we know we are not seeing its instance. */
3240 if (type_possibly_instantiated_p (outer_type->type))
3241 maybe_record_node (nodes, target, &inserted, can_refer, &complete);
3242 else
3243 skipped = true;
3245 if (binfo)
3246 matched_vtables.add (BINFO_VTABLE (binfo));
3248 /* Next walk recursively all derived types. */
3249 if (context.maybe_derived_type)
3251 for (i = 0; i < outer_type->derived_types.length(); i++)
3252 possible_polymorphic_call_targets_1 (nodes, &inserted,
3253 &matched_vtables,
3254 otr_type,
3255 outer_type->derived_types[i],
3256 otr_token, outer_type->type,
3257 context.offset, &complete,
3258 bases_to_consider,
3259 context.maybe_in_construction);
3261 if (!outer_type->all_derivations_known)
3263 if (!speculative && final_warning_records
3264 && nodes.length () == 1
3265 && TREE_CODE (TREE_TYPE (nodes[0]->decl)) == METHOD_TYPE)
3267 if (complete
3268 && warn_suggest_final_types
3269 && !outer_type->derived_types.length ())
3271 final_warning_records->grow_type_warnings
3272 (outer_type->id);
3273 final_warning_records->type_warnings[outer_type->id].count++;
3274 if (!final_warning_records->type_warnings
3275 [outer_type->id].dyn_count.initialized_p ())
3276 final_warning_records->type_warnings
3277 [outer_type->id].dyn_count = profile_count::zero ();
3278 final_warning_records->type_warnings[outer_type->id].dyn_count
3279 += final_warning_records->dyn_count;
3280 final_warning_records->type_warnings[outer_type->id].type
3281 = outer_type->type;
3282 (*slot)->type_warning = outer_type->id + 1;
3284 if (complete
3285 && warn_suggest_final_methods
3286 && types_same_for_odr (DECL_CONTEXT (nodes[0]->decl),
3287 outer_type->type))
3289 bool existed;
3290 struct decl_warn_count &c =
3291 final_warning_records->decl_warnings.get_or_insert
3292 (nodes[0]->decl, &existed);
3294 if (existed)
3296 c.count++;
3297 c.dyn_count += final_warning_records->dyn_count;
3299 else
3301 c.count = 1;
3302 c.dyn_count = final_warning_records->dyn_count;
3303 c.decl = nodes[0]->decl;
3305 (*slot)->decl_warning = nodes[0]->decl;
3308 complete = false;
3312 if (!speculative)
3314 /* Destructors are never called through construction virtual tables,
3315 because the type is always known. One of entries may be
3316 cxa_pure_virtual so look to at least two of them. */
3317 if (context.maybe_in_construction)
3318 for (i =0 ; i < MIN (nodes.length (), 2); i++)
3319 if (DECL_CXX_DESTRUCTOR_P (nodes[i]->decl))
3320 context.maybe_in_construction = false;
3321 if (context.maybe_in_construction)
3323 if (type != outer_type
3324 && (!skipped
3325 || (context.maybe_derived_type
3326 && !type_all_derivations_known_p (outer_type->type))))
3327 record_targets_from_bases (otr_type, otr_token, outer_type->type,
3328 context.offset, nodes, &inserted,
3329 &matched_vtables, &complete);
3330 if (skipped)
3331 maybe_record_node (nodes, target, &inserted, can_refer, &complete);
3332 for (i = 0; i < bases_to_consider.length(); i++)
3333 maybe_record_node (nodes, bases_to_consider[i], &inserted, can_refer, &complete);
3338 (*slot)->targets = nodes;
3339 (*slot)->complete = complete;
3340 (*slot)->n_odr_types = odr_types.length ();
3341 if (completep)
3342 *completep = complete;
3344 timevar_pop (TV_IPA_VIRTUAL_CALL);
3345 return nodes;
3348 bool
3349 add_decl_warning (const tree &key ATTRIBUTE_UNUSED, const decl_warn_count &value,
3350 vec<const decl_warn_count*> *vec)
3352 vec->safe_push (&value);
3353 return true;
3356 /* Dump target list TARGETS into FILE. */
3358 static void
3359 dump_targets (FILE *f, vec <cgraph_node *> targets, bool verbose)
3361 unsigned int i;
3363 for (i = 0; i < targets.length (); i++)
3365 char *name = NULL;
3366 if (in_lto_p)
3367 name = cplus_demangle_v3 (targets[i]->asm_name (), 0);
3368 fprintf (f, " %s", name ? name : targets[i]->dump_name ());
3369 if (in_lto_p)
3370 free (name);
3371 if (!targets[i]->definition)
3372 fprintf (f, " (no definition%s)",
3373 DECL_DECLARED_INLINE_P (targets[i]->decl)
3374 ? " inline" : "");
3375 /* With many targets for every call polymorphic dumps are going to
3376 be quadratic in size. */
3377 if (i > 10 && !verbose)
3379 fprintf (f, " ... and %i more targets\n", targets.length () - i);
3380 return;
3383 fprintf (f, "\n");
3386 /* Dump all possible targets of a polymorphic call. */
3388 void
3389 dump_possible_polymorphic_call_targets (FILE *f,
3390 tree otr_type,
3391 HOST_WIDE_INT otr_token,
3392 const ipa_polymorphic_call_context &ctx,
3393 bool verbose)
3395 vec <cgraph_node *> targets;
3396 bool final;
3397 odr_type type = get_odr_type (TYPE_MAIN_VARIANT (otr_type), false);
3398 unsigned int len;
3400 if (!type)
3401 return;
3402 targets = possible_polymorphic_call_targets (otr_type, otr_token,
3403 ctx,
3404 &final, NULL, false);
3405 fprintf (f, " Targets of polymorphic call of type %i:", type->id);
3406 print_generic_expr (f, type->type, TDF_SLIM);
3407 fprintf (f, " token %i\n", (int)otr_token);
3409 ctx.dump (f);
3411 fprintf (f, " %s%s%s%s\n ",
3412 final ? "This is a complete list." :
3413 "This is partial list; extra targets may be defined in other units.",
3414 ctx.maybe_in_construction ? " (base types included)" : "",
3415 ctx.maybe_derived_type ? " (derived types included)" : "",
3416 ctx.speculative_maybe_derived_type ? " (speculative derived types included)" : "");
3417 len = targets.length ();
3418 dump_targets (f, targets, verbose);
3420 targets = possible_polymorphic_call_targets (otr_type, otr_token,
3421 ctx,
3422 &final, NULL, true);
3423 if (targets.length () != len)
3425 fprintf (f, " Speculative targets:");
3426 dump_targets (f, targets, verbose);
3428 /* Ugly: during callgraph construction the target cache may get populated
3429 before all targets are found. While this is harmless (because all local
3430 types are discovered and only in those case we devirtualize fully and we
3431 don't do speculative devirtualization before IPA stage) it triggers
3432 assert here when dumping at that stage also populates the case with
3433 speculative targets. Quietly ignore this. */
3434 gcc_assert (symtab->state < IPA_SSA || targets.length () <= len);
3435 fprintf (f, "\n");
3439 /* Return true if N can be possibly target of a polymorphic call of
3440 OTR_TYPE/OTR_TOKEN. */
3442 bool
3443 possible_polymorphic_call_target_p (tree otr_type,
3444 HOST_WIDE_INT otr_token,
3445 const ipa_polymorphic_call_context &ctx,
3446 struct cgraph_node *n)
3448 vec <cgraph_node *> targets;
3449 unsigned int i;
3450 bool final;
3452 if (fndecl_built_in_p (n->decl, BUILT_IN_UNREACHABLE)
3453 || fndecl_built_in_p (n->decl, BUILT_IN_TRAP))
3454 return true;
3456 if (is_cxa_pure_virtual_p (n->decl))
3457 return true;
3459 if (!odr_hash)
3460 return true;
3461 targets = possible_polymorphic_call_targets (otr_type, otr_token, ctx, &final);
3462 for (i = 0; i < targets.length (); i++)
3463 if (n->semantically_equivalent_p (targets[i]))
3464 return true;
3466 /* At a moment we allow middle end to dig out new external declarations
3467 as a targets of polymorphic calls. */
3468 if (!final && !n->definition)
3469 return true;
3470 return false;
3475 /* Return true if N can be possibly target of a polymorphic call of
3476 OBJ_TYPE_REF expression REF in STMT. */
3478 bool
3479 possible_polymorphic_call_target_p (tree ref,
3480 gimple *stmt,
3481 struct cgraph_node *n)
3483 ipa_polymorphic_call_context context (current_function_decl, ref, stmt);
3484 tree call_fn = gimple_call_fn (stmt);
3486 return possible_polymorphic_call_target_p (obj_type_ref_class (call_fn),
3487 tree_to_uhwi
3488 (OBJ_TYPE_REF_TOKEN (call_fn)),
3489 context,
3494 /* After callgraph construction new external nodes may appear.
3495 Add them into the graph. */
3497 void
3498 update_type_inheritance_graph (void)
3500 struct cgraph_node *n;
3502 if (!odr_hash)
3503 return;
3504 free_polymorphic_call_targets_hash ();
3505 timevar_push (TV_IPA_INHERITANCE);
3506 /* We reconstruct the graph starting from types of all methods seen in the
3507 unit. */
3508 FOR_EACH_FUNCTION (n)
3509 if (DECL_VIRTUAL_P (n->decl)
3510 && !n->definition
3511 && n->real_symbol_p ())
3512 get_odr_type (TYPE_METHOD_BASETYPE (TREE_TYPE (n->decl)), true);
3513 timevar_pop (TV_IPA_INHERITANCE);
3517 /* Return true if N looks like likely target of a polymorphic call.
3518 Rule out cxa_pure_virtual, noreturns, function declared cold and
3519 other obvious cases. */
3521 bool
3522 likely_target_p (struct cgraph_node *n)
3524 int flags;
3525 /* cxa_pure_virtual and similar things are not likely. */
3526 if (TREE_CODE (TREE_TYPE (n->decl)) != METHOD_TYPE)
3527 return false;
3528 flags = flags_from_decl_or_type (n->decl);
3529 if (flags & ECF_NORETURN)
3530 return false;
3531 if (lookup_attribute ("cold",
3532 DECL_ATTRIBUTES (n->decl)))
3533 return false;
3534 if (n->frequency < NODE_FREQUENCY_NORMAL)
3535 return false;
3536 /* If there are no live virtual tables referring the target,
3537 the only way the target can be called is an instance coming from other
3538 compilation unit; speculative devirtualization is built around an
3539 assumption that won't happen. */
3540 if (!referenced_from_vtable_p (n))
3541 return false;
3542 return true;
3545 /* Compare type warning records P1 and P2 and choose one with larger count;
3546 helper for qsort. */
3548 static int
3549 type_warning_cmp (const void *p1, const void *p2)
3551 const odr_type_warn_count *t1 = (const odr_type_warn_count *)p1;
3552 const odr_type_warn_count *t2 = (const odr_type_warn_count *)p2;
3554 if (t1->dyn_count < t2->dyn_count)
3555 return 1;
3556 if (t1->dyn_count > t2->dyn_count)
3557 return -1;
3558 return t2->count - t1->count;
3561 /* Compare decl warning records P1 and P2 and choose one with larger count;
3562 helper for qsort. */
3564 static int
3565 decl_warning_cmp (const void *p1, const void *p2)
3567 const decl_warn_count *t1 = *(const decl_warn_count * const *)p1;
3568 const decl_warn_count *t2 = *(const decl_warn_count * const *)p2;
3570 if (t1->dyn_count < t2->dyn_count)
3571 return 1;
3572 if (t1->dyn_count > t2->dyn_count)
3573 return -1;
3574 return t2->count - t1->count;
3578 /* Try to speculatively devirtualize call to OTR_TYPE with OTR_TOKEN with
3579 context CTX. */
3581 struct cgraph_node *
3582 try_speculative_devirtualization (tree otr_type, HOST_WIDE_INT otr_token,
3583 ipa_polymorphic_call_context ctx)
3585 vec <cgraph_node *>targets
3586 = possible_polymorphic_call_targets
3587 (otr_type, otr_token, ctx, NULL, NULL, true);
3588 unsigned int i;
3589 struct cgraph_node *likely_target = NULL;
3591 for (i = 0; i < targets.length (); i++)
3592 if (likely_target_p (targets[i]))
3594 if (likely_target)
3595 return NULL;
3596 likely_target = targets[i];
3598 if (!likely_target
3599 ||!likely_target->definition
3600 || DECL_EXTERNAL (likely_target->decl))
3601 return NULL;
3603 /* Don't use an implicitly-declared destructor (c++/58678). */
3604 struct cgraph_node *non_thunk_target
3605 = likely_target->function_symbol ();
3606 if (DECL_ARTIFICIAL (non_thunk_target->decl))
3607 return NULL;
3608 if (likely_target->get_availability () <= AVAIL_INTERPOSABLE
3609 && likely_target->can_be_discarded_p ())
3610 return NULL;
3611 return likely_target;
3614 /* The ipa-devirt pass.
3615 When polymorphic call has only one likely target in the unit,
3616 turn it into a speculative call. */
3618 static unsigned int
3619 ipa_devirt (void)
3621 struct cgraph_node *n;
3622 hash_set<void *> bad_call_targets;
3623 struct cgraph_edge *e;
3625 int npolymorphic = 0, nspeculated = 0, nconverted = 0, ncold = 0;
3626 int nmultiple = 0, noverwritable = 0, ndevirtualized = 0, nnotdefined = 0;
3627 int nwrong = 0, nok = 0, nexternal = 0, nartificial = 0;
3628 int ndropped = 0;
3630 if (!odr_types_ptr)
3631 return 0;
3633 if (dump_file)
3634 dump_type_inheritance_graph (dump_file);
3636 /* We can output -Wsuggest-final-methods and -Wsuggest-final-types warnings.
3637 This is implemented by setting up final_warning_records that are updated
3638 by get_polymorphic_call_targets.
3639 We need to clear cache in this case to trigger recomputation of all
3640 entries. */
3641 if (warn_suggest_final_methods || warn_suggest_final_types)
3643 final_warning_records = new (final_warning_record);
3644 final_warning_records->dyn_count = profile_count::zero ();
3645 final_warning_records->grow_type_warnings (odr_types.length ());
3646 free_polymorphic_call_targets_hash ();
3649 FOR_EACH_DEFINED_FUNCTION (n)
3651 bool update = false;
3652 if (!opt_for_fn (n->decl, flag_devirtualize))
3653 continue;
3654 if (dump_file && n->indirect_calls)
3655 fprintf (dump_file, "\n\nProcesing function %s\n",
3656 n->dump_name ());
3657 for (e = n->indirect_calls; e; e = e->next_callee)
3658 if (e->indirect_info->polymorphic)
3660 struct cgraph_node *likely_target = NULL;
3661 void *cache_token;
3662 bool final;
3664 if (final_warning_records)
3665 final_warning_records->dyn_count = e->count.ipa ();
3667 vec <cgraph_node *>targets
3668 = possible_polymorphic_call_targets
3669 (e, &final, &cache_token, true);
3670 unsigned int i;
3672 /* Trigger warnings by calculating non-speculative targets. */
3673 if (warn_suggest_final_methods || warn_suggest_final_types)
3674 possible_polymorphic_call_targets (e);
3676 if (dump_file)
3677 dump_possible_polymorphic_call_targets
3678 (dump_file, e, (dump_flags & TDF_DETAILS));
3680 npolymorphic++;
3682 /* See if the call can be devirtualized by means of ipa-prop's
3683 polymorphic call context propagation. If not, we can just
3684 forget about this call being polymorphic and avoid some heavy
3685 lifting in remove_unreachable_nodes that will otherwise try to
3686 keep all possible targets alive until inlining and in the inliner
3687 itself.
3689 This may need to be revisited once we add further ways to use
3690 the may edges, but it is a reasonable thing to do right now. */
3692 if ((e->indirect_info->param_index == -1
3693 || (!opt_for_fn (n->decl, flag_devirtualize_speculatively)
3694 && e->indirect_info->vptr_changed))
3695 && !flag_ltrans_devirtualize)
3697 e->indirect_info->polymorphic = false;
3698 ndropped++;
3699 if (dump_file)
3700 fprintf (dump_file, "Dropping polymorphic call info;"
3701 " it cannot be used by ipa-prop\n");
3704 if (!opt_for_fn (n->decl, flag_devirtualize_speculatively))
3705 continue;
3707 if (!e->maybe_hot_p ())
3709 if (dump_file)
3710 fprintf (dump_file, "Call is cold\n\n");
3711 ncold++;
3712 continue;
3714 if (e->speculative)
3716 if (dump_file)
3717 fprintf (dump_file, "Call is already speculated\n\n");
3718 nspeculated++;
3720 /* When dumping see if we agree with speculation. */
3721 if (!dump_file)
3722 continue;
3724 if (bad_call_targets.contains (cache_token))
3726 if (dump_file)
3727 fprintf (dump_file, "Target list is known to be useless\n\n");
3728 nmultiple++;
3729 continue;
3731 for (i = 0; i < targets.length (); i++)
3732 if (likely_target_p (targets[i]))
3734 if (likely_target)
3736 likely_target = NULL;
3737 if (dump_file)
3738 fprintf (dump_file, "More than one likely target\n\n");
3739 nmultiple++;
3740 break;
3742 likely_target = targets[i];
3744 if (!likely_target)
3746 bad_call_targets.add (cache_token);
3747 continue;
3749 /* This is reached only when dumping; check if we agree or disagree
3750 with the speculation. */
3751 if (e->speculative)
3753 bool found = e->speculative_call_for_target (likely_target);
3754 if (found)
3756 fprintf (dump_file, "We agree with speculation\n\n");
3757 nok++;
3759 else
3761 fprintf (dump_file, "We disagree with speculation\n\n");
3762 nwrong++;
3764 continue;
3766 if (!likely_target->definition)
3768 if (dump_file)
3769 fprintf (dump_file, "Target is not a definition\n\n");
3770 nnotdefined++;
3771 continue;
3773 /* Do not introduce new references to external symbols. While we
3774 can handle these just well, it is common for programs to
3775 incorrectly with headers defining methods they are linked
3776 with. */
3777 if (DECL_EXTERNAL (likely_target->decl))
3779 if (dump_file)
3780 fprintf (dump_file, "Target is external\n\n");
3781 nexternal++;
3782 continue;
3784 /* Don't use an implicitly-declared destructor (c++/58678). */
3785 struct cgraph_node *non_thunk_target
3786 = likely_target->function_symbol ();
3787 if (DECL_ARTIFICIAL (non_thunk_target->decl))
3789 if (dump_file)
3790 fprintf (dump_file, "Target is artificial\n\n");
3791 nartificial++;
3792 continue;
3794 if (likely_target->get_availability () <= AVAIL_INTERPOSABLE
3795 && likely_target->can_be_discarded_p ())
3797 if (dump_file)
3798 fprintf (dump_file, "Target is overwritable\n\n");
3799 noverwritable++;
3800 continue;
3802 else if (dbg_cnt (devirt))
3804 if (dump_enabled_p ())
3806 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, e->call_stmt,
3807 "speculatively devirtualizing call "
3808 "in %s to %s\n",
3809 n->dump_name (),
3810 likely_target->dump_name ());
3812 if (!likely_target->can_be_discarded_p ())
3814 cgraph_node *alias;
3815 alias = dyn_cast<cgraph_node *> (likely_target->noninterposable_alias ());
3816 if (alias)
3817 likely_target = alias;
3819 nconverted++;
3820 update = true;
3821 e->make_speculative
3822 (likely_target, e->count.apply_scale (8, 10));
3825 if (update)
3826 ipa_update_overall_fn_summary (n);
3828 if (warn_suggest_final_methods || warn_suggest_final_types)
3830 if (warn_suggest_final_types)
3832 final_warning_records->type_warnings.qsort (type_warning_cmp);
3833 for (unsigned int i = 0;
3834 i < final_warning_records->type_warnings.length (); i++)
3835 if (final_warning_records->type_warnings[i].count)
3837 tree type = final_warning_records->type_warnings[i].type;
3838 int count = final_warning_records->type_warnings[i].count;
3839 profile_count dyn_count
3840 = final_warning_records->type_warnings[i].dyn_count;
3842 if (!(dyn_count > 0))
3843 warning_n (DECL_SOURCE_LOCATION (TYPE_NAME (type)),
3844 OPT_Wsuggest_final_types, count,
3845 "Declaring type %qD final "
3846 "would enable devirtualization of %i call",
3847 "Declaring type %qD final "
3848 "would enable devirtualization of %i calls",
3849 type,
3850 count);
3851 else
3852 warning_n (DECL_SOURCE_LOCATION (TYPE_NAME (type)),
3853 OPT_Wsuggest_final_types, count,
3854 "Declaring type %qD final "
3855 "would enable devirtualization of %i call "
3856 "executed %lli times",
3857 "Declaring type %qD final "
3858 "would enable devirtualization of %i calls "
3859 "executed %lli times",
3860 type,
3861 count,
3862 (long long) dyn_count.to_gcov_type ());
3866 if (warn_suggest_final_methods)
3868 auto_vec<const decl_warn_count*> decl_warnings_vec;
3870 final_warning_records->decl_warnings.traverse
3871 <vec<const decl_warn_count *> *, add_decl_warning> (&decl_warnings_vec);
3872 decl_warnings_vec.qsort (decl_warning_cmp);
3873 for (unsigned int i = 0; i < decl_warnings_vec.length (); i++)
3875 tree decl = decl_warnings_vec[i]->decl;
3876 int count = decl_warnings_vec[i]->count;
3877 profile_count dyn_count
3878 = decl_warnings_vec[i]->dyn_count;
3880 if (!(dyn_count > 0))
3881 if (DECL_CXX_DESTRUCTOR_P (decl))
3882 warning_n (DECL_SOURCE_LOCATION (decl),
3883 OPT_Wsuggest_final_methods, count,
3884 "Declaring virtual destructor of %qD final "
3885 "would enable devirtualization of %i call",
3886 "Declaring virtual destructor of %qD final "
3887 "would enable devirtualization of %i calls",
3888 DECL_CONTEXT (decl), count);
3889 else
3890 warning_n (DECL_SOURCE_LOCATION (decl),
3891 OPT_Wsuggest_final_methods, count,
3892 "Declaring method %qD final "
3893 "would enable devirtualization of %i call",
3894 "Declaring method %qD final "
3895 "would enable devirtualization of %i calls",
3896 decl, count);
3897 else if (DECL_CXX_DESTRUCTOR_P (decl))
3898 warning_n (DECL_SOURCE_LOCATION (decl),
3899 OPT_Wsuggest_final_methods, count,
3900 "Declaring virtual destructor of %qD final "
3901 "would enable devirtualization of %i call "
3902 "executed %lli times",
3903 "Declaring virtual destructor of %qD final "
3904 "would enable devirtualization of %i calls "
3905 "executed %lli times",
3906 DECL_CONTEXT (decl), count,
3907 (long long)dyn_count.to_gcov_type ());
3908 else
3909 warning_n (DECL_SOURCE_LOCATION (decl),
3910 OPT_Wsuggest_final_methods, count,
3911 "Declaring method %qD final "
3912 "would enable devirtualization of %i call "
3913 "executed %lli times",
3914 "Declaring method %qD final "
3915 "would enable devirtualization of %i calls "
3916 "executed %lli times",
3917 decl, count,
3918 (long long)dyn_count.to_gcov_type ());
3922 delete (final_warning_records);
3923 final_warning_records = 0;
3926 if (dump_file)
3927 fprintf (dump_file,
3928 "%i polymorphic calls, %i devirtualized,"
3929 " %i speculatively devirtualized, %i cold\n"
3930 "%i have multiple targets, %i overwritable,"
3931 " %i already speculated (%i agree, %i disagree),"
3932 " %i external, %i not defined, %i artificial, %i infos dropped\n",
3933 npolymorphic, ndevirtualized, nconverted, ncold,
3934 nmultiple, noverwritable, nspeculated, nok, nwrong,
3935 nexternal, nnotdefined, nartificial, ndropped);
3936 return ndevirtualized || ndropped ? TODO_remove_functions : 0;
3939 namespace {
3941 const pass_data pass_data_ipa_devirt =
3943 IPA_PASS, /* type */
3944 "devirt", /* name */
3945 OPTGROUP_NONE, /* optinfo_flags */
3946 TV_IPA_DEVIRT, /* tv_id */
3947 0, /* properties_required */
3948 0, /* properties_provided */
3949 0, /* properties_destroyed */
3950 0, /* todo_flags_start */
3951 ( TODO_dump_symtab ), /* todo_flags_finish */
3954 class pass_ipa_devirt : public ipa_opt_pass_d
3956 public:
3957 pass_ipa_devirt (gcc::context *ctxt)
3958 : ipa_opt_pass_d (pass_data_ipa_devirt, ctxt,
3959 NULL, /* generate_summary */
3960 NULL, /* write_summary */
3961 NULL, /* read_summary */
3962 NULL, /* write_optimization_summary */
3963 NULL, /* read_optimization_summary */
3964 NULL, /* stmt_fixup */
3965 0, /* function_transform_todo_flags_start */
3966 NULL, /* function_transform */
3967 NULL) /* variable_transform */
3970 /* opt_pass methods: */
3971 virtual bool gate (function *)
3973 /* In LTO, always run the IPA passes and decide on function basis if the
3974 pass is enabled. */
3975 if (in_lto_p)
3976 return true;
3977 return (flag_devirtualize
3978 && (flag_devirtualize_speculatively
3979 || (warn_suggest_final_methods
3980 || warn_suggest_final_types))
3981 && optimize);
3984 virtual unsigned int execute (function *) { return ipa_devirt (); }
3986 }; // class pass_ipa_devirt
3988 } // anon namespace
3990 ipa_opt_pass_d *
3991 make_pass_ipa_devirt (gcc::context *ctxt)
3993 return new pass_ipa_devirt (ctxt);
3996 /* Print ODR name of a TYPE if available.
3997 Use demangler when option DEMANGLE is used. */
3999 DEBUG_FUNCTION void
4000 debug_tree_odr_name (tree type, bool demangle)
4002 const char *odr = get_odr_name_for_type (type);
4003 if (demangle)
4005 const int opts = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
4006 odr = cplus_demangle (odr, opts);
4009 fprintf (stderr, "%s\n", odr);
4012 /* Register ODR enum so we later stream record about its values. */
4014 void
4015 register_odr_enum (tree t)
4017 if (flag_lto)
4018 vec_safe_push (odr_enums, t);
4021 /* Write ODR enums to LTO stream file. */
4023 static void
4024 ipa_odr_summary_write (void)
4026 if (!odr_enums && !odr_enum_map)
4027 return;
4028 struct output_block *ob = create_output_block (LTO_section_odr_types);
4029 unsigned int i;
4030 tree t;
4032 if (odr_enums)
4034 streamer_write_uhwi (ob, odr_enums->length ());
4036 /* For every ODR enum stream out
4037 - its ODR name
4038 - number of values,
4039 - value names and constant their represent
4040 - bitpack of locations so we can do good diagnostics. */
4041 FOR_EACH_VEC_ELT (*odr_enums, i, t)
4043 streamer_write_string (ob, ob->main_stream,
4044 IDENTIFIER_POINTER
4045 (DECL_ASSEMBLER_NAME (TYPE_NAME (t))),
4046 true);
4048 int n = 0;
4049 for (tree e = TYPE_VALUES (t); e; e = TREE_CHAIN (e))
4050 n++;
4051 streamer_write_uhwi (ob, n);
4052 for (tree e = TYPE_VALUES (t); e; e = TREE_CHAIN (e))
4054 streamer_write_string (ob, ob->main_stream,
4055 IDENTIFIER_POINTER (TREE_PURPOSE (e)),
4056 true);
4057 streamer_write_wide_int (ob,
4058 wi::to_wide (DECL_INITIAL
4059 (TREE_VALUE (e))));
4062 bitpack_d bp = bitpack_create (ob->main_stream);
4063 lto_output_location (ob, &bp, DECL_SOURCE_LOCATION (TYPE_NAME (t)));
4064 for (tree e = TYPE_VALUES (t); e; e = TREE_CHAIN (e))
4065 lto_output_location (ob, &bp,
4066 DECL_SOURCE_LOCATION (TREE_VALUE (e)));
4067 streamer_write_bitpack (&bp);
4069 vec_free (odr_enums);
4070 odr_enums = NULL;
4072 /* During LTO incremental linking we already have streamed in types. */
4073 else if (odr_enum_map)
4075 gcc_checking_assert (!odr_enums);
4076 streamer_write_uhwi (ob, odr_enum_map->elements ());
4078 hash_map<nofree_string_hash, odr_enum>::iterator iter
4079 = odr_enum_map->begin ();
4080 for (; iter != odr_enum_map->end (); ++iter)
4082 odr_enum &this_enum = (*iter).second;
4083 streamer_write_string (ob, ob->main_stream, (*iter).first, true);
4085 streamer_write_uhwi (ob, this_enum.vals.length ());
4086 for (unsigned j = 0; j < this_enum.vals.length (); j++)
4088 streamer_write_string (ob, ob->main_stream,
4089 this_enum.vals[j].name, true);
4090 streamer_write_wide_int (ob, this_enum.vals[j].val);
4093 bitpack_d bp = bitpack_create (ob->main_stream);
4094 lto_output_location (ob, &bp, this_enum.locus);
4095 for (unsigned j = 0; j < this_enum.vals.length (); j++)
4096 lto_output_location (ob, &bp, this_enum.vals[j].locus);
4097 streamer_write_bitpack (&bp);
4100 delete odr_enum_map;
4101 obstack_free (&odr_enum_obstack, NULL);
4102 odr_enum_map = NULL;
4105 produce_asm (ob, NULL);
4106 destroy_output_block (ob);
4109 /* Write ODR enums from LTO stream file and warn on mismatches. */
4111 static void
4112 ipa_odr_read_section (struct lto_file_decl_data *file_data, const char *data,
4113 size_t len)
4115 const struct lto_function_header *header
4116 = (const struct lto_function_header *) data;
4117 const int cfg_offset = sizeof (struct lto_function_header);
4118 const int main_offset = cfg_offset + header->cfg_size;
4119 const int string_offset = main_offset + header->main_size;
4120 class data_in *data_in;
4122 lto_input_block ib ((const char *) data + main_offset, header->main_size,
4123 file_data->mode_table);
4125 data_in
4126 = lto_data_in_create (file_data, (const char *) data + string_offset,
4127 header->string_size, vNULL);
4128 unsigned int n = streamer_read_uhwi (&ib);
4130 if (!odr_enum_map)
4132 gcc_obstack_init (&odr_enum_obstack);
4133 odr_enum_map = new (hash_map <nofree_string_hash, odr_enum>);
4136 for (unsigned i = 0; i < n; i++)
4138 const char *rname = streamer_read_string (data_in, &ib);
4139 unsigned int nvals = streamer_read_uhwi (&ib);
4140 char *name;
4142 obstack_grow (&odr_enum_obstack, rname, strlen (rname) + 1);
4143 name = XOBFINISH (&odr_enum_obstack, char *);
4145 bool existed_p;
4146 class odr_enum &this_enum
4147 = odr_enum_map->get_or_insert (xstrdup (name), &existed_p);
4149 /* If this is first time we see the enum, remember its definition. */
4150 if (!existed_p)
4152 this_enum.vals.safe_grow_cleared (nvals, true);
4153 this_enum.warned = false;
4154 if (dump_file)
4155 fprintf (dump_file, "enum %s\n{\n", name);
4156 for (unsigned j = 0; j < nvals; j++)
4158 const char *val_name = streamer_read_string (data_in, &ib);
4159 obstack_grow (&odr_enum_obstack, val_name, strlen (val_name) + 1);
4160 this_enum.vals[j].name = XOBFINISH (&odr_enum_obstack, char *);
4161 this_enum.vals[j].val = streamer_read_wide_int (&ib);
4162 if (dump_file)
4163 fprintf (dump_file, " %s = " HOST_WIDE_INT_PRINT_DEC ",\n",
4164 val_name, wi::fits_shwi_p (this_enum.vals[j].val)
4165 ? this_enum.vals[j].val.to_shwi () : -1);
4167 bitpack_d bp = streamer_read_bitpack (&ib);
4168 stream_input_location (&this_enum.locus, &bp, data_in);
4169 for (unsigned j = 0; j < nvals; j++)
4170 stream_input_location (&this_enum.vals[j].locus, &bp, data_in);
4171 data_in->location_cache.apply_location_cache ();
4172 if (dump_file)
4173 fprintf (dump_file, "}\n");
4175 /* If we already have definition, compare it with new one and output
4176 warnings if they differs. */
4177 else
4179 int do_warning = -1;
4180 char *warn_name = NULL;
4181 wide_int warn_value = wi::zero (1);
4183 if (dump_file)
4184 fprintf (dump_file, "Comparing enum %s\n", name);
4186 /* Look for differences which we will warn about later once locations
4187 are streamed. */
4188 for (unsigned j = 0; j < nvals; j++)
4190 const char *id = streamer_read_string (data_in, &ib);
4191 wide_int val = streamer_read_wide_int (&ib);
4193 if (do_warning != -1 || j >= this_enum.vals.length ())
4194 continue;
4195 if (strcmp (id, this_enum.vals[j].name)
4196 || val != this_enum.vals[j].val)
4198 warn_name = xstrdup (id);
4199 warn_value = val;
4200 do_warning = j;
4201 if (dump_file)
4202 fprintf (dump_file, " Different on entry %i\n", j);
4206 /* Stream in locations, but do not apply them unless we are going
4207 to warn. */
4208 bitpack_d bp = streamer_read_bitpack (&ib);
4209 location_t locus;
4211 stream_input_location (&locus, &bp, data_in);
4213 /* Did we find a difference? */
4214 if (do_warning != -1 || nvals != this_enum.vals.length ())
4216 data_in->location_cache.apply_location_cache ();
4218 const int opts = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
4219 char *dmgname = cplus_demangle (name, opts);
4220 if (this_enum.warned
4221 || !warning_at (this_enum.locus,
4222 OPT_Wodr, "type %qs violates the "
4223 "C++ One Definition Rule",
4224 dmgname))
4225 do_warning = -1;
4226 else
4228 this_enum.warned = true;
4229 if (do_warning == -1)
4230 inform (locus,
4231 "an enum with different number of values is defined"
4232 " in another translation unit");
4233 else if (warn_name)
4234 inform (locus,
4235 "an enum with different value name"
4236 " is defined in another translation unit");
4237 else
4238 inform (locus,
4239 "an enum with different values"
4240 " is defined in another translation unit");
4243 else
4244 data_in->location_cache.revert_location_cache ();
4246 /* Finally look up for location of the actual value that diverged. */
4247 for (unsigned j = 0; j < nvals; j++)
4249 location_t id_locus;
4251 data_in->location_cache.revert_location_cache ();
4252 stream_input_location (&id_locus, &bp, data_in);
4254 if ((int) j == do_warning)
4256 data_in->location_cache.apply_location_cache ();
4258 if (strcmp (warn_name, this_enum.vals[j].name))
4259 inform (this_enum.vals[j].locus,
4260 "name %qs differs from name %qs defined"
4261 " in another translation unit",
4262 this_enum.vals[j].name, warn_name);
4263 /* FIXME: In case there is easy way to print wide_ints,
4264 perhaps we could do it here instead of overflow check. */
4265 else if (wi::fits_shwi_p (this_enum.vals[j].val)
4266 && wi::fits_shwi_p (warn_value))
4267 inform (this_enum.vals[j].locus,
4268 "name %qs is defined to %wd while another "
4269 "translation unit defines it as %wd",
4270 warn_name, this_enum.vals[j].val.to_shwi (),
4271 warn_value.to_shwi ());
4272 else
4273 inform (this_enum.vals[j].locus,
4274 "name %qs is defined to different value "
4275 "in another translation unit",
4276 warn_name);
4278 inform (id_locus,
4279 "mismatching definition");
4281 else
4282 data_in->location_cache.revert_location_cache ();
4284 if (warn_name)
4285 free (warn_name);
4286 obstack_free (&odr_enum_obstack, name);
4289 lto_free_section_data (file_data, LTO_section_ipa_fn_summary, NULL, data,
4290 len);
4291 lto_data_in_delete (data_in);
4294 /* Read all ODR type sections. */
4296 static void
4297 ipa_odr_summary_read (void)
4299 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
4300 struct lto_file_decl_data *file_data;
4301 unsigned int j = 0;
4303 while ((file_data = file_data_vec[j++]))
4305 size_t len;
4306 const char *data
4307 = lto_get_summary_section_data (file_data, LTO_section_odr_types,
4308 &len);
4309 if (data)
4310 ipa_odr_read_section (file_data, data, len);
4312 /* Enum info is used only to produce warnings. Only case we will need it
4313 again is streaming for incremental LTO. */
4314 if (flag_incremental_link != INCREMENTAL_LINK_LTO)
4316 delete odr_enum_map;
4317 obstack_free (&odr_enum_obstack, NULL);
4318 odr_enum_map = NULL;
4322 namespace {
4324 const pass_data pass_data_ipa_odr =
4326 IPA_PASS, /* type */
4327 "odr", /* name */
4328 OPTGROUP_NONE, /* optinfo_flags */
4329 TV_IPA_ODR, /* tv_id */
4330 0, /* properties_required */
4331 0, /* properties_provided */
4332 0, /* properties_destroyed */
4333 0, /* todo_flags_start */
4334 0, /* todo_flags_finish */
4337 class pass_ipa_odr : public ipa_opt_pass_d
4339 public:
4340 pass_ipa_odr (gcc::context *ctxt)
4341 : ipa_opt_pass_d (pass_data_ipa_odr, ctxt,
4342 NULL, /* generate_summary */
4343 ipa_odr_summary_write, /* write_summary */
4344 ipa_odr_summary_read, /* read_summary */
4345 NULL, /* write_optimization_summary */
4346 NULL, /* read_optimization_summary */
4347 NULL, /* stmt_fixup */
4348 0, /* function_transform_todo_flags_start */
4349 NULL, /* function_transform */
4350 NULL) /* variable_transform */
4353 /* opt_pass methods: */
4354 virtual bool gate (function *)
4356 return (in_lto_p || flag_lto);
4359 virtual unsigned int execute (function *)
4361 return 0;
4364 }; // class pass_ipa_odr
4366 } // anon namespace
4368 ipa_opt_pass_d *
4369 make_pass_ipa_odr (gcc::context *ctxt)
4371 return new pass_ipa_odr (ctxt);
4375 #include "gt-ipa-devirt.h"