[PM] Enable registration of out-of-tree or plugin passes

[philip.pfaffe]

Summary

The PassBuilder used for creating pass pipelines for the new pass manager currently doesn't support out-of-tree passes or passes in plugins. This patch adds a mechanism for registering such passes, enabling them inside the PassBuilder.

Registration is done by installing Hooks, managed in a name -> hook map. Such a hook is a callable which, when invoked, gets passed an AnalysisManager or PassManager instance which the external pass can insert itself into. When parsing a pass pipeline, PassBuilder will first consult the list of installed hooks before it looks at the builtin passes. This way, external passes are able to steal the name of a builtin pass.

The HookManager, which manages the name->hook mapping, offers interfaces for registering, querying and invoking installed hooks. I maintain three global instances of it (one for each IRUnit type), accessible through a getGlobalHookManager() function. Moreover, the patch contains convenience types which abbreviate the default way to register passes a bit.

Unittest attached.

[hfinkel]

PassBuilder will first consult the list of installed hooks before it looks at the builtin passes. This way, external passes are able to steal the name of a builtin pass.

Does the original pass still run? Why not give the hook the ability to insert a new pass somewhere into the pipeline (perhaps by being able to examine the current pipeline configuration and modifying it)?

[philip.pfaffe]

Does the original pass still run?

Not in this case, no. That way, you can actively override a built-in pass.

Why not give the hook the ability to insert a new pass somewhere into the pipeline (perhaps by being able to examine the current pipeline configuration and modifying it)?

I think that would mix different responsibilities. It is the PassBuilder's task to construct the pipeline from its textual description, and I as a user would expect the pipeline to afterwards consist of precisely the passes I specified, and in that order. I think a pass should not be able to take this away from the PassBuilder and modify the pipeline setup externally (of course besides adding itself to the PassManager on request).

[hfinkel]

In D11032#202708, @philip.pfaffe wrote:

Does the original pass still run?

Not in this case, no. That way, you can actively override a built-in pass.

Why not give the hook the ability to insert a new pass somewhere into the pipeline (perhaps by being able to examine the current pipeline configuration and modifying it)?

I think that would mix different responsibilities. It is the PassBuilder's task to construct the pipeline from its textual description, and I as a user would expect the pipeline to afterwards consist of precisely the passes I specified, and in that order. I think a pass should not be able to take this away from the PassBuilder and modify the pipeline setup externally (of course besides adding itself to the PassManager on request).

I don't understand how you intend for this to be used. If I wanted to add a new pass that would run after InstCombine, for example, how would I do that? How about adding a pass to be run at the very end of the pass manager, or at the very beginning?

[philip.pfaffe]

I don't understand how you intend for this to be used. If I wanted to add a new pass that would run after InstCombine, for example, how would I do that? How about adding a pass to be run at the very end of the pass manager, or at the very beginning?

Currently, this is primarily a supplement to PassBuilder. So pass scheduling is done as it always was. In your example: "module(my-awesome-pass,instcombine)". Now, PassBuilder will first invoke the registered Hook for my-awesome-pass (which will in turn add the pass to the PassManager), and subsequently put instcombine into the PassManager.

This is not limited to PassBuilder though. Any other entity setting up PassManagers may do the same.

[philip.pfaffe]

Rebased and applied latest changes to the Pass Manager infrastructure and to PassBuilder, including AA and Loop Managers.

Also reworked the testcase a bit.

[philip.pfaffe]

Ping.

I'm aware that this patch has rotted a bit doesn't apply cleanly currently due to a few upstream API changes. Will update!

[philip.pfaffe]

Un-bitrot the patch.

[philip.pfaffe]

Redesign the HookManager to incorporate extension points. The basic idea is to maintain tables of hooks for the different places the PassBuilder will want to run them, for instance for different IRUnits when parsing textual pipeline descriptions, or the individual extension points. The places are identified by Tags, which need to be specified when registering a hook. The individual tags are either the respective IRUnit, for pipeline parsing, or an extension point. Extension points define certain positions in the various optimizer/LTO/PGO pipelines.

I've tried to match the extension points as closely as possible to the legacy PassManagerBuilder, but I'm not sure I succeeded. Most importantly in the context of the function simplification, the pipelines have changed a little bit, and I wasn't able to identify all the correct spots: At PassManagerBuilder::addFunctionSimplificationPasses, vectorizer passes are added to the PassManager, which isn't reflected in PassBuilder right now. There are hence 2 instances of the Peephole extension point missing.

[philip.pfaffe]

An additional modification I made is adding a reference to a HookManager instance to PassBuilder objects. They now default to using a global, singleton HM instance, but may also be constructed with a given existing HM object.

[philip.pfaffe]

Superseded by r307532.

include/llvm/Passes/PassBuilder.h

 /// configurations, and parsing of pass pipelines.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PASSES_PASSBUILDER_H
 #define LLVM_PASSES_PASSBUILDER_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/LoopPassManager.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 class AAManager;
 class TargetMachine;
 
private:
   bool parseFunctionPassPipeline(FunctionPassManager &FPM,
                                  StringRef &PipelineText, bool VerifyEachPass,
                                  bool DebugLogging);
   bool parseCGSCCPassPipeline(CGSCCPassManager &CGPM, StringRef &PipelineText,
                               bool VerifyEachPass, bool DebugLogging);
   bool parseModulePassPipeline(ModulePassManager &MPM, StringRef &PipelineText,
                                bool VerifyEachPass, bool DebugLogging);
 };
+
+/// \brief This class manages the registration of hooks through which
+/// out-of-tree or plugin passes are able to register themselves with a
+/// \c PassManager or \c AnalysisManager.
+///
+/// Such a hook is a Callable with a single argument, the Pass- or
+/// AnalysisManager which passes can be added to. Hooks are registered with the
+/// manager by name, which is the name used in the pass pipeline text. If the
+/// name matches a name of a built-in pass, this name is effectively "stolen",
+/// thus overriding the built-in pass.
+///
+/// To install a hook in an instance of this class, interfaces are supplied
+/// to handle analysis, transform and AA passes, respectively. Installing a hook
+/// for an analysis pass also automatically generates default hooks for the
+/// require<> and invalidate<> utility passes.
+template <typename IRUnitT> class HookManager {
+public:
+  typedef std::function<void(AnalysisManager<IRUnitT> &)> AnalysisPassHook;
+  typedef std::function<void(PassManager<IRUnitT> &)> TransformPassHook;
+  typedef std::function<void(AAManager &)> AAPassHook;
+
+  /// \brief Register a hook for a transform pass.
+  ///
+  /// If a hook has already been registered with the same Name, this hook is
+  /// overwritten.
+  void registerTransformPassHook(StringRef Name, TransformPassHook H) {
+    transformHooks.insert({Name, H});
+  }
+
+  /// \brief Register a hook for an analysis pass.
+  ///
+  /// Besides the pass Name, this interface also takes the Pass type as template
+  /// argument, used to install default hooks for the require<> and invalidate<>
+  /// utilities.
+  /// If a hook has already been registered with the same Name, the
+  /// utilitypasses for that name are overwritten.
+  template <typename PassT>
+  void registerAnalysisPassHook(StringRef Name, AnalysisPassHook H) {
+    analysisHooks.push_back(H);
+    requireUtilityHooks.insert({Name, [](PassManager<IRUnitT> &) {
+                                  return RequireAnalysisPass<PassT>();
+                                }});
+    invalidateUtilityHooks.insert({Name, [](PassManager<IRUnitT> &) {
+                                     return InvalidateAnalysisPass<PassT>();
+                                   }});
+  }
+
+  /// \brief Register a hook for an alias analysis pass.
+  ///
+  /// If a hook has already been registered with the same Name, this hook is
+  /// overwritten.
+  void registerAAPassHook(StringRef Name, AAPassHook H) {
+    AAHooks.insert({Name, H});
+  }
+
+  //@{
+  /// Public interface for the \c PassBuilder to query or invoke registered
+  /// hooks.
+  void registerAnalyses(AnalysisManager<IRUnitT> &AM) {
+    for (auto &H : analysisHooks)
+      H(AM);
+  }
+
+  inline StringRef getRequireUtilityName(StringRef Name) {
+    if (Name.endswith(">") && Name.startswith("require<"))
+      return Name.slice(8, Name.size() - 1);
+    return StringRef();
   }
 
+  inline StringRef getInvalidateUtilityName(StringRef Name) {
+    if (Name.endswith(">") && Name.startswith("invalidate<"))
+      return Name.slice(11, Name.size() - 1);
+    return StringRef();
+  }
+
+  bool hasPassName(StringRef Name) {
+    if (transformHooks.count(Name) > 0)
+      return true;
+    StringRef slice = getRequireUtilityName(Name);
+    if (!slice.empty())
+      if (requireUtilityHooks.count(slice))
+        return true;
+    slice = getInvalidateUtilityName(Name);
+    if (!slice.empty())
+      if (invalidateUtilityHooks.count(slice))
+        return true;
+    return false;
+  }
+
+  bool parsePassName(StringRef Name, PassManager<IRUnitT> &PM) {
+    if (transformHooks.count(Name) > 0) {
+      transformHooks[Name](PM);
+      return true;
+    }
+    StringRef slice = getRequireUtilityName(Name);
+    if (!slice.empty()) {
+      if (requireUtilityHooks.count(slice)) {
+        requireUtilityHooks[slice](PM);
+        return true;
+      }
+    }
+    slice = getInvalidateUtilityName(Name);
+    if (!slice.empty()) {
+      if (invalidateUtilityHooks.count(slice)) {
+        invalidateUtilityHooks[slice](PM);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool parseAAPassName(StringRef Name, AAManager &AA) {
+    if (!transformHooks.count(Name))
+      return false;
+    AAHooks[Name](AA);
+    return true;
+  }
+  //@}
+private:
+  std::vector<AnalysisPassHook> analysisHooks;
+  StringMap<TransformPassHook> transformHooks;
+  StringMap<TransformPassHook> requireUtilityHooks;
+  StringMap<TransformPassHook> invalidateUtilityHooks;
+  StringMap<AAPassHook> AAHooks;
+};
+
+/// \brief Return the global hook manager for this IRUnit type.
+template <typename IRUnitT> extern HookManager<IRUnitT> &getGlobalHookManager();
+//{@
+/// \brief Convenience types to install the hooks for a pass. Constructing an
+/// instance of this will perform the registration of a hook with the given
+/// arguments.
+template <typename IRUnitT, typename PassT> struct RegisterAnalysisPassHook {
+  RegisterAnalysisPassHook(
+      StringRef Name, typename HookManager<IRUnitT>::AnalysisPassHook Hook) {
+    getGlobalHookManager<IRUnitT>().template registerAnalysisPassHook<PassT>(
+        Name, Hook);
+  }
+};
+
+template <typename IRUnitT> struct RegisterTransformPassHook {
+  RegisterTransformPassHook(
+      StringRef Name, typename HookManager<IRUnitT>::TransformPassHook Hook) {
+    getGlobalHookManager<IRUnitT>().registerTransformPassHook(Name, Hook);
+  }
+};
+
+template <typename PassT> struct RegisterAAPassHook {
+  RegisterAAPassHook(StringRef Name,
+                     typename HookManager<Function>::AnalysisPassHook Hook,
+                     typename HookManager<Function>::AAPassHook AAHook) {
+    getGlobalHookManager<Function>().template registerAnalysisPassHook<PassT>(
+        Name, Hook);
+    getGlobalHookManager<Function>().registerAAPassHook(Name, AAHook);
+  }
+};
+
+template <typename IRUnitT, typename PassT>
+struct RegisterAnalysisPass : RegisterAnalysisPassHook<IRUnitT, PassT> {
+  struct Hook {
+    void operator()(AnalysisManager<IRUnitT> &AM) {
+      AM.registerPass([] { return PassT(); });
+    }
+  };
+  RegisterAnalysisPass(StringRef Name)
+      : RegisterAnalysisPassHook<IRUnitT, PassT>(Name, Hook()) {}
+};
+
+template <typename IRUnitT, typename PassT>
+struct RegisterTransformPass : RegisterTransformPassHook<IRUnitT> {
+  struct Hook {
+    void operator()(PassManager<IRUnitT> &PM) { PM.addPass(PassT()); }
+  };
+  RegisterTransformPass(StringRef Name)
+      : RegisterTransformPassHook<IRUnitT>(Name, Hook()) {}
+};
+
+template <typename PassT> struct RegisterAAPass : RegisterAAPassHook<PassT> {
+  struct Hook {
+    void operator()(AnalysisManager<Function> &AM) {
+      AM.registerPass([] { return PassT(); });
+    }
+    void operator()(AAManager &AA) { AA.registerFunctionAnalysis<PassT>(); }
+  };
+  RegisterAAPass(StringRef Name)
+      : RegisterAAPassHook<PassT>(Name, Hook(), Hook()) {}
+};
+//@}
+}
 #endif

lib/Passes/PassBuilder.cpp

 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/IPO/InferFunctionAttrs.h"
 #include "llvm/Transforms/IPO/StripDeadPrototypes.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
 #include "llvm/Transforms/Scalar/ADCE.h"

 
 char NoOpModuleAnalysis::PassID;
 char NoOpCGSCCAnalysis::PassID;
 char NoOpFunctionAnalysis::PassID;
 char NoOpLoopAnalysis::PassID;
 
 } // End anonymous namespace.
 
+//@{
+/// Global instances of HookManager for various IRUnit types.
+static ManagedStatic<HookManager<Module>> ModuleHookManager;
+static ManagedStatic<HookManager<LazyCallGraph::SCC>> CGSCCHookManager;
+static ManagedStatic<HookManager<Function>> FunctionHookManager;
+static ManagedStatic<HookManager<Loop>> LoopHookManager;
+//@}
+
+//@{
+/// Getters for global HookManager instances
+namespace llvm {
+template <> HookManager<Module> &getGlobalHookManager() {
+  return *ModuleHookManager;
+}
+template <> HookManager<LazyCallGraph::SCC> &getGlobalHookManager() {
+  return *CGSCCHookManager;
+}
+template <> HookManager<Function> &getGlobalHookManager() {
+  return *FunctionHookManager;
+}
+template <> HookManager<Loop> &getGlobalHookManager() {
+  return *LoopHookManager;
+}
+}
+//@}
+
 void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) {
+  getGlobalHookManager<Module>().registerAnalyses(MAM);
+
 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \
   MAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 }
 
 void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) {
+  getGlobalHookManager<LazyCallGraph::SCC>().registerAnalyses(CGAM);
+
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
   CGAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 }
 
 void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) {
+  getGlobalHookManager<Function>().registerAnalyses(FAM);
+
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
   FAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 }
 
 void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) {
+  getGlobalHookManager<Loop>().registerAnalyses(LAM);
+
 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \
   LAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 }
 
 void PassBuilder::addPerModuleDefaultPipeline(ModulePassManager &MPM,
                                               OptimizationLevel Level,
                                               bool DebugLogging) {

 }
 
 #ifndef NDEBUG
 static bool isModulePassName(StringRef Name) {
   // Manually handle aliases for pre-configured pipeline fragments.
   if (Name.startswith("default") || Name.startswith("lto"))
     return DefaultAliasRegex.match(Name);
 
+  if (getGlobalHookManager<Module>().hasPassName(Name))
+    return true;
+
 #define MODULE_PASS(NAME, CREATE_PASS) if (Name == NAME) return true;
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return false;
 }
 #endif
 
 static bool isCGSCCPassName(StringRef Name) {
+  if (getGlobalHookManager<LazyCallGraph::SCC>().hasPassName(Name))
+    return true;
+
 #define CGSCC_PASS(NAME, CREATE_PASS) if (Name == NAME) return true;
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)                                      \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return false;
 }
 
 static bool isFunctionPassName(StringRef Name) {
+  if (getGlobalHookManager<Function>().hasPassName(Name))
+    return true;
+
 #define FUNCTION_PASS(NAME, CREATE_PASS) if (Name == NAME) return true;
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return false;
 }
 
 static bool isLoopPassName(StringRef Name) {
+  if (getGlobalHookManager<Loop>().hasPassName(Name))
+    return true;
+
 #define LOOP_PASS(NAME, CREATE_PASS) if (Name == NAME) return true;
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
   if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
     return true;
 #include "PassRegistry.def"
 
   return false;
 }
if (Matches[1] == "default") {
       addLTOPreLinkDefaultPipeline(MPM, L, DebugLogging);
     } else {
       assert(Matches[1] == "lto" && "Not one of the matched options!");
       addLTODefaultPipeline(MPM, L, DebugLogging);
     }
     return true;
   }
 
+  if (getGlobalHookManager<Module>().parsePassName(Name, MPM))
+    return true;
+
 #define MODULE_PASS(NAME, CREATE_PASS)                                         \
   if (Name == NAME) {                                                          \
     MPM.addPass(CREATE_PASS);                                                  \
     return true;                                                               \
   }
 #define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
   if (Name == "require<" NAME ">") {                                           \
     MPM.addPass(RequireAnalysisPass<                                           \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return true;                                                               \
   }                                                                            \
   if (Name == "invalidate<" NAME ">") {                                        \
     MPM.addPass(InvalidateAnalysisPass<                                        \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return true;                                                               \
   }
 #include "PassRegistry.def"
 
   return false;
 }
 
 bool PassBuilder::parseCGSCCPassName(CGSCCPassManager &CGPM, StringRef Name) {
+  if (getGlobalHookManager<LazyCallGraph::SCC>().parsePassName(Name, CGPM))
+    return true;
+
 #define CGSCC_PASS(NAME, CREATE_PASS)                                          \
   if (Name == NAME) {                                                          \
     CGPM.addPass(CREATE_PASS);                                                 \
     return true;                                                               \
   }
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)                                      \
   if (Name == "require<" NAME ">") {                                           \
     CGPM.addPass(RequireAnalysisPass<                                          \
                  std::remove_reference<decltype(CREATE_PASS)>::type>());       \
     return true;                                                               \
   }                                                                            \
   if (Name == "invalidate<" NAME ">") {                                        \
     CGPM.addPass(InvalidateAnalysisPass<                                       \
                  std::remove_reference<decltype(CREATE_PASS)>::type>());       \
     return true;                                                               \
   }
 #include "PassRegistry.def"
 
   return false;
 }
 
 bool PassBuilder::parseFunctionPassName(FunctionPassManager &FPM,
                                         StringRef Name) {
+  if (getGlobalHookManager<Function>().parsePassName(Name, FPM))
+    return true;
+
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME) {                                                          \
     FPM.addPass(CREATE_PASS);                                                  \
     return true;                                                               \
   }
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
   if (Name == "require<" NAME ">") {                                           \
     FPM.addPass(RequireAnalysisPass<                                           \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return true;                                                               \
   }                                                                            \
   if (Name == "invalidate<" NAME ">") {                                        \
     FPM.addPass(InvalidateAnalysisPass<                                        \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return true;                                                               \
   }
 #include "PassRegistry.def"
 
   return false;
 }
 
 bool PassBuilder::parseLoopPassName(LoopPassManager &FPM,
                                     StringRef Name) {
+  if (getGlobalHookManager<Loop>().parsePassName(Name, FPM))
+    return true;
+
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME) {                                                          \
     FPM.addPass(CREATE_PASS);                                                  \
     return true;                                                               \
   }
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
   if (Name == "require<" NAME ">") {                                           \
     FPM.addPass(RequireAnalysisPass<                                           \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return true;                                                               \
   }                                                                            \
   if (Name == "invalidate<" NAME ">") {                                        \
     FPM.addPass(InvalidateAnalysisPass<                                        \
                 std::remove_reference<decltype(CREATE_PASS)>::type>());        \
     return true;                                                               \
   }
 #include "PassRegistry.def"
 
   return false;
 }
 
 bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
+  if (getGlobalHookManager<Function>().parseAAPassName(Name, AA))
+    return true;
+
 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)                               \
   if (Name == NAME) {                                                          \
     AA.registerModuleAnalysis<                                                 \
         std::remove_reference<decltype(CREATE_PASS)>::type>();                 \
     return true;                                                               \
   }
+
 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)                             \
   if (Name == NAME) {                                                          \
     AA.registerFunctionAnalysis<                                               \
         std::remove_reference<decltype(CREATE_PASS)>::type>();                 \
     return true;                                                               \
   }
 #include "PassRegistry.def"
 

unittests/IR/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Analysis
   AsmParser
   Core
   Support
+  Passes
   )
 
 set(IRSources
   AsmWriterTest.cpp
   AttributesTest.cpp
   ConstantRangeTest.cpp
   ConstantsTest.cpp
   DebugInfoTest.cpp
   DominatorTreeTest.cpp
+  HookManagerTest.cpp
   IRBuilderTest.cpp
   InstructionsTest.cpp
   IntrinsicsTest.cpp
   LegacyPassManagerTest.cpp
   MDBuilderTest.cpp
   MetadataTest.cpp
   PassManagerTest.cpp
   PatternMatch.cpp

unittests/IR/HookManagerTest.cpp

+//===- llvm/unittest/IR/HookManagerTest.cpp - HookManager unit tests ------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <gtest/gtest.h>
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/PassManager.h>
+#include <llvm/Passes/PassBuilder.h>
+
+using namespace llvm;
+
+namespace {
+template <typename IRUnitT>
+struct TestAnalysisPass : public AnalysisBase<TestAnalysisPass<IRUnitT>> {
+  typedef int Result;
+  int run(IRUnitT &M) { return 7; }
+};
+
+template <typename IRUnitT>
+struct TestTransformPass : public PassBase<TestTransformPass<IRUnitT>> {
+  PreservedAnalyses run(IRUnitT &M, AnalysisManager<IRUnitT> *AM) {
+    int R = AM->template getResult<TestAnalysisPass<IRUnitT>>(M);
+    EXPECT_EQ(R, 7);
+    PreservedAnalyses P;
+    P.preserve<TestAnalysisPass<IRUnitT>>();
+    return P;
+  }
+};
+
+template <typename T> class HookManagerTest : public testing::Test {};
+
+typedef testing::Types<Module, Function, LazyCallGraph::SCC, Loop> PMTypes;
+
+TYPED_TEST_CASE(HookManagerTest, PMTypes);
+
+TYPED_TEST(HookManagerTest, TransformPass) {
+  Module M("TestModule", getGlobalContext());
+  PassBuilder PB;
+  ModulePassManager PM;
+  ModuleAnalysisManager AM;
+
+  auto &HM = getGlobalHookManager<TypeParam>();
+  HM.template registerAnalysisPassHook<TestAnalysisPass<TypeParam>>(
+      "test-analysis",
+      typename RegisterAnalysisPass<TypeParam,
+                                    TestAnalysisPass<TypeParam>>::Hook());
+  HM.registerTransformPassHook(
+      "test-transform",
+      typename RegisterTransformPass<TypeParam,
+                                     TestTransformPass<TypeParam>>::Hook());
+  PB.registerModuleAnalyses(AM);
+  ASSERT_TRUE(PB.parsePassPipeline(PM, "test-transform", true));
+}
+
+TYPED_TEST(HookManagerTest, AnalysisPass) {
+  Module M("TestModule", getGlobalContext());
+  PassBuilder PB;
+  ModulePassManager PM;
+  ModuleAnalysisManager AM;
+
+  auto &HM = getGlobalHookManager<TypeParam>();
+  HM.template registerAnalysisPassHook<TestAnalysisPass<TypeParam>>(
+      "test-analysis",
+      typename RegisterAnalysisPass<TypeParam,
+                                    TestAnalysisPass<TypeParam>>::Hook());
+  PB.registerModuleAnalyses(AM);
+  ASSERT_TRUE(PB.parsePassPipeline(
+      PM, "require<test-analysis>,invalidate<test-analysis>", true));
+}
+} // end anonymous namespace