Index: include/llvm/Analysis/CGSCCPassManager.h
===================================================================
--- include/llvm/Analysis/CGSCCPassManager.h
+++ include/llvm/Analysis/CGSCCPassManager.h
@@ -119,6 +119,8 @@
 
 extern template class AnalysisManager<LazyCallGraph::SCC, LazyCallGraph &>;
 
+extern template class PassInstrumentationAnalysis<LazyCallGraph::SCC>;
+
 /// The CGSCC analysis manager.
 ///
 /// See the documentation for the AnalysisManager template for detail
@@ -364,6 +366,9 @@
                             InvalidSCCSet,       nullptr,   nullptr,
                             InlinedInternalEdges};
 
+    // Get pass instrumentation handler
+    PassInstrumentation<LazyCallGraph::SCC> PI = AM.getPassInstrumentation(M);
+
     PreservedAnalyses PA = PreservedAnalyses::all();
     CG.buildRefSCCs();
     for (auto RCI = CG.postorder_ref_scc_begin(),
@@ -428,8 +433,13 @@
 
             UR.UpdatedRC = nullptr;
             UR.UpdatedC = nullptr;
+            if (!PI.runBeforePass(Pass.name(), *C))
+              continue;
+
             PreservedAnalyses PassPA = Pass.run(*C, CGAM, CG, UR);
 
+            PI.runAfterPass(Pass.name(), *C);
+
             // Update the SCC and RefSCC if necessary.
             C = UR.UpdatedC ? UR.UpdatedC : C;
             RC = UR.UpdatedRC ? UR.UpdatedRC : RC;
@@ -615,12 +625,20 @@
       if (CG.lookupSCC(*N) != CurrentC)
         continue;
 
-      PreservedAnalyses PassPA = Pass.run(N->getFunction(), FAM);
+      Function& F = N->getFunction();
+
+      PassInstrumentation<Function> PI = FAM.getPassInstrumentation(F);
+      if (!PI.runBeforePass(Pass.name(), F))
+	continue;
+
+      PreservedAnalyses PassPA = Pass.run(F, FAM);
+
+      PI.runAfterPass(Pass.name(), F);
 
       // We know that the function pass couldn't have invalidated any other
       // function's analyses (that's the contract of a function pass), so
       // directly handle the function analysis manager's invalidation here.
-      FAM.invalidate(N->getFunction(), PassPA);
+      FAM.invalidate(F, PassPA);
 
       // Then intersect the preserved set so that invalidation of module
       // analyses will eventually occur when the module pass completes.
@@ -690,6 +708,7 @@
   PreservedAnalyses run(LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR) {
     PreservedAnalyses PA = PreservedAnalyses::all();
+    PassInstrumentation<LazyCallGraph::SCC> PI = AM.getPassInstrumentation(InitialC, CG);
 
     // The SCC may be refined while we are running passes over it, so set up
     // a pointer that we can update.
@@ -733,8 +752,14 @@
     auto CallCounts = ScanSCC(*C, CallHandles);
 
     for (int Iteration = 0;; ++Iteration) {
+
+      if (!PI.runBeforePass(Pass.name(), *C))
+        continue;
+
       PreservedAnalyses PassPA = Pass.run(*C, AM, CG, UR);
 
+      PI.runAfterPass(Pass.name(), *C);
+
       // If the SCC structure has changed, bail immediately and let the outer
       // CGSCC layer handle any iteration to reflect the refined structure.
       if (UR.UpdatedC && UR.UpdatedC != C) {
Index: include/llvm/IR/PassInstrumentation.h
===================================================================
--- /dev/null
+++ include/llvm/IR/PassInstrumentation.h
@@ -0,0 +1,211 @@
+//===- llvm/IR/PassInstrumentation.h ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the PassInstrumentation class that is used to provide
+// instrumentation points into the pass execution by PassManager.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_PASSINSTRUMENTATION_H
+#define LLVM_IR_PASSINSTRUMENTATION_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/UniqueVector.h"
+#include "llvm/Support/TypeName.h"
+
+namespace llvm {
+
+class PreservedAnalyses;
+
+class PassExecutionCounter {
+  unsigned count = 0;
+
+public:
+  PassExecutionCounter() = default;
+  PassExecutionCounter(const PassExecutionCounter &PC) = default;
+  PassExecutionCounter(PassExecutionCounter &&PC) = default;
+
+  PassExecutionCounter& operator=(const PassExecutionCounter& PC) { count = PC.count; return *this; }
+  bool zero() const { return count == 0; }
+  // preincrement, advance the counter
+  void operator++() { count++; }
+};
+
+//===----------------------------------------------------------------------===//
+/// This class provides the main interface for pass instrumentation.
+/// It handles both registration of callbacks and exposes instrumentation calls
+/// to be invoked by PassManagers.
+
+class PassInstrumentationImpl {
+public:
+  template <typename IRUnitT> using BeforePassFunc = bool(StringRef, IRUnitT, PassExecutionCounter);
+  template <typename IRUnitT> using AfterPassFunc = void(StringRef, IRUnitT, PassExecutionCounter);
+
+  class IRUnitWrapper {
+    static UniqueVector<StringRef> IRUnits;
+
+  public:
+    using IRUnitID = unsigned;
+
+  private:
+    void* IRUnit;
+    IRUnitID ID;
+
+  public:
+    IRUnitWrapper() : IRUnit(nullptr), ID(0) {}
+
+    IRUnitWrapper(const IRUnitWrapper&) = default;
+    IRUnitWrapper(IRUnitWrapper&) = default;
+
+    template <typename IRUnitT> IRUnitWrapper(IRUnitT& IR)
+      : IRUnit(reinterpret_cast<void*>(&IR)), ID(idForType<IRUnitT>())
+    { }
+
+    template <typename IRUnitT> IRUnitWrapper(IRUnitT& IR, IRUnitID ID)
+      : IRUnit(reinterpret_cast<void*>(&IR)), ID(ID)
+    { }
+
+    IRUnitID getID() const { return ID; }
+
+    template <typename IRUnitT>
+    IRUnitT* unwrap() {
+      if (idForType<IRUnitT>() == ID) return reinterpret_cast<IRUnitT*>(IRUnit);
+      else return nullptr;
+    }
+
+    template <typename IRUnitT>
+    static IRUnitID idForType() {
+      return IRUnits.insert(llvm::getTypeName<IRUnitT>());
+    }
+  };
+
+public:
+  PassInstrumentationImpl() {}
+
+  template <typename IRUnitT>
+  bool runBeforePass(StringRef PassID, IRUnitT&) const;
+
+  template <typename IRUnitT>
+  void runAfterPass(StringRef PassID, IRUnitT&) const;
+
+  void runStartPipeline() const;
+
+  void runEndPipeline() const;
+
+  void registerBeforePassCallback(const std::function<BeforePassFunc<IRUnitWrapper>> &C) {
+    BeforePassCallbacks.push_back(C);
+  }
+
+  void registerAfterPassCallback(const std::function<AfterPassFunc<IRUnitWrapper>> &C) {
+    AfterPassCallbacks.push_back(C);
+  }
+
+  void registerStartPipelineCallback(const std::function<void()> &C) {
+    StartPipelineCallbacks.push_back(C);
+  }
+  void registerEndPipelineCallback(const std::function<void()> &C) {
+    EndPipelineCallbacks.push_back(C);
+  }
+
+  PassExecutionCounter& getPC() { return PC; }
+
+private:
+  mutable PassExecutionCounter PC;
+
+  // instrumentation callbacks
+
+  // before/after pass callbacks accept IRUnits
+  // so they need to mock with IRUnitWrapper handling
+  SmallVector<std::function<BeforePassFunc<IRUnitWrapper>>, 4> BeforePassCallbacks;
+  SmallVector<std::function<AfterPassFunc<IRUnitWrapper>>, 4> AfterPassCallbacks;
+  SmallVector<std::function<void()>, 2> StartPipelineCallbacks;
+  SmallVector<std::function<void()>, 2> EndPipelineCallbacks;
+};
+
+template <typename IRUnitT>
+class PassInstrumentation {
+  PassInstrumentationImpl* Impl;
+
+public:
+  PassInstrumentation() : Impl(nullptr) { }
+
+  explicit PassInstrumentation(PassInstrumentationImpl &Impl) : Impl(&Impl) {}
+
+  template <typename> friend class PassInstrumentation;
+
+  template <typename OtherIRUnitT>
+  PassInstrumentation(const PassInstrumentation<OtherIRUnitT>& PI) : Impl(PI.Impl) { }
+
+  // Provide value semantics.
+  PassInstrumentation(const PassInstrumentation &PI) : Impl(PI.Impl) {}
+  PassInstrumentation(PassInstrumentation &&PI) : Impl(PI.Impl) {}
+
+  PassInstrumentation &operator=(const PassInstrumentation &PI) {
+    Impl = PI.Impl;
+    return *this;
+  }
+  PassInstrumentation &operator=(PassInstrumentation &&PI) {
+    Impl = PI.Impl;
+    return *this;
+  }
+
+  // pass-instrumentation calls
+  bool runBeforePass(StringRef PassID, IRUnitT& IR) {
+    return (Impl ? Impl->runBeforePass(PassID, IR) : true);
+  }
+
+  void runAfterPass(StringRef PassID, IRUnitT& IR) {
+    if (Impl) Impl->runAfterPass(PassID, IR);
+  }
+
+  void runStartPipeline() {
+    if (Impl) Impl->runStartPipeline();
+  }
+
+  void runEndPipeline() {
+    if (Impl) Impl->runEndPipeline();
+  }
+
+  void registerBeforePassCallback(const std::function<PassInstrumentationImpl::BeforePassFunc<PassInstrumentationImpl::IRUnitWrapper>> &C) {
+    assert(Impl);
+    Impl->registerBeforePassCallback(C);
+  }
+
+  void registerAfterPassCallback(const std::function<PassInstrumentationImpl::AfterPassFunc<PassInstrumentationImpl::IRUnitWrapper>> &C) {
+    assert(Impl);
+    Impl->registerAfterPassCallback(C);
+  }
+
+  void registerStartPipelineCallback(const std::function<void()> &C) {
+    assert(Impl);
+    Impl->registerStartPipelineCallback(C);
+  }
+
+  void registerEndPpelineCallback(const std::function<void()> &C) {
+    assert(Impl);
+    Impl->registerEndPipelineCallback(C);
+  }
+
+  PassExecutionCounter& getPC() {
+    assert(Impl);
+    return Impl->getPC();
+  }
+
+  /// Handle invalidation from the pass manager.
+  ///
+  /// On attempt to invalidate just return false. There is nothing to become invalid here.
+  template <typename ...ExtraArgsT>
+  bool invalidate(IRUnitT &, const class llvm::PreservedAnalyses&, ExtraArgsT...) {
+    return false;
+  }
+};
+
+} // End llvm namespace
+
+#endif
Index: include/llvm/IR/PassManager.h
===================================================================
--- include/llvm/IR/PassManager.h
+++ include/llvm/IR/PassManager.h
@@ -44,6 +44,7 @@
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PassManagerInternal.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/TypeName.h"
@@ -402,6 +403,9 @@
   }
 };
 
+template <typename IRUnitT>
+class PassInstrumentationAnalysis;
+
 /// Manages a sequence of passes over a particular unit of IR.
 ///
 /// A pass manager contains a sequence of passes to run over a particular unit
@@ -445,6 +449,8 @@
                         ExtraArgTs... ExtraArgs) {
     PreservedAnalyses PA = PreservedAnalyses::all();
 
+    PassInstrumentation<IRUnitT> PI = AM.getPassInstrumentation(IR, std::tuple<ExtraArgTs...>(ExtraArgs...));
+
     if (DebugLogging)
       dbgs() << "Starting " << getTypeName<IRUnitT>() << " pass manager run.\n";
 
@@ -452,9 +458,13 @@
       if (DebugLogging)
         dbgs() << "Running pass: " << Passes[Idx]->name() << " on "
                << IR.getName() << "\n";
+      if (!PI.runBeforePass(Passes[Idx]->name(), IR))
+	continue;
 
       PreservedAnalyses PassPA = Passes[Idx]->run(IR, AM, ExtraArgs...);
 
+      PI.runAfterPass(Passes[Idx]->name(), IR);
+
       // Update the analysis manager as each pass runs and potentially
       // invalidates analyses.
       AM.invalidate(IR, PassPA);
@@ -491,6 +501,7 @@
   }
 
 private:
+
   using PassConceptT =
       detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
 
@@ -680,6 +691,37 @@
     AnalysisResultLists.clear();
   }
 
+  /// Helper for partial unpacking of extra arguments in getPassInstrumentation
+  ///
+  /// Arguments passed in tuple come from PassManager, so they might have extra arguments
+  /// after those AnalysisManager's ExtraArgTs ones that we need to pass to getResult.
+  template <typename ...ArgTs>
+  PassInstrumentation<IRUnitT> getPassInstrumentation(IRUnitT& IR, std::tuple<ArgTs...> Args) {
+    return getPassInstrumentation(IR, Args, llvm::index_sequence_for<ExtraArgTs...>{});
+  }
+
+  /// Actual unpacker of extra arguments in getPassInstrumentation,
+  /// passes only those tuple arguments that are mentioned in index_sequence.
+  template <typename ...ArgTs, size_t... Ns>
+  PassInstrumentation<IRUnitT> getPassInstrumentation(IRUnitT& IR, std::tuple<ArgTs...> Args,
+						      llvm::index_sequence<Ns...>) {
+    (void)Args;
+    return getPassInstrumentation(IR, std::get<Ns>(Args)...);
+  }
+
+  /// Get the result of a PassInstrumentationAnalysis
+  PassInstrumentation<IRUnitT> getPassInstrumentation(IRUnitT& IR, ExtraArgTs... ExtraArgs) {
+    // avoid failing when analysis is not registered (mostly for tests)
+    if (!isRegisteredAnalysis<PassInstrumentationAnalysis<IRUnitT>>())
+      return PassInstrumentation<IRUnitT>();
+    return getResult<PassInstrumentationAnalysis<IRUnitT>>(IR, ExtraArgs...);
+  }
+
+  template <typename PassT>
+  bool isRegisteredAnalysis() const {
+    return AnalysisPasses.count(PassT::ID()) != 0;
+  }
+
   /// Get the result of an analysis pass for a given IR unit.
   ///
   /// Runs the analysis if a cached result is not available.
@@ -688,7 +730,7 @@
     assert(AnalysisPasses.count(PassT::ID()) &&
            "This analysis pass was not registered prior to being queried");
     ResultConceptT &ResultConcept =
-        getResultImpl(PassT::ID(), IR, ExtraArgs...);
+      getResultImpl(PassT::ID(), IR, ExtraArgs...);
 
     using ResultModelT =
         detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
@@ -1147,6 +1189,33 @@
   const AnalysisManagerT *AM;
 };
 
+/// Pseudo-analysis pass that exposes the \c PassInstrumentation for IRUnit being processed.
+template <typename IRUnitT>
+class PassInstrumentationAnalysis : public AnalysisInfoMixin<PassInstrumentationAnalysis<IRUnitT>> {
+  friend AnalysisInfoMixin<PassInstrumentationAnalysis<IRUnitT>>;
+  static AnalysisKey Key;
+
+  PassInstrumentationImpl &PIImpl;
+
+public:
+  PassInstrumentationAnalysis(PassInstrumentationImpl &_PIImpl)
+    : PIImpl(_PIImpl) { }
+    
+  typedef PassInstrumentation<IRUnitT> Result;
+
+  template <typename AnalysisManagerT, typename ...ExtraArgTs>
+  Result run(IRUnitT&, AnalysisManagerT&, ExtraArgTs&&...) {
+    return PassInstrumentation<IRUnitT>(PIImpl);
+  }
+
+};
+
+template <typename IRUnitT>
+AnalysisKey PassInstrumentationAnalysis<IRUnitT>::Key;
+
+extern template class PassInstrumentationAnalysis<Module>;
+extern template class PassInstrumentationAnalysis<Function>;
+
 template <typename AnalysisManagerT, typename IRUnitT, typename... ExtraArgTs>
 AnalysisKey
     OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>::Key;
@@ -1192,13 +1261,19 @@
     FunctionAnalysisManager &FAM =
         AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
 
+    PassInstrumentation<Function> PI = AM.getPassInstrumentation(M);
+
     PreservedAnalyses PA = PreservedAnalyses::all();
     for (Function &F : M) {
       if (F.isDeclaration())
         continue;
 
+      if (!PI.runBeforePass(Pass.name(), F))
+	continue;
       PreservedAnalyses PassPA = Pass.run(F, FAM);
 
+      PI.runAfterPass(Pass.name(), F);
+
       // We know that the function pass couldn't have invalidated any other
       // function's analyses (that's the contract of a function pass), so
       // directly handle the function analysis manager's invalidation here.
@@ -1302,10 +1377,17 @@
   RepeatedPass(int Count, PassT P) : Count(Count), P(std::move(P)) {}
 
   template <typename IRUnitT, typename AnalysisManagerT, typename... Ts>
-  PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, Ts &&... Args) {
+    PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, Ts &&... Args) {
+
+    PassInstrumentation<IRUnitT> PI = AM.getPassInstrumentation(IR, std::tuple<Ts...>(Args...));
+
     auto PA = PreservedAnalyses::all();
-    for (int i = 0; i < Count; ++i)
-      PA.intersect(P.run(Arg, AM, std::forward<Ts>(Args)...));
+    for (int i = 0; i < Count; ++i) {
+      if (!PI.runBeforePass(P.name(), IR))
+	continue;
+      PA.intersect(P.run(IR, AM, std::forward<Ts>(Args)...));
+      PI.runAfterPass(P.name(), IR);
+    }
     return PA;
   }
 
Index: include/llvm/IR/PassManagerInternal.h
===================================================================
--- include/llvm/IR/PassManagerInternal.h
+++ include/llvm/IR/PassManagerInternal.h
@@ -290,7 +290,7 @@
       AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>>
   run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
       ExtraArgTs... ExtraArgs) override {
-    return llvm::make_unique<ResultModelT>(Pass.run(IR, AM, ExtraArgs...));
+    return llvm::make_unique<ResultModelT>(Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
   }
 
   /// The model delegates to a static \c PassT::name method.
Index: include/llvm/Passes/PassBuilder.h
===================================================================
--- include/llvm/Passes/PassBuilder.h
+++ include/llvm/Passes/PassBuilder.h
@@ -58,6 +58,9 @@
 class PassBuilder {
   TargetMachine *TM;
   Optional<PGOOptions> PGOOpt;
+  std::unique_ptr<PassInstrumentationImpl> PIImpl;
+
+  PassInstrumentationImpl* getPassInst() const { return PIImpl.get(); }
 
 public:
   /// A struct to capture parsed pass pipeline names.
@@ -555,6 +558,13 @@
     TopLevelPipelineParsingCallbacks.push_back(C);
   }
 
+  void registerPassInstrumentation(
+      const std::function<void(PassInstrumentationImpl &)> &C) {
+    if (!PIImpl.get())
+      PIImpl = llvm::make_unique<PassInstrumentationImpl>();
+    C(*PIImpl.get());
+  }
+
 private:
   static Optional<std::vector<PipelineElement>>
   parsePipelineText(StringRef Text);
Index: include/llvm/Transforms/Scalar/LoopPassManager.h
===================================================================
--- include/llvm/Transforms/Scalar/LoopPassManager.h
+++ include/llvm/Transforms/Scalar/LoopPassManager.h
@@ -71,6 +71,8 @@
 extern template class PassManager<Loop, LoopAnalysisManager,
                                   LoopStandardAnalysisResults &, LPMUpdater &>;
 
+extern template class PassInstrumentationAnalysis<Loop>;
+
 /// The Loop pass manager.
 ///
 /// See the documentation for the PassManager template for details. It runs
@@ -321,6 +323,9 @@
     // FIXME: Consider changing the order in LoopInfo.
     internal::appendLoopsToWorklist(reverse(LI), Worklist);
 
+    // Get pass instrumentation handler
+    PassInstrumentation<Loop> PI = AM.getPassInstrumentation(F);
+
     do {
       Loop *L = Worklist.pop_back_val();
 
@@ -337,8 +342,12 @@
       assert(L->isRecursivelyLCSSAForm(LAR.DT, LI) &&
              "Loops must remain in LCSSA form!");
 #endif
-
+      if (!PI.runBeforePass(Pass.name(), *L))
+	continue;
       PreservedAnalyses PassPA = Pass.run(*L, LAM, LAR, Updater);
+
+      PI.runAfterPass(Pass.name(), *L);
+
       // FIXME: We should verify the set of analyses relevant to Loop passes
       // are preserved.
 
Index: lib/Analysis/CGSCCPassManager.cpp
===================================================================
--- lib/Analysis/CGSCCPassManager.cpp
+++ lib/Analysis/CGSCCPassManager.cpp
@@ -45,6 +45,7 @@
 template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
                                          LazyCallGraph::SCC, LazyCallGraph &>;
 template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
+template class PassInstrumentationAnalysis<LazyCallGraph::SCC>;
 
 /// Explicitly specialize the pass manager run method to handle call graph
 /// updates.
@@ -54,6 +55,9 @@
             CGSCCUpdateResult &>::run(LazyCallGraph::SCC &InitialC,
                                       CGSCCAnalysisManager &AM,
                                       LazyCallGraph &G, CGSCCUpdateResult &UR) {
+  // Get pass instrumentation handler
+  PassInstrumentation<LazyCallGraph::SCC> PI = AM.getPassInstrumentation(InitialC, G);
+
   PreservedAnalyses PA = PreservedAnalyses::all();
 
   if (DebugLogging)
@@ -67,8 +71,13 @@
     if (DebugLogging)
       dbgs() << "Running pass: " << Pass->name() << " on " << *C << "\n";
 
+    if (!PI.runBeforePass(Pass->name(), *C))
+      continue;
+
     PreservedAnalyses PassPA = Pass->run(*C, AM, G, UR);
 
+    PI.runAfterPass(Pass->name(), *C);
+
     // Update the SCC if necessary.
     C = UR.UpdatedC ? UR.UpdatedC : C;
 
Index: lib/IR/CMakeLists.txt
===================================================================
--- lib/IR/CMakeLists.txt
+++ lib/IR/CMakeLists.txt
@@ -42,6 +42,7 @@
   Operator.cpp
   OptBisect.cpp
   Pass.cpp
+  PassInstrumentation.cpp
   PassManager.cpp
   PassRegistry.cpp
   SafepointIRVerifier.cpp
Index: lib/IR/PassInstrumentation.cpp
===================================================================
--- /dev/null
+++ lib/IR/PassInstrumentation.cpp
@@ -0,0 +1,61 @@
+//===- PassInstrumentation.h - Pass Instrumentation interface ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/PassInstrumentation.h"
+#include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/IR/PassManager.h"
+
+
+namespace llvm {
+
+UniqueVector<StringRef> PassInstrumentationImpl::IRUnitWrapper::IRUnits;
+
+template <typename IRUnitT>
+bool PassInstrumentationImpl::runBeforePass(StringRef PassID, IRUnitT& IR) const {
+  ++PC;
+
+  bool shouldRun = true;
+
+  static IRUnitWrapper::IRUnitID IRID = IRUnitWrapper::idForType<IRUnitT>();
+  for (auto& C : BeforePassCallbacks)
+    shouldRun &= C(PassID, IRUnitWrapper(IR, IRID), PC);
+  return shouldRun;
+}
+
+template <typename IRUnitT>
+void PassInstrumentationImpl::runAfterPass(StringRef PassID, IRUnitT& IR) const {
+  static IRUnitWrapper::IRUnitID IRID = IRUnitWrapper::idForType<IRUnitT>();
+  for (auto& C : AfterPassCallbacks)
+    C(PassID, IRUnitWrapper(IR, IRID), PC);
+}
+
+void PassInstrumentationImpl::runStartPipeline() const {
+  for (auto& C : StartPipelineCallbacks)
+    C();
+}
+
+void PassInstrumentationImpl::runEndPipeline() const {
+  for (auto& C : EndPipelineCallbacks)
+    C();
+}
+
+template bool PassInstrumentationImpl::runBeforePass(StringRef PassID, Module& IR) const;
+template bool PassInstrumentationImpl::runBeforePass(StringRef PassID, Function& IR) const;
+template bool PassInstrumentationImpl::runBeforePass(StringRef PassID, Loop& IR) const;
+template bool PassInstrumentationImpl::runBeforePass(StringRef PassID, LazyCallGraph::SCC& IR) const;
+template void PassInstrumentationImpl::runAfterPass(StringRef PassID, Module& IR) const;
+template void PassInstrumentationImpl::runAfterPass(StringRef PassID, Function& IR) const;
+template void PassInstrumentationImpl::runAfterPass(StringRef PassID, Loop& IR) const;
+template void PassInstrumentationImpl::runAfterPass(StringRef PassID, LazyCallGraph::SCC& IR) const;
+
+template class PassInstrumentationAnalysis<Module>;
+template class PassInstrumentationAnalysis<Function>;
+
+}
Index: lib/Passes/PassBuilder.cpp
===================================================================
--- lib/Passes/PassBuilder.cpp
+++ lib/Passes/PassBuilder.cpp
@@ -1764,6 +1764,12 @@
                                        ModuleAnalysisManager &MAM) {
   MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
   MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
+
+  MAM.registerPass([&] { return PassInstrumentationAnalysis<Module>(*this->getPassInst()); });
+  FAM.registerPass([&] { return PassInstrumentationAnalysis<Function>(*this->getPassInst()); });
+  CGAM.registerPass([&] { return PassInstrumentationAnalysis<LazyCallGraph::SCC>(*this->getPassInst()); });
+  LAM.registerPass([&] { return PassInstrumentationAnalysis<Loop>(*this->getPassInst()); });
+
   CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
   FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
   FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
Index: lib/Transforms/Scalar/LoopPassManager.cpp
===================================================================
--- lib/Transforms/Scalar/LoopPassManager.cpp
+++ lib/Transforms/Scalar/LoopPassManager.cpp
@@ -18,6 +18,8 @@
 template class PassManager<Loop, LoopAnalysisManager,
                            LoopStandardAnalysisResults &, LPMUpdater &>;
 
+template class PassInstrumentationAnalysis<Loop>;
+
 /// Explicitly specialize the pass manager's run method to handle loop nest
 /// structure updates.
 template <>
@@ -30,6 +32,7 @@
   if (DebugLogging)
     dbgs() << "Starting Loop pass manager run.\n";
 
+  PassInstrumentation<Loop> PI = AM.getPassInstrumentation(L, AR);
   for (auto &Pass : Passes) {
     if (DebugLogging)
       dbgs() << "Running pass: " << Pass->name() << " on " << L;
Index: test/Other/loop-pm-invalidation.ll
===================================================================
--- test/Other/loop-pm-invalidation.ll
+++ test/Other/loop-pm-invalidation.ll
@@ -73,6 +73,7 @@
 ; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-LOOP-INV-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}LoopAnalysis
@@ -90,6 +91,7 @@
 ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
 ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run.
@@ -108,6 +110,7 @@
 ; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-SCEV-INV-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}ScalarEvolutionAnalysis
@@ -123,6 +126,7 @@
 ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
 ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run.
@@ -153,9 +157,11 @@
 ; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-LOOP-INV: Finished {{.*}}Loop pass manager run.
 ; CHECK-LOOP-INV-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}LoopAnalysis
@@ -174,9 +180,11 @@
 ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
 ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-LOOP-INV: Finished {{.*}}Loop pass manager run.
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run.
@@ -195,9 +203,11 @@
 ; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV: Finished {{.*}}Loop pass manager run.
 ; CHECK-SCEV-INV-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}ScalarEvolutionAnalysis
@@ -214,9 +224,11 @@
 ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
 ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV: Finished {{.*}}Loop pass manager run.
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run.
@@ -254,6 +266,7 @@
 ; CHECK-LOOP-INV-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-LOOP-INV-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}LoopAnalysis
@@ -271,6 +284,7 @@
 ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
 ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-LOOP-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-LOOP-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run.
@@ -289,6 +303,7 @@
 ; CHECK-SCEV-INV-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-SCEV-INV-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}ScalarEvolutionAnalysis
@@ -304,6 +319,7 @@
 ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis
 ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Loop pass manager run.
 ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run.
@@ -322,6 +338,7 @@
 ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop
 ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Starting {{.*}}Loop pass manager run.
+; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: NoOpLoopPass
 ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LoopDeletionPass
 ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Clearing all analysis results for:
Index: test/Other/new-pass-manager.ll
===================================================================
--- test/Other/new-pass-manager.ll
+++ test/Other/new-pass-manager.ll
@@ -24,6 +24,7 @@
 ; CHECK-CGSCC-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*(FunctionAnalysisManager|AnalysisManager<.*Function.*>).*}},{{.*}}Module>
 ; CHECK-CGSCC-PASS-NEXT: Running analysis: LazyCallGraphAnalysis
 ; CHECK-CGSCC-PASS-NEXT: Running analysis: TargetLibraryAnalysis
+; CHECK-CGSCC-PASS-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}LazyCallGraph::SCC>
 ; CHECK-CGSCC-PASS-NEXT: Starting CGSCC pass manager run
 ; CHECK-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
 ; CHECK-CGSCC-PASS-NEXT: Finished CGSCC pass manager run
@@ -38,6 +39,7 @@
 ; CHECK-FUNCTION-PASS: Starting llvm::Module pass manager run
 ; CHECK-FUNCTION-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-FUNCTION-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
+; CHECK-FUNCTION-PASS-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Function>
 ; CHECK-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
 ; CHECK-FUNCTION-PASS-NEXT: Running pass: NoOpFunctionPass
 ; CHECK-FUNCTION-PASS-NEXT: Finished llvm::Function pass manager run
@@ -408,6 +410,7 @@
 ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*(FunctionAnalysisManager|AnalysisManager<.*Function.*>).*}},{{.*}}Module>
 ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: LazyCallGraphAnalysis
 ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: TargetLibraryAnalysis
+; CHECK-REPEAT-CGSCC-PASS-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}LazyCallGraph::SCC>
 ; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting CGSCC pass manager run
 ; CHECK-REPEAT-CGSCC-PASS-NEXT: Running pass: RepeatedPass
 ; CHECK-REPEAT-CGSCC-PASS-NEXT: Starting CGSCC pass manager run
@@ -428,6 +431,7 @@
 ; CHECK-REPEAT-FUNCTION-PASS: Starting llvm::Module pass manager run
 ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
+; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Function>
 ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
 ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Running pass: RepeatedPass
 ; CHECK-REPEAT-FUNCTION-PASS-NEXT: Starting llvm::Function pass manager run
@@ -448,6 +452,7 @@
 ; CHECK-REPEAT-LOOP-PASS: Starting llvm::Module pass manager run
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Function>
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: FunctionToLoopPassAdaptor
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run
@@ -464,6 +469,7 @@
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: TargetIRAnalysis
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting Loop pass manager run
+; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: RepeatedPass
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting Loop pass manager run
 ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: NoOpLoopPass
Index: test/Other/new-pm-defaults.ll
===================================================================
--- test/Other/new-pm-defaults.ll
+++ test/Other/new-pm-defaults.ll
@@ -67,7 +67,8 @@
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \
 ; RUN:     --check-prefix=CHECK-EP-PIPELINE-START
 
-; CHECK-O: Starting llvm::Module pass manager run.
+; CHECK-O: Running analysis: PassInstrumentationAnalysis<{{.*}}Module>
+; CHECK-O-NEXT: Starting llvm::Module pass manager run.
 ; CHECK-O-NEXT: Running pass: PassManager<{{.*}}Module{{.*}}>
 ; CHECK-O-NEXT: Starting llvm::Module pass manager run.
 ; CHECK-O-NEXT: Running pass: ForceFunctionAttrsPass
@@ -78,6 +79,7 @@
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
+; CHECK-O-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Function>
 ; CHECK-O-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis
@@ -110,6 +112,7 @@
 ; CHECK-O-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor<{{.*}}LazyCallGraph{{.*}}>
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: LazyCallGraphAnalysis
+; CHECK-O-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}LazyCallGraph{{.*}}>
 ; CHECK-O-NEXT: Starting CGSCC pass manager run.
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy<{{.*}}LazyCallGraph{{.*}}>
@@ -145,6 +148,7 @@
 ; CHECK-O-NEXT: Running analysis: ScalarEvolutionAnalysis
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Starting Loop pass manager run.
+; CHECK-O-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-O-NEXT: Running pass: LoopInstSimplifyPass
 ; CHECK-O-NEXT: Running pass: LoopSimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: LoopRotatePass
Index: test/Other/new-pm-lto-defaults.ll
===================================================================
--- test/Other/new-pm-lto-defaults.ll
+++ test/Other/new-pm-lto-defaults.ll
@@ -32,6 +32,7 @@
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O2-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-O2-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Module
+; CHECK-O2-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Function>
 ; CHECK-O2-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O2-NEXT: Running pass: CallSiteSplittingPass on foo
 ; CHECK-O2-NEXT: Running analysis: TargetLibraryAnalysis on foo
Index: test/Other/new-pm-thinlto-defaults.ll
===================================================================
--- test/Other/new-pm-thinlto-defaults.ll
+++ test/Other/new-pm-thinlto-defaults.ll
@@ -64,6 +64,7 @@
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}>
 ; CHECK-PRELINK-O-NODIS-NEXT: Running analysis: InnerAnalysisManagerProxy
+; CHECK-O-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Function>
 ; CHECK-O-NEXT: Starting llvm::Function pass manager run.
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis
@@ -95,6 +96,7 @@
 ; CHECK-O-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor<{{.*}}LazyCallGraph{{.*}}>
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: LazyCallGraphAnalysis
+; CHECK-O-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}LazyCallGraph{{.*}}>
 ; CHECK-O-NEXT: Starting CGSCC pass manager run.
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy<{{.*}}LazyCallGraph{{.*}}>
@@ -129,6 +131,7 @@
 ; CHECK-O-NEXT: Running analysis: ScalarEvolutionAnalysis
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Starting Loop pass manager run.
+; CHECK-O-NEXT: Running analysis: PassInstrumentationAnalysis<{{.*}}Loop>
 ; CHECK-O-NEXT: Running pass: LoopInstSimplifyPass
 ; CHECK-O-NEXT: Running pass: LoopSimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: LoopRotatePass
Index: test/Transforms/Inline/cgscc-incremental-invalidate.ll
===================================================================
--- test/Transforms/Inline/cgscc-incremental-invalidate.ll
+++ test/Transforms/Inline/cgscc-incremental-invalidate.ll
@@ -33,7 +33,8 @@
 ; CHECK-NEXT: Running pass: DominatorTreeVerifierPass on test1_g
 ; CHECK-NEXT: Running analysis: DominatorTreeAnalysis on test1_g
 ; CHECK-NEXT: Finished llvm::Function pass manager run.
-; CHECK-NEXT: Starting llvm::Function pass manager run.
+; CHECK-NOT: Invalidating analysis:
+; CHECK: Starting llvm::Function pass manager run.
 ; CHECK-NEXT: Running pass: DominatorTreeVerifierPass on test1_h
 ; CHECK-NEXT: Running analysis: DominatorTreeAnalysis on test1_h
 ; CHECK-NEXT: Finished llvm::Function pass manager run.