Index: include/llvm/Passes/PassBuilder.h
===================================================================
--- include/llvm/Passes/PassBuilder.h
+++ include/llvm/Passes/PassBuilder.h
@@ -17,6 +17,7 @@
 #define LLVM_PASSES_PASSBUILDER_H
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
@@ -26,6 +27,7 @@
 class StringRef;
 class AAManager;
 class TargetMachine;
+class HookManager;
 
 /// A struct capturing PGO tunables.
 struct PGOOptions {
@@ -45,6 +47,8 @@
   TargetMachine *TM;
   Optional<PGOOptions> PGOOpt;
 
+  const HookManager &HM;
+
 public:
   /// \brief LLVM-provided high-level optimization levels.
   ///
@@ -133,8 +137,9 @@
   };
 
   explicit PassBuilder(TargetMachine *TM = nullptr,
-                       Optional<PGOOptions> PGOOpt = None)
-      : TM(TM), PGOOpt(PGOOpt) {}
+                       Optional<PGOOptions> PGOOpt = None,
+                       HookManager *HM = nullptr)
+      : TM(TM), PGOOpt(PGOOpt), HM(HM ? *HM : GlobalHookManager()) {}
 
   /// \brief Cross register the analysis managers through their proxies.
   ///
@@ -287,6 +292,9 @@
   /// returns false.
   bool parseAAPipeline(AAManager &AA, StringRef PipelineText);
 
+  /// \brief Access the global singleton hook manager instance
+  static HookManager &GlobalHookManager();
+
 private:
   /// A struct to capture parsed pass pipeline names.
   struct PipelineElement {
@@ -320,6 +328,390 @@
                                ArrayRef<PipelineElement> Pipeline,
                                bool VerifyEachPass, bool DebugLogging);
 };
-}
 
+template <typename Tag> struct HookTable { typedef Tag TableTag; };
+
+template <typename _IRUnitT,
+          typename _AnalysisManagerT = AnalysisManager<_IRUnitT>,
+          typename _PassManagerT = PassManager<_IRUnitT>>
+struct CustomPipelineHookTable : public HookTable<_IRUnitT> {
+  typedef _IRUnitT IRUnitT;
+  typedef _AnalysisManagerT AnalysisManagerT;
+  typedef _PassManagerT PassManagerT;
+  typedef std::function<void(AnalysisManagerT &)> AnalysisPassHook;
+  typedef std::function<void(PassManagerT &)> TransformPassHook;
+
+  SmallVector<AnalysisPassHook, 4> Analyses;
+  StringMap<TransformPassHook> Transforms;
+  StringMap<TransformPassHook> RequireUtilities;
+  StringMap<TransformPassHook> InvalidateUtilities;
+};
+
+struct FunctionPipelineHookTable : public CustomPipelineHookTable<Function> {
+  typedef std::function<void(AAManager &)> AAPassHook;
+  StringMap<AAPassHook> AliasAnalyses;
+};
+
+using ModulePipelineHookTable = CustomPipelineHookTable<Module>;
+using SCCPipelineHookTable =
+    CustomPipelineHookTable<LazyCallGraph::SCC, CGSCCAnalysisManager,
+                            CGSCCPassManager>;
+using LoopPipelineHookTable =
+    CustomPipelineHookTable<Loop, LoopAnalysisManager, LoopPassManager>;
+
+template <typename ExtensionPoint, typename _PassManagerT = PassManager<Module>>
+struct ExtensionHookTable : public HookTable<ExtensionPoint> {
+  typedef _PassManagerT PassManagerT;
+  typedef std::function<void(PassManagerT &)> TransformPassHook;
+  SmallVector<TransformPassHook, 4> Transforms;
+};
+
+//{{@ Extension Point Tags
+namespace EP {
+/// EarlyAsPossible - This extension point allows adding passes before
+/// any other transformations, allowing them to see the code as it is coming
+/// out of the frontend.
+struct EarlyAsPossible {};
+
+/// ModuleOptimizerEarly - This extension point allows adding passes
+/// just before the main module-level optimization passes.
+struct ModuleOptimizerEarly {};
+
+/// LoopOptimizerEnd - This extension point allows adding loop passes to
+/// the end of the loop optimizer.
+struct LoopOptimizerEnd {};
+
+/// ScalarOptimizerLate - This extension point allows adding optimization
+/// passes after most of the main optimizations, but before the last
+/// cleanup-ish optimizations.
+struct ScalarOptimizerLate {};
+
+/// OptimizerLast -- This extension point allows adding passes that
+/// run after everything else.
+struct OptimizerLast {};
+
+/// VectorizerStart - This extension point allows adding optimization
+/// passes before the vectorizer and other highly target specific
+/// optimization passes are executed.
+struct VectorizerStart {};
+
+/// EnabledOnOptLevel0 - This extension point allows adding passes that
+/// should not be disabled by O0 optimization level. The passes will be
+/// inserted after the inlining pass.
+struct EnabledOnOptLevel0 {};
+
+/// Peephole - This extension point allows adding passes that perform
+/// peephole optimizations similar to the instruction combiner. These passes
+/// will be inserted after each instance of the instruction combiner pass.
+struct Peephole {};
+
+/// LateLoopOptimizations - This extension point allows adding late loop
+/// canonicalization and simplification passes. This is the last point in
+/// the loop optimization pipeline before loop deletion. Each pass added
+/// here must be an instance of LoopPass.
+/// This is the place to add passes that can remove loops, such as target-
+/// specific loop idiom recognition.
+struct LateLoopOptimizations {};
+
+/// CGSCCOptimizerLate - This extension point allows adding CallGraphSCC
+/// passes at the end of the main CallGraphSCC passes and before any
+/// function simplification passes run by CGPassManager.
+struct CGSCCOptimizerLate {};
+} // namespace EP
+//@}}
+
+/// \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. Passes are registered by name
+/// or with a specific extension point.
+///
+/// When used within a PassBuilder instance, the name is used when parsing a
+/// textual pipeline description. If the name matches a name of a built-in pass,
+/// this name is effectively "stolen", thus overriding the built-in pass. When
+/// constructing default pipelines, such as the O<n>.pipelines, the PassBuilder
+/// will invoke transform pass hooks registered with specific extension points
+/// at specific places in the pipeline.
+///
+/// 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
+class HookManager {
+
+  // {{@ Helpers for accessing elements of an std::tuple by a Tag typedef
+  template <class Tag, size_t N, class... Args> struct get_type_index {
+    static constexpr auto value = N;
+  };
+  template <class Tag, size_t N, class... Args>
+  struct get_type_index<Tag, N, Tag, Args...> {
+    static constexpr auto value = N;
+  };
+  template <class Tag, size_t N, class U, class... Args>
+  struct get_type_index<Tag, N, U, Args...> {
+    static constexpr auto value = get_type_index<Tag, N + 1, Args...>::value;
+  };
+
+  template <typename Tag, typename... Args>
+  static auto get_tag_index(std::tuple<Args...> &t) -> decltype(
+      std::get<get_type_index<Tag, 0, typename Args::TableTag...>::value>(t)) {
+    return std::get<get_type_index<Tag, 0, typename Args::TableTag...>::value>(
+        t);
+  }
+
+  template <typename Tag, typename... Args>
+  static auto get_tag_index(const std::tuple<Args...> &t) -> decltype(
+      std::get<get_type_index<Tag, 0, typename Args::TableTag...>::value>(t)) {
+    return std::get<get_type_index<Tag, 0, typename Args::TableTag...>::value>(
+        t);
+  }
+  //@}}
+
+  /// \brief The static table containing the registered hooks for the different
+  /// pass types and extension points.
+  std::tuple<FunctionPipelineHookTable, ModulePipelineHookTable,
+             SCCPipelineHookTable, LoopPipelineHookTable,
+             ExtensionHookTable<EP::EarlyAsPossible, FunctionPassManager>,
+             ExtensionHookTable<EP::ModuleOptimizerEarly>,
+             ExtensionHookTable<EP::LoopOptimizerEnd, LoopPassManager>,
+             ExtensionHookTable<EP::ScalarOptimizerLate, FunctionPassManager>,
+             ExtensionHookTable<EP::CGSCCOptimizerLate, CGSCCPassManager>,
+             ExtensionHookTable<EP::OptimizerLast>,
+             ExtensionHookTable<EP::VectorizerStart, FunctionPassManager>,
+             ExtensionHookTable<EP::EnabledOnOptLevel0>,
+             ExtensionHookTable<EP::LateLoopOptimizations, LoopPassManager>,
+             ExtensionHookTable<EP::Peephole, FunctionPassManager>>
+      Tables;
+
+  //{{@ \brief Compile-time accessor for the individual tables
+  template <typename Tag>
+  auto getTable() -> decltype(HookManager::get_tag_index<Tag>(Tables)) {
+    return HookManager::get_tag_index<Tag>(Tables);
+  }
+
+  template <typename Tag>
+  auto getTable() const -> decltype(HookManager::get_tag_index<Tag>(Tables)) {
+    return HookManager::get_tag_index<Tag>(Tables);
+  }
+  //@}}
+
+  //{{@ Shortcuts for accessing typedefs of a table entry
+  template <typename Tag>
+  using TableT = typename std::remove_reference<decltype(
+      get_tag_index<Tag>(Tables))>::type;
+  template <typename Tag>
+  using AnalysisManagerT = typename TableT<Tag>::AnalysisManagerT;
+  template <typename Tag>
+  using PassManagerT = typename TableT<Tag>::PassManagerT;
+  template <typename Tag> using IRUnitT = typename TableT<Tag>::IRUnitT;
+  //@}}
+
+public:
+  /// \brief Register a hook for a transform pass.
+  ///
+  /// If a hook has already been registered with the same Name, this hook is
+  /// overwritten.
+  template <typename Tag, typename Callable>
+  void registerTransformPassHook(StringRef Name, Callable TransformCB) {
+    auto &C = getTable<Tag>();
+    C.Transforms.insert({Name, TransformCB});
+  }
+
+  /// \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 Tag, typename PassT, typename Callable>
+  void registerAnalysisPassHook(StringRef Name, Callable AnalysisCB) {
+    auto &C = getTable<Tag>();
+    C.Analyses.push_back(AnalysisCB);
+    C.RequireUtilities.insert(
+        {Name, [](PassManagerT<Tag> &) {
+           return RequireAnalysisPass<PassT, IRUnitT<Tag>>();
+         }});
+    C.InvalidateUtilities.insert({Name, [](PassManagerT<Tag> &) {
+                                    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.
+  template <typename Tag, typename Callable>
+  void registerAAPassHook(StringRef Name, Callable AACB) {
+    auto &C = getTable<Tag>();
+    C.AliasAnalyses.insert({Name, AACB});
+  }
+
+  /// \brief Register a hook for an extension point
+  template <typename Tag, typename Callable>
+  void registerExtensionPointHook(Callable EPCB) {
+    auto &C = getTable<Tag>();
+    C.Transforms.push_back(EPCB);
+  }
+
+  //@{
+  /// Public interface for the \c PassBuilder to query or invoke registered
+  /// hooks.
+  template <typename Tag>
+  void registerAnalyses(AnalysisManagerT<Tag> &AM) const {
+    auto &C = getTable<Tag>();
+    for (auto &H : C.Analyses)
+      H(AM);
+  }
+
+  template <typename Tag> bool hasPassName(StringRef Name) const {
+    auto &C = getTable<Tag>();
+    if (C.Transforms.count(Name) > 0)
+      return true;
+    StringRef slice = getRequireUtilityName(Name);
+    if (!slice.empty())
+      if (C.RequireUtilities.count(slice))
+        return true;
+    slice = getInvalidateUtilityName(Name);
+    if (!slice.empty())
+      if (C.InvalidateUtilities.count(slice))
+        return true;
+    return false;
+  }
+
+  template <typename Tag>
+  bool parsePassName(StringRef Name, PassManagerT<Tag> &PM) const {
+    auto &C = getTable<Tag>();
+    auto T = C.Transforms.find(Name);
+    if (T != C.Transforms.end()) {
+      T->getValue()(PM);
+      return true;
+    }
+    StringRef slice = getRequireUtilityName(Name);
+    if (!slice.empty()) {
+      auto R = C.RequireUtilities.find(slice);
+      if (R != C.RequireUtilities.end()) {
+        R->getValue()(PM);
+        return true;
+      }
+    }
+    slice = getInvalidateUtilityName(Name);
+    if (!slice.empty()) {
+      auto I = C.InvalidateUtilities.find(slice);
+      if (I != C.InvalidateUtilities.end()) {
+        I->getValue()(PM);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool parseAAPassName(StringRef Name, AAManager &AA) const {
+    auto &C = getTable<Function>();
+    auto A = C.AliasAnalyses.find(Name);
+    if (A != C.AliasAnalyses.end()) {
+      A->getValue()(AA);
+      return true;
+    }
+    return false;
+  }
+
+  template <typename Tag, typename _PassManagerT>
+  void injectExtensions(_PassManagerT &PM) const {
+    auto &C = getTable<Tag>();
+    for (auto &P : C.Transforms)
+      P(PM);
+  }
+  //@}
+private:
+  inline StringRef getRequireUtilityName(StringRef Name) const {
+    if (Name.endswith(">") && Name.startswith("require<"))
+      return Name.slice(8, Name.size() - 1);
+    return StringRef();
+  }
+
+  inline StringRef getInvalidateUtilityName(StringRef Name) const {
+    if (Name.endswith(">") && Name.startswith("invalidate<"))
+      return Name.slice(11, Name.size() - 1);
+    return StringRef();
+  }
+};
+
+//{@
+/// \brief Convenience types to install global hooks for a pass. Constructing an
+/// instance of this will perform the registration of a hook with the given
+/// arguments, or register a default hook for the given PassT.
+template <typename IRUnitT, typename PassT> struct RegisterAnalysisPass {
+  struct DefaultHook {
+    template <typename AnalysisManagerT> void operator()(AnalysisManagerT &AM) {
+      AM.registerPass([] { return PassT(); });
+    }
+  };
+
+  RegisterAnalysisPass(StringRef Name)
+      : RegisterAnalysisPass(Name, DefaultHook()) {}
+
+  template <typename Callable>
+  RegisterAnalysisPass(StringRef Name, Callable AnalysisCB) {
+    auto &HM = PassBuilder::GlobalHookManager();
+    HM.registerAnalysisPassHook<IRUnitT, PassT>(Name, AnalysisCB);
+  }
+};
+
+template <typename IRUnitT, typename PassT> struct RegisterTransformPass {
+  struct DefaultHook {
+    template <typename PassManagerT> void operator()(PassManagerT &PM) {
+      PM.addPass(PassT());
+    }
+  };
+  RegisterTransformPass(StringRef Name)
+      : RegisterTransformPass(Name, DefaultHook()) {}
+
+  template <typename Callable>
+  RegisterTransformPass(StringRef Name, Callable TransformCB) {
+    auto &HM = PassBuilder::GlobalHookManager();
+    HM.registerTransformPassHook<IRUnitT>(Name, TransformCB);
+  }
+};
+
+template <typename PassT> struct RegisterAAPass {
+  struct DefaultHook {
+    template <typename AnalysisManagerT> void operator()(AnalysisManagerT &AM) {
+      AM.registerPass([] { return PassT(); });
+    }
+    void operator()(AAManager &AA) { AA.registerFunctionAnalysis<PassT>(); }
+  };
+
+  RegisterAAPass(StringRef Name)
+      : RegisterAAPass(Name, DefaultHook(), DefaultHook()) {}
+
+  /// An alias analysis pass is both an AAPass and an AnalysisPass, thus it
+  /// needs two hooks.
+  template <typename Callable, typename AACallable>
+  RegisterAAPass(StringRef Name, Callable AnalysisCB, AACallable AACB) {
+    auto &HM = PassBuilder::GlobalHookManager();
+    HM.registerAnalysisPassHook<Function, PassT>(Name, AnalysisCB);
+    HM.registerAAPassHook<Function>(Name, AACB);
+  }
+};
+
+template <typename ExtensionPoint, typename PassT> struct InjectExtensionPoint {
+  struct DefaultHook {
+    template <typename PassManagerT> void operator()(PassManagerT &PM) {
+      PM.addPass(PassT());
+    }
+  };
+
+  InjectExtensionPoint() : InjectExtensionPoint(DefaultHook()) {}
+
+  template <typename Callable> InjectExtensionPoint(Callable EPCB) {
+    auto &HM = PassBuilder::GlobalHookManager();
+    HM.registerExtensionPointHook<ExtensionPoint>(EPCB);
+  }
+}; // namespace llvm
+
+//@}
+} // namespace llvm
 #endif
Index: lib/Passes/PassBuilder.cpp
===================================================================
--- lib/Passes/PassBuilder.cpp
+++ lib/Passes/PassBuilder.cpp
@@ -57,6 +57,7 @@
 #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/GCOVProfiler.h"
@@ -258,26 +259,39 @@
 
 } // End anonymous namespace.
 
+HookManager &PassBuilder::GlobalHookManager() {
+  static HookManager instance;
+  return instance;
+}
+
 void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) {
-#define MODULE_ANALYSIS(NAME, CREATE_PASS)                                     \
+  HM.registerAnalyses<Module>(MAM);
+
+#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
   MAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 }
 
 void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) {
-#define CGSCC_ANALYSIS(NAME, CREATE_PASS)                                      \
+  HM.registerAnalyses<LazyCallGraph::SCC>(CGAM);
+
+#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
   CGAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 }
 
 void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) {
-#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)                                   \
+  HM.registerAnalyses<Function>(FAM);
+
+#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
   FAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 }
 
 void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) {
-#define LOOP_ANALYSIS(NAME, CREATE_PASS)                                       \
+  HM.registerAnalyses<Loop>(LAM);
+
+#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
   LAM.registerPass([&] { return CREATE_PASS; });
 #include "PassRegistry.def"
 }
@@ -306,6 +320,7 @@
 
   if (!isOptimizingForSize(Level))
     FPM.addPass(LibCallsShrinkWrapPass());
+  HM.injectExtensions<EP::Peephole>(FPM);
 
   FPM.addPass(TailCallElimPass());
   FPM.addPass(SimplifyCFGPass());
@@ -333,8 +348,10 @@
 #endif
   LPM2.addPass(IndVarSimplifyPass());
   LPM2.addPass(LoopIdiomRecognizePass());
+  HM.injectExtensions<EP::LateLoopOptimizations>(LPM2);
   LPM2.addPass(LoopDeletionPass());
   LPM2.addPass(LoopUnrollPass::createFull(Level));
+  HM.injectExtensions<EP::LoopOptimizerEnd>(LPM2);
 
   // We provide the opt remark emitter pass for LICM to use. We only need to do
   // this once as it is immutable.
@@ -367,6 +384,7 @@
   // Run instcombine after redundancy and dead bit elimination to exploit
   // opportunities opened up by them.
   FPM.addPass(InstCombinePass());
+  HM.injectExtensions<EP::Peephole>(FPM);
 
   // Re-consider control flow based optimizations after redundancy elimination,
   // redo DCE, etc.
@@ -375,16 +393,20 @@
   FPM.addPass(DSEPass());
   FPM.addPass(createFunctionToLoopPassAdaptor(LICMPass()));
 
+  HM.injectExtensions<EP::ScalarOptimizerLate>(FPM);
+
   // Finally, do an expensive DCE pass to catch all the dead code exposed by
   // the simplifications and basic cleanup after all the simplifications.
   FPM.addPass(ADCEPass());
   FPM.addPass(SimplifyCFGPass());
   FPM.addPass(InstCombinePass());
+  HM.injectExtensions<EP::Peephole>(FPM);
 
   return FPM;
 }
 
-static void addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
+static void addPGOInstrPasses(const HookManager &HM, ModulePassManager &MPM,
+                              bool DebugLogging,
                               PassBuilder::OptimizationLevel Level,
                               bool RunProfileGen, std::string ProfileGenFile,
                               std::string ProfileUseFile) {
@@ -412,9 +434,8 @@
     FPM.addPass(EarlyCSEPass());    // Catch trivial redundancies.
     FPM.addPass(SimplifyCFGPass()); // Merge & remove basic blocks.
     FPM.addPass(InstCombinePass()); // Combine silly sequences.
+    HM.injectExtensions<EP::Peephole>(FPM);
 
-    // FIXME: Here the old pass manager inserts peephole extensions.
-    // Add them when they're supported.
     CGPipeline.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
 
     MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPipeline)));
@@ -446,10 +467,12 @@
   // Do basic inference of function attributes from known properties of system
   // libraries and other oracles.
   MPM.addPass(InferFunctionAttrsPass());
+  HM.injectExtensions<EP::ModuleOptimizerEarly>(MPM);
 
   // Create an early function pass manager to cleanup the output of the
   // frontend.
   FunctionPassManager EarlyFPM(DebugLogging);
+  HM.injectExtensions<EP::EarlyAsPossible>(EarlyFPM);
   EarlyFPM.addPass(SimplifyCFGPass());
   EarlyFPM.addPass(SROA());
   EarlyFPM.addPass(EarlyCSEPass());
@@ -481,6 +504,7 @@
   // optimizations.
   FunctionPassManager GlobalCleanupPM(DebugLogging);
   GlobalCleanupPM.addPass(InstCombinePass());
+  HM.injectExtensions<EP::Peephole>(GlobalCleanupPM);
   GlobalCleanupPM.addPass(SimplifyCFGPass());
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(GlobalCleanupPM)));
 
@@ -488,7 +512,7 @@
   if (PGOOpt) {
     assert(PGOOpt->RunProfileGen || PGOOpt->SamplePGO ||
            !PGOOpt->ProfileUseFile.empty());
-    addPGOInstrPasses(MPM, DebugLogging, Level, PGOOpt->RunProfileGen,
+    addPGOInstrPasses(HM, MPM, DebugLogging, Level, PGOOpt->RunProfileGen,
                       PGOOpt->ProfileGenFile, PGOOpt->ProfileUseFile);
   }
 
@@ -528,6 +552,7 @@
   // CGSCC walk.
   MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(
       buildFunctionSimplificationPipeline(Level, DebugLogging)));
+  HM.injectExtensions<EP::CGSCCOptimizerLate>(MainCGPipeline);
 
   // We wrap the CGSCC pipeline in a devirtualization repeater. This will try
   // to detect when we devirtualize indirect calls and iterate the SCC passes
@@ -569,6 +594,8 @@
   // rather than on each loop in an inside-out manner, and so they are actually
   // function passes.
 
+  HM.injectExtensions<EP::VectorizerStart>(OptimizePM);
+
   // First rotate loops that may have been un-rotated by prior passes.
   OptimizePM.addPass(createFunctionToLoopPassAdaptor(LoopRotatePass()));
 
@@ -633,6 +660,7 @@
   // ordering here.
   MPM.addPass(GlobalDCEPass());
   MPM.addPass(ConstantMergePass());
+  HM.injectExtensions<EP::OptimizerLast>(MPM);
 
   return MPM;
 }
@@ -712,8 +740,10 @@
   // simplification opportunities, and both can propagate functions through
   // function pointers.  When this happens, we often have to resolve varargs
   // calls, etc, so let instcombine do this.
-  // FIXME: add peephole extensions here as the legacy PM does.
-  MPM.addPass(createModuleToFunctionPassAdaptor(InstCombinePass()));
+  FunctionPassManager SimplifyFPM(DebugLogging);
+  SimplifyFPM.addPass(InstCombinePass());
+  HM.injectExtensions<EP::Peephole>(SimplifyFPM);
+  MPM.addPass(createModuleToFunctionPassAdaptor(std::move(SimplifyFPM)));
 
   // Note: historically, the PruneEH pass was run first to deduce nounwind and
   // generally clean up exception handling overhead. It isn't clear this is
@@ -730,10 +760,10 @@
   MPM.addPass(GlobalDCEPass());
 
   FunctionPassManager FPM(DebugLogging);
-
   // The IPO Passes may leave cruft around. Clean up after them.
-  // FIXME: add peephole extensions here as the legacy PM does.
   FPM.addPass(InstCombinePass());
+  HM.injectExtensions<EP::Peephole>(FPM);
+
   FPM.addPass(JumpThreadingPass());
 
   // Break up allocas
@@ -780,8 +810,8 @@
   // FIXME: Conditionally run LoadCombine here, after it's ported
   // (in case we still have this pass, given its questionable usefulness).
 
-  // FIXME: add peephole extensions to the PM here.
   MainFPM.addPass(InstCombinePass());
+  HM.injectExtensions<EP::Peephole>(MainFPM);
   MainFPM.addPass(JumpThreadingPass());
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(MainFPM)));
 
@@ -857,7 +887,7 @@
   return Count;
 }
 
-static bool isModulePassName(StringRef Name) {
+static bool isModulePassName(StringRef Name, const HookManager &HM) {
   // Manually handle aliases for pre-configured pipeline fragments.
   if (Name.startswith("default") || Name.startswith("lto"))
     return DefaultAliasRegex.match(Name);
@@ -870,6 +900,9 @@
   if (Name == "function")
     return true;
 
+  if (HM.hasPassName<Module>(Name))
+    return true;
+
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
@@ -885,13 +918,16 @@
   return false;
 }
 
-static bool isCGSCCPassName(StringRef Name) {
+static bool isCGSCCPassName(StringRef Name, const HookManager &HM) {
   // Explicitly handle pass manager names.
   if (Name == "cgscc")
     return true;
   if (Name == "function")
     return true;
 
+  if (HM.hasPassName<LazyCallGraph::SCC>(Name))
+    return true;
+
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
@@ -909,13 +945,16 @@
   return false;
 }
 
-static bool isFunctionPassName(StringRef Name) {
+static bool isFunctionPassName(StringRef Name, const HookManager &HM) {
   // Explicitly handle pass manager names.
   if (Name == "function")
     return true;
   if (Name == "loop")
     return true;
 
+  if (HM.hasPassName<Function>(Name))
+    return true;
+
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
@@ -931,11 +970,14 @@
   return false;
 }
 
-static bool isLoopPassName(StringRef Name) {
+static bool isLoopPassName(StringRef Name, const HookManager &HM) {
   // Explicitly handle pass manager names.
   if (Name == "loop")
     return true;
 
+  if (HM.hasPassName<Loop>(Name))
+    return true;
+
   // Explicitly handle custom-parsed pass names.
   if (parseRepeatPassName(Name))
     return true;
@@ -1067,9 +1109,11 @@
         .Case("O3", O3)
         .Case("Os", Os)
         .Case("Oz", Oz);
-    if (L == O0)
+    if (L == O0) {
+      HM.injectExtensions<EP::EnabledOnOptLevel0>(MPM);
       // At O0 we do nothing at all!
       return true;
+    }
 
     if (Matches[1] == "default") {
       MPM.addPass(buildPerModuleDefaultPipeline(L, DebugLogging));
@@ -1082,6 +1126,9 @@
     return true;
   }
 
+  if (HM.parsePassName<Module>(Name, MPM))
+    return true;
+
   // Finally expand the basic registered passes from the .inc file.
 #define MODULE_PASS(NAME, CREATE_PASS)                                         \
   if (Name == NAME) {                                                          \
@@ -1153,6 +1200,9 @@
     return false;
   }
 
+  if (HM.parsePassName<LazyCallGraph::SCC>(Name, CGPM))
+    return true;
+
   // Now expand the basic registered passes from the .inc file.
 #define CGSCC_PASS(NAME, CREATE_PASS)                                          \
   if (Name == NAME) {                                                          \
@@ -1215,6 +1265,9 @@
     return false;
   }
 
+  if (HM.parsePassName<Function>(Name, FPM))
+    return true;
+
   // Now expand the basic registered passes from the .inc file.
 #define FUNCTION_PASS(NAME, CREATE_PASS)                                       \
   if (Name == NAME) {                                                          \
@@ -1266,6 +1319,9 @@
     return false;
   }
 
+  if (HM.parsePassName<Loop>(Name, LPM))
+    return true;
+
   // Now expand the basic registered passes from the .inc file.
 #define LOOP_PASS(NAME, CREATE_PASS)                                           \
   if (Name == NAME) {                                                          \
@@ -1291,12 +1347,16 @@
 }
 
 bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
+  if (HM.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<                                               \
@@ -1385,12 +1445,12 @@
   // automatically.
   StringRef FirstName = Pipeline->front().Name;
 
-  if (!isModulePassName(FirstName)) {
-    if (isCGSCCPassName(FirstName))
+  if (!isModulePassName(FirstName, HM)) {
+    if (isCGSCCPassName(FirstName, HM))
       Pipeline = {{"cgscc", std::move(*Pipeline)}};
-    else if (isFunctionPassName(FirstName))
+    else if (isFunctionPassName(FirstName, HM))
       Pipeline = {{"function", std::move(*Pipeline)}};
-    else if (isLoopPassName(FirstName))
+    else if (isLoopPassName(FirstName, HM))
       Pipeline = {{"function", {{"loop", std::move(*Pipeline)}}}};
     else
       // Unknown pass name!
Index: test/Other/new-pm-lto-defaults.ll
===================================================================
--- test/Other/new-pm-lto-defaults.ll
+++ test/Other/new-pm-lto-defaults.ll
@@ -45,7 +45,10 @@
 ; CHECK-O2-NEXT: Running analysis: AssumptionAnalysis
 ; CHECK-O2-NEXT: Running pass: ConstantMergePass
 ; CHECK-O2-NEXT: Running pass: DeadArgumentEliminationPass
-; CHECK-O2-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}InstCombinePass>
+; CHECK-O2-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
+; CHECK-O2-NEXT: Starting llvm::Function pass manager run.
+; CHECK-O2-NEXT: Running pass: InstCombinePass
+; CHECK-O2-NEXT: Finished llvm::Function pass manager run.
 ; CHECK-O2-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor<{{.*}}InlinerPass>
 ; CHECK-O2-NEXT: Running pass: GlobalOptPass
 ; CHECK-O2-NEXT: Running pass: GlobalDCEPass
Index: unittests/IR/CMakeLists.txt
===================================================================
--- unittests/IR/CMakeLists.txt
+++ unittests/IR/CMakeLists.txt
@@ -3,6 +3,7 @@
   AsmParser
   Core
   Support
+  Passes
   )
 
 set(IRSources
@@ -14,6 +15,7 @@
   DebugTypeODRUniquingTest.cpp
   DominatorTreeTest.cpp
   FunctionTest.cpp
+  HookManagerTest.cpp
   IRBuilderTest.cpp
   InstructionsTest.cpp
   IntrinsicsTest.cpp
Index: unittests/IR/HookManagerTest.cpp
===================================================================
--- /dev/null
+++ unittests/IR/HookManagerTest.cpp
@@ -0,0 +1,98 @@
+//===- 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 AnalysisInfoMixin<TestAnalysisPass<IRUnitT>> {
+  struct Result {};
+  template <typename AnalysisManagerT, typename... ExtraTs>
+  Result run(IRUnitT &M, AnalysisManagerT &, ExtraTs &&... ExtraArgs) {
+    return Result();
+  }
+  static AnalysisKey Key;
+};
+
+template <typename IRUnitT>
+struct TestTransformPass : public PassInfoMixin<TestTransformPass<IRUnitT>> {
+  template <typename AnalysisManagerT, typename ResultT, typename... ExtraTs>
+  PreservedAnalyses run(IRUnitT &M, AnalysisManagerT &AM, ResultT &&R,
+                        ExtraTs &&... ExtraArgs) {
+    AM.template getResult<TestAnalysisPass<IRUnitT>>(M, R);
+    PreservedAnalyses P;
+    P.preserve<TestAnalysisPass<IRUnitT>>();
+    return P;
+  }
+  template <typename AnalysisManagerT>
+  PreservedAnalyses run(IRUnitT &M, AnalysisManagerT &AM) {
+    AM.template getResult<TestAnalysisPass<IRUnitT>>(M);
+    PreservedAnalyses P;
+    P.preserve<TestAnalysisPass<IRUnitT>>();
+    return P;
+  }
+};
+
+template <typename IRUnitT> AnalysisKey TestAnalysisPass<IRUnitT>::Key;
+
+template <typename T> class HookManagerTest : public testing::Test {};
+
+typedef testing::Types<Module, Function, Loop, LazyCallGraph::SCC> PMTypes;
+
+TYPED_TEST_CASE(HookManagerTest, PMTypes);
+
+template <typename TypeParam, typename... Extra> bool TransformPassTest() {
+  LLVMContext Ctx;
+  Module M("TestModule", Ctx);
+  PassBuilder PB;
+  ModulePassManager PM;
+  ModuleAnalysisManager AM;
+
+  auto &HM = PassBuilder::GlobalHookManager();
+  HM.registerAnalysisPassHook<TypeParam, TestAnalysisPass<TypeParam>>(
+      "test-analysis",
+      typename RegisterAnalysisPass<
+          TypeParam, TestAnalysisPass<TypeParam>>::DefaultHook());
+  HM.registerTransformPassHook<TypeParam>(
+      "test-transform",
+      typename RegisterTransformPass<
+          TypeParam, TestTransformPass<TypeParam>>::DefaultHook());
+  PB.registerModuleAnalyses(AM);
+  return PB.parsePassPipeline(PM, "test-transform", true);
+}
+
+TYPED_TEST(HookManagerTest, TransformPass) {
+  ASSERT_TRUE(TransformPassTest<TypeParam>());
+}
+
+template <typename TypeParam, typename... Extra> bool AnalysisPassTest() {
+  LLVMContext Ctx;
+  Module M("TestModule", Ctx);
+  PassBuilder PB;
+  ModulePassManager PM;
+  ModuleAnalysisManager AM;
+
+  auto &HM = PassBuilder::GlobalHookManager();
+  HM.registerAnalysisPassHook<TypeParam, TestAnalysisPass<TypeParam>>(
+      "test-analysis",
+      typename RegisterAnalysisPass<
+          TypeParam, TestAnalysisPass<TypeParam>>::DefaultHook());
+  PB.registerModuleAnalyses(AM);
+  return PB.parsePassPipeline(
+      PM, "require<test-analysis>,invalidate<test-analysis>", true);
+}
+TYPED_TEST(HookManagerTest, AnalysisPass) {
+  ASSERT_TRUE(AnalysisPassTest<TypeParam>());
+}
+} // end anonymous namespace