[PM] Port TargetLibraryInfo to the new pass manager, provided by the

TargetLibraryAnalysis pass.

There are actually no direct tests of this already in the tree. I've
added the most basic test that the pass manager bits themselves work,
and the TLI object produced will be tested by an upcoming patches as
they port passes which rely on TLI.

This is starting to point out the awkwardness of the invalidate API --
it seems poorly fitting on the *result* object. I suspect I will change
it to live on the analysis instead, but that's not for this change, and
I'd rather have a few more passes ported in order to have more
experience with how this plays out.

I believe there is only one more analysis required in order to start
porting instcombine. =]

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@226160 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/TargetLibraryInfo.h b/include/llvm/Analysis/TargetLibraryInfo.h
index 7e563c1e386d8acf000d90d4c575f8093ee5e3bc..ef7b7b4a388d358b0dd0c810286495399db90fb3 100644 (file)
--- a/include/llvm/Analysis/TargetLibraryInfo.h
+++ b/include/llvm/Analysis/TargetLibraryInfo.h
@@ -11,10 +11,14 @@
 #define LLVM_ANALYSIS_TARGETLIBRARYINFO_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
-  class Triple;
+class PreservedAnalyses;
 
   namespace LibFunc {
     enum Func {
@@ -718,7 +722,12 @@ class TargetLibraryInfo {
 public:
   TargetLibraryInfo();
   explicit TargetLibraryInfo(const Triple &T);
-  explicit TargetLibraryInfo(const TargetLibraryInfo &TLI);
+
+  // Provide value semantics.
+  TargetLibraryInfo(const TargetLibraryInfo &TLI);
+  TargetLibraryInfo(TargetLibraryInfo &&TLI);
+  TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI);
+  TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI);
 
   /// \brief Searches for a particular function name.
   ///
@@ -799,6 +808,66 @@ public:
   ///
   /// This can be used for options like -fno-builtin.
   void disableAllFunctions();
+
+  /// \brief Handle invalidation from the pass manager.
+  ///
+  /// If we try to invalidate this info, just return false. It cannot become
+  /// invalid even if the module changes.
+  bool invalidate(Module &, const PreservedAnalyses &) { return false; }
+};
+
+/// \brief Analysis pass providing the \c TargetLibraryInfo.
+///
+/// Note that this pass's result cannot be invalidated, it is immutable for the
+/// life of the module.
+class TargetLibraryAnalysis {
+public:
+  typedef TargetLibraryInfo Result;
+
+  /// \brief Opaque, unique identifier for this analysis pass.
+  static void *ID() { return (void *)&PassID; }
+
+  /// \brief Default construct the library analysis.
+  ///
+  /// This will use the module's triple to construct the library info for that
+  /// module.
+  TargetLibraryAnalysis() {}
+
+  /// \brief Construct a library analysis with preset info.
+  ///
+  /// This will directly copy the preset info into the result without
+  /// consulting the module's triple.
+  TargetLibraryAnalysis(TargetLibraryInfo PresetInfo)
+      : PresetInfo(std::move(PresetInfo)) {}
+
+  // Value semantics. We spell out the constructors for MSVC.
+  TargetLibraryAnalysis(const TargetLibraryAnalysis &Arg)
+      : PresetInfo(Arg.PresetInfo) {}
+  TargetLibraryAnalysis(TargetLibraryAnalysis &&Arg)
+      : PresetInfo(std::move(Arg.PresetInfo)) {}
+  TargetLibraryAnalysis &operator=(const TargetLibraryAnalysis &RHS) {
+    PresetInfo = RHS.PresetInfo;
+    return *this;
+  }
+  TargetLibraryAnalysis &operator=(TargetLibraryAnalysis &&RHS) {
+    PresetInfo = std::move(RHS.PresetInfo);
+    return *this;
+  }
+
+  TargetLibraryInfo run(Module &M) {
+    if (PresetInfo)
+      return *PresetInfo;
+
+    return TargetLibraryInfo(Triple(M.getTargetTriple()));
+  }
+
+  /// \brief Provide access to a name for this pass for debugging purposes.
+  static StringRef name() { return "TargetLibraryAnalysis"; }
+
+private:
+  static char PassID;
+
+  Optional<TargetLibraryInfo> PresetInfo;
 };
 
 class TargetLibraryInfoWrapperPass : public ImmutablePass {

diff --git a/lib/Analysis/TargetLibraryInfo.cpp b/lib/Analysis/TargetLibraryInfo.cpp
index 1b6ebfa09060e7a5c4d1a70d0e0af9db5857a79e..417f570bb6f68e294e47c6fc67cbfddb71f392fc 100644 (file)
--- a/lib/Analysis/TargetLibraryInfo.cpp
+++ b/lib/Analysis/TargetLibraryInfo.cpp
@@ -690,9 +690,28 @@ TargetLibraryInfo::TargetLibraryInfo(const Triple &T) {
   initialize(*this, T, StandardNames);
 }
 
-TargetLibraryInfo::TargetLibraryInfo(const TargetLibraryInfo &TLI) {
+TargetLibraryInfo::TargetLibraryInfo(const TargetLibraryInfo &TLI)
+    : CustomNames(TLI.CustomNames) {
   memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
+}
+
+TargetLibraryInfo::TargetLibraryInfo(TargetLibraryInfo &&TLI)
+    : CustomNames(std::move(TLI.CustomNames)) {
+  std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
+            AvailableArray);
+}
+
+TargetLibraryInfo &TargetLibraryInfo::operator=(const TargetLibraryInfo &TLI) {
   CustomNames = TLI.CustomNames;
+  memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
+  return *this;
+}
+
+TargetLibraryInfo &TargetLibraryInfo::operator=(TargetLibraryInfo &&TLI) {
+  CustomNames = std::move(TLI.CustomNames);
+  std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
+            AvailableArray);
+  return *this;
 }
 
 namespace {
@@ -756,6 +775,8 @@ TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass(
   initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
+char TargetLibraryAnalysis::PassID;
+
 // Register the basic pass.
 INITIALIZE_PASS(TargetLibraryInfoWrapperPass, "targetlibinfo",
                 "Target Library Information", false, true)

diff --git a/test/Other/new-pass-manager.ll b/test/Other/new-pass-manager.ll
index 6454ffc1fb099c068ff5de6a8970cb0e41c5dac0..2cb54ba49a80e9ffc2ac440f9493f60fdbedee3a 100644 (file)
--- a/test/Other/new-pass-manager.ll
+++ b/test/Other/new-pass-manager.ll
@@ -266,6 +266,18 @@
 ; CHECK-INVALIDATE-ALL-CG-NOT: Running analysis: NoOpModuleAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Finished pass manager
 
+; RUN: opt -disable-output -disable-verify -debug-pass-manager %s 2>&1 \
+; RUN:     -passes='require<targetlibinfo>,invalidate<all>,require<targetlibinfo>' \
+; RUN:     | FileCheck %s --check-prefix=CHECK-TLI
+; CHECK-TLI: Starting pass manager
+; CHECK-TLI: Running pass: RequireAnalysisPass
+; CHECK-TLI: Running analysis: TargetLibraryAnalysis
+; CHECK-TLI: Running pass: InvalidateAllAnalysesPass
+; CHECK-TLI-NOT: Invalidating analysis: TargetLibraryAnalysis
+; CHECK-TLI: Running pass: RequireAnalysisPass
+; CHECK-TLI-NOT: Running analysis: TargetLibraryAnalysis
+; CHECK-TLI: Finished pass manager
+
 define void @foo() {
   ret void
 }

diff --git a/tools/opt/PassRegistry.def b/tools/opt/PassRegistry.def
index c98de60b5706826c5bfa162ac5acd58b2c4a8653..411ca0f02d8adae0cd45db539359870d06fa5d56 100644 (file)
--- a/tools/opt/PassRegistry.def
+++ b/tools/opt/PassRegistry.def
@@ -21,6 +21,7 @@
 #endif
 MODULE_ANALYSIS("lcg", LazyCallGraphAnalysis())
 MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis())
+MODULE_ANALYSIS("targetlibinfo", TargetLibraryAnalysis())
 #undef MODULE_ANALYSIS
 
 #ifndef MODULE_PASS

diff --git a/tools/opt/Passes.cpp b/tools/opt/Passes.cpp
index 518112a1c88c05475bf6f0fd853c88f3ec3f417d..1af4d52b8700d9d26832cbf44388a8e0e3cdc937 100644 (file)
--- a/tools/opt/Passes.cpp
+++ b/tools/opt/Passes.cpp
@@ -17,6 +17,7 @@
 #include "Passes.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/PassManager.h"