Commit 59733525 authored by Teresa Johnson's avatar Teresa Johnson
Browse files

[LTO/WPD] Enable aggressive WPD under LTO option 

Summary:
Third part in series to support Safe Whole Program Devirtualization
Enablement, see RFC here:
http://lists.llvm.org/pipermail/llvm-dev/2019-December/137543.html

This patch adds type test metadata under -fwhole-program-vtables,
even for classes without hidden visibility. It then changes WPD to skip
devirtualization for a virtual function call when any of the compatible
vtables has public vcall visibility.

Additionally, internal LLVM options as well as lld and gold-plugin
options are added which enable upgrading all public vcall visibility
to linkage unit (hidden) visibility during LTO. This enables the more
aggressive WPD to kick in based on LTO time knowledge of the visibility
guarantees.

Support was added to all flavors of LTO WPD (regular, hybrid and
index-only), and to both the new and old LTO APIs.

Unfortunately it was not simple to split the first and second parts of
this part of the change (the unconditional emission of type tests and
the upgrading of the vcall visiblity) as I needed a way to upgrade the
public visibility on legacy WPD llvm assembly tests that don't include
linkage unit vcall visibility specifiers, to avoid a lot of test churn.

I also added a mechanism to LowerTypeTests that allows dropping type
test assume sequences we now aggressively insert when we invoke
distributed ThinLTO backends with null indexes, which is used in testing
mode, and which doesn't invoke the normal ThinLTO backend pipeline.

Depends on D71907 and D71911.

Reviewers: pcc, evgeny777, steven_wu, espindola

Subscribers: emaste, Prazek, inglorion, arichardson, hiraditya, MaskRay, dexonsmith, dang, davidxl, cfe-commits, llvm-commits

Tags: #clang, #llvm

Differential Revision: https://reviews.llvm.org/D71913
parent 9e66c4ec

clang/lib/CodeGen/BackendUtil.cpp

+32 −0
Original line number Diff line number Diff line
@@ -51,6 +51,7 @@ 
#include "llvm/Transforms/Coroutines.h"

#include "llvm/Transforms/IPO.h"

#include "llvm/Transforms/IPO/AlwaysInliner.h"

#include "llvm/Transforms/IPO/LowerTypeTests.h"

#include "llvm/Transforms/IPO/PassManagerBuilder.h"

#include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"

#include "llvm/Transforms/InstCombine/InstCombine.h"
@@ -553,6 +554,16 @@ void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM, 
  std::unique_ptr<TargetLibraryInfoImpl> TLII(

      createTLII(TargetTriple, CodeGenOpts));



  // If we reached here with a non-empty index file name, then the index file

  // was empty and we are not performing ThinLTO backend compilation (used in

  // testing in a distributed build environment). Drop any the type test

  // assume sequences inserted for whole program vtables so that codegen doesn't

  // complain.

  if (!CodeGenOpts.ThinLTOIndexFile.empty())

    MPM.add(createLowerTypeTestsPass(/*ExportSummary=*/nullptr,

                                     /*ImportSummary=*/nullptr,

                                     /*DropTypeTests=*/true));



  PassManagerBuilderWrapper PMBuilder(TargetTriple, CodeGenOpts, LangOpts);



  // At O0 and O1 we only run the always inliner which is more efficient. At
@@ -1114,6 +1125,15 @@ void EmitAssemblyHelper::EmitAssemblyWithNewPassManager( 
    bool IsLTO = CodeGenOpts.PrepareForLTO;



    if (CodeGenOpts.OptimizationLevel == 0) {

      // If we reached here with a non-empty index file name, then the index

      // file was empty and we are not performing ThinLTO backend compilation

      // (used in testing in a distributed build environment). Drop any the type

      // test assume sequences inserted for whole program vtables so that

      // codegen doesn't complain.

      if (!CodeGenOpts.ThinLTOIndexFile.empty())

        MPM.addPass(LowerTypeTestsPass(/*ExportSummary=*/nullptr,

                                       /*ImportSummary=*/nullptr,

                                       /*DropTypeTests=*/true));

      if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts))

        MPM.addPass(GCOVProfilerPass(*Options));

      if (Optional<InstrProfOptions> Options =
@@ -1150,6 +1170,18 @@ void EmitAssemblyHelper::EmitAssemblyWithNewPassManager( 
      // configure the pipeline.

      PassBuilder::OptimizationLevel Level = mapToLevel(CodeGenOpts);



      // If we reached here with a non-empty index file name, then the index

      // file was empty and we are not performing ThinLTO backend compilation

      // (used in testing in a distributed build environment). Drop any the type

      // test assume sequences inserted for whole program vtables so that

      // codegen doesn't complain.

      if (!CodeGenOpts.ThinLTOIndexFile.empty())

        PB.registerPipelineStartEPCallback([](ModulePassManager &MPM) {

          MPM.addPass(LowerTypeTestsPass(/*ExportSummary=*/nullptr,

                                         /*ImportSummary=*/nullptr,

                                         /*DropTypeTests=*/true));

        });



      PB.registerPipelineStartEPCallback([](ModulePassManager &MPM) {

        MPM.addPass(createModuleToFunctionPassAdaptor(

            EntryExitInstrumenterPass(/*PostInlining=*/false)));

clang/lib/CodeGen/CGClass.cpp

+3 −1
Original line number Diff line number Diff line
@@ -2641,7 +2641,9 @@ void CodeGenFunction::EmitTypeMetadataCodeForVCall(const CXXRecordDecl *RD, 
  if (SanOpts.has(SanitizerKind::CFIVCall))

    EmitVTablePtrCheckForCall(RD, VTable, CodeGenFunction::CFITCK_VCall, Loc);

  else if (CGM.getCodeGenOpts().WholeProgramVTables &&

           CGM.HasHiddenLTOVisibility(RD)) {

           // Don't insert type test assumes if we are forcing public std

           // visibility.

           !CGM.HasLTOVisibilityPublicStd(RD)) {

    llvm::Metadata *MD =

        CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));

    llvm::Value *TypeId =

clang/lib/CodeGen/CGVTables.cpp

+21 −16
Original line number Diff line number Diff line
@@ -1011,23 +1011,10 @@ void CodeGenModule::EmitDeferredVTables() { 
  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>())

bool CodeGenModule::HasLTOVisibilityPublicStd(const CXXRecordDecl *RD) {

  if (!getCodeGenOpts().LTOVisibilityPublicStd)

    return false;



  if (getTriple().isOSBinFormatCOFF()) {

    if (RD->hasAttr<DLLExportAttr>() || RD->hasAttr<DLLImportAttr>())

      return false;

  } else {

    if (LV.getVisibility() != HiddenVisibility)

      return false;

  }



  if (getCodeGenOpts().LTOVisibilityPublicStd) {

  const DeclContext *DC = RD;

  while (1) {

    auto *D = cast<Decl>(DC);
@@ -1036,13 +1023,31 @@ bool CodeGenModule::HasHiddenLTOVisibility(const CXXRecordDecl *RD) { 
      if (auto *ND = dyn_cast<NamespaceDecl>(D))

        if (const IdentifierInfo *II = ND->getIdentifier())

          if (II->isStr("std") || II->isStr("stdext"))

              return false;

            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);

}



llvm::GlobalObject::VCallVisibility

clang/lib/CodeGen/CodeGenModule.h

+5 −0
Original line number Diff line number Diff line
@@ -1292,6 +1292,11 @@ public: 
  /// 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

clang/lib/CodeGen/ItaniumCXXABI.cpp

+10 −4
Original line number Diff line number Diff line
@@ -670,6 +670,10 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer( 
                            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);

  llvm::Value *VirtualFn = nullptr;



  {
@@ -677,8 +681,9 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer( 
    llvm::Value *TypeId = nullptr;

    llvm::Value *CheckResult = nullptr;



    if (ShouldEmitCFICheck || ShouldEmitVFEInfo) {

      // If doing CFI or VFE, we will need the metadata node to check against.

    if (ShouldEmitCFICheck || ShouldEmitVFEInfo || ShouldEmitWPDInfo) {

      // If doing CFI, VFE or WPD, we will need the metadata node to check

      // against.

      llvm::Metadata *MD =

          CGM.CreateMetadataIdentifierForVirtualMemPtrType(QualType(MPT, 0));

      TypeId = llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD);
@@ -702,7 +707,7 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer( 
    } else {

      // When not doing VFE, emit a normal load, as it allows more

      // optimisations than type.checked.load.

      if (ShouldEmitCFICheck) {

      if (ShouldEmitCFICheck || ShouldEmitWPDInfo) {

        CheckResult = Builder.CreateCall(

            CGM.getIntrinsic(llvm::Intrinsic::type_test),

            {Builder.CreateBitCast(VFPAddr, CGF.Int8PtrTy), TypeId});
@@ -713,7 +718,8 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer( 
                                            "memptr.virtualfn");

    }

    assert(VirtualFn && "Virtual fuction pointer not created!");

    assert((!ShouldEmitCFICheck || !ShouldEmitVFEInfo || CheckResult) &&

    assert((!ShouldEmitCFICheck || !ShouldEmitVFEInfo || !ShouldEmitWPDInfo ||

            CheckResult) &&

           "Check result required but not created!");



    if (ShouldEmitCFICheck) {