Make CodeGen choose when to emit vtables.

[rsmith]

Summary

Previously, we expected Sema to make this ABI decision for us, resulting
in our emitting vtables in some cases where we didn't need them. With
this change, we emit vtables in precisely three cases:

1. When we emit a reference to the vtable and it has suitable linkage.
2. When we emit a key function definition.
3. When we emit an explicit instantiation of a class.

This also removes the need to mark key functions as "must be emitted",
which means that an inline key function is no longer added to the list
of eagerly deserialized declarations in an AST file.

In exchange, we do now list explicit instantiation definitions of
dynamic classes as eagerly deserialized declarations. But they should
be much rarer in header files!

[rsmith]

lib/CodeGen/CodeGenModule.cpp

3991–3992

@rjmccall Is there any reason we (from the CodeGen perspective) should treat an inline key function as emitting the vtable? I can't think of any reason to do so -- it's not in a comdat with the vtable or anything like that, so every translation unit that emits a reference to the vtable should emit its own copy anyway.

[rjmccall]

lib/CodeGen/CodeGenModule.cpp

3991–3992

The thinking was as follows: translation units that can't see a definition of the key function don't know that the definition is actually inline, so they'll emit a reference to an external v-table definition, which will lead to link failures if the translation units that do contain the inline definition don't eagerly emit the v-table. However, ARM pointed out years ago that the ODR requires inline definitions of virtual functions to be present in every translation unit which declares the virtual function at all, so there's no legal situation where a translation unit can't see the definition of an inline key function. Furthermore, I believe Clang has never made v-tables undiscardable in translation units with inline key function definitions, so there's no real guarantee that ODR-violating code will actually link, although you can certainly imagine ways in which an ODR-violating program might get by without such a guarantee.

Personally, I think the strongest argument for "deviating" here is that the language standard takes priority over the ABI, which means we're allowed to assume the program is overall well-formed, i.e. we're only required to interoperate with legal code. Now, that's a line of reasoning which leads us into some grey areas of implementation-definedness, but I feel fairly comfortable about deviating in this particular instance because I don't know why someone would really *want* to take advantage of v-tables being emitted eagerly; in general, eager emission of inline code is a bad thing that significantly slows down builds.

Now, ARM used this property of inline definitions to change the key function to the first non-inline function, and unfortunately we can't do that on existing targets without breaking interoperation. (We did do it on some newer Darwin targets, though, and we haven't had any problem with it.) But I do think we could use this property of inline definitions to just treat the class as no longer having a key function when we see an inline definition of it. That would rid us of this particular scourge of eager emission of inline code.

[rsmith]

lib/CodeGen/CodeGenModule.cpp

3991–3992

My thinking is this: if a vtable has discardable linkage, then it can be discarded when optimizing if it's not referenced. So there's no point emitting it unless we also emit a reference to it. So we should only emit vtables with discardable linkage if they're actually referenced, just like we do for other symbols with discardable linkage. This is, I think, stronger than what you're suggesting, because it affects internal-linkage explicit instantiations too.

[rjmccall]

lib/CodeGen/CodeGenModule.cpp

3991–3992

Given only the ABI rule, using discardable linkage is a bug. If you take the "those translation units containing the definition must emit the v-table so that other translation units can use it" argument seriously, you obviously can't use discardable linkage, because the other translation units can't use it. That's why I bothered developing the whole argument above about why it's okay to ignore the ABI rule here.

Your argument about internal-linkage explicit instantiations abstractly makes a lot of sense but also sets off a bunch of klaxons in my mind about ignoring obvious programmer intent. Still, I think it's reasonable to try it out.

[rsmith]

lib/CodeGen/CodeGenModule.cpp

3991–3992

OK, fair enough. I was only starting from the "these vtables have discardable linkage" position because that has been the status quo in Clang ~forever (godbolt.org only goes back to Clang 3). I'll give it a go and see what shakes out.

[rjmccall]

lib/CodeGen/CodeGenModule.cpp

3991–3992

Yeah, we've never actually taken that argument seriously, but we never took our current stance to its logical conclusion of emitting the v-table lazily, either.

[rsmith]

• Do not emit unused discardable vtables.

[lebedev.ri]

Will -fforce-emit-vtables still work?

[rjmccall]

lib/AST/ASTContext.cpp

9801

Does it matter if it's not this particular declaration that's the explicit instantiation?

lib/AST/RecordLayoutBuilder.cpp

3069

Why not just change computeKeyFunction to decide that the class doesn't have a key function if it would be an inline definition? We can do the same updating we do with the ARM rule except just bailing out instead of scanning for another candidate.

lib/CodeGen/CGVTables.cpp

889

I feel like "don't emit the v-table for this" should be handled in the caller.

[rsmith]

In D54986#1312435, @lebedev.ri wrote:

Will -fforce-emit-vtables still work?

Yes, it still works. (The tests for it still pass and I've manually tested it too.)

lib/AST/ASTContext.cpp

9801

The explicit instantiation definition decl itself is the only one that CodeGen needs to see. (Earlier declarations would have a different TSK, and the language rules generally don't permit any later decls.)

lib/AST/RecordLayoutBuilder.cpp

3069

It seems desirable to me for Clang's notion of what the "key function" is to exactly match the ABI specification. That way, the decision to not emit a vtable with an inline key function is purely a lowering concern, not part of the program model represented by the frontend, and non-compiler tools who query this data will get correct answers. Also, if we made the suggested change, I'd still want to perform the linkage check to avoid unnecessary emission of vtables for explicit instantiation definitions, so this wouldn't remove any complexity from CodeGen.

If we want to go down this path, I'd prefer that we also change the ABI document to say that an inline virtual function definition results in the class having no key function.

lib/CodeGen/CGVTables.cpp

889

OK, but that'd mean putting the same check into both callers of this function. As an alternative, what do you think about renaming this function to something more like "MarkVTableDemanded" that doesn't suggest that we'll necessarily emit it?

[rjmccall]

lib/AST/RecordLayoutBuilder.cpp

3069

That's fair. We could instead wrap all the calls to the function from IRGen to apply this rule retroactively; that should be easy.

[v.g.vassilev]

@rsmith, what was the fate of this patch? I thought it landed but cannot find a trace of it in the master...

[v.g.vassilev]

I think this landed in a different form.

lib/AST/ASTContext.cpp

bool ASTContext::DeclMustBeEmitted(const Decl *D) {
   else if (isa<PragmaDetectMismatchDecl>(D))
     return true;
   else if (isa<OMPThreadPrivateDecl>(D))
     return !D->getDeclContext()->isDependentContext();
   else if (isa<OMPDeclareReductionDecl>(D))
     return !D->getDeclContext()->isDependentContext();
   else if (isa<ImportDecl>(D))
     return true;
+  else if (auto *RD = dyn_cast<CXXRecordDecl>(D))
+    // An explicit instantiation of a dynamic class emits the vtable and
+    // type_info objects, so must be emitted.
+    return RD->hasDefinition() && RD->isDynamicClass() &&
+           RD->getTemplateSpecializationKind() ==
+               TSK_ExplicitInstantiationDefinition;
   else
     return false;
 
   if (D->isFromASTFile() && !LangOpts.BuildingPCHWithObjectFile) {
     assert(getExternalSource() && "It's from an AST file; must have a source.");
     // On Windows, PCH files are built together with an object file. If this
     // declaration comes from such a PCH and DeclMustBeEmitted would return
     // true, it would have returned true and the decl would have been emitted
bool ASTContext::DeclMustBeEmitted(const Decl *D) {
 
   // Aliases and used decls are required.
   if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
     return true;
 
   if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
     // Multiversioned functions always have to be emitted, because they are used
     // by the resolver.
+    // FIXME: This doesn't appear to be correct. Multiversioned functions should
+    // only be emitted if the resolver is emitted.
     if (FD->isMultiVersion())
       return true;
+
     // Forward declarations aren't required.
     if (!FD->doesThisDeclarationHaveABody())
       return FD->doesDeclarationForceExternallyVisibleDefinition();
 
     // Constructors and destructors are required.
     if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>())
       return true;
 
-    // The key function for a class is required.  This rule only comes
-    // into play when inline functions can be key functions, though.
-    if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
-      if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
-        const CXXRecordDecl *RD = MD->getParent();
-        if (MD->isOutOfLine() && RD->isDynamicClass()) {
-          const CXXMethodDecl *KeyFunc = getCurrentKeyFunction(RD);
-          if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl())
-            return true;
-        }
-      }
-    }
-
     GVALinkage Linkage = GetGVALinkageForFunction(FD);
 
     // static, static inline, always_inline, and extern inline functions can
     // always be deferred.  Normal inline functions can be deferred in C99/C++.
     // Implicit template instantiations can also be deferred in C++.
     return !isDiscardableGVALinkage(Linkage);
   }
 

lib/AST/RecordLayoutBuilder.cpp

if (getLangOpts().DumpRecordLayouts) {
     llvm::outs() << "\n*** Dumping AST Record Layout\n";
     DumpRecordLayout(D, llvm::outs(), getLangOpts().DumpRecordLayoutsSimple);
   }
 
   return *NewEntry;
 }
 
 const CXXMethodDecl *ASTContext::getCurrentKeyFunction(const CXXRecordDecl *RD) {
-  if (!getTargetInfo().getCXXABI().hasKeyFunctions())
+  if (!getTargetInfo().getCXXABI().hasKeyFunctions() || !RD->isDynamicClass())
     return nullptr;
 
   assert(RD->getDefinition() && "Cannot get key function for forward decl!");
   RD = RD->getDefinition();
 
   // Beware:
   //  1) computing the key function might trigger deserialization, which might
   //     invalidate iterators into KeyFunctions
   //  2) 'get' on the LazyDeclPtr might also trigger deserialization and
   //     invalidate the LazyDeclPtr within the map itself
   LazyDeclPtr Entry = KeyFunctions[RD];
   const Decl *Result =
       Entry ? Entry.get(getExternalSource()) : computeKeyFunction(*this, RD);
 
   // Store it back if it changed.
   if (Entry.isOffset() || Entry.isValid() != bool(Result))
     KeyFunctions[RD] = const_cast<Decl*>(Result);
 
   return cast_or_null<CXXMethodDecl>(Result);
 }
 

lib/CodeGen/CGCXX.cpp

bool CodeGenModule::TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D) {
   // Finally, set up the alias with its proper name and attributes.
   SetCommonAttributes(AliasDecl, Alias);
 
   return false;
 }
 
 llvm::Function *CodeGenModule::codegenCXXStructor(const CXXMethodDecl *MD,
                                                   StructorType Type) {
-  const CGFunctionInfo &FnInfo =
-      getTypes().arrangeCXXStructorDeclaration(MD, Type);
-  auto *Fn = cast<llvm::Function>(
-      getAddrOfCXXStructor(MD, Type, &FnInfo, /*FnType=*/nullptr,
-                           /*DontDefer=*/true, ForDefinition));
-
   GlobalDecl GD;
   if (const auto *DD = dyn_cast<CXXDestructorDecl>(MD)) {
     GD = GlobalDecl(DD, toCXXDtorType(Type));
   } else {
     const auto *CD = cast<CXXConstructorDecl>(MD);
     GD = GlobalDecl(CD, toCXXCtorType(Type));
   }
 
-  setFunctionLinkage(GD, Fn);
-
-  CodeGenFunction(*this).GenerateCode(GD, Fn, FnInfo);
-  setNonAliasAttributes(GD, Fn);
-  SetLLVMFunctionAttributesForDefinition(MD, Fn);
-  return Fn;
+  return cast<llvm::Function>(EmitGlobalFunctionDefinition(GD));
 }
 
 llvm::Constant *CodeGenModule::getAddrOfCXXStructor(
     const CXXMethodDecl *MD, StructorType Type, const CGFunctionInfo *FnInfo,
     llvm::FunctionType *FnType, bool DontDefer,
     ForDefinition_t IsForDefinition) {
   GlobalDecl GD;
   if (auto *CD = dyn_cast<CXXConstructorDecl>(MD)) {

lib/CodeGen/CGCXXABI.h

public:
   getVTableAddressPointForConstExpr(BaseSubobject Base,
                                     const CXXRecordDecl *VTableClass) = 0;
 
   /// Get the address of the vtable for the given record decl which should be
   /// used for the vptr at the given offset in RD.
   virtual llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
                                                 CharUnits VPtrOffset) = 0;
 
+  /// Ensure that all vtables for the given class are emitted.
+  virtual void emitVTables(const CXXRecordDecl *RD) = 0;
+
   /// Build a virtual function pointer in the ABI-specific way.
   virtual CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF,
                                              GlobalDecl GD, Address This,
                                              llvm::Type *Ty,
                                              SourceLocation Loc) = 0;
 
   /// Emit the ABI-specific virtual destructor call.
   virtual llvm::Value *

lib/CodeGen/CGVTables.cpp

switch (RD->getTemplateSpecializationKind()) {
 
     case TSK_ExplicitInstantiationDefinition:
       return NonDiscardableODRLinkage;
   }
 
   llvm_unreachable("Invalid TemplateSpecializationKind!");
 }
 
-/// This is a callback from Sema to tell us that a particular vtable is
-/// required to be emitted in this translation unit.
+/// This is called when a particular vtable is required to be emitted in this
+/// translation unit.
 ///
-/// This is only called for vtables that _must_ be emitted (mainly due to key
-/// functions).  For weak vtables, CodeGen tracks when they are needed and
-/// emits them as-needed.
-void CodeGenModule::EmitVTable(CXXRecordDecl *theClass) {
-  VTables.GenerateClassData(theClass);
+/// This is only called for vtables that must be emitted due to key functions
+/// or explicit instantiations. For weak vtables, CodeGen tracks when they are
+/// needed and emits them as-needed.
+void CodeGenModule::EmitVTable(const CXXRecordDecl *theClass) {
+  // Skip emitting a vtable that would be discardable. We'll still emit it
+  // if it's actually used.
+  if (!llvm::GlobalValue::isDiscardableIfUnused(getVTableLinkage(theClass)))
+    getCXXABI().emitVTables(theClass);
 }
 
 void
 CodeGenVTables::GenerateClassData(const CXXRecordDecl *RD) {
   if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
     DI->completeClassData(RD);
 
   if (RD->getNumVBases())
static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM,
   // If it's external then maybe we will need it as available_externally.
   return shouldEmitAvailableExternallyVTable(CGM, RD);
 }
 
 /// Given that at some point we emitted a reference to one or more
 /// vtables, and that we are now at the end of the translation unit,
 /// decide whether we should emit them.
 void CodeGenModule::EmitDeferredVTables() {
-#ifndef NDEBUG
-  // Remember the size of DeferredVTables, because we're going to assume
-  // that this entire operation doesn't modify it.
-  size_t savedSize = DeferredVTables.size();
-#endif
-
-  for (const CXXRecordDecl *RD : DeferredVTables)
+  while (!DeferredVTables.empty()) {
+    auto WorkList = std::move(DeferredVTables);
+    DeferredVTables.clear();
+    for (const CXXRecordDecl *RD : WorkList)
       if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD))
         VTables.GenerateClassData(RD);
       else if (shouldOpportunisticallyEmitVTables())
         OpportunisticVTables.push_back(RD);
-
-  assert(savedSize == DeferredVTables.size() &&
-         "deferred extra vtables during vtable emission?");
-  DeferredVTables.clear();
+  }
 }
 
 bool CodeGenModule::HasHiddenLTOVisibility(const CXXRecordDecl *RD) {
   LinkageInfo LV = RD->getLinkageAndVisibility();
   if (!isExternallyVisible(LV.getLinkage()))
     return true;
 
   if (RD->hasAttr<LTOVisibilityPublicAttr>() || RD->hasAttr<UuidAttr>())

lib/CodeGen/CodeGenAction.cpp

public:
     void CompleteTentativeDefinition(VarDecl *D) override {
       Gen->CompleteTentativeDefinition(D);
     }
 
     void AssignInheritanceModel(CXXRecordDecl *RD) override {
       Gen->AssignInheritanceModel(RD);
     }
 
-    void HandleVTable(CXXRecordDecl *RD) override {
-      Gen->HandleVTable(RD);
-    }
-
     static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,void *Context,
                                      unsigned LocCookie) {
       SourceLocation Loc = SourceLocation::getFromRawEncoding(LocCookie);
       ((BackendConsumer*)Context)->InlineAsmDiagHandler2(SM, Loc);
     }
 
     /// Get the best possible source location to represent a diagnostic that
     /// may have associated debug info.

lib/CodeGen/CodeGenModule.h

public:
   // passed in function.
   void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap, GlobalDecl GD);
 
   StringRef getMangledName(GlobalDecl GD);
   StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD);
 
   void EmitTentativeDefinition(const VarDecl *D);
 
-  void EmitVTable(CXXRecordDecl *Class);
+  void EmitVTable(const CXXRecordDecl *Class);
 
   void RefreshTypeCacheForClass(const CXXRecordDecl *Class);
 
   /// Appends Opts to the "llvm.linker.options" metadata value.
   void AppendLinkerOptions(StringRef Opts);
 
   /// Appends a detect mismatch command to the linker options.
   void AddDetectMismatch(StringRef Name, StringRef Value);
private:
   void setNonAliasAttributes(GlobalDecl GD, llvm::GlobalObject *GO);
 
   /// Set function attributes for a function declaration.
   void SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
                              bool IsIncompleteFunction, bool IsThunk);
 
   void EmitGlobalDefinition(GlobalDecl D, llvm::GlobalValue *GV = nullptr);
 
-  void EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);
+  llvm::GlobalValue *
+  EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV = nullptr);
   void EmitMultiVersionFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);
 
   void EmitGlobalVarDefinition(const VarDecl *D, bool IsTentative = false);
   void EmitAliasDefinition(GlobalDecl GD);
   void emitIFuncDefinition(GlobalDecl GD);
   void emitCPUDispatchDefinition(GlobalDecl GD);
   void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);
   void EmitObjCIvarInitializations(ObjCImplementationDecl *D);

lib/CodeGen/CodeGenModule.cpp

if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
       if (Method->isVirtual())
         getVTables().EmitThunks(GD);
 
       return;
     }
 
     if (FD->isMultiVersion())
       return EmitMultiVersionFunctionDefinition(GD, GV);
-    return EmitGlobalFunctionDefinition(GD, GV);
+    EmitGlobalFunctionDefinition(GD, GV);
+    return;
   }
 
   if (const auto *VD = dyn_cast<VarDecl>(D))
     return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
 
   llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
 }
 
void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
   // If we have a definition, this might be a deferred decl. If the
   // instantiation is explicit, make sure we emit it at the end.
   if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
     GetAddrOfGlobalVar(VD);
 
   EmitTopLevelDecl(VD);
 }
 
-void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
+llvm::GlobalValue *CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
                                                  llvm::GlobalValue *GV) {
   const auto *D = cast<FunctionDecl>(GD.getDecl());
 
   // Compute the function info and LLVM type.
   const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
   llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
 
   // Get or create the prototype for the function.
   if (!GV || (GV->getType()->getElementType() != Ty))
     GV = cast<llvm::GlobalValue>(GetAddrOfFunction(GD, Ty, /*ForVTable=*/false,
                                                    /*DontDefer=*/true,
                                                    ForDefinition));
 
   // Already emitted.
   if (!GV->isDeclaration())
-    return;
+    return GV;
 
   // We need to set linkage and visibility on the function before
   // generating code for it because various parts of IR generation
   // want to propagate this information down (e.g. to local static
   // declarations).
   auto *Fn = cast<llvm::Function>(GV);
   setFunctionLinkage(GD, Fn);
 
   // FIXME: this is redundant with part of setFunctionDefinitionAttributes
   setGVProperties(Fn, GD);
 
   MaybeHandleStaticInExternC(D, Fn);
 
 
   maybeSetTrivialComdat(*D, *Fn);
 
-  CodeGenFunction(*this).GenerateCode(D, Fn, FI);
+  CodeGenFunction(*this).GenerateCode(GD, Fn, FI);
 
   setNonAliasAttributes(GD, Fn);
   SetLLVMFunctionAttributesForDefinition(D, Fn);
 
   if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
     AddGlobalCtor(Fn, CA->getPriority());
   if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
     AddGlobalDtor(Fn, DA->getPriority());
   if (D->hasAttr<AnnotateAttr>())
     AddGlobalAnnotations(D, Fn);
+
+  // If we emit a key function, also emit the vtable.
+  if (auto *MD = dyn_cast<CXXMethodDecl>(D)) {
+    if (declaresSameEntity(Context.getCurrentKeyFunction(MD->getParent()), MD))
+      EmitVTable(MD->getParent());
+  }
+
+  return Fn;
 }
 
 void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
   const auto *D = cast<ValueDecl>(GD.getDecl());
   const AliasAttr *AA = D->getAttr<AliasAttr>();
   assert(AA && "Not an alias?");
 
   StringRef MangledName = getMangledName(GD);
void CodeGenModule::EmitTopLevelDecl(Decl *D) {
   // ignored; only the actual variable requires IR gen support.
   case Decl::IndirectField:
     break;
 
   // C++ Decls
   case Decl::Namespace:
     EmitDeclContext(cast<NamespaceDecl>(D));
     break;
-  case Decl::ClassTemplateSpecialization: {
-    const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
-    if (DebugInfo &&
-        Spec->getSpecializationKind() == TSK_ExplicitInstantiationDefinition &&
-        Spec->hasDefinition())
-      DebugInfo->completeTemplateDefinition(*Spec);
-  } LLVM_FALLTHROUGH;
-  case Decl::CXXRecord:
+  case Decl::ClassTemplateSpecialization:
+  case Decl::CXXRecord: {
+    auto *RD = cast<CXXRecordDecl>(D);
+    // If this class was explicitly instantiated, emit the accompanying data.
+    if (RD->getTemplateSpecializationKind() ==
+            TSK_ExplicitInstantiationDefinition &&
+        RD->hasDefinition()) {
+      if (DebugInfo) {
+        // FIXME: This should almost certainly apply to explicitly instantiated
+        // member classes of class templates too.
+        if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
+          DebugInfo->completeTemplateDefinition(*CTSD);
+      }
+      if (RD->isDynamicClass())
+        EmitVTable(RD);
+    }
     if (DebugInfo) {
       if (auto *ES = D->getASTContext().getExternalSource())
         if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
           DebugInfo->completeUnusedClass(cast<CXXRecordDecl>(*D));
     }
     // Emit any static data members, they may be definitions.
     for (auto *I : cast<CXXRecordDecl>(D)->decls())
       if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
         EmitTopLevelDecl(I);
     break;
+  }
     // No code generation needed.
   case Decl::UsingShadow:
   case Decl::ClassTemplate:
   case Decl::VarTemplate:
   case Decl::VarTemplatePartialSpecialization:
   case Decl::FunctionTemplate:
   case Decl::TypeAliasTemplate:
   case Decl::Block:

lib/CodeGen/ItaniumCXXABI.cpp

public:
 
   llvm::Constant *
   getVTableAddressPointForConstExpr(BaseSubobject Base,
                                     const CXXRecordDecl *VTableClass) override;
 
   llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
                                         CharUnits VPtrOffset) override;
 
+  void emitVTables(const CXXRecordDecl *RD) override {
+    (void) getAddrOfVTable(RD, CharUnits());
+  }
+
   CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
                                      Address This, llvm::Type *Ty,
                                      SourceLocation Loc) override;
 
   llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
                                          const CXXDestructorDecl *Dtor,
                                          CXXDtorType DtorType,
                                          Address This,

lib/CodeGen/MicrosoftCXXABI.cpp

public:
 
   llvm::Constant *
   getVTableAddressPointForConstExpr(BaseSubobject Base,
                                     const CXXRecordDecl *VTableClass) override;
 
   llvm::GlobalVariable *getAddrOfVTable(const CXXRecordDecl *RD,
                                         CharUnits VPtrOffset) override;
 
+  void emitVTables(const CXXRecordDecl *RD) override;
+
   CGCallee getVirtualFunctionPointer(CodeGenFunction &CGF, GlobalDecl GD,
                                      Address This, llvm::Type *Ty,
                                      SourceLocation Loc) override;
 
   llvm::Value *EmitVirtualDestructorCall(CodeGenFunction &CGF,
                                          const CXXDestructorDecl *Dtor,
                                          CXXDtorType DtorType,
                                          Address This,
llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
   if (!Inserted)
     return I->second;
 
   llvm::GlobalVariable *&VTable = I->second;
 
   MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext();
   const VPtrInfoVector &VFPtrs = VTContext.getVFPtrOffsets(RD);
 
-  if (DeferredVFTables.insert(RD).second) {
-    // We haven't processed this record type before.
-    // Queue up this vtable for possible deferred emission.
-    CGM.addDeferredVTable(RD);
-
-#ifndef NDEBUG
-    // Create all the vftables at once in order to make sure each vftable has
-    // a unique mangled name.
-    llvm::StringSet<> ObservedMangledNames;
-    for (size_t J = 0, F = VFPtrs.size(); J != F; ++J) {
-      SmallString<256> Name;
-      mangleVFTableName(getMangleContext(), RD, *VFPtrs[J], Name);
-      if (!ObservedMangledNames.insert(Name.str()).second)
-        llvm_unreachable("Already saw this mangling before?");
-    }
-#endif
-  }
+  emitVTables(RD);
 
   const std::unique_ptr<VPtrInfo> *VFPtrI = std::find_if(
       VFPtrs.begin(), VFPtrs.end(), [&](const std::unique_ptr<VPtrInfo>& VPI) {
         return VPI->FullOffsetInMDC == VPtrOffset;
       });
   if (VFPtrI == VFPtrs.end()) {
     VFTablesMap[ID] = nullptr;
     return nullptr;
llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
 
   if (RD->hasAttr<DLLExportAttr>())
     VFTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
 
   VFTablesMap[ID] = VFTable;
   return VTable;
 }
 
+void MicrosoftCXXABI::emitVTables(const CXXRecordDecl *RD) {
+  if (DeferredVFTables.insert(RD).second) {
+    // We haven't processed this record type before.
+    // Queue up this vtable for possible deferred emission.
+    CGM.addDeferredVTable(RD);
+
+#ifndef NDEBUG
+    MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext();
+    const VPtrInfoVector &VFPtrs = VTContext.getVFPtrOffsets(RD);
+
+    // Create all the vftables at once in order to make sure each vftable has
+    // a unique mangled name.
+    llvm::StringSet<> ObservedMangledNames;
+    for (size_t J = 0, F = VFPtrs.size(); J != F; ++J) {
+      SmallString<256> Name;
+      mangleVFTableName(getMangleContext(), RD, *VFPtrs[J], Name);
+      assert(ObservedMangledNames.insert(Name.str()).second &&
+             "Already saw this mangling before?");
+    }
+#endif
+  }
+}
+
 CGCallee MicrosoftCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
                                                     GlobalDecl GD,
                                                     Address This,
                                                     llvm::Type *Ty,
                                                     SourceLocation Loc) {
   CGBuilderTy &Builder = CGF.Builder;
 
   Ty = Ty->getPointerTo()->getPointerTo();

lib/CodeGen/ModuleBuilder.cpp

public:
     }
 
     void CompleteTentativeDefinition(VarDecl *D) override {
       if (Diags.hasErrorOccurred())
         return;
 
       Builder->EmitTentativeDefinition(D);
     }
-
-    void HandleVTable(CXXRecordDecl *RD) override {
-      if (Diags.hasErrorOccurred())
-        return;
-
-      Builder->EmitVTable(RD);
-    }
   };
 }
 
 void CodeGenerator::anchor() { }
 
 CodeGenModule &CodeGenerator::CGM() {
   return static_cast<CodeGeneratorImpl*>(this)->CGM();
 }

lib/Serialization/ASTReaderDecl.cpp

static bool isConsumerInterestedIn(ASTContext &Ctx, Decl *D, bool HasBody) {
   // emitted when we import the relevant module.
   if (isa<ImportDecl>(D) || isa<VarDecl>(D)) {
     auto *M = D->getImportedOwningModule();
     if (M && M->Kind == Module::ModuleMapModule &&
         Ctx.DeclMustBeEmitted(D))
       return false;
   }
 
+  if (auto *ES = D->getASTContext().getExternalSource())
+    if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
+      return true;
+
   if (isa<FileScopeAsmDecl>(D) ||
       isa<ObjCProtocolDecl>(D) ||
       isa<ObjCImplDecl>(D) ||
       isa<ImportDecl>(D) ||
       isa<PragmaCommentDecl>(D) ||
       isa<PragmaDetectMismatchDecl>(D))
     return true;
   if (isa<OMPThreadPrivateDecl>(D) || isa<OMPDeclareReductionDecl>(D))
     return !D->getDeclContext()->isFunctionOrMethod();
   if (const auto *Var = dyn_cast<VarDecl>(D))
     return Var->isFileVarDecl() &&
            (Var->isThisDeclarationADefinition() == VarDecl::Definition ||
             OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Var));
   if (const auto *Func = dyn_cast<FunctionDecl>(D))
     return Func->doesThisDeclarationHaveABody() || HasBody;
-
-  if (auto *ES = D->getASTContext().getExternalSource())
-    if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
-      return true;
+  if (const auto *RD = dyn_cast<CXXRecordDecl>(D))
+    return RD->getTemplateSpecializationKind() ==
+           TSK_ExplicitInstantiationDefinition;
 
   return false;
 }
 
 /// Get the correct cursor and offset for loading a declaration.
 ASTReader::RecordLocation
 ASTReader::DeclCursorForID(DeclID ID, SourceLocation &Loc) {
   GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);

test/CodeGenCXX/aarch64-cxxabi.cpp

 // the end of the translation unit.
 
 // We construct a class which needs a VTable here under generic ABI, but not
 // AArch32.
 
 // (see next section for explanation of guard)
 // CHECK: @_ZGVZ15guard_variablesiE4mine = internal global i64 0
 
-// CHECK: @_ZTV16CheckKeyFunction =
-struct CheckKeyFunction {
+// An inline key function is not sufficient to trigger vtable emission: the
+// corresponding vtable symbol would be discardable, so we only actually emit
+// it if it would be referenced.
+// CHECK-NOT: @_ZTV22CheckKeyFunctionUnused =
+struct CheckKeyFunctionUnused {
   virtual void foo();
 };
+inline void CheckKeyFunctionUnused::foo() {
+}
 
-// This is not inline when CheckKeyFunction is completed, so
-// CheckKeyFunction::foo is the key function. VTables should be emitted.
+// The same applies even if an inline key function is emitted.
+// CHECK-NOT: @_ZTV16CheckKeyFunction =
+struct CheckKeyFunction {
+  virtual void foo();
+  void bar();
+};
 inline void CheckKeyFunction::foo() {
 }
 
+void CheckKeyFunction::bar() {
+  // Explicit use triggers emission of foo, which triggers emission of vtable.
+  CheckKeyFunction::foo();
+}
+
+// CHECK: @_ZTV14CheckVTableUse =
+// Check that using the vtable is enough to trigger emission of the key
+// function and thus the vtable.
+struct CheckVTableUse {
+  virtual void foo();
+};
+inline void CheckVTableUse::foo() {
+}
+void *useVTable() { return new CheckVTableUse; }
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // Guard variables only specify and use the low bit to determine status, rather
 // than the low byte as in the generic Itanium ABI. However, unlike 32-bit ARM,
 // they *are* 64-bits wide so check that in case confusion has occurred.
 
 class Guarded {
 public:

test/CodeGenCXX/dllimport.cpp

// GNU2-NOT: @llvm.global_ctors
   // MSC-DAG: @"?y@?$D@$0CK@@PR19933@@2HA" = external dllimport global i32
 }
 
 namespace PR21355 {
   struct __declspec(dllimport) S {
     virtual ~S();
   };
   S::~S() {}
+  void *use_S_vtable() { return new S; }
 
   // S::~S is a key function, so we would ordinarily emit a strong definition for
-  // the vtable. However, S is imported, so the vtable should be too.
+  // the vtable. However, S is imported, so the vtable should be too (if it's
+  // emitted at all.)
 
   // GNU-DAG: @_ZTVN7PR213551SE = available_externally dllimport unnamed_addr constant { [4 x i8*] }
+
+  // If the vtable isn't needed in this case, it won't be emitted at all.
+  struct __declspec(dllimport) T {
+    virtual ~T();
+  };
+  T::~T() {}
+  // GNU-NOT: @_ZTVN7PR213551TE
 }
 
 namespace PR21366 {
   struct __declspec(dllimport) S {
     void outOfLineMethod();
     void inlineMethod() {}
     inline void anotherInlineMethod();
     void outOfClassInlineMethod();

test/CodeGenCXX/key-function-vtable.cpp

-// RUN: %clang_cc1 -triple x86_64-none-linux-gnu %s -emit-llvm -o - | FileCheck %s
-// RUN: %clang_cc1 -triple arm-apple-darwin %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-none-linux-gnu %s -emit-llvm -o - | FileCheck %s --implicit-check-not=@_ZTV5testc --implicit-check-not=@_ZTV5testh
+// RUN: %clang_cc1 -triple arm-apple-darwin %s -emit-llvm -o - | FileCheck %s --implicit-check-not=@_ZTV5testc --implicit-check-not=@_ZTV5testh
 
 // Simple key function test
 struct testa { virtual void a(); };
 void testa::a() {}
 
 // Simple key function test
 struct testb { virtual void a() {} };
 testb *testbvar = new testb;
 
 // Key function with out-of-line inline definition
+// vtable is discardable and unused, so is not emitted.
 struct testc { virtual void a(); };
 inline void testc::a() {}
 
 // Functions with inline specifier are not key functions (PR5705)
 struct testd { inline virtual void a(); };
 void testd::a() {}
 
 // Functions with inline specifier are not key functions (PR5705)
 struct teste { inline virtual void a(); };
 teste *testevar = new teste;
 
 // Key functions with namespace (PR5711)
 namespace {
   struct testf { virtual void a(); };
 }
 void testf::a() {}
 
 // Key functions with namespace (PR5711)
 namespace {
   struct testg { virtual void a(); };
 }
 void testg::a() {}
 testg *testgvar = new testg;
 
+// Key function with out-of-line inline definition
+// vtable is discardable and unused, so is not emitted even though key function is.
+struct testh { virtual void a(); void b(); };
+inline void testh::a() {}
+void testh::b() { testh::a(); }
+
+// Key function with out-of-line inline definition
+// VTable is used, so is emitted.
+struct testi { virtual void a(); };
+inline void testi::a() {}
+void use_i() { testi ti; }
+
 struct X0 { virtual ~X0(); };
 struct X1 : X0 {
   virtual void f();
 };
 
 inline void X1::f() { }
 
 void use_X1() { X1 x1; }
 
 // CHECK-DAG: @_ZTV2X1 = linkonce_odr unnamed_addr constant
 // CHECK-DAG: @_ZTV5testa = unnamed_addr constant { [3 x i8*] } { [3 x i8*] [i8* null
-// CHECK-DAG: @_ZTV5testc = linkonce_odr unnamed_addr constant { [3 x i8*] } { [3 x i8*] [i8* null
 // CHECK-DAG: @_ZTV5testb = linkonce_odr unnamed_addr constant { [3 x i8*] } { [3 x i8*] [i8* null
 // CHECK-DAG: @_ZTV5teste = linkonce_odr unnamed_addr constant { [3 x i8*] } { [3 x i8*] [i8* null
 // CHECK-DAG: @_ZTVN12_GLOBAL__N_15testgE = internal unnamed_addr constant { [3 x i8*] } { [3 x i8*] [i8* null
+// CHECK-DAG: @_ZTV5testi = linkonce_odr unnamed_addr constant { [3 x i8*] } { [3 x i8*] [i8* null

test/CodeGenCXX/rtti-linkage.cpp

 
 // F has a key function defined in the translation unit, but it is inline so the RTTI
 // data should be emitted with linkonce_odr linkage.
 struct F {
   virtual void f();
 };
 
 inline void F::f() { }
+void *use_vtable() { return new F; }
 const D getD();
 
 const std::type_info &t2() {
   (void)typeid(const D);
   (void)typeid(D *);
   (void)typeid(D (*)());
   (void)typeid(void (*)(D));
   (void)typeid(void (*)(D&));

test/CodeGenCXX/type_visibility.cpp

 namespace temp0 {
   struct A;
   template <class T> struct TYPE_DEFAULT B {
     virtual void foo() {}
   };
 
   template struct B<A>;
   // FUNS-LABEL:        define weak_odr void @_ZN5temp01BINS_1AEE3fooEv(
-  // VARS:        @_ZTVN5temp01BINS_1AEEE = weak_odr unnamed_addr constant
-  // VARS:        @_ZTSN5temp01BINS_1AEEE = weak_odr constant
-  // VARS:        @_ZTIN5temp01BINS_1AEEE = weak_odr constant
+  // VARS-DAG:          @_ZTVN5temp01BINS_1AEEE = weak_odr unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5temp01BINS_1AEEE = weak_odr constant
+  // VARS-DAG:          @_ZTIN5temp01BINS_1AEEE = weak_odr constant
   // FUNS-HIDDEN-LABEL: define weak_odr hidden void @_ZN5temp01BINS_1AEE3fooEv(
-  // VARS-HIDDEN: @_ZTVN5temp01BINS_1AEEE = weak_odr hidden unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5temp01BINS_1AEEE = weak_odr hidden constant
-  // VARS-HIDDEN: @_ZTIN5temp01BINS_1AEEE = weak_odr hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5temp01BINS_1AEEE = weak_odr hidden unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5temp01BINS_1AEEE = weak_odr hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTIN5temp01BINS_1AEEE = weak_odr hidden constant
 }
 
 namespace temp1 {
   struct TYPE_DEFAULT A;
   template <class T> struct TYPE_DEFAULT B {
     virtual void foo() {}
   };
 
   template struct B<A>;
   // FUNS-LABEL:        define weak_odr void @_ZN5temp11BINS_1AEE3fooEv(
-  // VARS:        @_ZTVN5temp11BINS_1AEEE = weak_odr unnamed_addr constant
-  // VARS:        @_ZTSN5temp11BINS_1AEEE = weak_odr constant
-  // VARS:        @_ZTIN5temp11BINS_1AEEE = weak_odr constant
+  // VARS-DAG:          @_ZTVN5temp11BINS_1AEEE = weak_odr unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5temp11BINS_1AEEE = weak_odr constant
+  // VARS-DAG:          @_ZTIN5temp11BINS_1AEEE = weak_odr constant
   // FUNS-HIDDEN-LABEL: define weak_odr hidden void @_ZN5temp11BINS_1AEE3fooEv(
-  // VARS-HIDDEN: @_ZTVN5temp11BINS_1AEEE = weak_odr unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5temp11BINS_1AEEE = weak_odr constant
-  // VARS-HIDDEN: @_ZTIN5temp11BINS_1AEEE = weak_odr constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5temp11BINS_1AEEE = weak_odr unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5temp11BINS_1AEEE = weak_odr constant
+  // VARS-HIDDEN-DAG:   @_ZTIN5temp11BINS_1AEEE = weak_odr constant
 }
 
 namespace temp2 {
   struct TYPE_DEFAULT A;
   template <class T> struct B {
     virtual void foo() {}
   };
 
   template struct B<A>;
   // FUNS-LABEL:        define weak_odr void @_ZN5temp21BINS_1AEE3fooEv(
-  // VARS:        @_ZTVN5temp21BINS_1AEEE = weak_odr unnamed_addr constant
-  // VARS:        @_ZTSN5temp21BINS_1AEEE = weak_odr constant
-  // VARS:        @_ZTIN5temp21BINS_1AEEE = weak_odr constant
+  // VARS-DAG:          @_ZTVN5temp21BINS_1AEEE = weak_odr unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5temp21BINS_1AEEE = weak_odr constant
+  // VARS-DAG:          @_ZTIN5temp21BINS_1AEEE = weak_odr constant
   // FUNS-HIDDEN-LABEL: define weak_odr hidden void @_ZN5temp21BINS_1AEE3fooEv(
-  // VARS-HIDDEN: @_ZTVN5temp21BINS_1AEEE = weak_odr hidden unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5temp21BINS_1AEEE = weak_odr hidden constant
-  // VARS-HIDDEN: @_ZTIN5temp21BINS_1AEEE = weak_odr hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5temp21BINS_1AEEE = weak_odr hidden unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5temp21BINS_1AEEE = weak_odr hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTIN5temp21BINS_1AEEE = weak_odr hidden constant
 }
 
 namespace temp3 {
   struct TYPE_HIDDEN A;
   template <class T> struct TYPE_DEFAULT B {
     virtual void foo() {}
   };
 
   template struct B<A>;
   // FUNS-LABEL:        define weak_odr hidden void @_ZN5temp31BINS_1AEE3fooEv(
-  // VARS:        @_ZTVN5temp31BINS_1AEEE = weak_odr hidden unnamed_addr constant
-  // VARS:        @_ZTSN5temp31BINS_1AEEE = weak_odr hidden constant
-  // VARS:        @_ZTIN5temp31BINS_1AEEE = weak_odr hidden constant
+  // VARS-DAG:          @_ZTVN5temp31BINS_1AEEE = weak_odr hidden unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5temp31BINS_1AEEE = weak_odr hidden constant
+  // VARS-DAG:          @_ZTIN5temp31BINS_1AEEE = weak_odr hidden constant
   // FUNS-HIDDEN-LABEL: define weak_odr hidden void @_ZN5temp31BINS_1AEE3fooEv(
-  // VARS-HIDDEN: @_ZTVN5temp31BINS_1AEEE = weak_odr hidden unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5temp31BINS_1AEEE = weak_odr hidden constant
-  // VARS-HIDDEN: @_ZTIN5temp31BINS_1AEEE = weak_odr hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5temp31BINS_1AEEE = weak_odr hidden unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5temp31BINS_1AEEE = weak_odr hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTIN5temp31BINS_1AEEE = weak_odr hidden constant
 }
 
 namespace temp4 {
   struct TYPE_DEFAULT A;
   template <class T> struct TYPE_HIDDEN B {
     virtual void foo() {}
   };
 
   template struct B<A>;
   // FUNS-LABEL:        define weak_odr void @_ZN5temp41BINS_1AEE3fooEv(
-  // VARS:        @_ZTVN5temp41BINS_1AEEE = weak_odr hidden unnamed_addr constant
-  // VARS:        @_ZTSN5temp41BINS_1AEEE = weak_odr hidden constant
-  // VARS:        @_ZTIN5temp41BINS_1AEEE = weak_odr hidden constant
+  // VARS-DAG:          @_ZTVN5temp41BINS_1AEEE = weak_odr hidden unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5temp41BINS_1AEEE = weak_odr hidden constant
+  // VARS-DAG:          @_ZTIN5temp41BINS_1AEEE = weak_odr hidden constant
   // FUNS-HIDDEN-LABEL: define weak_odr hidden void @_ZN5temp41BINS_1AEE3fooEv(
-  // VARS-HIDDEN: @_ZTVN5temp41BINS_1AEEE = weak_odr hidden unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5temp41BINS_1AEEE = weak_odr hidden constant
-  // VARS-HIDDEN: @_ZTIN5temp41BINS_1AEEE = weak_odr hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5temp41BINS_1AEEE = weak_odr hidden unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5temp41BINS_1AEEE = weak_odr hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTIN5temp41BINS_1AEEE = weak_odr hidden constant
 }
 
 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:        @_ZTIN5type01AE = constant
+  // VARS-DAG:          @_ZTVN5type01AE = unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5type01AE = constant
+  // VARS-DAG:          @_ZTIN5type01AE = constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type01A3fooEv(
-  // VARS-HIDDEN: @_ZTVN5type01AE = unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type01AE = constant
-  // VARS-HIDDEN: @_ZTIN5type01AE = constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5type01AE = unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5type01AE = constant
+  // VARS-HIDDEN-DAG:   @_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:        @_ZTIN5type11AE = constant
+  // VARS-DAG:          @_ZTVN5type11AE = unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5type11AE = constant
+  // VARS-DAG:          @_ZTIN5type11AE = constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type11A3fooEv(
-  // VARS-HIDDEN: @_ZTVN5type11AE = unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type11AE = constant
-  // VARS-HIDDEN: @_ZTIN5type11AE = constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5type11AE = unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5type11AE = constant
+  // VARS-HIDDEN-DAG:   @_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:        @_ZTIN5type21AE = hidden constant
+  // VARS-DAG:          @_ZTVN5type21AE = hidden unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5type21AE = hidden constant
+  // VARS-DAG:          @_ZTIN5type21AE = hidden constant
   // FUNS-HIDDEN-LABEL: define hidden void @_ZN5type21A3fooEv(
-  // VARS-HIDDEN: @_ZTVN5type21AE = hidden unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type21AE = hidden constant
-  // VARS-HIDDEN: @_ZTIN5type21AE = hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5type21AE = hidden unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5type21AE = hidden constant
+  // VARS-HIDDEN-DAG:   @_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:        @_ZTIN5type31AE = hidden constant
+  // VARS-DAG:          @_ZTVN5type31AE = hidden unnamed_addr constant
+  // VARS-DAG:          @_ZTSN5type31AE = hidden constant
+  // VARS-DAG:          @_ZTIN5type31AE = hidden constant
   // FUNS-HIDDEN-LABEL: define void @_ZN5type31A3fooEv(
-  // VARS-HIDDEN: @_ZTVN5type31AE = hidden unnamed_addr constant
-  // VARS-HIDDEN: @_ZTSN5type31AE = hidden constant
-  // VARS-HIDDEN: @_ZTIN5type31AE = hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTVN5type31AE = hidden unnamed_addr constant
+  // VARS-HIDDEN-DAG:   @_ZTSN5type31AE = hidden constant
+  // VARS-HIDDEN-DAG:   @_ZTIN5type31AE = hidden constant
 }
 

test/CodeGenCXX/visibility.cpp

struct bar {
     };
   };
 
   bar::zed<&x> y;
   // CHECK: _ZN6test481yE = hidden global
   // CHECK-HIDDEN: _ZN6test481yE = hidden global
 }
 
-// CHECK: @_ZN5Test425VariableInHiddenNamespaceE = hidden global i32 10
-// CHECK: @_ZN5Test71aE = hidden global
-// CHECK: @_ZN5Test71bE = global
-// CHECK: @test9_var = global
-// CHECK-HIDDEN: @test9_var = global
-// CHECK: @_ZN6Test121A6hiddenE = external hidden global
-// CHECK: @_ZN6Test121A7visibleE = external global
-// CHECK-HIDDEN: @_ZN6Test121A6hiddenE = external hidden global
-// CHECK-HIDDEN: @_ZN6Test121A7visibleE = external global
-// CHECK: @_ZN6Test131B1aE = hidden global
-// CHECK: @_ZN6Test131C1aE = global
-// CHECK-HIDDEN: @_ZN6Test131B1aE = hidden global
-// CHECK-HIDDEN: @_ZN6Test131C1aE = global
-// CHECK: @_ZN6Test143varE = external global
-// CHECK-HIDDEN: @_ZN6Test143varE = external global
-// CHECK: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]
-// CHECK-HIDDEN: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]
-
 namespace test27 {
   template<typename T>
   class C {
     class DEFAULT D {
       void f();
     };
   };
 
   template<>
   class C<int>::D {
     virtual void g();
   };
 
   void C<int>::D::g() {
   }
   // CHECK: _ZTVN6test271CIiE1DE = unnamed_addr constant
   // CHECK-HIDDEN: _ZTVN6test271CIiE1DE = unnamed_addr constant
 }
 
+// CHECK: @_ZN5Test425VariableInHiddenNamespaceE = hidden global i32 10
+// CHECK: @_ZN5Test71aE = hidden global
+// CHECK: @_ZN5Test71bE = global
+// CHECK: @test9_var = global
+// CHECK-HIDDEN: @test9_var = global
+// CHECK: @_ZN6Test121A6hiddenE = external hidden global
+// CHECK: @_ZN6Test121A7visibleE = external global
+// CHECK-HIDDEN: @_ZN6Test121A6hiddenE = external hidden global
+// CHECK-HIDDEN: @_ZN6Test121A7visibleE = external global
+// CHECK: @_ZN6Test131B1aE = hidden global
+// CHECK: @_ZN6Test131C1aE = global
+// CHECK-HIDDEN: @_ZN6Test131B1aE = hidden global
+// CHECK-HIDDEN: @_ZN6Test131C1aE = global
+// CHECK: @_ZN6Test143varE = external global
+// CHECK-HIDDEN: @_ZN6Test143varE = external global
+// CHECK: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]
+// CHECK-HIDDEN: @_ZN6Test154TempINS_1AEE5Inner6bufferE = external global [0 x i8]
+
 // CHECK: @_ZTVN5Test63fooE = linkonce_odr hidden unnamed_addr constant
 
 // CHECK-HIDDEN: @_ZTVN6Test161AIcEE = external unnamed_addr constant
 // CHECK-HIDDEN: @_ZTTN6Test161AIcEE = external unnamed_addr constant
 
 // CHECK: @_ZZN6test681fC1EvE4test = linkonce_odr global
 // CHECK-HIDDEN: @_ZZN6test681fC1EvE4test = linkonce_odr hidden global
 

test/CodeGenCXX/vtable-assume-load.cpp

 
 // CHECK8-DAG: @_ZTVN5test81BE = available_externally unnamed_addr constant
 struct B : A {
   B();
   void foo();
   void bar();
 };
 
-// CHECK8-DAG: @_ZTVN5test81CE = linkonce_odr unnamed_addr constant
+// CHECK8-NOT: @_ZTVN5test81CE
 struct C : A {
   C();
   void bar();
   void foo() {}
 };
 inline void C::bar() {}
 
 struct D : A {

 // CHECK8: call void @llvm.assume(
 // CHECK8-LABEL: {{^}}}
 void b() {
   B b;
   b.bar();
 }
 
 // FIXME: C has inline virtual functions which prohibits as from generating
-// assumption loads, but because vtable is generated in this TU (key function
-// defined here) it would be correct to refer to it.
+// assumption loads, but because vtable can be generated in this TU (key
+// function defined here) it would be correct to refer to it.
 // CHECK8-LABEL: define void @_ZN5test81cEv()
 // CHECK8-NOT: call void @llvm.assume(
 // CHECK8-LABEL: {{^}}}
 void c() {
   C c;
   c.bar();
 }
 

test/CodeGenCXX/vtt-layout.cpp

struct A {
     virtual void f() = delete;
     virtual void anchor();
   };
 
   void A::anchor() {
   }
 }
 
-// CHECK: @_ZTTN5Test11BE = unnamed_addr constant [1 x i8*] [i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTVN5Test11BE, i32 0, inrange i32 0, i32 3) to i8*)]
-// CHECK: @_ZTVN5Test51AE = unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTIN5Test51AE to i8*), i8* bitcast (void ()* @__cxa_pure_virtual to i8*), i8* bitcast (void (%"struct.Test5::A"*)* @_ZN5Test51A6anchorEv to i8*)] }
-// CHECK: @_ZTVN5Test61AE = unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTIN5Test61AE to i8*), i8* bitcast (void ()* @__cxa_deleted_virtual to i8*), i8* bitcast (void (%"struct.Test6::A"*)* @_ZN5Test61A6anchorEv to i8*)] }
-// CHECK: @_ZTTN5Test21CE = linkonce_odr unnamed_addr constant [2 x i8*] [i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*] }, { [5 x i8*] }* @_ZTVN5Test21CE, i32 0, inrange i32 0, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*] }, { [5 x i8*] }* @_ZTVN5Test21CE, i32 0, inrange i32 0, i32 4) to i8*)]
-// CHECK: @_ZTTN5Test31DE = linkonce_odr unnamed_addr constant [13 x i8*] [i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 0, i32 5) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE0_NS_2C1E, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE0_NS_2C1E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [7 x i8*], [3 x i8*], [4 x i8*] }, { [7 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE16_NS_2C2E, i32 0, inrange i32 0, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [7 x i8*], [3 x i8*], [4 x i8*] }, { [7 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE16_NS_2C2E, i32 0, inrange i32 0, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [7 x i8*], [3 x i8*], [4 x i8*] }, { [7 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE16_NS_2C2E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [7 x i8*], [3 x i8*], [4 x i8*] }, { [7 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE16_NS_2C2E, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 1, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 1, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 3, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE64_NS_2V2E, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE64_NS_2V2E, i32 0, inrange i32 1, i32 3) to i8*)]
-// CHECK: @_ZTVN5Test41DE = linkonce_odr unnamed_addr constant { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] } { [6 x i8*] [i8* inttoptr (i64 72 to i8*), i8* inttoptr (i64 16 to i8*), i8* inttoptr (i64 56 to i8*), i8* inttoptr (i64 40 to i8*), i8* null, i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*)], [8 x i8*] [i8* inttoptr (i64 40 to i8*), i8* inttoptr (i64 24 to i8*), i8* inttoptr (i64 56 to i8*), i8* null, i8* null, i8* inttoptr (i64 -16 to i8*), i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*), i8* bitcast (void (%"class.Test4::V3"*)* @_ZN5Test42V31gEv to i8*)], [3 x i8*] [i8* inttoptr (i64 16 to i8*), i8* inttoptr (i64 -40 to i8*), i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*)], [4 x i8*] [i8* null, i8* inttoptr (i64 -56 to i8*), i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*), i8* bitcast (void (%"class.Test4::A2"*)* @_ZN5Test42A21fEv to i8*)], [4 x i8*] [i8* inttoptr (i64 -16 to i8*), i8* inttoptr (i64 -32 to i8*), i8* inttoptr (i64 -72 to i8*), i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*)] }
-// CHECK: @_ZTTN5Test41DE = linkonce_odr unnamed_addr constant [19 x i8*] [i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 0, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE0_NS_2C1E, i32 0, inrange i32 0, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE0_NS_2C1E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE0_NS_2C1E, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 0, i32 7) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 0, i32 7) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 1, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 3, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 3, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 1, i32 7) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 1, i32 7) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 4, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE40_NS_2V1E, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE40_NS_2V1E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE72_NS_2V2E, i32 0, inrange i32 0, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE72_NS_2V2E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE72_NS_2V2E, i32 0, inrange i32 2, i32 3) to i8*)]
+// CHECK-DAG: @_ZTTN5Test11BE = unnamed_addr constant [1 x i8*] [i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTVN5Test11BE, i32 0, inrange i32 0, i32 3) to i8*)]
+// CHECK-DAG: @_ZTVN5Test51AE = unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTIN5Test51AE to i8*), i8* bitcast (void ()* @__cxa_pure_virtual to i8*), i8* bitcast (void (%"struct.Test5::A"*)* @_ZN5Test51A6anchorEv to i8*)] }
+// CHECK-DAG: @_ZTVN5Test61AE = unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTIN5Test61AE to i8*), i8* bitcast (void ()* @__cxa_deleted_virtual to i8*), i8* bitcast (void (%"struct.Test6::A"*)* @_ZN5Test61A6anchorEv to i8*)] }
+// CHECK-DAG: @_ZTTN5Test21CE = linkonce_odr unnamed_addr constant [2 x i8*] [i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*] }, { [5 x i8*] }* @_ZTVN5Test21CE, i32 0, inrange i32 0, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*] }, { [5 x i8*] }* @_ZTVN5Test21CE, i32 0, inrange i32 0, i32 4) to i8*)]
+// CHECK-DAG: @_ZTTN5Test31DE = linkonce_odr unnamed_addr constant [13 x i8*] [i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 0, i32 5) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE0_NS_2C1E, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE0_NS_2C1E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [7 x i8*], [3 x i8*], [4 x i8*] }, { [7 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE16_NS_2C2E, i32 0, inrange i32 0, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [7 x i8*], [3 x i8*], [4 x i8*] }, { [7 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE16_NS_2C2E, i32 0, inrange i32 0, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [7 x i8*], [3 x i8*], [4 x i8*] }, { [7 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE16_NS_2C2E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [7 x i8*], [3 x i8*], [4 x i8*] }, { [7 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE16_NS_2C2E, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 1, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 1, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }, { [5 x i8*], [7 x i8*], [4 x i8*], [3 x i8*] }* @_ZTVN5Test31DE, i32 0, inrange i32 3, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE64_NS_2V2E, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test31DE64_NS_2V2E, i32 0, inrange i32 1, i32 3) to i8*)]
+// CHECK-DAG: @_ZTVN5Test41DE = linkonce_odr unnamed_addr constant { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] } { [6 x i8*] [i8* inttoptr (i64 72 to i8*), i8* inttoptr (i64 16 to i8*), i8* inttoptr (i64 56 to i8*), i8* inttoptr (i64 40 to i8*), i8* null, i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*)], [8 x i8*] [i8* inttoptr (i64 40 to i8*), i8* inttoptr (i64 24 to i8*), i8* inttoptr (i64 56 to i8*), i8* null, i8* null, i8* inttoptr (i64 -16 to i8*), i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*), i8* bitcast (void (%"class.Test4::V3"*)* @_ZN5Test42V31gEv to i8*)], [3 x i8*] [i8* inttoptr (i64 16 to i8*), i8* inttoptr (i64 -40 to i8*), i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*)], [4 x i8*] [i8* null, i8* inttoptr (i64 -56 to i8*), i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*), i8* bitcast (void (%"class.Test4::A2"*)* @_ZN5Test42A21fEv to i8*)], [4 x i8*] [i8* inttoptr (i64 -16 to i8*), i8* inttoptr (i64 -32 to i8*), i8* inttoptr (i64 -72 to i8*), i8* bitcast ({ i8*, i8*, i32, i32, i8*, i64, i8*, i64, i8*, i64 }* @_ZTIN5Test41DE to i8*)] }
+// CHECK-DAG: @_ZTTN5Test41DE = linkonce_odr unnamed_addr constant [19 x i8*] [i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 0, i32 6) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE0_NS_2C1E, i32 0, inrange i32 0, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE0_NS_2C1E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE0_NS_2C1E, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 0, i32 7) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 0, i32 7) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 1, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }, { [8 x i8*], [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE16_NS_2C2E, i32 0, inrange i32 3, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 2, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 3, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 1, i32 7) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 1, i32 7) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }, { [6 x i8*], [8 x i8*], [3 x i8*], [4 x i8*], [4 x i8*] }* @_ZTVN5Test41DE, i32 0, inrange i32 4, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE40_NS_2V1E, i32 0, inrange i32 0, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [3 x i8*], [4 x i8*] }, { [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE40_NS_2V1E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE72_NS_2V2E, i32 0, inrange i32 0, i32 4) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE72_NS_2V2E, i32 0, inrange i32 1, i32 3) to i8*), i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*], [3 x i8*], [4 x i8*] }, { [4 x i8*], [3 x i8*], [4 x i8*] }* @_ZTCN5Test41DE72_NS_2V2E, i32 0, inrange i32 2, i32 3) to i8*)]
 // CHECK: declare void @__cxa_pure_virtual() unnamed_addr
 // CHECK: declare void @__cxa_deleted_virtual() unnamed_addr