diff --git a/llvm/include/llvm/CodeGen/PassManager.h b/llvm/include/llvm/CodeGen/PassManager.h
--- a/llvm/include/llvm/CodeGen/PassManager.h
+++ b/llvm/include/llvm/CodeGen/PassManager.h
@@ -40,33 +40,28 @@
 
 /// Expose IR analysis results to machine function pass.
 class MachineFunctionIRAnalysisManager : public MachineFunctionAnalysisManager {
-  ModuleAnalysisManager MAM;
-  FunctionAnalysisManager FAM;
+  // Add LoopAnalysisManager or CGSCCAnalysisManager in the future if needed.
+  FunctionAnalysisManager *FAM;
+  ModuleAnalysisManager *MAM;
 
 public:
-  MachineFunctionIRAnalysisManager(bool DebugLogging = false) {}
+  MachineFunctionIRAnalysisManager(bool DebugLogging = false,
+                                   FunctionAnalysisManager *FAM = nullptr,
+                                   ModuleAnalysisManager *MAM = nullptr)
+      : MachineFunctionAnalysisManager(DebugLogging), FAM(FAM), MAM(MAM) {}
   MachineFunctionIRAnalysisManager(MachineFunctionIRAnalysisManager &&) =
       default;
   MachineFunctionIRAnalysisManager &
   operator=(MachineFunctionIRAnalysisManager &&) = default;
 
-  template <typename PassBuilderT>
-  bool registerModuleAnalysisPass(PassBuilderT &&PassBuilder) {
-    return MAM.registerPass<PassBuilderT>(
-        std::forward<PassBuilderT>(PassBuilder));
-  }
-  template <typename PassBuilderT>
-  bool registerFunctionAnalysisPass(PassBuilderT &&PassBuilder) {
-    return FAM.registerPass<PassBuilderT>(
-        std::forward<PassBuilderT>(PassBuilder));
-  }
-
   template <typename PassT> typename PassT::Result &getResult(const Module &M) {
-    return MAM.getResult<PassT>(const_cast<Module &>(M));
+    assert (MAM);
+    return MAM->getResult<PassT>(const_cast<Module &>(M));
   }
   template <typename PassT>
   typename PassT::Result &getResult(const Function &F) {
-    return FAM.getResult<PassT>(const_cast<Function &>(F));
+    assert (FAM);
+    return FAM->getResult<PassT>(const_cast<Function &>(F));
   }
 };
 
diff --git a/llvm/unittests/CodeGen/CMakeLists.txt b/llvm/unittests/CodeGen/CMakeLists.txt
--- a/llvm/unittests/CodeGen/CMakeLists.txt
+++ b/llvm/unittests/CodeGen/CMakeLists.txt
@@ -6,6 +6,7 @@
   CodeGen
   Core
   MC
+  Passes
   SelectionDAG
   Support
   Target
diff --git a/llvm/unittests/CodeGen/PassManagerTest.cpp b/llvm/unittests/CodeGen/PassManagerTest.cpp
--- a/llvm/unittests/CodeGen/PassManagerTest.cpp
+++ b/llvm/unittests/CodeGen/PassManagerTest.cpp
@@ -6,11 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/Analysis/LoopAnalysisManager.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/PassManager.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Target/TargetMachine.h"
@@ -143,19 +146,23 @@
   LLVMTargetMachine *LLVMTM = static_cast<LLVMTargetMachine *>(TM.get());
   M->setDataLayout(TM->createDataLayout());
 
+  LoopAnalysisManager LAM(/*DebugLogging*/ true);
+  FunctionAnalysisManager FAM(/*DebugLogging*/ true);
+  CGSCCAnalysisManager CGAM(/*DebugLogging*/ true);
+  ModuleAnalysisManager MAM(/*DebugLogging*/ true);
+  MAM.registerPass([&] { return PassInstrumentationAnalysis(); });
+  MAM.registerPass([&] { return MachineModuleAnalysis(LLVMTM); });
+  FAM.registerPass([&] { return PassInstrumentationAnalysis(); });
+  FAM.registerPass([&] { return TestFunctionAnalysis(); });
+  PassBuilder PB;
+  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+
   MachineFunctionIRAnalysisManager MFAM;
   {
     // Test move assignment.
-    MachineFunctionIRAnalysisManager NestedMFAM(/*DebugLogging*/ true);
+    MachineFunctionIRAnalysisManager NestedMFAM(/*DebugLogging*/ true, &FAM,
+                                                &MAM);
     NestedMFAM.registerPass([&] { return PassInstrumentationAnalysis(); });
-    NestedMFAM.registerModuleAnalysisPass(
-        [&] { return PassInstrumentationAnalysis(); });
-    NestedMFAM.registerFunctionAnalysisPass(
-        [&] { return PassInstrumentationAnalysis(); });
-    NestedMFAM.registerModuleAnalysisPass(
-        [&] { return MachineModuleAnalysis(LLVMTM); });
-    NestedMFAM.registerFunctionAnalysisPass(
-        [&] { return TestFunctionAnalysis(); });
     NestedMFAM.registerPass([&] { return TestMachineFunctionAnalysis(); });
     MFAM = std::move(NestedMFAM);
   }