Revert "CodeGen: Add LibcallLoweringInfo analysis pass (llvm#168622)"

This reverts commit 04c81a9.

Author: bangtianliu

clang/lib/CodeGen/BackendUtil.cpp

@@ -19,7 +19,6 @@
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Analysis/GlobalsModRef.h"
-#include "llvm/Analysis/RuntimeLibcallInfo.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeReader.h"
@@ -656,11 +655,6 @@ bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
       llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));
   CodeGenPasses.add(new TargetLibraryInfoWrapperPass(*TLII));
 
-  const llvm::TargetOptions &Options = TM->Options;
-  CodeGenPasses.add(new RuntimeLibraryInfoWrapper(
-      TargetTriple, Options.ExceptionModel, Options.FloatABIType,
-      Options.EABIVersion, Options.MCOptions.ABIName, Options.VecLib));
-
   // Normal mode, emit a .s or .o file by running the code generator. Note,
   // this also adds codegenerator level optimization passes.
   CodeGenFileType CGFT = getCodeGenFileType(Action);

llvm/include/llvm/Analysis/RuntimeLibcallInfo.h

@@ -22,12 +22,7 @@ class LLVM_ABI RuntimeLibraryAnalysis
   RuntimeLibraryAnalysis() = default;
   RuntimeLibraryAnalysis(RTLIB::RuntimeLibcallsInfo &&BaselineInfoImpl)
       : LibcallsInfo(std::move(BaselineInfoImpl)) {}
-  RuntimeLibraryAnalysis(
-      const Triple &TT,
-      ExceptionHandling ExceptionModel = ExceptionHandling::None,
-      FloatABI::ABIType FloatABI = FloatABI::Default,
-      EABI EABIVersion = EABI::Default, StringRef ABIName = "",
-      VectorLibrary VecLib = VectorLibrary::NoLibrary);
+  explicit RuntimeLibraryAnalysis(const Triple &T) : LibcallsInfo(T) {}
 
   RTLIB::RuntimeLibcallsInfo run(const Module &M, ModuleAnalysisManager &);
 
@@ -45,19 +40,12 @@ class LLVM_ABI RuntimeLibraryInfoWrapper : public ImmutablePass {
 public:
   static char ID;
   RuntimeLibraryInfoWrapper();
-  RuntimeLibraryInfoWrapper(
-      const Triple &TT,
-      ExceptionHandling ExceptionModel = ExceptionHandling::None,
-      FloatABI::ABIType FloatABI = FloatABI::Default,
-      EABI EABIVersion = EABI::Default, StringRef ABIName = "",
-      VectorLibrary VecLib = VectorLibrary::NoLibrary);
+  explicit RuntimeLibraryInfoWrapper(const Triple &T);
+  explicit RuntimeLibraryInfoWrapper(const RTLIB::RuntimeLibcallsInfo &RTLCI);
 
   const RTLIB::RuntimeLibcallsInfo &getRTLCI(const Module &M) {
-    if (!RTLCI) {
-      ModuleAnalysisManager DummyMAM;
-      RTLCI = RTLA.run(M, DummyMAM);
-    }
-
+    ModuleAnalysisManager DummyMAM;
+    RTLCI = RTLA.run(M, DummyMAM);
     return *RTLCI;
   }
 

llvm/include/llvm/CodeGen/LibcallLoweringInfo.h

@@ -9,16 +9,12 @@
 #ifndef LLVM_CODEGEN_LIBCALLLOWERINGINFO_H
 #define LLVM_CODEGEN_LIBCALLLOWERINGINFO_H
 
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/RuntimeLibcalls.h"
-#include "llvm/Pass.h"
 
 namespace llvm {
 
 class TargetSubtargetInfo;
-class TargetMachine;
 
-/// Tracks which library functions to use for a particular subtarget.
 class LibcallLoweringInfo {
 private:
   const RTLIB::RuntimeLibcallsInfo &RTLCI;
@@ -77,70 +73,6 @@ class LibcallLoweringInfo {
   }
 };
 
-/// Record a mapping from subtarget to LibcallLoweringInfo.
-class LibcallLoweringModuleAnalysisResult {
-private:
-  using LibcallLoweringMap =
-      DenseMap<const TargetSubtargetInfo *, LibcallLoweringInfo>;
-  mutable LibcallLoweringMap LoweringMap;
-  const RTLIB::RuntimeLibcallsInfo *RTLCI = nullptr;
-
-public:
-  LibcallLoweringModuleAnalysisResult() = default;
-  LibcallLoweringModuleAnalysisResult(RTLIB::RuntimeLibcallsInfo &RTLCI)
-      : RTLCI(&RTLCI) {}
-
-  void init(const RTLIB::RuntimeLibcallsInfo *RT) { RTLCI = RT; }
-
-  void clear() {
-    RTLCI = nullptr;
-    LoweringMap.clear();
-  }
-
-  LLVM_ABI bool invalidate(Module &, const PreservedAnalyses &,
-                           ModuleAnalysisManager::Invalidator &);
-
-  const LibcallLoweringInfo &
-  getLibcallLowering(const TargetSubtargetInfo &Subtarget) const {
-    return LoweringMap.try_emplace(&Subtarget, *RTLCI, Subtarget).first->second;
-  }
-};
-
-class LibcallLoweringModuleAnalysis
-    : public AnalysisInfoMixin<LibcallLoweringModuleAnalysis> {
-private:
-  friend AnalysisInfoMixin<LibcallLoweringModuleAnalysis>;
-  static AnalysisKey Key;
-
-  LibcallLoweringModuleAnalysisResult LibcallLoweringMap;
-
-public:
-  using Result = LibcallLoweringModuleAnalysisResult;
-
-  LLVM_ABI Result run(Module &M, ModuleAnalysisManager &);
-};
-
-class LLVM_ABI LibcallLoweringInfoWrapper : public ImmutablePass {
-  LibcallLoweringModuleAnalysisResult Result;
-
-public:
-  static char ID;
-  LibcallLoweringInfoWrapper();
-
-  const LibcallLoweringInfo &
-  getLibcallLowering(const TargetSubtargetInfo &Subtarget) const {
-    return Result.getLibcallLowering(Subtarget);
-  }
-
-  const LibcallLoweringModuleAnalysisResult &getResult() const {
-    return Result;
-  }
-
-  bool doInitialization(Module &M) override;
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
-  void releaseMemory() override;
-};
-
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_LIBCALLLOWERINGINFO_H

llvm/include/llvm/InitializePasses.h

@@ -134,7 +134,6 @@ LLVM_ABI void initializeGlobalMergeFuncPassWrapperPass(PassRegistry &);
 LLVM_ABI void initializeGlobalMergePass(PassRegistry &);
 LLVM_ABI void initializeGlobalsAAWrapperPassPass(PassRegistry &);
 LLVM_ABI void initializeHardwareLoopsLegacyPass(PassRegistry &);
-LLVM_ABI void initializeLibcallLoweringInfoWrapperPass(PassRegistry &);
 LLVM_ABI void initializeMIRProfileLoaderPassPass(PassRegistry &);
 LLVM_ABI void initializeIRSimilarityIdentifierWrapperPassPass(PassRegistry &);
 LLVM_ABI void initializeIRTranslatorPass(PassRegistry &);

llvm/lib/Analysis/RuntimeLibcallInfo.cpp

@@ -13,15 +13,6 @@ using namespace llvm;
 
 AnalysisKey RuntimeLibraryAnalysis::Key;
 
-RuntimeLibraryAnalysis::RuntimeLibraryAnalysis(const Triple &TT,
-                                               ExceptionHandling ExceptionModel,
-                                               FloatABI::ABIType FloatABI,
-                                               EABI EABIVersion,
-                                               StringRef ABIName,
-                                               VectorLibrary VecLib)
-    : LibcallsInfo(std::in_place, TT, ExceptionModel, FloatABI, EABIVersion,
-                   ABIName, VecLib) {}
-
 RTLIB::RuntimeLibcallsInfo
 RuntimeLibraryAnalysis::run(const Module &M, ModuleAnalysisManager &) {
   if (!LibcallsInfo)
@@ -35,13 +26,6 @@ INITIALIZE_PASS(RuntimeLibraryInfoWrapper, "runtime-library-info",
 RuntimeLibraryInfoWrapper::RuntimeLibraryInfoWrapper()
     : ImmutablePass(ID), RTLA(RTLIB::RuntimeLibcallsInfo(Triple())) {}
 
-RuntimeLibraryInfoWrapper::RuntimeLibraryInfoWrapper(
-    const Triple &TT, ExceptionHandling ExceptionModel,
-    FloatABI::ABIType FloatABI, EABI EABIVersion, StringRef ABIName,
-    VectorLibrary VecLib)
-    : ImmutablePass(ID), RTLCI(std::in_place, TT, ExceptionModel, FloatABI,
-                               EABIVersion, ABIName, VecLib) {}
-
 char RuntimeLibraryInfoWrapper::ID = 0;
 
 ModulePass *llvm::createRuntimeLibraryInfoWrapperPass() {

llvm/lib/CodeGen/CodeGen.cpp

@@ -57,7 +57,6 @@ void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeInterleavedLoadCombinePass(Registry);
   initializeInterleavedAccessPass(Registry);
   initializeJMCInstrumenterPass(Registry);
-  initializeLibcallLoweringInfoWrapperPass(Registry);
   initializeLiveDebugValuesLegacyPass(Registry);
   initializeLiveDebugVariablesWrapperLegacyPass(Registry);
   initializeLiveIntervalsWrapperPassPass(Registry);

llvm/lib/CodeGen/ExpandFp.cpp

@@ -975,12 +975,11 @@ static RTLIB::Libcall fremToLibcall(Type *Ty) {
 /* Return true if, according to \p LibInfo, the target either directly
    supports the frem instruction for the \p Ty, has a custom lowering,
    or uses a libcall. */
-static bool targetSupportsFrem(const TargetLowering &TLI,
-                               const LibcallLoweringInfo &Libcalls, Type *Ty) {
+static bool targetSupportsFrem(const TargetLowering &TLI, Type *Ty) {
   if (!TLI.isOperationExpand(ISD::FREM, EVT::getEVT(Ty)))
     return true;
 
-  return Libcalls.getLibcallName(fremToLibcall(Ty->getScalarType()));
+  return TLI.getLibcallName(fremToLibcall(Ty->getScalarType()));
 }
 
 static void addToWorklist(Instruction &I,
@@ -992,7 +991,7 @@ static void addToWorklist(Instruction &I,
 }
 
 static bool runImpl(Function &F, const TargetLowering &TLI,
-                    const LibcallLoweringInfo &Libcalls, AssumptionCache *AC) {
+                    AssumptionCache *AC) {
   SmallVector<Instruction *, 4> Worklist;
 
   unsigned MaxLegalFpConvertBitWidth =
@@ -1011,7 +1010,7 @@ static bool runImpl(Function &F, const TargetLowering &TLI,
 
     switch (I.getOpcode()) {
     case Instruction::FRem:
-      return !targetSupportsFrem(TLI, Libcalls, Ty) &&
+      return !targetSupportsFrem(TLI, Ty) &&
              FRemExpander::canExpandType(Ty->getScalarType());
 
     case Instruction::FPToUI:
@@ -1091,27 +1090,20 @@ class ExpandFpLegacyPass : public FunctionPass {
 
   bool runOnFunction(Function &F) override {
     auto *TM = &getAnalysis<TargetPassConfig>().getTM<TargetMachine>();
-    const TargetSubtargetInfo *Subtarget = TM->getSubtargetImpl(F);
-    auto *TLI = Subtarget->getTargetLowering();
+    auto *TLI = TM->getSubtargetImpl(F)->getTargetLowering();
     AssumptionCache *AC = nullptr;
 
-    const LibcallLoweringInfo &Libcalls =
-        getAnalysis<LibcallLoweringInfoWrapper>().getLibcallLowering(
-            *Subtarget);
-
     if (OptLevel != CodeGenOptLevel::None && !F.hasOptNone())
       AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
-    return runImpl(F, *TLI, Libcalls, AC);
+    return runImpl(F, *TLI, AC);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequired<LibcallLoweringInfoWrapper>();
     AU.addRequired<TargetPassConfig>();
     if (OptLevel != CodeGenOptLevel::None)
       AU.addRequired<AssumptionCacheTracker>();
     AU.addPreserved<AAResultsWrapperPass>();
     AU.addPreserved<GlobalsAAWrapperPass>();
-    AU.addRequired<LibcallLoweringInfoWrapper>();
   }
 };
 } // namespace
@@ -1134,29 +1126,13 @@ PreservedAnalyses ExpandFpPass::run(Function &F, FunctionAnalysisManager &FAM) {
   AssumptionCache *AC = nullptr;
   if (OptLevel != CodeGenOptLevel::None)
     AC = &FAM.getResult<AssumptionAnalysis>(F);
-
-  auto &MAMProxy = FAM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
-
-  const LibcallLoweringModuleAnalysisResult *LibcallLowering =
-      MAMProxy.getCachedResult<LibcallLoweringModuleAnalysis>(*F.getParent());
-
-  if (!LibcallLowering) {
-    F.getContext().emitError("'" + LibcallLoweringModuleAnalysis::name() +
-                             "' analysis required");
-    return PreservedAnalyses::all();
-  }
-
-  const LibcallLoweringInfo &Libcalls =
-      LibcallLowering->getLibcallLowering(*STI);
-
-  return runImpl(F, TLI, Libcalls, AC) ? PreservedAnalyses::none()
-                                       : PreservedAnalyses::all();
+  return runImpl(F, TLI, AC) ? PreservedAnalyses::none()
+                             : PreservedAnalyses::all();
 }
 
 char ExpandFpLegacyPass::ID = 0;
 INITIALIZE_PASS_BEGIN(ExpandFpLegacyPass, "expand-fp",
                       "Expand certain fp instructions", false, false)
-INITIALIZE_PASS_DEPENDENCY(LibcallLoweringInfoWrapper)
 INITIALIZE_PASS_END(ExpandFpLegacyPass, "expand-fp", "Expand fp", false, false)
 
 FunctionPass *llvm::createExpandFpPass(CodeGenOptLevel OptLevel) {

llvm/lib/CodeGen/LibcallLoweringInfo.cpp

@@ -7,10 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/LibcallLoweringInfo.h"
-#include "llvm/Analysis/RuntimeLibcallInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/Target/TargetMachine.h"
 
 using namespace llvm;
 
@@ -31,42 +28,3 @@ LibcallLoweringInfo::LibcallLoweringInfo(
 
   Subtarget.initLibcallLoweringInfo(*this);
 }
-
-AnalysisKey LibcallLoweringModuleAnalysis::Key;
-
-bool LibcallLoweringModuleAnalysisResult::invalidate(
-    Module &, const PreservedAnalyses &PA,
-    ModuleAnalysisManager::Invalidator &) {
-  // Passes that change the runtime libcall set must explicitly invalidate this
-  // pass.
-  auto PAC = PA.getChecker<LibcallLoweringModuleAnalysis>();
-  return !PAC.preservedWhenStateless();
-}
-
-LibcallLoweringModuleAnalysisResult
-LibcallLoweringModuleAnalysis::run(Module &M, ModuleAnalysisManager &MAM) {
-  LibcallLoweringMap.init(&MAM.getResult<RuntimeLibraryAnalysis>(M));
-  return LibcallLoweringMap;
-}
-
-INITIALIZE_PASS_BEGIN(LibcallLoweringInfoWrapper, "libcall-lowering-info",
-                      "Library Function Lowering Analysis", false, true)
-INITIALIZE_PASS_DEPENDENCY(RuntimeLibraryInfoWrapper)
-INITIALIZE_PASS_END(LibcallLoweringInfoWrapper, "libcall-lowering-info",
-                    "Library Function Lowering Analysis", false, true)
-
-char LibcallLoweringInfoWrapper::ID = 0;
-
-LibcallLoweringInfoWrapper::LibcallLoweringInfoWrapper() : ImmutablePass(ID) {}
-
-bool LibcallLoweringInfoWrapper::doInitialization(Module &M) {
-  Result.init(&getAnalysis<RuntimeLibraryInfoWrapper>().getRTLCI(M));
-  return false;
-}
-
-void LibcallLoweringInfoWrapper::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addRequired<RuntimeLibraryInfoWrapper>();
-  AU.setPreservesAll();
-}
-
-void LibcallLoweringInfoWrapper::releaseMemory() { Result.clear(); }