Index: include/llvm/IR/PassInstrumentation.h
===================================================================
--- include/llvm/IR/PassInstrumentation.h
+++ include/llvm/IR/PassInstrumentation.h
@@ -47,10 +47,12 @@
 
 class PassInstrumentationImpl {
 public:
-  // Before/After Pass callbacks accept IRUnits, so they need to take them
+  // Before/After callbacks accept IRUnits, so they need to take them
   // as pointers, wrapped with llvm::Any
   using BeforePassFunc = bool(StringRef, Any, PassExecutionCounter);
   using AfterPassFunc = void(StringRef, Any, PassExecutionCounter);
+  using BeforeAnalysisFunc = void(StringRef, Any, PassExecutionCounter);
+  using AfterAnalysisFunc = void(StringRef, Any, PassExecutionCounter);
 
 public:
   PassInstrumentationImpl() {}
@@ -61,6 +63,12 @@
   template <typename IRUnitT>
   void runAfterPass(StringRef PassID, IRUnitT &) const;
 
+  template <typename IRUnitT>
+  void runBeforeAnalysis(StringRef PassID, IRUnitT &) const;
+
+  template <typename IRUnitT>
+  void runAfterAnalysis(StringRef PassID, IRUnitT &) const;
+
   void runStartPipeline() const;
 
   void runEndPipeline() const;
@@ -73,6 +81,16 @@
     AfterPassCallbacks.push_back(C);
   }
 
+  void
+  registerBeforeAnalysisCallback(const std::function<BeforeAnalysisFunc> &C) {
+    BeforeAnalysisCallbacks.push_back(C);
+  }
+
+  void
+  registerAfterAnalysisCallback(const std::function<AfterAnalysisFunc> &C) {
+    AfterAnalysisCallbacks.push_back(C);
+  }
+
   void registerStartPipelineCallback(const std::function<void()> &C) {
     StartPipelineCallbacks.push_back(C);
   }
@@ -89,6 +107,8 @@
 
   SmallVector<std::function<BeforePassFunc>, 4> BeforePassCallbacks;
   SmallVector<std::function<AfterPassFunc>, 4> AfterPassCallbacks;
+  SmallVector<std::function<BeforeAnalysisFunc>, 4> BeforeAnalysisCallbacks;
+  SmallVector<std::function<AfterAnalysisFunc>, 4> AfterAnalysisCallbacks;
   SmallVector<std::function<void()>, 2> StartPipelineCallbacks;
   SmallVector<std::function<void()>, 2> EndPipelineCallbacks;
 };
@@ -130,6 +150,16 @@
       Impl->runAfterPass(PassID, IR);
   }
 
+  void runBeforeAnalysis(StringRef PassID, IRUnitT &IR) {
+    if (Impl)
+      Impl->runBeforeAnalysis(PassID, IR);
+  }
+
+  void runAfterAnalysis(StringRef PassID, IRUnitT &IR) {
+    if (Impl)
+      Impl->runAfterAnalysis(PassID, IR);
+  }
+
   void runStartPipeline() {
     if (Impl)
       Impl->runStartPipeline();
@@ -152,6 +182,18 @@
     Impl->registerAfterPassCallback(C);
   }
 
+  void registerBeforeAnalysisCallback(
+      const std::function<PassInstrumentationImpl::BeforeAnalysisFunc> &C) {
+    assert(Impl);
+    Impl->registerBeforeAnalysisCallback(C);
+  }
+
+  void registerAfterAnalysisCallback(
+      const std::function<PassInstrumentationImpl::AfterAnalysisFunc> &C) {
+    assert(Impl);
+    Impl->registerAfterAnalysisCallback(C);
+  }
+
   void registerStartPipelineCallback(const std::function<void()> &C) {
     assert(Impl);
     Impl->registerStartPipelineCallback(C);
Index: include/llvm/IR/PassManager.h
===================================================================
--- include/llvm/IR/PassManager.h
+++ include/llvm/IR/PassManager.h
@@ -905,9 +905,22 @@
       if (DebugLogging)
         dbgs() << "Running analysis: " << P.name() << " on " << IR.getName()
                << "\n";
+
+      PassInstrumentation<IRUnitT> PI;
+      bool IsInstrumentationAnalysis =
+          (ID == PassInstrumentationAnalysis<IRUnitT>::ID());
+      if (!IsInstrumentationAnalysis) {
+        PI =
+            getPassInstrumentation(IR, std::tuple<ExtraArgTs...>(ExtraArgs...));
+        PI.runBeforeAnalysis(P.name(), IR);
+      }
+
       AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
       ResultList.emplace_back(ID, P.run(IR, *this, ExtraArgs...));
 
+      if (!IsInstrumentationAnalysis)
+        PI.runAfterAnalysis(P.name(), IR);
+
       // P.run may have inserted elements into AnalysisResults and invalidated
       // RI.
       RI = AnalysisResults.find({ID, &IR});
Index: lib/IR/PassInstrumentation.cpp
===================================================================
--- lib/IR/PassInstrumentation.cpp
+++ lib/IR/PassInstrumentation.cpp
@@ -33,6 +33,20 @@
     C(PassID, llvm::Any(&IR), PC);
 }
 
+template <typename IRUnitT>
+void PassInstrumentationImpl::runBeforeAnalysis(StringRef PassID,
+                                                IRUnitT &IR) const {
+  for (auto &C : BeforeAnalysisCallbacks)
+    C(PassID, llvm::Any(&IR), PC);
+}
+
+template <typename IRUnitT>
+void PassInstrumentationImpl::runAfterAnalysis(StringRef PassID,
+                                               IRUnitT &IR) const {
+  for (auto &C : AfterAnalysisCallbacks)
+    C(PassID, llvm::Any(&IR), PC);
+}
+
 void PassInstrumentationImpl::runStartPipeline() const {
   for (auto &C : StartPipelineCallbacks)
     C();
@@ -62,6 +76,25 @@
 PassInstrumentationImpl::runAfterPass(StringRef PassID,
                                       LazyCallGraph::SCC &IR) const;
 
+template void PassInstrumentationImpl::runBeforeAnalysis(StringRef PassID,
+                                                         Module &IR) const;
+template void PassInstrumentationImpl::runBeforeAnalysis(StringRef PassID,
+                                                         Function &IR) const;
+template void PassInstrumentationImpl::runBeforeAnalysis(StringRef PassID,
+                                                         Loop &IR) const;
+template void
+PassInstrumentationImpl::runBeforeAnalysis(StringRef PassID,
+                                           LazyCallGraph::SCC &IR) const;
+template void PassInstrumentationImpl::runAfterAnalysis(StringRef PassID,
+                                                        Module &IR) const;
+template void PassInstrumentationImpl::runAfterAnalysis(StringRef PassID,
+                                                        Function &IR) const;
+template void PassInstrumentationImpl::runAfterAnalysis(StringRef PassID,
+                                                        Loop &IR) const;
+template void
+PassInstrumentationImpl::runAfterAnalysis(StringRef PassID,
+                                          LazyCallGraph::SCC &IR) const;
+
 template class PassInstrumentationAnalysis<Module>;
 template class PassInstrumentationAnalysis<Function>;