diff --git a/llvm/include/llvm/Analysis/CGSCCPassManager.h b/llvm/include/llvm/Analysis/CGSCCPassManager.h
--- a/llvm/include/llvm/Analysis/CGSCCPassManager.h
+++ b/llvm/include/llvm/Analysis/CGSCCPassManager.h
@@ -497,7 +497,9 @@
       Function &F = N->getFunction();
 
       PassInstrumentation PI = FAM.getResult<PassInstrumentationAnalysis>(F);
-      if (!PI.runBeforePass<Function>(Pass, F))
+
+      bool IsFPM = std::is_base_of<FunctionPassT, FunctionPassManager>::value;
+      if (!PI.runBeforePass<Function>(Pass, F) && !IsFPM)
         continue;
 
       PreservedAnalyses PassPA;
diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h
--- a/llvm/include/llvm/IR/PassManager.h
+++ b/llvm/include/llvm/IR/PassManager.h
@@ -459,9 +459,7 @@
 /// argument. The pass manager will propagate that analysis manager to each
 /// pass it runs, and will call the analysis manager's invalidation routine with
 /// the PreservedAnalyses of each pass it runs.
-template <typename IRUnitT,
-          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
-          typename... ExtraArgTs>
+template <typename IRUnitT, typename AnalysisManagerT, typename... ExtraArgTs>
 class PassManager : public PassInfoMixin<
                         PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>> {
 public:
@@ -510,7 +508,7 @@
       // Check the PassInstrumentation's BeforePass callbacks before running the
       // pass, skip its execution completely if asked to (callback returns
       // false).
-      if (!PI.runBeforePass<IRUnitT>(*P, IR))
+      if (!PI.runBeforePass<IRUnitT>(*P, IR) && P->isSkippable())
         continue;
 
       PreservedAnalyses PassPA;
@@ -1228,7 +1226,8 @@
       // Check the PassInstrumentation's BeforePass callbacks before running the
       // pass, skip its execution completely if asked to (callback returns
       // false).
-      if (!PI.runBeforePass<Function>(Pass, F))
+      bool IsFPM = std::is_base_of<FunctionPassT, FunctionPassManager>::value;
+      if (!PI.runBeforePass<Function>(Pass, F) && !IsFPM)
         continue;
 
       PreservedAnalyses PassPA;
diff --git a/llvm/include/llvm/IR/PassManagerInternal.h b/llvm/include/llvm/IR/PassManagerInternal.h
--- a/llvm/include/llvm/IR/PassManagerInternal.h
+++ b/llvm/include/llvm/IR/PassManagerInternal.h
@@ -28,6 +28,37 @@
 template <typename IRUnitT, typename... ExtraArgTs> class AnalysisManager;
 class PreservedAnalyses;
 
+template <typename IRUnitT,
+          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
+          typename... ExtraArgTs>
+class PassManager;
+
+class Function;
+using FunctionPassManager = PassManager<Function>;
+
+class Loop;
+struct LoopStandardAnalysisResults;
+class LPMUpdater;
+using LoopAnalysisManager =
+    AnalysisManager<Loop, LoopStandardAnalysisResults &>;
+using LoopPassManager =
+    PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
+                LPMUpdater &>;
+
+// class LazyCallGraph;
+// class LazyCallGraph::SCC; // <----- can not forward declare
+// class CGSCCUpdateResult;
+// using CGSCCAnalysisManager =
+//     AnalysisManager<LazyCallGraph::SCC, LazyCallGraph &>;
+// using CGSCCPassManager =
+//     PassManager<LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &,
+//                 CGSCCUpdateResult &>;
+
+template <typename FunctionPassT> class ModuleToFunctionPassAdaptor;
+template <typename LoopPassT> class FunctionToLoopPassAdaptor;
+// template <typename CGSCCPassT> class ModuleToPostOrderCGSCCPassAdaptor;
+template <typename FunctionPassT> class CGSCCToFunctionPassAdaptor;
+
 /// Implementation details of the pass manager interfaces.
 namespace detail {
 
@@ -48,6 +79,8 @@
 
   /// Polymorphic method to access the name of a pass.
   virtual StringRef name() const = 0;
+
+  virtual bool isSkippable() const = 0;
 };
 
 /// A template wrapper used to implement the polymorphic API.
@@ -81,6 +114,19 @@
 
   StringRef name() const override { return PassT::name(); }
 
+  bool isSkippable() const override {
+    return !(
+        std::is_base_of<
+            PassT, ModuleToFunctionPassAdaptor<FunctionPassManager>>::value ||
+        std::is_base_of<PassT,
+                        FunctionToLoopPassAdaptor<LoopPassManager>>::value ||
+        // TODO:
+        // std::is_base_of<PassT,
+        //     ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassManager>>::value ||
+        std::is_base_of<
+            PassT, CGSCCToFunctionPassAdaptor<FunctionPassManager>>::value);
+  }
+
   PassT Pass;
 };
 
diff --git a/llvm/include/llvm/Transforms/Scalar/LoopPassManager.h b/llvm/include/llvm/Transforms/Scalar/LoopPassManager.h
--- a/llvm/include/llvm/Transforms/Scalar/LoopPassManager.h
+++ b/llvm/include/llvm/Transforms/Scalar/LoopPassManager.h
@@ -250,7 +250,8 @@
     PreservedAnalyses PA = PreservedAnalyses::all();
     // Check the PassInstrumentation's BeforePass callbacks before running the
     // canonicalization pipeline.
-    if (PI.runBeforePass<Function>(LoopCanonicalizationFPM, F)) {
+    bool IsLPM = std::is_base_of<LoopPassT, LoopPassManager>::value;
+    if (PI.runBeforePass<Function>(LoopCanonicalizationFPM, F) || IsLPM) {
       PA = LoopCanonicalizationFPM.run(F, AM);
       PI.runAfterPass<Function>(LoopCanonicalizationFPM, F);
     }