downgrade strong type info names to weak_odr linkage

[rsmith]

Summary

After https://reviews.llvm.org/D46665 / rC332028, we now emit linkonce_odr definitions of type info names for incomplete class types. This results in formal violations of LLVM's linkage rules (which, for example, cause ASan's ODR violation checker to complain) if the type info name is declared with external linkage in another IR module. To solve this, downgrade any type info names that we would give external linkage to instead have weak_odr linkage. Exception: if we would emit a non-unique type_info name anyway, leave the linkage alone.

This required a bit of rearrangement: the uniqueness of the name can no longer depend on the linkage of the name, because the linkage of the name now depends on the uniqueness of the name! Fortunately, the uniqueness doesn't *really* depend on the linkage of the name, it only depends on the uniqueness of the type. I've split out the type uniqueness / name uniqueness / type_info uniqueness calculations to try to make this a bit clearer.

[efriedma]

This results in formal violations of LLVM's linkage rules

I'm pretty sure this isn't actually a violation of LLVM's linkage rules as they are described in LangRef... at least, my understanding is that "equivalent" doesn't imply anything about linkage. (If this should be a violation, we need to clarify the rules.)

[rjmccall]

Incomplete classes are a curse. I don't suppose we can just modify the language specification to make it illegal to use typeid(Incomplete*)? Or make equality/hashing undefined in these cases?

test/CodeGenCXX/arm64.cpp

48

The way the Darwin ARM64 ABI handles non-unique RTTI is by setting a flag indicating that clients should do string comparisons/hashes; it does not rely on the type name symbols being uniqued. So this should stay external and the _ZTI definition should change to set the bit.

test/CodeGenCXX/windows-itanium-type-info.cpp

31

Is this actually okay? I didn't think dllexport supported weak symbols.

[rjmccall]

In D47092#1105317, @rjmccall wrote:

Incomplete classes are a curse. I don't suppose we can just modify the language specification to make it illegal to use typeid(Incomplete*)? Or make equality/hashing undefined in these cases?

Honestly, I'm somewhat inclined to just declare this for Darwin and make us non-conformant. It's not like this has ever previously worked, and this patch is going to be disruptive for our internal C++ developers by introducing new global weak symbols that they can't get rid of except by disabling RTTI. (It would always have been a problem if they were actually using RTTI, of course, but one of the whole problems with RTTI is that you live with the consequences whether you use it or not.)

[EricWF]

Sorry @rsmith, I was just about to tackle this.

[rsmith]

In D47092#1105315, @efriedma wrote:

I'm pretty sure this isn't actually a violation of LLVM's linkage rules as they are described in LangRef... at least, my understanding is that "equivalent" doesn't imply anything about linkage. (If this should be a violation, we need to clarify the rules.)

This is a fair point. (Though I would note that the LangRef doesn't even say that you can't have two external definitions of the same symbol, so it would clearly benefit from some clarification in this area.)

We could certainly teach ASan to just ignore "odr violations" on type info names, if we think that the IR generated here is in fact correct.

If we go down that path, do we still need changes for the Darwin ARM64 case? (That is, is it OK to emit some weak_odr definitions along with an external definition for the same _ZTS symbol, and not use the 'non-unique type info name' flag? Or should we still be treating that case -- and, as a consequence, all external-linkage _ZTS symbols for classes -- as non-unique?)

test/CodeGenCXX/arm64.cpp

48

OK. I was trying to avoid introducing more cases where we do string comparisons, but if you prefer string comparisons over link-time deduplication in all cases for that target, that seems easy enough to support.

(Out of curiosity, does the link-time deduplication not reliably work on that platform? If so, how do you deal with the other cases that require deduplication? If not, what's the motivation for using string comparisons?)

test/CodeGenCXX/windows-itanium-type-info.cpp

31

Good question, I don't know. Do we have some way to specify "weak_odr within this DSO but strong at the DSO boundary"? I suppose a COMDAT would give that effect.

[rjmccall]

test/CodeGenCXX/arm64.cpp

48

Static and dynamic linking work the same on ARM64 as on any other Mach-O platform. As you say, there are language features that depend on symbols resolving to the same object; we haven't changed that. The issue is that, while deduplication in the *static* linker is great, deduplication in the *dynamic* linker means extra, unavoidable work at load time — mostly, paging in a bunch of data from the symbol table. For an implicitly-activated language feature like RTTI, that can add up to a lot of overhead, which hits you regardless of whether you actually ever use any of the language features that depend on it. On Darwin we really like dynamic libraries, and we really like processes to launch quickly. So the ARM64 ABI says that RTTI which would otherwise need to be potentially deduplicated across a dynamic-library boundary (because the type is external and not hidden) is instead hidden and must be compared using the string data — a classic load-time vs. execution-time trade-off, in this case easy to make because the features that depend on dynamic type matching are rarely used and generally slow anyway.

The GCC type_info ABI uses string comparisons for a completely different purpose: they assume that users can't be trusted to mark visibility correctly on types, so they use string comparisons as a fallback. Darwin ARM64 is still as strict about type visibility as we are on every other platform, so if you use -fvisibility=hidden and forget to mark a type as visible, dynamic_cast and EH will fail across library boundaries.

It occurs to me that all this might be unnecessary, though:

1. It's never possible to ask for the type_info of an incomplete class type directly.
2. The features that use RTTI which can actually do pointer conversions don't allow pointers to incomplete class types, either — at best, you can have pointers-to-pointers.
3. As far as I know, none of those features would ever depend on the pointee type_info object of a pointer-to-pointer. For example, you cannot do a dynamic_cast from a Base** to a Derived**. They only care about the direct pointee type, which cannot be incomplete.
4. I think the only feature that allows a pointer to an incomplete class type is typeid.
5. None of the standard operations on a type_info actually cares about the pointee type_info. They care about the name symbol for the pointer type, but that already has to be deduplicated (modulo the ARM64 trick) because we don't eagerly emit RTTI for pointer types.
6. You can get at the pointee type_info with the cxxabi.h interface, but I would argue that we should not make the ABI worse solely for the benefit of clients of the cxxabi.h interface, especially in a corner case of a corner case (a pointer to an incomplete type which would have turned out to be a dynamic class with a key function).
7. So I think we could actually get away with always using internal linkage for the ZTSes of incomplete class types, as long as we continue to use the standard rule for the ZTSes of *pointers* to incomplete class types, because the only thing that would break would be the cxxabi.h interface.
8. And if we find a way to convince LLVM / ASan to let us use weak linkage even if there might also be a strong definition out there, we don't even have that problem long-term.

[ldionne]

I'm revisiting http://llvm.org/PR37398 as it looks like a pretty serious bug to me.

I read http://llvm.org/D46665, this patch and http://llvm.org/PR37545, and my understanding is that this patch supersedes @EricWF 's original patch http://llvm.org/D46665. The only remaining problem would be http://llvm.org/PR37545. Is that correct?

[efriedma]

I think the preferred solution is something like https://bugs.llvm.org/show_bug.cgi?id=37545#c4, which is slightly different from both this patch and D46665.

[ldionne]

In D47092#2049842, @efriedma wrote:

I think the preferred solution is something like https://bugs.llvm.org/show_bug.cgi?id=37545#c4, which is slightly different from both this patch and D46665.

My understanding was that once the ASAN issue in PR37545 is solved (and https://bugs.llvm.org/show_bug.cgi?id=37545#c4 is a suggestion about how to do that), we can apply this change (D47092). Is that correct? If so, I can see how easy it might be to fix PR37545 in order to unblock this.

[efriedma]

Oh, you're right, sorry, the suggestion was to make asan instrumentation introduce the alias, not the frontend. In which case you'd want that fix plus D46665, I think: external linkage optimizes better.

lib/CodeGen/ItaniumCXXABI.cpp

#include "clang/AST/TypeNodes.def"
   llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
   VTable =
       llvm::ConstantExpr::getInBoundsGetElementPtr(CGM.Int8PtrTy, VTable, Two);
   VTable = llvm::ConstantExpr::getBitCast(VTable, CGM.Int8PtrTy);
 
   Fields.push_back(VTable);
 }
 
-/// Return the linkage that the type info and type info name constants
-/// should have for the given type.
-static std::pair<llvm::GlobalVariable::LinkageTypes,
-                 llvm::GlobalVariable::LinkageTypes>
-getTypeInfoLinkage(CodeGenModule &CGM, QualType Ty) {
-  llvm::GlobalValue::LinkageTypes TypeLinkage = [&]() {
-    switch (Ty->getLinkage()) {
-    case NoLinkage:
-    case InternalLinkage:
-    case UniqueExternalLinkage:
-      return llvm::GlobalValue::InternalLinkage;
+/// Return the linkage that the type info constant should have for the given
+/// type. This does not take into account the demotion of incomplete type info 
+/// to internal linkage required by the Itanium ABI.
+static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM,
+                                                             QualType Ty) {
 
-    case VisibleNoLinkage:
-    case ModuleInternalLinkage:
-    case ModuleLinkage:
-    case ExternalLinkage:
-      // RTTI is not enabled, which means that this type info struct is going
-      // to be used for exception handling. Give it linkonce_odr linkage.
-      if (!CGM.getLangOpts().RTTI)
-        return llvm::GlobalValue::LinkOnceODRLinkage;
 
-      if (const RecordType *Record = dyn_cast<RecordType>(Ty)) {
-        const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
-        if (RD->hasAttr<WeakAttr>())
-          return llvm::GlobalValue::WeakODRLinkage;
-        if (CGM.getTriple().isWindowsItaniumEnvironment())
-          if (RD->hasAttr<DLLImportAttr>() &&
-              ShouldUseExternalRTTIDescriptor(CGM, Ty))
-            return llvm::GlobalValue::ExternalLinkage;
-        // MinGW always uses LinkOnceODRLinkage for type info.
-        if (RD->isCompleteDefinition() && RD->isDynamicClass() &&
-            !CGM.getContext()
-                 .getTargetInfo()
-                 .getTriple()
-                 .isWindowsGNUEnvironment())
-          return CGM.getVTableLinkage(RD);
-      }
 
-      return llvm::GlobalValue::LinkOnceODRLinkage;
-    }
-    llvm_unreachable("Invalid linkage!");
-  }();
-  // Itanium C++ ABI 2.9.5p7:
-  //   In addition, it and all of the intermediate abi::__pointer_type_info
-  //   structs in the chain down to the abi::__class_type_info for the
-  //   incomplete class type must be prevented from resolving to the
-  //   corresponding type_info structs for the complete class type, possibly
-  //   by making them local static objects. Finally, a dummy class RTTI is
-  //   generated for the incomplete type that will not resolve to the final
-  //   complete class RTTI (because the latter need not exist), possibly by
-  //   making it a local static object.
-  if (ContainsIncompleteClassType(Ty))
-    return {llvm::GlobalValue::InternalLinkage, TypeLinkage};
-  return {TypeLinkage, TypeLinkage};
+}
+
+/// Determine the linkage that the type info name constant should have for
+/// the given type in the current translation unit.
+static llvm::GlobalVariable::LinkageTypes
+getTypeInfoNameLinkage(CodeGenModule &CGM, QualType Ty,
+                       llvm::GlobalVariable::LinkageTypes TypeLinkage,
+                       ItaniumCXXABI::RTTIUniquenessKind NameUniqueness) {
+  // If a class could be forward-declared in another translation unit, and
+  // we want a globally unique type info name constant, we cannot emit its type
+  // info name with external linkage even if this TU contains the type's key
+  // function, because we might emit a linkonce_odr type info name for the type
+  // in the other TU.
+  if (TypeLinkage == llvm::GlobalValue::ExternalLinkage &&
+      NameUniqueness == ItaniumCXXABI::RUK_Unique)
+    return llvm::GlobalValue::WeakODRLinkage;
+
+  return TypeLinkage;
 }
 
 llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force,
                                                   bool DLLExport) {
   // We want to operate on the canonical type.
   Ty = Ty.getCanonicalType();
 
   // Check if we've already emitted an RTTI descriptor for this type.
llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty, bool Force,
   }
 
   // Check if there is already an external RTTI descriptor for this type.
   bool IsStdLib = IsStandardLibraryRTTIDescriptor(Ty);
   if (!Force && (IsStdLib || ShouldUseExternalRTTIDescriptor(CGM, Ty)))
     return GetAddrOfExternalRTTIDescriptor(Ty);
 
   // Emit the standard library with external linkage.
-  llvm::GlobalVariable::LinkageTypes InfoLinkage, NameLinkage;
+  llvm::GlobalVariable::LinkageTypes TypeLinkage;
   if (IsStdLib)
-    InfoLinkage = NameLinkage = llvm::GlobalValue::ExternalLinkage;
-  else {
-    auto LinkagePair = getTypeInfoLinkage(CGM, Ty);
-    InfoLinkage = LinkagePair.first;
-    NameLinkage = LinkagePair.second;
-  }
+    TypeLinkage = llvm::GlobalValue::ExternalLinkage;
+  else
+    TypeLinkage = getTypeInfoLinkage(CGM, Ty);
+
+  // Determine the uniqueness and linkage to use for the name.
+  ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
+      CXXABI.classifyRTTIUniqueness(Ty, TypeLinkage);
+  llvm::GlobalVariable::LinkageTypes NameLinkage =
+      getTypeInfoNameLinkage(CGM, Ty, TypeLinkage, RTTIUniqueness);
+
+  // Determine the linkage to use for this type_info object.
+  //
+  // Itanium C++ ABI 2.9.5p7:
+  //   In addition, it and all of the intermediate abi::__pointer_type_info
+  //   structs in the chain down to the abi::__class_type_info for the
+  //   incomplete class type must be prevented from resolving to the
+  //   corresponding type_info structs for the complete class type, possibly
+  //   by making them local static objects. Finally, a dummy class RTTI is
+  //   generated for the incomplete type that will not resolve to the final
+  //   complete class RTTI (because the latter need not exist), possibly by
+  //   making it a local static object.
+  llvm::GlobalVariable::LinkageTypes InfoLinkage =
+      ContainsIncompleteClassType(Ty) ? llvm::GlobalValue::InternalLinkage
+                                      : TypeLinkage;
+
   // Add the vtable pointer.
   BuildVTablePointer(cast<Type>(Ty));
 
-  // And the name.
+  // Add the name.
   llvm::GlobalVariable *TypeName = GetAddrOfTypeName(Ty, NameLinkage);
   llvm::Constant *TypeNameField;
 
   // If we're supposed to demote the visibility, be sure to set a flag
   // to use a string comparison for type_info comparisons.
-  ItaniumCXXABI::RTTIUniquenessKind RTTIUniqueness =
-      CXXABI.classifyRTTIUniqueness(Ty, NameLinkage);
   if (RTTIUniqueness != ItaniumCXXABI::RUK_Unique) {
     // The flag is the sign bit, which on ARM64 is defined to be clear
     // for global pointers.  This is very ARM64-specific.
     TypeNameField = llvm::ConstantExpr::getPtrToInt(TypeName, CGM.Int64Ty);
     llvm::Constant *flag =
         llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
     TypeNameField = llvm::ConstantExpr::getAdd(TypeNameField, flag);
     TypeNameField =

test/CodeGenCXX/arm64.cpp

 
 // ARM64 uses string comparisons for what would otherwise be
 // default-visibility weak RTTI.  rdar://12650568
 namespace test2 {
   struct A {
     virtual void foo();
   };
   void A::foo() {}
-  // CHECK-GLOBALS-DAG: @_ZTSN5test21AE = constant [11 x i8]
+  // CHECK-GLOBALS-DAG: @_ZTSN5test21AE = weak_odr constant [11 x i8]
   // CHECK-GLOBALS-DAG: @_ZTIN5test21AE = constant { {{.*}}, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @_ZTSN5test21AE, i32 0, i32 0) }
 
   struct __attribute__((visibility("hidden"))) B {};
   const std::type_info &b0 = typeid(B);
   // CHECK-GLOBALS-DAG: @_ZTSN5test21BE = linkonce_odr hidden constant
   // CHECK-GLOBALS-DAG: @_ZTIN5test21BE = linkonce_odr hidden constant { {{.*}}, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @_ZTSN5test21BE, i32 0, i32 0) }
 
   const std::type_info &b1 = typeid(B*);

test/CodeGenCXX/rtti-linkage.cpp

 // CHECK: _ZTIN12_GLOBAL__N_11EE = internal constant
 // CHECK: _ZTSA10_i = linkonce_odr constant
 // CHECK: _ZTIA10_i = linkonce_odr constant
 // CHECK: _ZTI1TILj0EE = linkonce_odr constant
 // CHECK: _ZTI1TILj1EE = weak_odr constant
 // CHECK: _ZTI1TILj2EE = external constant
 // CHECK: _ZTSZ2t5vE1A = internal constant
 // CHECK: _ZTIZ2t5vE1A = internal constant
-// CHECK: _ZTS1B = constant
+// CHECK: _ZTS1B = weak_odr constant
 // CHECK: _ZTI1B = constant
 // CHECK: _ZTS1F = linkonce_odr constant
 // CHECK: _ZTSZ2t6vE1A = linkonce_odr constant
 // CHECK: _ZTIZ2t6vE1A = linkonce_odr constant
 // CHECK: _ZTSPZ2t7vE1A = linkonce_odr constant
 // CHECK: _ZTSZ2t7vE1A = linkonce_odr constant
 // CHECK: _ZTIZ2t7vE1A = linkonce_odr constant
 // CHECK: _ZTIPZ2t7vE1A = linkonce_odr constant

test/CodeGenCXX/type_visibility.cpp

 namespace type0 {
   struct TYPE_DEFAULT A {
     virtual void foo();
   };
 
   void A::foo() {}
   // FUNS-LABEL:        define void @_ZN5type01A3fooEv(
   // VARS:        @_ZTVN5type01AE = unnamed_addr constant
-  // VARS:        @_ZTSN5type01AE = constant
+  // VARS:        @_ZTSN5type01AE = weak_odr constant
   // VARS:        @_ZTIN5type01AE = constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type01A3fooEv(
   // VARS-HIDDEN: @_ZTVN5type01AE = unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type01AE = constant
+  // VARS-HIDDEN: @_ZTSN5type01AE = weak_odr constant
   // VARS-HIDDEN: @_ZTIN5type01AE = constant
 }
 
 namespace type1 {
   struct HIDDEN TYPE_DEFAULT A {
     virtual void foo();
   };
 
   void A::foo() {}
   // FUNS-LABEL:        define hidden void @_ZN5type11A3fooEv(
   // VARS:        @_ZTVN5type11AE = unnamed_addr constant
-  // VARS:        @_ZTSN5type11AE = constant
+  // VARS:        @_ZTSN5type11AE = weak_odr constant
   // VARS:        @_ZTIN5type11AE = constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type11A3fooEv(
   // VARS-HIDDEN: @_ZTVN5type11AE = unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type11AE = constant
+  // VARS-HIDDEN: @_ZTSN5type11AE = weak_odr constant
   // VARS-HIDDEN: @_ZTIN5type11AE = constant
 }
 
 namespace type2 {
   struct TYPE_HIDDEN A {
     virtual void foo();
   };
 
   void A::foo() {}
   // FUNS-LABEL:        define void @_ZN5type21A3fooEv(
   // VARS:        @_ZTVN5type21AE = hidden unnamed_addr constant
-  // VARS:        @_ZTSN5type21AE = hidden constant
+  // VARS:        @_ZTSN5type21AE = weak_odr hidden constant
   // VARS:        @_ZTIN5type21AE = hidden constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type21A3fooEv(
   // VARS-HIDDEN: @_ZTVN5type21AE = hidden unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type21AE = hidden constant
+  // VARS-HIDDEN: @_ZTSN5type21AE = weak_odr hidden constant
   // VARS-HIDDEN: @_ZTIN5type21AE = hidden constant
 }
 
 namespace type3 {
   struct DEFAULT TYPE_HIDDEN A {
     virtual void foo();
   };
 
   void A::foo() {}
   // FUNS-LABEL:        define void @_ZN5type31A3fooEv(
   // VARS:        @_ZTVN5type31AE = hidden unnamed_addr constant
-  // VARS:        @_ZTSN5type31AE = hidden constant
+  // VARS:        @_ZTSN5type31AE = weak_odr hidden constant
   // VARS:        @_ZTIN5type31AE = hidden constant
   // FUNS-HIDDEN-LABEL: define void @_ZN5type31A3fooEv(
   // VARS-HIDDEN: @_ZTVN5type31AE = hidden unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type31AE = hidden constant
+  // VARS-HIDDEN: @_ZTSN5type31AE = weak_odr hidden constant
   // VARS-HIDDEN: @_ZTIN5type31AE = hidden constant
 }
 

test/CodeGenCXX/vtable-available-externally.cpp

 
 }
 
 // Test2::A's key function (f) is defined in this translation unit, but when
 // we're doing codegen for the typeid(A) call, we don't know that yet.
 // This tests mainly that the typeinfo and typename constants have their linkage
 // updated correctly.
 
-// CHECK-TEST2: @_ZTSN5Test21AE = constant
+// CHECK-TEST2: @_ZTSN5Test21AE = weak_odr constant
 // CHECK-TEST2: @_ZTIN5Test21AE = constant
 // CHECK-TEST2: @_ZTVN5Test21AE = unnamed_addr constant
 namespace Test2 {
   struct A {
     virtual void f();
   };
 
   const std::type_info &g() {

test/CodeGenCXX/vtable-key-function-arm.cpp

struct Test2a {
   Test2a();
   virtual void foo();
   virtual void bar();
 };
 
 // V-table should be defined with strong linkage.
 Test2a::Test2a() { use(typeid(Test2a)); }
 // CHECK:      @_ZTV6Test2a = unnamed_addr constant
-// CHECK-LATE: @_ZTS6Test2a = constant
+// CHECK-LATE: @_ZTS6Test2a = weak_odr constant
 // CHECK-LATE: @_ZTI6Test2a = constant
 
 // 'bar' becomes the key function when 'foo' is defined inline.
 void Test2a::bar() {}
 inline void Test2a::foo() {}
 
 /*** Test2b ******************************************************************/
 
 struct Test2b {
   Test2b();
   virtual void foo();
   virtual void bar();
 };
 
 // 'bar' becomes the key function when 'foo' is defined inline.
 void Test2b::bar() {}
 
 // V-table should be defined with strong linkage.
 Test2b::Test2b() { use(typeid(Test2b)); }
 // CHECK:      @_ZTV6Test2b = unnamed_addr constant
-// CHECK-LATE: @_ZTS6Test2b = constant
+// CHECK-LATE: @_ZTS6Test2b = weak_odr constant
 // CHECK-LATE: @_ZTI6Test2b = constant
 
 inline void Test2b::foo() {}
 
 /*** Test2c ******************************************************************/
 
 struct Test2c {
   Test2c();
   virtual void foo();
   virtual void bar();
 };
 
 // 'bar' becomes the key function when 'foo' is defined inline.
 void Test2c::bar() {}
 inline void Test2c::foo() {}
 
 // V-table should be defined with strong linkage.
 Test2c::Test2c() { use(typeid(Test2c)); }
 // CHECK: @_ZTV6Test2c = unnamed_addr constant
-// CHECK: @_ZTS6Test2c = constant
+// CHECK: @_ZTS6Test2c = weak_odr constant
 // CHECK: @_ZTI6Test2c = constant
 
 /*** Test3a ******************************************************************/
 
 struct Test3a {
   Test3a();
   virtual void foo();
   virtual void bar();

test/CodeGenCXX/vtable-linkage.cpp

 // CHECK-DAG: @_ZTV1C = linkonce_odr unnamed_addr constant {{.*}}, comdat,
 // CHECK-DAG: @_ZTS1C = linkonce_odr constant {{.*}}, comdat{{$}}
 // CHECK-DAG: @_ZTI1C = linkonce_odr constant {{.*}}, comdat{{$}}
 // CHECK-DAG: @_ZTT1C = linkonce_odr unnamed_addr constant {{.*}}, comdat{{$}}
 
 // D has a key function that is defined in this translation unit so its vtable is
 // defined in the translation unit.
 // CHECK-DAG: @_ZTV1D = unnamed_addr constant
-// CHECK-DAG: @_ZTS1D = constant
+// CHECK-DAG: @_ZTS1D = weak_odr constant
 // CHECK-DAG: @_ZTI1D = constant
 
 // E<char> is an explicit specialization with a key function defined
 // in this translation unit, so its vtable should have external
 // linkage.
 // CHECK-DAG: @_ZTV1EIcE = unnamed_addr constant
-// CHECK-DAG: @_ZTS1EIcE = constant
+// CHECK-DAG: @_ZTS1EIcE = weak_odr constant
 // CHECK-DAG: @_ZTI1EIcE = constant
 
 // E<short> is an explicit template instantiation with a key function
 // defined in this translation unit, so its vtable should have
 // weak_odr linkage.
 // CHECK-DAG: @_ZTV1EIsE = weak_odr unnamed_addr constant {{.*}}, comdat,
 // CHECK-DAG: @_ZTS1EIsE = weak_odr constant {{.*}}, comdat{{$}}
 // CHECK-DAG: @_ZTI1EIsE = weak_odr constant {{.*}}, comdat{{$}}

 public:
   virtual ~H();
 };
 
 void use_H() {
   H<int> h;
 }
 
+// local_class()::J is local to this translation unit, so is given internal
+// linkage.
+// CHECK-DAG: @_ZTVZ11local_classvE1J = internal unnamed_addr constant
+// CHECK-DAG: @_ZTSZ11local_classvE1J = internal constant
+// CHECK-DAG: @_ZTIZ11local_classvE1J = internal constant
+void local_class() {
+  struct J {
+    virtual void f() {}
+  };
+  J().f();
+}
+
 // I<int> has an explicit instantiation declaration and needs a VTT and
 // construction vtables.
 
 // CHECK-DAG: @_ZTV1IIiE = external unnamed_addr constant
 // CHECK-DAG: @_ZTT1IIiE = external unnamed_addr constant
 // CHECK-NOT: @_ZTC1IIiE
 //
 // CHECK-OPT-DAG: @_ZTV1IIiE = available_externally unnamed_addr constant
 // CHECK-OPT-DAG: @_ZTT1IIiE = available_externally unnamed_addr constant
 struct VBase1 { virtual void f(); }; struct VBase2 : virtual VBase1 {};
 template<typename T>
 struct I : VBase2 {};
 extern template struct I<int>;
 I<int> i;

test/CodeGenCXX/windows-itanium-type-info.cpp

 void f() {
   throw base();
 }
 
 // CHECK-DAG: @_ZTIi = dso_local dllexport constant
 // CHECK-DAG: @_ZTSi = dso_local dllexport constant
 
 // CHECK-DAG: @_ZTI7derived = dso_local dllexport constant
-// CHECK-DAG: @_ZTS7derived = dso_local dllexport constant
+// CHECK-DAG: @_ZTS7derived = weak_odr dso_local dllexport constant
 // CHECK-DAG: @_ZTV7derived = dso_local dllexport unnamed_addr constant
 
 // CHECK-DAG: @_ZTI4base = external dllimport constant
 
 // CHECK-EH-IMPORT: @_ZTS4base = linkonce_odr dso_local constant
 // CHECK-EH-IMPORT: @_ZTI4base = linkonce_odr dso_local constant
 
 struct __declspec(dllimport) gatekeeper {};
 struct zuul : gatekeeper {
   virtual ~zuul();
 };
 zuul::~zuul() {}
 
 // CHECK-DAG: @_ZTI10gatekeeper = linkonce_odr dso_local constant
 // CHECK-DAG: @_ZTS10gatekeeper = linkonce_odr dso_local constant