CbC/CbC_gcc: gcc/ipa-devirt.c comparison

comparison gcc/ipa-devirt.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Basic IPA utilities for type inheritance graph construction and
 devirtualization.
-Copyright (C) 2013-2018 Free Software Foundation, Inc.
+Copyright (C) 2013-2020 Free Software Foundation, Inc.
 Contributed by Jan Hubicka
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 static hashval_t
 hash (type_pair p)
 {
 return TYPE_UID (p.first) ^ TYPE_UID (p.second);
 }
+static const bool empty_zero_p = true;
 static bool
 is_empty (type_pair p)
 {
 return p.first == NULL;
 }
 {
 e.first = NULL;
 }
 };
+/* HACK alert: this is used to communicate with ipa-inline-transform that
+thunk is being expanded and there is no need to clear the polymorphic
+call target cache.  */
+bool thunk_expansion;
 static bool odr_types_equivalent_p (tree, tree, bool, bool *,
 				    hash_set<type_pair> *,
 				    location_t, location_t);
+static void warn_odr (tree t1, tree t2, tree st1, tree st2,
+		      bool warn, bool *warned, const char *reason);
 static bool odr_violation_reported = false;
 /* Pointer set of all call targets appearing in the cache.  */
 bool anonymous_namespace;
 /* Do we know about all derivations of given type?  */
 bool all_derivations_known;
 /* Did we report ODR violation here?  */
 bool odr_violated;
-/* Set when virtual table without RTTI previaled table with.  */
+/* Set when virtual table without RTTI prevailed table with.  */
 bool rtti_broken;
+/* Set when the canonical type is determined using the type name.  */
+bool tbaa_enabled;
 };
 /* Return TRUE if all derived types of T are known and thus
 we may consider the walk of derived type complete.
 static bool
 type_all_ctors_visible_p (tree t)
 {
 return !flag_ltrans
 	 && symtab->state >= CONSTRUCTION
-	 /* We can not always use type_all_derivations_known_p.
+	 /* We cannot always use type_all_derivations_known_p.
 	    For function local types we must assume case where
 	    the function is COMDAT and shared in between units.
 	    TODO: These cases are quite easy to get, but we need
 	    to keep track of C++ privatizing via -Wno-weak
 static inline hashval_t hash (const odr_type_d *);
 static inline bool equal (const odr_type_d *, const tree_node *);
 static inline void remove (odr_type_d *);
 };
-/* Has used to unify ODR types based on their associated virtual table.
-This hash is needed to keep -fno-lto-odr-type-merging to work and contains
-only polymorphic types.  Types with mangled names are inserted to both.  */
-struct odr_vtable_hasher:odr_name_hasher
-{
-static inline hashval_t hash (const odr_type_d *);
-static inline bool equal (const odr_type_d *, const tree_node *);
-};
-/* Return type that was declared with T's name so that T is an
-qualified variant of it.  */
-static inline tree
-main_odr_variant (const_tree t)
-{
-if (TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
-return TREE_TYPE (TYPE_NAME (t));
-/* Unnamed types and non-C++ produced types can be compared by variants.  */
-else
-return TYPE_MAIN_VARIANT (t);
-}
 static bool
 can_be_name_hashed_p (tree t)
 {
 return (!in_lto_p || odr_type_p (t));
 }
 /* Hash type by its ODR name.  */
 static hashval_t
 hash_odr_name (const_tree t)
 {
-gcc_checking_assert (main_odr_variant (t) == t);
+gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t);
 /* If not in LTO, all main variants are unique, so we can do
 pointer hash.  */
 if (!in_lto_p)
 return htab_hash_pointer (t);
 odr_name_hasher::hash (const odr_type_d *odr_type)
 {
 return hash_odr_name (odr_type->type);
 }
-static bool
-can_be_vtable_hashed_p (tree t)
-{
-/* vtable hashing can distinguish only main variants.  */
-if (TYPE_MAIN_VARIANT (t) != t)
-return false;
-/* Anonymous namespace types are always handled by name hash.  */
-if (type_with_linkage_p (t) && type_in_anonymous_namespace_p (t))
-return false;
-return (TREE_CODE (t) == RECORD_TYPE
-	  && TYPE_BINFO (t) && BINFO_VTABLE (TYPE_BINFO (t)));
-}
-/* Hash type by assembler name of its vtable.  */
-static hashval_t
-hash_odr_vtable (const_tree t)
-{
-tree v = BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
-inchash::hash hstate;
-gcc_checking_assert (in_lto_p);
-gcc_checking_assert (!type_in_anonymous_namespace_p (t));
-gcc_checking_assert (TREE_CODE (t) == RECORD_TYPE
-		       && TYPE_BINFO (t) && BINFO_VTABLE (TYPE_BINFO (t)));
-gcc_checking_assert (main_odr_variant (t) == t);
-if (TREE_CODE (v) == POINTER_PLUS_EXPR)
-{
-add_expr (TREE_OPERAND (v, 1), hstate);
-v = TREE_OPERAND (TREE_OPERAND (v, 0), 0);
-}
-hstate.add_hwi (IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (v)));
-return hstate.end ();
-}
-/* Return the computed hashcode for ODR_TYPE.  */
-inline hashval_t
-odr_vtable_hasher::hash (const odr_type_d *odr_type)
-{
-return hash_odr_vtable (odr_type->type);
-}
 /* For languages with One Definition Rule, work out if
 types are the same based on their name.
 This is non-trivial for LTO where minor differences in
 the type representation may have prevented type merging
 to merge two copies of otherwise equivalent type.
 Until we start streaming mangled type names, this function works
 only for polymorphic types.
-When STRICT is true, we compare types by their names for purposes of
-ODR violation warnings.  When strict is false, we consider variants
-equivalent, because it is all that matters for devirtualization machinery.
 */
 bool
-types_same_for_odr (const_tree type1, const_tree type2, bool strict)
+types_same_for_odr (const_tree type1, const_tree type2)
 {
 gcc_checking_assert (TYPE_P (type1) && TYPE_P (type2));
-type1 = main_odr_variant (type1);
+type1 = TYPE_MAIN_VARIANT (type1);
-type2 = main_odr_variant (type2);
+type2 = TYPE_MAIN_VARIANT (type2);
-if (!strict)
-{
-type1 = TYPE_MAIN_VARIANT (type1);
-type2 = TYPE_MAIN_VARIANT (type2);
-}
 if (type1 == type2)
 return true;
 if (!in_lto_p)
 return false;
-/* Check for anonymous namespaces. Those have !TREE_PUBLIC
+/* Anonymous namespace types are never duplicated.  */
-on the corresponding TYPE_STUB_DECL.  */
 if ((type_with_linkage_p (type1) && type_in_anonymous_namespace_p (type1))
 || (type_with_linkage_p (type2) && type_in_anonymous_namespace_p (type2)))
 return false;
+/* If both type has mangled defined check if they are same.
-/* ODR name of the type is set in DECL_ASSEMBLER_NAME of its TYPE_NAME.
+Watch for anonymous types which are all mangled as "<anon">.  */
+if (!type_with_linkage_p (type1) || !type_with_linkage_p (type2))
-Ideally we should never need types without ODR names here.  It can however
+return false;
-happen in two cases:
+if (type_in_anonymous_namespace_p (type1)
+|| type_in_anonymous_namespace_p (type2))
-1) for builtin types that are not streamed but rebuilt in lto/lto-lang.c
+return false;
-Here testing for equivalence is safe, since their MAIN_VARIANTs are
-unique.
-2) for units streamed with -fno-lto-odr-type-merging.  Here we can't
-	  establish precise ODR equivalency, but for correctness we care only
-	  about equivalency on complete polymorphic types.  For these we can
-	  compare assembler names of their virtual tables.  */
-if ((!TYPE_NAME (type1) || !DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (type1)))
-|| (!TYPE_NAME (type2) || !DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (type2))))
-{
-/* See if types are obviously different (i.e. different codes
-	 or polymorphic wrt non-polymorphic).  This is not strictly correct
-	 for ODR violating programs, but we can't do better without streaming
-	 ODR names.  */
-if (TREE_CODE (type1) != TREE_CODE (type2))
-	return false;
-if (TREE_CODE (type1) == RECORD_TYPE
-	  && (TYPE_BINFO (type1) == NULL_TREE)
-	      != (TYPE_BINFO (type2) == NULL_TREE))
-	return false;
-if (TREE_CODE (type1) == RECORD_TYPE && TYPE_BINFO (type1)
-	  && (BINFO_VTABLE (TYPE_BINFO (type1)) == NULL_TREE)
-	     != (BINFO_VTABLE (TYPE_BINFO (type2)) == NULL_TREE))
-	return false;
-/* At the moment we have no way to establish ODR equivalence at LTO
-	 other than comparing virtual table pointers of polymorphic types.
-	 Eventually we should start saving mangled names in TYPE_NAME.
-	 Then this condition will become non-trivial.  */
-if (TREE_CODE (type1) == RECORD_TYPE
-	  && TYPE_BINFO (type1) && TYPE_BINFO (type2)
-	  && BINFO_VTABLE (TYPE_BINFO (type1))
-	  && BINFO_VTABLE (TYPE_BINFO (type2)))
-	{
-	  tree v1 = BINFO_VTABLE (TYPE_BINFO (type1));
-	  tree v2 = BINFO_VTABLE (TYPE_BINFO (type2));
-	  gcc_assert (TREE_CODE (v1) == POINTER_PLUS_EXPR
-		      && TREE_CODE (v2) == POINTER_PLUS_EXPR);
-	  return (operand_equal_p (TREE_OPERAND (v1, 1),
-				   TREE_OPERAND (v2, 1), 0)
-		  && DECL_ASSEMBLER_NAME
-			 (TREE_OPERAND (TREE_OPERAND (v1, 0), 0))
-		     == DECL_ASSEMBLER_NAME
-			 (TREE_OPERAND (TREE_OPERAND (v2, 0), 0)));
-	}
-gcc_unreachable ();
-}
 return (DECL_ASSEMBLER_NAME (TYPE_NAME (type1))
 	  == DECL_ASSEMBLER_NAME (TYPE_NAME (type2)));
 }
 /* Return true if we can decide on ODR equivalency.
 In non-LTO it is always decide, in LTO however it depends in the type has
-ODR info attached.
+ODR info attached. */
-When STRICT is false, compare main variants.  */
 bool
-types_odr_comparable (tree t1, tree t2, bool strict)
+types_odr_comparable (tree t1, tree t2)
 {
 return (!in_lto_p
-	  || (strict ? (main_odr_variant (t1) == main_odr_variant (t2)
+	  || TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)
-			&& main_odr_variant (t1))
+	  || (odr_type_p (TYPE_MAIN_VARIANT (t1))
-	      : TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
+	      && odr_type_p (TYPE_MAIN_VARIANT (t2))));
-	  || (odr_type_p (t1) && odr_type_p (t2))
-	  || (TREE_CODE (t1) == RECORD_TYPE && TREE_CODE (t2) == RECORD_TYPE
-	      && TYPE_BINFO (t1) && TYPE_BINFO (t2)
-	      && polymorphic_type_binfo_p (TYPE_BINFO (t1))
-	      && polymorphic_type_binfo_p (TYPE_BINFO (t2))));
 }
 /* Return true if T1 and T2 are ODR equivalent.  If ODR equivalency is not
 known, be conservative and return false.  */
 bool
 odr_or_derived_type_p (const_tree t)
 {
 do
 {
-if (odr_type_p (t))
+if (odr_type_p (TYPE_MAIN_VARIANT (t)))
 	return true;
 /* Function type is a tricky one. Basically we can consider it
 	 ODR derived if return type or any of the parameters is.
 	 We need to check all parameters because LTO streaming merges
 	 common types (such as void) and they are not considered ODR then.  */
 	  else
 	   {
 	     if (TREE_TYPE (t) && odr_or_derived_type_p (TREE_TYPE (t)))
 	       return true;
 	     for (t = TYPE_ARG_TYPES (t); t; t = TREE_CHAIN (t))
-	       if (odr_or_derived_type_p (TREE_VALUE (t)))
+	       if (odr_or_derived_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (t))))
 		 return true;
 	     return false;
 	   }
 	}
 else
 inline bool
 odr_name_hasher::equal (const odr_type_d *o1, const tree_node *t2)
 {
 tree t1 = o1->type;
-gcc_checking_assert (main_odr_variant (t2) == t2);
+gcc_checking_assert (TYPE_MAIN_VARIANT (t2) == t2);
-gcc_checking_assert (main_odr_variant (t1) == t1);
+gcc_checking_assert (TYPE_MAIN_VARIANT (t1) == t1);
 if (t1 == t2)
 return true;
 if (!in_lto_p)
 return false;
-/* Check for anonymous namespaces. Those have !TREE_PUBLIC
+/* Check for anonymous namespaces.  */
-on the corresponding TYPE_STUB_DECL.  */
 if ((type_with_linkage_p (t1) && type_in_anonymous_namespace_p (t1))
 || (type_with_linkage_p (t2) && type_in_anonymous_namespace_p (t2)))
 return false;
 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t1)));
 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t2)));
 return (DECL_ASSEMBLER_NAME (TYPE_NAME (t1))
 	  == DECL_ASSEMBLER_NAME (TYPE_NAME (t2)));
 }
-/* Compare types T1 and T2 and return true if they are
-equivalent.  */
-inline bool
-odr_vtable_hasher::equal (const odr_type_d *o1, const tree_node *t2)
-{
-tree t1 = o1->type;
-gcc_checking_assert (main_odr_variant (t2) == t2);
-gcc_checking_assert (main_odr_variant (t1) == t1);
-gcc_checking_assert (in_lto_p);
-t1 = TYPE_MAIN_VARIANT (t1);
-t2 = TYPE_MAIN_VARIANT (t2);
-if (t1 == t2)
-return true;
-tree v1 = BINFO_VTABLE (TYPE_BINFO (t1));
-tree v2 = BINFO_VTABLE (TYPE_BINFO (t2));
-return (operand_equal_p (TREE_OPERAND (v1, 1),
-			   TREE_OPERAND (v2, 1), 0)
-	  && DECL_ASSEMBLER_NAME
-		 (TREE_OPERAND (TREE_OPERAND (v1, 0), 0))
-	     == DECL_ASSEMBLER_NAME
-		 (TREE_OPERAND (TREE_OPERAND (v2, 0), 0)));
-}
 /* Free ODR type V.  */
 inline void
 odr_name_hasher::remove (odr_type_d *v)
 {
 /* ODR type hash used to look up ODR type based on tree type node.  */
 typedef hash_table<odr_name_hasher> odr_hash_type;
 static odr_hash_type *odr_hash;
-typedef hash_table<odr_vtable_hasher> odr_vtable_hash_type;
-static odr_vtable_hash_type *odr_vtable_hash;
 /* ODR types are also stored into ODR_TYPE vector to allow consistent
 walking.  Bases appear before derived types.  Vector is garbage collected
 so we won't end up visiting empty types.  */
 TYPE_BINFO (type) = binfo;
 else
 gcc_assert (!TYPE_BINFO (type));
 }
+/* Return true if type variants match.
+This assumes that we already verified that T1 and T2 are variants of the
+same type.  */
+static bool
+type_variants_equivalent_p (tree t1, tree t2)
+{
+if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
+return false;
+if (comp_type_attributes (t1, t2) != 1)
+return false;
+if (COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2)
+&& TYPE_ALIGN (t1) != TYPE_ALIGN (t2))
+return false;
+return true;
+}
 /* Compare T1 and T2 based on name or structure.  */
 static bool
 odr_subtypes_equivalent_p (tree t1, tree t2,
 			   hash_set<type_pair> *visited,
 {
 /* This can happen in incomplete types that should be handled earlier.  */
 gcc_assert (t1 && t2);
-t1 = main_odr_variant (t1);
-t2 = main_odr_variant (t2);
 if (t1 == t2)
 return true;
 /* Anonymous namespace types must match exactly.  */
-if ((type_with_linkage_p (t1) && type_in_anonymous_namespace_p (t1))
+if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1))
-|| (type_with_linkage_p (t2) && type_in_anonymous_namespace_p (t2)))
+&& type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1)))
+|| (type_with_linkage_p (TYPE_MAIN_VARIANT (t2))
+	  && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2))))
 return false;
 /* For ODR types be sure to compare their names.
 To support -Wno-odr-type-merging we allow one type to be non-ODR
 and other ODR even though it is a violation.  */
-if (types_odr_comparable (t1, t2, true))
+if (types_odr_comparable (t1, t2))
 {
-if (!types_same_for_odr (t1, t2, true))
+if (t1 != t2
+	  && odr_type_p (TYPE_MAIN_VARIANT (t1))
+	  && get_odr_type (TYPE_MAIN_VARIANT (t1), true)->odr_violated)
+	return false;
+if (!types_same_for_odr (t1, t2))
 return false;
+if (!type_variants_equivalent_p (t1, t2))
+	return false;
 /* Limit recursion: If subtypes are ODR types and we know
 	 that they are same, be happy.  */
-if (!odr_type_p (t1) || !get_odr_type (t1, true)->odr_violated)
+if (odr_type_p (TYPE_MAIN_VARIANT (t1)))
 return true;
 }
 /* Component types, builtins and possibly violating ODR types
 have to be compared structurally.  */
 return false;
 if (AGGREGATE_TYPE_P (t1)
 && (TYPE_NAME (t1) == NULL_TREE) != (TYPE_NAME (t2) == NULL_TREE))
 return false;
-type_pair pair={t1,t2};
+type_pair pair={TYPE_MAIN_VARIANT (t1), TYPE_MAIN_VARIANT (t2)};
-if (TYPE_UID (t1) > TYPE_UID (t2))
+if (TYPE_UID (TYPE_MAIN_VARIANT (t1)) > TYPE_UID (TYPE_MAIN_VARIANT (t2)))
 {
-pair.first = t2;
+pair.first = TYPE_MAIN_VARIANT (t2);
-pair.second = t1;
+pair.second = TYPE_MAIN_VARIANT (t1);
 }
 if (visited->add (pair))
 return true;
-return odr_types_equivalent_p (t1, t2, false, NULL, visited, loc1, loc2);
+if (!odr_types_equivalent_p (TYPE_MAIN_VARIANT (t1), TYPE_MAIN_VARIANT (t2),
+			      false, NULL, visited, loc1, loc2))
+return false;
+if (!type_variants_equivalent_p (t1, t2))
+return false;
+return true;
 }
 /* Return true if DECL1 and DECL2 are identical methods.  Consider
 name equivalent to name.localalias.xyz.  */
 end1 = !prevailing->iterate_reference (n1, ref1);
 end2 = !vtable->iterate_reference (n2, ref2);
 /* !DECL_VIRTUAL_P means RTTI entry;
-	 We warn when RTTI is lost because non-RTTI previals; we silently
+	 We warn when RTTI is lost because non-RTTI prevails; we silently
 	 accept the other case.  */
 while (!end2
 	     && (end1
 	         || (methods_equal_p (ref1->referred->decl,
 				      ref2->referred->decl)
 	     is not output too often.  */
 	  if (DECL_SIZE (prevailing->decl) != DECL_SIZE (vtable->decl))
 	    {
 	      class_type->odr_violated = true;
 	      auto_diagnostic_group d;
-	      if (warning_at (DECL_SOURCE_LOCATION
+	      tree ctx = TYPE_NAME (DECL_CONTEXT (vtable->decl));
-				(TYPE_NAME (DECL_CONTEXT (vtable->decl))),
+	      if (warning_at (DECL_SOURCE_LOCATION (ctx), OPT_Wodr,
-			      OPT_Wodr,
 			      "virtual table of type %qD violates "
-			      "one definition rule  ",
+			      "one definition rule",
 			      DECL_CONTEXT (vtable->decl)))
 		{
-		  inform (DECL_SOURCE_LOCATION
+		  ctx = TYPE_NAME (DECL_CONTEXT (prevailing->decl));
-			    (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
+		  inform (DECL_SOURCE_LOCATION (ctx),
-			  "the conflicting type defined in another translation "
+			  "the conflicting type defined in another translation"
-			  "unit has virtual table of different size");
+			  " unit has virtual table of different size");
 		}
 	    }
 	  return;
 	}
 	      auto_diagnostic_group d;
 	      if (warning_at (DECL_SOURCE_LOCATION
 				(TYPE_NAME (DECL_CONTEXT (vtable->decl))),
 			      OPT_Wodr,
 			      "virtual table of type %qD violates "
-			      "one definition rule  ",
+			      "one definition rule",
 			      DECL_CONTEXT (vtable->decl)))
 		{
 		  inform (DECL_SOURCE_LOCATION
 			    (TYPE_NAME (DECL_CONTEXT (prevailing->decl))),
 			  "the conflicting type defined in another translation "
 	    }
 	}
 class_type->odr_violated = true;
-/* Complain about size mismatch.  Either we have too many virutal
+/* Complain about size mismatch.  Either we have too many virtual
 	 functions or too many virtual table pointers.  */
 if (end1 || end2)
 	{
 	  if (end1)
 	    {
 		}
 	    }
 	  return;
 	}
-/* And in the last case we have either mistmatch in between two virtual
+/* And in the last case we have either mismatch in between two virtual
 	 methods or two virtual table pointers.  */
 auto_diagnostic_group d;
 if (warning_at (DECL_SOURCE_LOCATION
 			(TYPE_NAME (DECL_CONTEXT (vtable->decl))), OPT_Wodr,
 		      "virtual table of type %qD violates "
-		      "one definition rule  ",
+		      "one definition rule",
 		      DECL_CONTEXT (vtable->decl)))
 	{
 	  if (TREE_CODE (ref1->referred->decl) == FUNCTION_DECL)
 	    {
 	      inform (DECL_SOURCE_LOCATION
 Display location of ST1 and ST2 if REASON speaks about field or
 method of the type.
 If WARN is false, do nothing. Set WARNED if warning was indeed
 output.  */
-void
+static void
 warn_odr (tree t1, tree t2, tree st1, tree st2,
 	  bool warn, bool *warned, const char *reason)
 {
-tree decl2 = TYPE_NAME (t2);
+tree decl2 = TYPE_NAME (TYPE_MAIN_VARIANT (t2));
 if (warned)
 *warned = false;
-if (!warn || !TYPE_NAME(t1))
+if (!warn || !TYPE_NAME(TYPE_MAIN_VARIANT (t1)))
 return;
-/* ODR warnings are output druing LTO streaming; we must apply location
+/* ODR warnings are output during LTO streaming; we must apply location
 cache for potential warnings to be output correctly.  */
 if (lto_location_cache::current_cache)
 lto_location_cache::current_cache->apply_location_cache ();
 auto_diagnostic_group d;
-if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (t1)), OPT_Wodr,
+if (t1 != TYPE_MAIN_VARIANT (t1)
-		   "type %qT violates the C++ One Definition Rule",
+&& TYPE_NAME (t1) != TYPE_NAME (TYPE_MAIN_VARIANT (t1)))
-		   t1))
+{
-return;
+if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (TYPE_MAIN_VARIANT (t1))),
+		       OPT_Wodr, "type %qT (typedef of %qT) violates the "
+		       "C++ One Definition Rule",
+		       t1, TYPE_MAIN_VARIANT (t1)))
+	return;
+}
+else
+{
+if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (TYPE_MAIN_VARIANT (t1))),
+		       OPT_Wodr, "type %qT violates the C++ One Definition Rule",
+		       t1))
+	return;
+}
 if (!st1 && !st2)
 ;
 /* For FIELD_DECL support also case where one of fields is
 NULL - this is used when the structures have mismatching number of
 elements.  */
 if (warned)
 *warned = true;
 }
-/* Return ture if T1 and T2 are incompatible and we want to recusively
+/* Return true if T1 and T2 are incompatible and we want to recursively
 dive into them from warn_type_mismatch to give sensible answer.  */
 static bool
 type_mismatch_p (tree t1, tree t2)
 {
 extra information on how the types mismatch.
 This is hard to do in general.  We basically handle the common cases.
 If LOC1 and LOC2 are meaningful locations, use it in the case the types
-themselves do no thave one.*/
+themselves do not have one.  */
 void
 warn_types_mismatch (tree t1, tree t2, location_t loc1, location_t loc2)
 {
 /* Location of type is known only if it has TYPE_NAME and the name is
 location_t loc = loc_t1 <= BUILTINS_LOCATION ? loc_t2 : loc_t1;
 /* It is a quite common bug to reference anonymous namespace type in
 non-anonymous namespace class.  */
-if ((type_with_linkage_p (t1) && type_in_anonymous_namespace_p (t1))
+tree mt1 = TYPE_MAIN_VARIANT (t1);
-|| (type_with_linkage_p (t2) && type_in_anonymous_namespace_p (t2)))
+tree mt2 = TYPE_MAIN_VARIANT (t2);
-{
+if ((type_with_linkage_p (mt1)
-if (type_with_linkage_p (t1) && !type_in_anonymous_namespace_p (t1))
+&& type_in_anonymous_namespace_p (mt1))
+|| (type_with_linkage_p (mt2)
+	  && type_in_anonymous_namespace_p (mt2)))
+{
+if (!type_with_linkage_p (mt1)
+	  || !type_in_anonymous_namespace_p (mt1))
 	{
 	  std::swap (t1, t2);
+	  std::swap (mt1, mt2);
 	  std::swap (loc_t1, loc_t2);
 	}
-gcc_assert (TYPE_NAME (t1) && TYPE_NAME (t2)
+gcc_assert (TYPE_NAME (mt1)
-		  && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
+		  && TREE_CODE (TYPE_NAME (mt1)) == TYPE_DECL);
-		  && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL);
+tree n1 = TYPE_NAME (mt1);
-/* Most of the time, the type names will match, do not be unnecesarily
+tree n2 = TYPE_NAME (mt2) ? TYPE_NAME (mt2) : NULL;
+if (TREE_CODE (n1) == TYPE_DECL)
+	n1 = DECL_NAME (n1);
+if (n2 && TREE_CODE (n2) == TYPE_DECL)
+	n2 = DECL_NAME (n2);
+/* Most of the time, the type names will match, do not be unnecessarily
 verbose.  */
-if (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t1)))
+if (n1 != n2)
-	  != IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t2))))
 inform (loc_t1,
-	        "type %qT defined in anonymous namespace can not match "
+	        "type %qT defined in anonymous namespace cannot match "
 	        "type %qT across the translation unit boundary",
 	        t1, t2);
 else
 inform (loc_t1,
-	        "type %qT defined in anonymous namespace can not match "
+	        "type %qT defined in anonymous namespace cannot match "
 	        "across the translation unit boundary",
 	        t1);
 if (loc_t2_useful)
 inform (loc_t2,
 	        "the incompatible type defined in another translation unit");
 return;
 }
 /* If types have mangled ODR names and they are different, it is most
 informative to output those.
 This also covers types defined in different namespaces.  */
-if (TYPE_NAME (t1) && TYPE_NAME (t2)
+const char *odr1 = get_odr_name_for_type (mt1);
-&& TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
+const char *odr2 = get_odr_name_for_type (mt2);
-&& TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
+if (odr1 != NULL && odr2 != NULL && odr1 != odr2)
-&& DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t1))
+{
-&& DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t2))
+const int opts = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
-&& DECL_ASSEMBLER_NAME (TYPE_NAME (t1))
+char *name1 = xstrdup (cplus_demangle (odr1, opts));
-	 != DECL_ASSEMBLER_NAME (TYPE_NAME (t2)))
+char *name2 = cplus_demangle (odr2, opts);
-{
-char *name1 = xstrdup (cplus_demangle
-	 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (t1))),
-	  DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES));
-char *name2 = cplus_demangle
-	 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (t2))),
-	  DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES);
 if (name1 && name2 && strcmp (name1, name2))
 	{
 	  inform (loc_t1,
 		  "type name %qs should match type name %qs",
 		  name1, name2);
 	    }
 	}
 return;
 }
-if (types_odr_comparable (t1, t2, true)
+if (types_odr_comparable (t1, t2)
-&& types_same_for_odr (t1, t2, true))
+/* We make assign integers mangled names to be able to handle
+	 signed/unsigned chars.  Accepting them here would however lead to
+	 confusing message like
+	 "type ‘const int’ itself violates the C++ One Definition Rule"  */
+&& TREE_CODE (t1) != INTEGER_TYPE
+&& types_same_for_odr (t1, t2))
 inform (loc_t1,
 	    "type %qT itself violates the C++ One Definition Rule", t1);
 /* Prevent pointless warnings like "struct aa" should match "struct aa".  */
 else if (TYPE_NAME (t1) == TYPE_NAME (t2)
 	   && TREE_CODE (t1) == TREE_CODE (t2) && !loc_t2_useful)
 	    t1, t2);
 if (loc_t2_useful)
 inform (loc_t2, "the incompatible type is defined here");
 }
+/* Return true if T should be ignored in TYPE_FIELDS for ODR comparison.  */
+static bool
+skip_in_fields_list_p (tree t)
+{
+if (TREE_CODE (t) != FIELD_DECL)
+return true;
+/* C++ FE introduces zero sized fields depending on -std setting, see
+PR89358.  */
+if (DECL_SIZE (t)
+&& integer_zerop (DECL_SIZE (t))
+&& DECL_ARTIFICIAL (t)
+&& DECL_IGNORED_P (t)
+&& !DECL_NAME (t))
+return true;
+return false;
+}
 /* Compare T1 and T2, report ODR violations if WARN is true and set
 WARNED to true if anything is reported.  Return true if types match.
 If true is returned, the types are also compatible in the sense of
 gimple_canonical_types_compatible_p.
 If LOC1 and LOC2 is not UNKNOWN_LOCATION it may be used to output a warning
 			location_t loc1, location_t loc2)
 {
 /* Check first for the obvious case of pointer identity.  */
 if (t1 == t2)
 return true;
-gcc_assert (!type_with_linkage_p (t1) || !type_in_anonymous_namespace_p (t1));
-gcc_assert (!type_with_linkage_p (t2) || !type_in_anonymous_namespace_p (t2));
 /* Can't be the same type if the types don't have the same code.  */
 if (TREE_CODE (t1) != TREE_CODE (t2))
 {
 warn_odr (t1, t2, NULL, NULL, warn, warned,
 	        G_("a different type is defined in another translation unit"));
 return false;
 }
-if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
+if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1))
-{
+&& type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1)))
-warn_odr (t1, t2, NULL, NULL, warn, warned,
+|| (type_with_linkage_p (TYPE_MAIN_VARIANT (t2))
-	        G_("a type with different qualifiers is defined in another "
+	  && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2))))
-		   "translation unit"));
+{
-return false;
+/* We cannot trip this when comparing ODR types, only when trying to
-}
-if ((type_with_linkage_p (t1) && type_in_anonymous_namespace_p (t1))
-|| (type_with_linkage_p (t2) && type_in_anonymous_namespace_p (t2)))
-{
-/* We can not trip this when comparing ODR types, only when trying to
 	 match different ODR derivations from different declarations.
 	 So WARN should be always false.  */
 gcc_assert (!warn);
-return false;
-}
-if (comp_type_attributes (t1, t2) != 1)
-{
-warn_odr (t1, t2, NULL, NULL, warn, warned,
-	        G_("a type with different attributes "
-		   "is defined in another translation unit"));
 return false;
 }
 if (TREE_CODE (t1) == ENUMERAL_TYPE
 && TYPE_VALUES (t1) && TYPE_VALUES (t2))
 	      warn_odr (t1, t2, NULL, NULL, warn, warned,
 			G_("an enum with different value name"
 			   " is defined in another translation unit"));
 	      return false;
 	    }
-	  if (TREE_VALUE (v1) != TREE_VALUE (v2)
+	  if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2), 0))
-	      && !operand_equal_p (DECL_INITIAL (TREE_VALUE (v1)),
-				   DECL_INITIAL (TREE_VALUE (v2)), 0))
 	    {
 	      warn_odr (t1, t2, NULL, NULL, warn, warned,
 			G_("an enum with different values is defined"
 			   " in another translation unit"));
 	      return false;
 	tree i2 = TYPE_DOMAIN (t2);
 	/* For an incomplete external array, the type domain can be
 	   NULL_TREE.  Check this condition also.  */
 	if (i1 == NULL_TREE || i2 == NULL_TREE)
-	  return true;
+return type_variants_equivalent_p (t1, t2);
 	tree min1 = TYPE_MIN_VALUE (i1);
 	tree min2 = TYPE_MIN_VALUE (i2);
 	tree max1 = TYPE_MAX_VALUE (i1);
 	tree max2 = TYPE_MAX_VALUE (i2);
 	  return false;
 	}
 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2)
 	  || !prototype_p (t1) || !prototype_p (t2))
-	return true;
+return type_variants_equivalent_p (t1, t2);
 else
 	{
 	  tree parms1, parms2;
 	  for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
 	       parms1 && parms2;
 	       parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
 	    {
 	      if (!odr_subtypes_equivalent_p
-		     (TREE_VALUE (parms1), TREE_VALUE (parms2), visited,
+		     (TREE_VALUE (parms1), TREE_VALUE (parms2),
-		      loc1, loc2))
+		      visited, loc1, loc2))
 		{
 		  warn_odr (t1, t2, NULL, NULL, warn, warned,
 			    G_("has different parameters in another "
 			       "translation unit"));
 		  if (warn && warned)
 			G_("has different parameters "
 			   "in another translation unit"));
 	      return false;
 	    }
-	  return true;
+return type_variants_equivalent_p (t1, t2);
 	}
 case RECORD_TYPE:
 case UNION_TYPE:
 case QUAL_UNION_TYPE:
 	    for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
 		 f1 || f2;
 		 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
 	      {
 		/* Skip non-fields.  */
-		while (f1 && TREE_CODE (f1) != FIELD_DECL)
+		while (f1 && skip_in_fields_list_p (f1))
 		  f1 = TREE_CHAIN (f1);
-		while (f2 && TREE_CODE (f2) != FIELD_DECL)
+		while (f2 && skip_in_fields_list_p (f2))
 		  f2 = TREE_CHAIN (f2);
 		if (!f1 || !f2)
 		  break;
 		if (DECL_VIRTUAL_P (f1) != DECL_VIRTUAL_P (f2))
 		  {
 			      G_("a field with different name is defined "
 				 "in another translation unit"));
 		    return false;
 		  }
 		if (!odr_subtypes_equivalent_p (TREE_TYPE (f1),
-						TREE_TYPE (f2), visited,
+						TREE_TYPE (f2),
-						loc1, loc2))
+						visited, loc1, loc2))
 		  {
 		    /* Do not warn about artificial fields and just go into
 		       generic field mismatch warning.  */
 		    if (DECL_ARTIFICIAL (f1))
 		      break;
 		    return false;
 		  }
 		if (DECL_BIT_FIELD (f1) != DECL_BIT_FIELD (f2))
 		  {
 		    warn_odr (t1, t2, f1, f2, warn, warned,
-			      G_("one field is bitfield while other is not"));
+			      G_("one field is a bitfield while the other "
+				 "is not"));
 		    return false;
 		  }
 		else
 		  gcc_assert (DECL_NONADDRESSABLE_P (f1)
 			      == DECL_NONADDRESSABLE_P (f2));
 warn_odr (t1, t2, NULL, NULL, warn, warned,
 		G_("a type with different size "
 		   "is defined in another translation unit"));
 return false;
 }
-if (COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2)
-&& TYPE_ALIGN (t1) != TYPE_ALIGN (t2))
+if (TREE_ADDRESSABLE (t1) != TREE_ADDRESSABLE (t2)
+&& COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2))
 {
 warn_odr (t1, t2, NULL, NULL, warn, warned,
-		G_("a type with different alignment "
+		G_("one type needs to be constructed while other not"));
-		   "is defined in another translation unit"));
+gcc_checking_assert (RECORD_OR_UNION_TYPE_P (t1));
 return false;
 }
+/* There is no really good user facing warning for this.
+Either the original reason for modes being different is lost during
+streaming or we should catch earlier warnings.  We however must detect
+the mismatch to avoid type verifier from cmplaining on mismatched
+types between type and canonical type. See PR91576.  */
+if (TYPE_MODE (t1) != TYPE_MODE (t2)
+&& COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2))
+{
+warn_odr (t1, t2, NULL, NULL, warn, warned,
+		G_("memory layout mismatch"));
+return false;
+}
 gcc_assert (!TYPE_SIZE_UNIT (t1) || !TYPE_SIZE_UNIT (t2)
 	      || operand_equal_p (TYPE_SIZE_UNIT (t1),
 				  TYPE_SIZE_UNIT (t2), 0));
-return true;
+return type_variants_equivalent_p (t1, t2);
 }
 /* Return true if TYPE1 and TYPE2 are equivalent for One Definition Rule.  */
 bool
 }
 /* Always prefer complete type to be the leader.  */
 else if (!COMPLETE_TYPE_P (val->type) && COMPLETE_TYPE_P (type))
 {
 prevail = true;
-build_bases = TYPE_BINFO (type);
+if (TREE_CODE (type) == RECORD_TYPE)
+build_bases = TYPE_BINFO (type);
 }
 else if (COMPLETE_TYPE_P (val->type) && !COMPLETE_TYPE_P (type))
 ;
 else if (TREE_CODE (val->type) == ENUMERAL_TYPE
 	   && TREE_CODE (type) == ENUMERAL_TYPE
 if (prevail)
 std::swap (val->type, type);
 val->types_set->add (type);
-/* If we now have a mangled name, be sure to record it to val->type
+if (!odr_hash)
-so ODR hash can work.  */
+return false;
-if (can_be_name_hashed_p (type) && !can_be_name_hashed_p (val->type))
+gcc_checking_assert (can_be_name_hashed_p (type)
-SET_DECL_ASSEMBLER_NAME (TYPE_NAME (val->type),
+		       && can_be_name_hashed_p (val->type));
-			     DECL_ASSEMBLER_NAME (TYPE_NAME (type)));
 bool merge = true;
 bool base_mismatch = false;
 unsigned int i;
 bool warned = false;
 The DECL_SOURCE_LOCATIONs in this invocation came from LTO streaming.
 We must apply the location cache to ensure that they are valid
 before we can pass them to odr_types_equivalent_p (PR lto/83121).  */
 if (lto_location_cache::current_cache)
 lto_location_cache::current_cache->apply_location_cache ();
-if (!odr_types_equivalent_p (val->type, type,
+/* As a special case we stream mangles names of integer types so we can see
+if they are believed to be same even though they have different
+representation.  Avoid bogus warning on mismatches in these.  */
+if (TREE_CODE (type) != INTEGER_TYPE
+&& TREE_CODE (val->type) != INTEGER_TYPE
+&& !odr_types_equivalent_p (val->type, type,
 			       !flag_ltrans && !val->odr_violated && !warned,
 			       &warned, &visited,
 			       DECL_SOURCE_LOCATION (TYPE_NAME (val->type)),
 			       DECL_SOURCE_LOCATION (TYPE_NAME (type))))
 {
 	set_type_binfo (type, master_binfo);
 }
 return build_bases;
 }
+/* REF is OBJ_TYPE_REF, return the class the ref corresponds to.  */
+tree
+obj_type_ref_class (const_tree ref)
+{
+gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF);
+ref = TREE_TYPE (ref);
+gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
+ref = TREE_TYPE (ref);
+/* We look for type THIS points to.  ObjC also builds
+OBJ_TYPE_REF with non-method calls, Their first parameter
+ID however also corresponds to class type. */
+gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE
+		       || TREE_CODE (ref) == FUNCTION_TYPE);
+ref = TREE_VALUE (TYPE_ARG_TYPES (ref));
+gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE);
+tree ret = TREE_TYPE (ref);
+if (!in_lto_p && !TYPE_STRUCTURAL_EQUALITY_P (ret))
+ret = TYPE_CANONICAL (ret);
+else
+ret = get_odr_type (ret)->type;
+return ret;
+}
 /* Get ODR type hash entry for TYPE.  If INSERT is true, create
 possibly new entry.  */
 odr_type
 get_odr_type (tree type, bool insert)
 {
 odr_type_d **slot = NULL;
-odr_type_d **vtable_slot = NULL;
 odr_type val = NULL;
 hashval_t hash;
 bool build_bases = false;
 bool insert_to_odr_array = false;
 int base_id = -1;
-type = main_odr_variant (type);
+type = TYPE_MAIN_VARIANT (type);
+if (!in_lto_p && !TYPE_STRUCTURAL_EQUALITY_P (type))
-gcc_checking_assert (can_be_name_hashed_p (type)
+type = TYPE_CANONICAL (type);
-		       || can_be_vtable_hashed_p (type));
+gcc_checking_assert (can_be_name_hashed_p (type));
-/* Lookup entry, first try name hash, fallback to vtable hash.  */
-if (can_be_name_hashed_p (type))
+hash = hash_odr_name (type);
-{
+slot = odr_hash->find_slot_with_hash (type, hash,
-hash = hash_odr_name (type);
+					insert ? INSERT : NO_INSERT);
-slot = odr_hash->find_slot_with_hash (type, hash,
-					    insert ? INSERT : NO_INSERT);
+if (!slot)
-}
-if ((!slot || !*slot) && in_lto_p && can_be_vtable_hashed_p (type))
-{
-hash = hash_odr_vtable (type);
-vtable_slot = odr_vtable_hash->find_slot_with_hash (type, hash,
-					           insert ? INSERT : NO_INSERT);
-}
-if (!slot && !vtable_slot)
 return NULL;
 /* See if we already have entry for type.  */
-if ((slot && *slot) || (vtable_slot && *vtable_slot))
+if (*slot)
 {
-if (slot && *slot)
+val = *slot;
-	{
-	  val = *slot;
+if (val->type != type && insert
-	  if (flag_checking
-	      && in_lto_p && can_be_vtable_hashed_p (type))
-	    {
-	      hash = hash_odr_vtable (type);
-	      vtable_slot = odr_vtable_hash->find_slot_with_hash (type, hash,
-						                  NO_INSERT);
-	      gcc_assert (!vtable_slot || *vtable_slot == *slot);
-	      vtable_slot = NULL;
-	    }
-	}
-else if (*vtable_slot)
-	val = *vtable_slot;
-if (val->type != type
 	  && (!val->types_set || !val->types_set->add (type)))
-	{
+	build_bases = add_type_duplicate (val, type);
-	  gcc_assert (insert);
-	  /* We have type duplicate, but it may introduce vtable name or
-	     mangled name; be sure to keep hashes in sync.  */
-	  if (in_lto_p && can_be_vtable_hashed_p (type)
-	      && (!vtable_slot || !*vtable_slot))
-	    {
-	      if (!vtable_slot)
-		{
-		  hash = hash_odr_vtable (type);
-		  vtable_slot = odr_vtable_hash->find_slot_with_hash
-			     (type, hash, INSERT);
-		  gcc_checking_assert (!*vtable_slot || *vtable_slot == val);
-		}
-	      *vtable_slot = val;
-	    }
-	  if (slot && !*slot)
-	    *slot = val;
-	  build_bases = add_type_duplicate (val, type);
-	}
 }
 else
 {
 val = ggc_cleared_alloc<odr_type_d> ();
 val->type = type;
 val->anonymous_namespace = type_in_anonymous_namespace_p (type);
 else
 	val->anonymous_namespace = 0;
 build_bases = COMPLETE_TYPE_P (val->type);
 insert_to_odr_array = true;
-if (slot)
+*slot = val;
-*slot = val;
-if (vtable_slot)
-	*vtable_slot = val;
 }
 if (build_bases && TREE_CODE (type) == RECORD_TYPE && TYPE_BINFO (type)
 && type_with_linkage_p (type)
 && type == TYPE_MAIN_VARIANT (type))
 gcc_assert (BINFO_TYPE (TYPE_BINFO (val->type)) == type);
 val->all_derivations_known = type_all_derivations_known_p (type);
 for (i = 0; i < BINFO_N_BASE_BINFOS (binfo); i++)
 	/* For now record only polymorphic types. other are
-	   pointless for devirtualization and we can not precisely
+	   pointless for devirtualization and we cannot precisely
 	   determine ODR equivalency of these during LTO.  */
 	if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (binfo, i)))
 	  {
 	    tree base_type= BINFO_TYPE (BINFO_BASE_BINFO (binfo, i));
 	    odr_type base = get_odr_type (base_type, true);
 vec_safe_push (odr_types_ptr, val);
 }
 return val;
 }
-/* Add TYPE od ODR type hash.  */
+/* Return type that in ODR type hash prevailed TYPE.  Be careful and punt
+on ODR violations.  */
+tree
+prevailing_odr_type (tree type)
+{
+odr_type t = get_odr_type (type, false);
+if (!t || t->odr_violated)
+return type;
+return t->type;
+}
+/* Set tbaa_enabled flag for TYPE.  */
+void
+enable_odr_based_tbaa (tree type)
+{
+odr_type t = get_odr_type (type, true);
+t->tbaa_enabled = true;
+}
+/* True if canonical type of TYPE is determined using ODR name.  */
+bool
+odr_based_tbaa_p (const_tree type)
+{
+if (!RECORD_OR_UNION_TYPE_P (type))
+return false;
+odr_type t = get_odr_type (const_cast <tree> (type), false);
+if (!t || !t->tbaa_enabled)
+return false;
+return true;
+}
+/* Set TYPE_CANONICAL of type and all its variants and duplicates
+to CANONICAL.  */
+void
+set_type_canonical_for_odr_type (tree type, tree canonical)
+{
+odr_type t = get_odr_type (type, false);
+unsigned int i;
+tree tt;
+for (tree t2 = t->type; t2; t2 = TYPE_NEXT_VARIANT (t2))
+TYPE_CANONICAL (t2) = canonical;
+if (t->types)
+FOR_EACH_VEC_ELT (*t->types, i, tt)
+for (tree t2 = tt; t2; t2 = TYPE_NEXT_VARIANT (t2))
+TYPE_CANONICAL (t2) = canonical;
+}
+/* Return true if we reported some ODR violation on TYPE.  */
+bool
+odr_type_violation_reported_p (tree type)
+{
+return get_odr_type (type, false)->odr_violated;
+}
+/* Add TYPE of ODR type hash.  */
 void
 register_odr_type (tree type)
 {
 if (!odr_hash)
-{
+odr_hash = new odr_hash_type (23);
-odr_hash = new odr_hash_type (23);
+if (type == TYPE_MAIN_VARIANT (type))
-if (in_lto_p)
+{
-odr_vtable_hash = new odr_vtable_hash_type (23);
+/* To get ODR warnings right, first register all sub-types.  */
-}
+if (RECORD_OR_UNION_TYPE_P (type)
-/* Arrange things to be nicer and insert main variants first.
+	  && COMPLETE_TYPE_P (type))
-??? fundamental prerecorded types do not have mangled names; this
+	{
-makes it possible that non-ODR type is main_odr_variant of ODR type.
+	  /* Limit recursion on types which are already registered.  */
-Things may get smoother if LTO FE set mangled name of those types same
+	  odr_type ot = get_odr_type (type, false);
-way as C++ FE does.  */
+	  if (ot
-if (odr_type_p (main_odr_variant (TYPE_MAIN_VARIANT (type)))
+	      && (ot->type == type
-&& odr_type_p (TYPE_MAIN_VARIANT (type)))
+		  || (ot->types_set
-get_odr_type (TYPE_MAIN_VARIANT (type), true);
+		      && ot->types_set->contains (type))))
-if (TYPE_MAIN_VARIANT (type) != type && odr_type_p (main_odr_variant (type)))
+	    return;
-get_odr_type (type, true);
+	  for (tree f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f))
+	    if (TREE_CODE (f) == FIELD_DECL)
+	      {
+		tree subtype = TREE_TYPE (f);
+		while (TREE_CODE (subtype) == ARRAY_TYPE)
+		  subtype = TREE_TYPE (subtype);
+		if (type_with_linkage_p (TYPE_MAIN_VARIANT (subtype)))
+		  register_odr_type (TYPE_MAIN_VARIANT (subtype));
+	      }
+	   if (TYPE_BINFO (type))
+	     for (unsigned int i = 0;
+	          i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); i++)
+	       register_odr_type (BINFO_TYPE (BINFO_BASE_BINFO
+						 (TYPE_BINFO (type), i)));
+	}
+get_odr_type (type, true);
+}
 }
 /* Return true if type is known to have no derivations.  */
 bool
 print_generic_expr (f, t->type, TDF_SLIM);
 fprintf (f, "%s", t->anonymous_namespace ? " (anonymous namespace)":"");
 fprintf (f, "%s\n", t->all_derivations_known ? " (derivations known)":"");
 if (TYPE_NAME (t->type))
 {
-/*fprintf (f, "%*s defined at: %s:%i\n", indent * 2, "",
-	       DECL_SOURCE_FILE (TYPE_NAME (t->type)),
-	       DECL_SOURCE_LINE (TYPE_NAME (t->type)));*/
 if (DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t->type)))
 fprintf (f, "%*s mangled name: %s\n", indent * 2, "",
 		 IDENTIFIER_POINTER
 		   (DECL_ASSEMBLER_NAME (TYPE_NAME (t->type))));
 }
 static void
 dump_type_inheritance_graph (FILE *f)
 {
 unsigned int i;
+unsigned int num_all_types = 0, num_types = 0, num_duplicates = 0;
 if (!odr_types_ptr)
 return;
 fprintf (f, "\n\nType inheritance graph:\n");
 for (i = 0; i < odr_types.length (); i++)
 {
 if (odr_types[i] && odr_types[i]->bases.length () == 0)
 	dump_odr_type (f, odr_types[i]);
 }
 for (i = 0; i < odr_types.length (); i++)
 {
-if (odr_types[i] && odr_types[i]->types && odr_types[i]->types->length ())
+if (!odr_types[i])
-	{
+	continue;
-	  unsigned int j;
-	  fprintf (f, "Duplicate tree types for odr type %i\n", i);
+num_all_types++;
-	  print_node (f, "", odr_types[i]->type, 0);
+if (!odr_types[i]->types || !odr_types[i]->types->length ())
-	  for (j = 0; j < odr_types[i]->types->length (); j++)
+	continue;
+/* To aid ODR warnings we also mangle integer constants but do
+	 not consider duplicates there.  */
+if (TREE_CODE (odr_types[i]->type) == INTEGER_TYPE)
+	continue;
+/* It is normal to have one duplicate and one normal variant.  */
+if (odr_types[i]->types->length () == 1
+	  && COMPLETE_TYPE_P (odr_types[i]->type)
+	  && !COMPLETE_TYPE_P ((*odr_types[i]->types)[0]))
+	continue;
+num_types ++;
+unsigned int j;
+fprintf (f, "Duplicate tree types for odr type %i\n", i);
+print_node (f, "", odr_types[i]->type, 0);
+print_node (f, "", TYPE_NAME (odr_types[i]->type), 0);
+putc ('\n',f);
+for (j = 0; j < odr_types[i]->types->length (); j++)
+	{
+	  tree t;
+	  num_duplicates ++;
+	  fprintf (f, "duplicate #%i\n", j);
+	  print_node (f, "", (*odr_types[i]->types)[j], 0);
+	  t = (*odr_types[i]->types)[j];
+	  while (TYPE_P (t) && TYPE_CONTEXT (t))
 	    {
-	      tree t;
+	      t = TYPE_CONTEXT (t);
-	      fprintf (f, "duplicate #%i\n", j);
+	      print_node (f, "", t, 0);
-	      print_node (f, "", (*odr_types[i]->types)[j], 0);
-	      t = (*odr_types[i]->types)[j];
-	      while (TYPE_P (t) && TYPE_CONTEXT (t))
-		{
-		  t = TYPE_CONTEXT (t);
-	          print_node (f, "", t, 0);
-		}
-	      putc ('\n',f);
 	    }
-	}
+	  print_node (f, "", TYPE_NAME ((*odr_types[i]->types)[j]), 0);
-}
+	  putc ('\n',f);
+	}
+}
+fprintf (f, "Out of %i types there are %i types with duplicates; "
+	   "%i duplicates overall\n", num_all_types, num_types, num_duplicates);
+}
+/* Save some WPA->ltrans streaming by freeing stuff needed only for good
+ODR warnings.
+We free TYPE_VALUES of enums and also make TYPE_DECLs to not point back
+to the type (which is needed to keep them in the same SCC and preserve
+location information to output warnings) and subsequently we make all
+TYPE_DECLS of same assembler name equivalent.  */
+static void
+free_odr_warning_data ()
+{
+static bool odr_data_freed = false;
+if (odr_data_freed || !flag_wpa || !odr_types_ptr)
+return;
+odr_data_freed = true;
+for (unsigned int i = 0; i < odr_types.length (); i++)
+if (odr_types[i])
+{
+	tree t = odr_types[i]->type;
+	if (TREE_CODE (t) == ENUMERAL_TYPE)
+	  TYPE_VALUES (t) = NULL;
+	TREE_TYPE (TYPE_NAME (t)) = void_type_node;
+	if (odr_types[i]->types)
+for (unsigned int j = 0; j < odr_types[i]->types->length (); j++)
+	    {
+	      tree td = (*odr_types[i]->types)[j];
+	      if (TREE_CODE (td) == ENUMERAL_TYPE)
+	        TYPE_VALUES (td) = NULL;
+	      TYPE_NAME (td) = TYPE_NAME (t);
+	    }
+}
+odr_data_freed = true;
 }
 /* Initialize IPA devirt and build inheritance tree graph.  */
 void
 struct symtab_node *n;
 FILE *inheritance_dump_file;
 dump_flags_t flags;
 if (odr_hash)
-return;
+{
+free_odr_warning_data ();
+return;
+}
 timevar_push (TV_IPA_INHERITANCE);
 inheritance_dump_file = dump_begin (TDI_inheritance, &flags);
 odr_hash = new odr_hash_type (23);
-if (in_lto_p)
-odr_vtable_hash = new odr_vtable_hash_type (23);
 /* We reconstruct the graph starting of types of all methods seen in the
 unit.  */
 FOR_EACH_SYMBOL (n)
 if (is_a <cgraph_node *> (n)
 if (inheritance_dump_file)
 {
 dump_type_inheritance_graph (inheritance_dump_file);
 dump_end (TDI_inheritance, inheritance_dump_file);
 }
+free_odr_warning_data ();
 timevar_pop (TV_IPA_INHERITANCE);
 }
 /* Return true if N has reference from live virtual table
 (and thus can be a destination of polymorphic call).
 		     "__cxa_pure_virtual");
 }
 /* If TARGET has associated node, record it in the NODES array.
 CAN_REFER specify if program can refer to the target directly.
-if TARGET is unknown (NULL) or it can not be inserted (for example because
+if TARGET is unknown (NULL) or it cannot be inserted (for example because
 its body was already removed and there is no way to refer to it), clear
 COMPLETEP.  */
 static void
 maybe_record_node (vec <cgraph_node *> &nodes,
 	   && (TREE_PUBLIC (target)
 	       || DECL_EXTERNAL (target)
 	       || target_node->definition)
 	   && target_node->real_symbol_p ())
 {
-gcc_assert (!target_node->global.inlined_to);
+gcc_assert (!target_node->inlined_to);
 gcc_assert (target_node->real_symbol_p ());
 /* When sanitizing, do not assume that __cxa_pure_virtual is not called
 	 by valid program.  */
 if (flag_sanitize & SANITIZE_UNREACHABLE)
 	;
 	}
 }
 else if (!completep)
 ;
 /* We have definition of __cxa_pure_virtual that is not accessible (it is
-optimized out or partitioned to other unit) so we can not add it.  When
+optimized out or partitioned to other unit) so we cannot add it.  When
 not sanitizing, there is nothing to do.
 Otherwise declare the list incomplete.  */
 else if (pure_virtual)
 {
 if (flag_sanitize & SANITIZE_UNREACHABLE)
 Enumerating all call targets may get expensive when there are many
 polymorphic calls in the program, so we memoize all the previous
 queries and avoid duplicated work.  */
-struct polymorphic_call_target_d
+class polymorphic_call_target_d
 {
+public:
 HOST_WIDE_INT otr_token;
 ipa_polymorphic_call_context context;
 odr_type type;
 vec <cgraph_node *> targets;
 tree decl_warning;
 int type_warning;
+unsigned int n_odr_types;
 bool complete;
 bool speculative;
 };
 /* Polymorphic call target cache helpers.  */
 inchash::hash hstate (odr_query->otr_token);
 hstate.add_hwi (odr_query->type->id);
 hstate.merge_hash (TYPE_UID (odr_query->context.outer_type));
 hstate.add_hwi (odr_query->context.offset);
+hstate.add_hwi (odr_query->n_odr_types);
 if (odr_query->context.speculative_outer_type)
 {
 hstate.merge_hash (TYPE_UID (odr_query->context.speculative_outer_type));
 hstate.add_hwi (odr_query->context.speculative_offset);
 	  && t1->context.speculative_outer_type == t2->context.speculative_outer_type
 	  && t1->context.maybe_in_construction
 	      == t2->context.maybe_in_construction
 	  && t1->context.maybe_derived_type == t2->context.maybe_derived_type
 	  && (t1->context.speculative_maybe_derived_type
-	      == t2->context.speculative_maybe_derived_type));
+	      == t2->context.speculative_maybe_derived_type)
+	  /* Adding new type may affect outcome of target search.  */
+	  && t1->n_odr_types == t2->n_odr_types);
 }
 /* Remove entry in polymorphic call target cache hash.  */
 inline void
 rebuild_type_inheritance_graph ()
 {
 if (!odr_hash)
 return;
 delete odr_hash;
-if (in_lto_p)
-delete odr_vtable_hash;
 odr_hash = NULL;
-odr_vtable_hash = NULL;
 odr_types_ptr = NULL;
 free_polymorphic_call_targets_hash ();
 }
 /* When virtual function is removed, we may need to flush the cache.  */
 static void
 devirt_node_removal_hook (struct cgraph_node *n, void *d ATTRIBUTE_UNUSED)
 {
 if (cached_polymorphic_call_targets
+&& !thunk_expansion
 && cached_polymorphic_call_targets->contains (n))
 free_polymorphic_call_targets_hash ();
 }
 /* Look up base of BINFO that has virtual table VTABLE with OFFSET.  */
 profile_count dyn_count;
 };
 /* Information about type and decl warnings.  */
-struct final_warning_record
+class final_warning_record
 {
+public:
 /* If needed grow type_warnings vector and initialize new decl_warn_count
 to have dyn_count set to profile_count::zero ().  */
 void grow_type_warnings (unsigned newlen);
 profile_count dyn_count;
 for (unsigned i = len; i < newlen; i++)
 	type_warnings[i].dyn_count = profile_count::zero ();
 }
 }
-struct final_warning_record *final_warning_records;
+class final_warning_record *final_warning_records;
 /* Return vector containing possible targets of polymorphic call of type
 OTR_TYPE calling method OTR_TOKEN within type of OTR_OUTER_TYPE and OFFSET.
 If INCLUDE_BASES is true, walk also base types of OUTER_TYPES containing
 OTR_TYPE and include their virtual method.  This is useful for types
 possibly in construction or destruction where the virtual table may
-temporarily change to one of base types.  INCLUDE_DERIVER_TYPES make
+temporarily change to one of base types.  INCLUDE_DERIVED_TYPES make
 us to walk the inheritance graph for all derivations.
 If COMPLETEP is non-NULL, store true if the list is complete.
 CACHE_TOKEN (if non-NULL) will get stored to an unique ID of entry
 in the target cache.  If user needs to visit every target list
 /* Look up cached answer.  */
 key.type = type;
 key.otr_token = otr_token;
 key.speculative = speculative;
 key.context = context;
+key.n_odr_types = odr_types.length ();
 slot = polymorphic_call_target_hash->find_slot (&key, INSERT);
 if (cache_token)
 *cache_token = (void *)*slot;
 if (*slot)
 {
 	}
 }
 (*slot)->targets = nodes;
 (*slot)->complete = complete;
+(*slot)->n_odr_types = odr_types.length ();
 if (completep)
 *completep = complete;
 timevar_pop (TV_IPA_VIRTUAL_CALL);
 return nodes;
 }
 /* Dump target list TARGETS into FILE.  */
 static void
-dump_targets (FILE *f, vec <cgraph_node *> targets)
+dump_targets (FILE *f, vec <cgraph_node *> targets, bool verbose)
 {
 unsigned int i;
 for (i = 0; i < targets.length (); i++)
 {
 char *name = NULL;
 if (in_lto_p)
 	name = cplus_demangle_v3 (targets[i]->asm_name (), 0);
-fprintf (f, " %s/%i", name ? name : targets[i]->name (),
+fprintf (f, " %s", name ? name : targets[i]->dump_name ());
-	       targets[i]->order);
 if (in_lto_p)
 	free (name);
 if (!targets[i]->definition)
 	fprintf (f, " (no definition%s)",
 		 DECL_DECLARED_INLINE_P (targets[i]->decl)
 		 ? " inline" : "");
+/* With many targets for every call polymorphic dumps are going to
+	 be quadratic in size.  */
+if (i > 10 && !verbose)
+	{
+	  fprintf (f, " ... and %i more targets\n", targets.length () - i);
+	  return;
+	}
 }
 fprintf (f, "\n");
 }
 /* Dump all possible targets of a polymorphic call.  */
 void
 dump_possible_polymorphic_call_targets (FILE *f,
 					tree otr_type,
 					HOST_WIDE_INT otr_token,
-					const ipa_polymorphic_call_context &ctx)
+					const ipa_polymorphic_call_context &ctx,
+					bool verbose)
 {
 vec <cgraph_node *> targets;
 bool final;
 odr_type type = get_odr_type (TYPE_MAIN_VARIANT (otr_type), false);
 unsigned int len;
 	   "This is partial list; extra targets may be defined in other units.",
 	   ctx.maybe_in_construction ? " (base types included)" : "",
 	   ctx.maybe_derived_type ? " (derived types included)" : "",
 	   ctx.speculative_maybe_derived_type ? " (speculative derived types included)" : "");
 len = targets.length ();
-dump_targets (f, targets);
+dump_targets (f, targets, verbose);
 targets = possible_polymorphic_call_targets (otr_type, otr_token,
 					       ctx,
 					       &final, NULL, true);
 if (targets.length () != len)
 {
 fprintf (f, "  Speculative targets:");
-dump_targets (f, targets);
+dump_targets (f, targets, verbose);
 }
 /* Ugly: during callgraph construction the target cache may get populated
 before all targets are found.  While this is harmless (because all local
 types are discovered and only in those case we devirtualize fully and we
 don't do speculative devirtualization before IPA stage) it triggers
 				    const ipa_polymorphic_call_context &ctx,
 				    struct cgraph_node *n)
 {
 vec <cgraph_node *> targets;
 unsigned int i;
-enum built_in_function fcode;
 bool final;
-if (TREE_CODE (TREE_TYPE (n->decl)) == FUNCTION_TYPE
+if (fndecl_built_in_p (n->decl, BUILT_IN_UNREACHABLE)
-&& ((fcode = DECL_FUNCTION_CODE (n->decl)) == BUILT_IN_UNREACHABLE
+|| fndecl_built_in_p (n->decl, BUILT_IN_TRAP))
-|| fcode == BUILT_IN_TRAP))
 return true;
 if (is_cxa_pure_virtual_p (n->decl))
 return true;
 }
 /* Compare type warning records P1 and P2 and choose one with larger count;
 helper for qsort.  */
-int
+static int
 type_warning_cmp (const void *p1, const void *p2)
 {
 const odr_type_warn_count *t1 = (const odr_type_warn_count *)p1;
 const odr_type_warn_count *t2 = (const odr_type_warn_count *)p2;
 }
 /* Compare decl warning records P1 and P2 and choose one with larger count;
 helper for qsort.  */
-int
+static int
 decl_warning_cmp (const void *p1, const void *p2)
 {
 const decl_warn_count *t1 = *(const decl_warn_count * const *)p1;
 const decl_warn_count *t2 = *(const decl_warn_count * const *)p2;
 	    if (warn_suggest_final_methods || warn_suggest_final_types)
 	      possible_polymorphic_call_targets (e);
 	    if (dump_file)
 	      dump_possible_polymorphic_call_targets
-		(dump_file, e);
+		(dump_file, e, (dump_flags & TDF_DETAILS));
 	    npolymorphic++;
 	    /* See if the call can be devirtualized by means of ipa-prop's
 	       polymorphic call context propagation.  If not, we can just
 	       lifting in remove_unreachable_nodes that will otherwise try to
 	       keep all possible targets alive until inlining and in the inliner
 	       itself.
 	       This may need to be revisited once we add further ways to use
-	       the may edges, but it is a resonable thing to do right now.  */
+	       the may edges, but it is a reasonable thing to do right now.  */
 	    if ((e->indirect_info->param_index == -1
 		|| (!opt_for_fn (n->decl, flag_devirtualize_speculatively)
 		    && e->indirect_info->vptr_changed))
 		&& !flag_ltrans_devirtualize)
 	      {
 		e->indirect_info->polymorphic = false;
 		ndropped++;
 	        if (dump_file)
 		  fprintf (dump_file, "Dropping polymorphic call info;"
-			   " it can not be used by ipa-prop\n");
+			   " it cannot be used by ipa-prop\n");
 	      }
 	    if (!opt_for_fn (n->decl, flag_devirtualize_speculatively))
 	      continue;
 	      }
 	    /* This is reached only when dumping; check if we agree or disagree
 	       with the speculation.  */
 	    if (e->speculative)
 	      {
-		struct cgraph_edge *e2;
+		bool found = e->speculative_call_for_target (likely_target);
-		struct ipa_ref *ref;
+		if (found)
-		e->speculative_call_info (e2, e, ref);
-		if (e2->callee->ultimate_alias_target ()
-		    == likely_target->ultimate_alias_target ())
 		  {
 		    fprintf (dump_file, "We agree with speculation\n\n");
 		    nok++;
 		  }
 		else
 make_pass_ipa_devirt (gcc::context *ctxt)
 {
 return new pass_ipa_devirt (ctxt);
 }
+/* Print ODR name of a TYPE if available.
+Use demangler when option DEMANGLE is used.  */
+DEBUG_FUNCTION void
+debug_tree_odr_name (tree type, bool demangle)
+{
+const char *odr = get_odr_name_for_type (type);
+if (demangle)
+{
+const int opts = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
+odr = cplus_demangle (odr, opts);
+}
+fprintf (stderr, "%s\n", odr);
+}
 #include "gt-ipa-devirt.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ipa-devirt.c @ 145:1830386684a0