[LTO/WPD] Remove special type test handling for -flto-visibility-public-std

[tejohnson]

Summary

As discussed in follow up comments on D71913, the special case handling
for -flto-visibility-public-std of not inserting type tests is unneeded,
because that is a Windows option, and the Windows linker does not
support the -lto-whole-program-visibility option which would relax the
visibility. By default, the type tests will get public visibility, which
is what we want for the std classes under that option, and it can't be
relaxed. Therefore the handling that was preventing the type tests from
being inserted (to avoid any visibility relaxation) isn't needed.

[tejohnson]

ping

clang/lib/CodeGen/CGClass.cpp

return LeastDerivedClassWithSameLayout(
       RD->bases_begin()->getType()->getAsCXXRecordDecl());
 }
 
 void CodeGenFunction::EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD,
                                                    llvm::Value *VTable,
                                                    SourceLocation Loc) {
   if (SanOpts.has(SanitizerKind::CFIVCall))
     EmitVTablePtrCheckForCall(RD, VTable, CodeGenFunction::CFITCK_VCall, Loc);
-  else if (CGM.getCodeGenOpts().WholeProgramVTables &&
-           // Don't insert type test assumes if we are forcing public std
-           // visibility.
-           !CGM.HasLTOVisibilityPublicStd(RD)) {
+  else if (CGM.getCodeGenOpts().WholeProgramVTables) {
     llvm::Metadata *MD =
         CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
     llvm::Value *TypeId =
         llvm::MetadataAsValue::get(CGM.getLLVMContext(), MD);
 
     llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
     llvm::Value *TypeTest =
         Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::type_test),

clang/lib/CodeGen/CGVTables.cpp

for (const CXXRecordDecl *RD : DeferredVTables)
     else if (shouldOpportunisticallyEmitVTables())
       OpportunisticVTables.push_back(RD);
 
   assert(savedSize == DeferredVTables.size() &&
          "deferred extra vtables during vtable emission?");
   DeferredVTables.clear();
 }
 
-bool CodeGenModule::HasLTOVisibilityPublicStd(const CXXRecordDecl *RD) {
-  if (!getCodeGenOpts().LTOVisibilityPublicStd)
-    return false;
-
-  const DeclContext *DC = RD;
-  while (1) {
-    auto *D = cast<Decl>(DC);
-    DC = DC->getParent();
-    if (isa<TranslationUnitDecl>(DC->getRedeclContext())) {
-      if (auto *ND = dyn_cast<NamespaceDecl>(D))
-        if (const IdentifierInfo *II = ND->getIdentifier())
-          if (II->isStr("std") || II->isStr("stdext"))
-            return true;
-      break;
-    }
-  }
-
-  return false;
-}
-
 bool CodeGenModule::HasHiddenLTOVisibility(const CXXRecordDecl *RD) {
   LinkageInfo LV = RD->getLinkageAndVisibility();
   if (!isExternallyVisible(LV.getLinkage()))
     return true;
 
   if (RD->hasAttr<LTOVisibilityPublicAttr>() || RD->hasAttr<UuidAttr>())
     return false;
 
   if (getTriple().isOSBinFormatCOFF()) {
     if (RD->hasAttr<DLLExportAttr>() || RD->hasAttr<DLLImportAttr>())
       return false;
   } else {
     if (LV.getVisibility() != HiddenVisibility)
       return false;
   }
 
-  return !HasLTOVisibilityPublicStd(RD);
+  if (getCodeGenOpts().LTOVisibilityPublicStd) {
+    const DeclContext *DC = RD;
+    while (1) {
+      auto *D = cast<Decl>(DC);
+      DC = DC->getParent();
+      if (isa<TranslationUnitDecl>(DC->getRedeclContext())) {
+        if (auto *ND = dyn_cast<NamespaceDecl>(D))
+          if (const IdentifierInfo *II = ND->getIdentifier())
+            if (II->isStr("std") || II->isStr("stdext"))
+              return false;
+        break;
+      }
+    }
+  }
+
+  return true;
 }
 
 llvm::GlobalObject::VCallVisibility
 CodeGenModule::GetVCallVisibilityLevel(const CXXRecordDecl *RD) {
   LinkageInfo LV = RD->getLinkageAndVisibility();
   llvm::GlobalObject::VCallVisibility TypeVis;
   if (!isExternallyVisible(LV.getLinkage()))
     TypeVis = llvm::GlobalObject::VCallVisibilityTranslationUnit;

clang/lib/CodeGen/CodeGenModule.h

public:
   /// \param D Requires declaration
   void EmitOMPRequiresDecl(const OMPRequiresDecl *D);
 
   /// Returns whether the given record has hidden LTO visibility and therefore
   /// may participate in (single-module) CFI and whole-program vtable
   /// optimization.
   bool HasHiddenLTOVisibility(const CXXRecordDecl *RD);
 
-  /// Returns whether the given record has public std LTO visibility
-  /// and therefore may not participate in (single-module) CFI and whole-program
-  /// vtable optimization.
-  bool HasLTOVisibilityPublicStd(const CXXRecordDecl *RD);
-
   /// Returns the vcall visibility of the given type. This is the scope in which
   /// a virtual function call could be made which ends up being dispatched to a
   /// member function of this class. This scope can be wider than the visibility
   /// of the class itself when the class has a more-visible dynamic base class.
   llvm::GlobalObject::VCallVisibility
   GetVCallVisibilityLevel(const CXXRecordDecl *RD);
 
   /// Emit type metadata for the given vtable using the given layout.

clang/lib/CodeGen/ItaniumCXXABI.cpp

CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer(
   // Check the address of the function pointer if CFI on member function
   // pointers is enabled.
   llvm::Constant *CheckSourceLocation;
   llvm::Constant *CheckTypeDesc;
   bool ShouldEmitCFICheck = CGF.SanOpts.has(SanitizerKind::CFIMFCall) &&
                             CGM.HasHiddenLTOVisibility(RD);
   bool ShouldEmitVFEInfo = CGM.getCodeGenOpts().VirtualFunctionElimination &&
                            CGM.HasHiddenLTOVisibility(RD);
-  bool ShouldEmitWPDInfo =
-      CGM.getCodeGenOpts().WholeProgramVTables &&
-      // Don't insert type tests if we are forcing public std visibility.
-      !CGM.HasLTOVisibilityPublicStd(RD);
+  bool ShouldEmitWPDInfo = CGM.getCodeGenOpts().WholeProgramVTables;
   llvm::Value *VirtualFn = nullptr;
 
   {
     CodeGenFunction::SanitizerScope SanScope(&CGF);
     llvm::Value *TypeId = nullptr;
     llvm::Value *CheckResult = nullptr;
 
     if (ShouldEmitCFICheck || ShouldEmitVFEInfo || ShouldEmitWPDInfo) {

clang/test/CodeGenCXX/lto-visibility-inference.cpp

 // RUN: %clang_cc1 -flto -triple x86_64-unknown-linux -std=c++11 -fms-extensions -fvisibility hidden -fwhole-program-vtables -emit-llvm -o - %s | FileCheck --check-prefix=ITANIUM %s
-// RUN: %clang_cc1 -flto -triple x86_64-pc-windows-msvc -std=c++11 -fms-extensions -fwhole-program-vtables -emit-llvm -o - %s | FileCheck --check-prefix=MS --check-prefix=MS-STD %s
-// RUN: %clang_cc1 -flto -triple x86_64-pc-windows-msvc -std=c++11 -fms-extensions -fwhole-program-vtables -flto-visibility-public-std -emit-llvm -o - %s | FileCheck --check-prefix=MS --check-prefix=MS-NOSTD %s
+// RUN: %clang_cc1 -flto -triple x86_64-pc-windows-msvc -std=c++11 -fms-extensions -fwhole-program-vtables -emit-llvm -o - %s | FileCheck --check-prefix=MS %s
+// RUN: %clang_cc1 -flto -triple x86_64-pc-windows-msvc -std=c++11 -fms-extensions -fwhole-program-vtables -flto-visibility-public-std -emit-llvm -o - %s | FileCheck --check-prefix=MS %s
 
 struct C1 {
   virtual void f();
 };
 
 struct __attribute__((visibility("default"))) C2 {
   virtual void f();
 };
void f(C1 *c1, C2 *c2, C3 *c3, C4 *c4, C5 *c5, C6 *c6, std::C7 *c7,
   c4->f();
   // ITANIUM: type.test{{.*}}!"_ZTS2C5"
   // MS: type.test{{.*}}!"?AUC5@@"
   c5->f();
   // ITANIUM: type.test{{.*}}!"_ZTS2C6"
   // MS: type.test{{.*}}!"?AUC6@@"
   c6->f();
   // ITANIUM: type.test{{.*}}!"_ZTSSt2C7"
-  // MS-STD: type.test{{.*}}!"?AUC7@std@@"
-  // MS-NOSTD-NOT: type.test{{.*}}!"?AUC7@std@@"
+  // MS: type.test{{.*}}!"?AUC7@std@@"
   c7->f();
   // ITANIUM: type.test{{.*}}!"_ZTSNSt2C72C8E"
-  // MS-STD: type.test{{.*}}!"?AUC8@C7@std@@"
-  // MS-NOSTD-NOT: type.test{{.*}}!"?AUC8@C7@std@@"
+  // MS: type.test{{.*}}!"?AUC8@C7@std@@"
   c8->f();
   // ITANIUM: type.test{{.*}}!"_ZTSN6stdext2C9E"
-  // MS-STD: type.test{{.*}}!"?AUC9@stdext@@"
-  // MS-NOSTD-NOT: type.test{{.*}}!"?AUC9@stdext@@"
+  // MS: type.test{{.*}}!"?AUC9@stdext@@"
   c9->f();
   // ITANIUM: type.test{{.*}}!"_ZTSN5other3C10E"
   // MS: type.test{{.*}}!"?AUC10@other@@"
   c10->f();
   // ITANIUM: type.test{{.*}}!{{[0-9]}}
   // MS: type.test{{.*}}!{{[0-9]}}
   C11 *c11;
   c11->f();
 }