[CodeGen] Align pass manager ownership

39 files changed, 268 insertions, 659 deletions

diff --git a/backend/lib/CodeGen/CMakeLists.txt b/backend/lib/CodeGen/CMakeLists.txt
index 470571d..4488903 100644
--- a/backend/lib/CodeGen/CMakeLists.txt
+++ b/backend/lib/CodeGen/CMakeLists.txt
@@ -48,7 +48,7 @@ set(
   MachineMetadata.cpp
   MachineOperand.cpp
   MachineOptimizationPipeline.cpp
-  MachinePass.cpp
+  MachinePassManager.cpp
   MachinePseudoExpansion.cpp
   MachineRegisterInfo.cpp
   MachineScheduler.cpp
@@ -136,7 +136,10 @@ set(
   "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineMetadata.h"
   "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineOperand.h"
   "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineOptimizationPipeline.h"
-  "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachinePass.h"
+  "${RCC_BACKEND_SOURCE_DIR}/include/rcc/IR/PassManager.h"
+  "${RCC_BACKEND_SOURCE_DIR}/include/rcc/IR/PassInstrumentation.h"
+  "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachineFunctionAnalysisManager.h"
+  "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachinePassManager.h"
   "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/MachinePseudoExpansion.h"
   "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/PrologueEpilogueInsertion.h"
   "${RCC_BACKEND_SOURCE_DIR}/include/rcc/CodeGen/RegisterPressure.h"
@@ -262,7 +265,7 @@ rcc_backend_register_format_files(
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineMetadata.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineOperand.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineOptimizationPipeline.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/MachinePass.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/MachinePassManager.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachinePseudoExpansion.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineRegisterInfo.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineScheduler.cpp"
@@ -350,7 +353,7 @@ rcc_backend_register_tidy_files(
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineMetadata.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineOperand.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineOptimizationPipeline.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/MachinePass.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/MachinePassManager.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachinePseudoExpansion.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineRegisterInfo.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineScheduler.cpp"
diff --git a/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp b/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp
index ff32eda..344e63e 100644
--- a/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp
+++ b/backend/lib/CodeGen/GlobalISel/InstructionSelect.cpp
@@ -194,7 +194,7 @@ const MachinePassContract &InstructionSelect::contract() const noexcept {
 
 Expected<MachinePassResult> InstructionSelect::run(MachineFunction &Function,
                                                    const TargetDescription &Target,
-                                                   MachineAnalysisManager &Analyses) {
+                                                   MachineFunctionAnalysisManager &Analyses) {
   if (Info == nullptr)
     return std::unexpected(passFailure("instruction select has no target behavior interface",
                                        ErrorCode::InvalidArgument));
diff --git a/backend/lib/CodeGen/GlobalISel/Legalizer.cpp b/backend/lib/CodeGen/GlobalISel/Legalizer.cpp
index 60f388d..7781818 100644
--- a/backend/lib/CodeGen/GlobalISel/Legalizer.cpp
+++ b/backend/lib/CodeGen/GlobalISel/Legalizer.cpp
@@ -175,7 +175,7 @@ const MachinePassContract &Legalizer::contract() const noexcept {
 
 Expected<MachinePassResult> Legalizer::run(MachineFunction &Function,
                                            const TargetDescription &Target,
-                                           MachineAnalysisManager &Analyses) {
+                                           MachineFunctionAnalysisManager &Analyses) {
   if (Info == nullptr)
     return std::unexpected(
         passFailure("legalizer has no target behavior interface", ErrorCode::InvalidArgument));
diff --git a/backend/lib/CodeGen/GlobalISel/RegBankSelect.cpp b/backend/lib/CodeGen/GlobalISel/RegBankSelect.cpp
index c36c500..041ab74 100644
--- a/backend/lib/CodeGen/GlobalISel/RegBankSelect.cpp
+++ b/backend/lib/CodeGen/GlobalISel/RegBankSelect.cpp
@@ -122,7 +122,7 @@ const MachinePassContract &RegBankSelect::contract() const noexcept {
 
 Expected<MachinePassResult> RegBankSelect::run(MachineFunction &Function,
                                                const TargetDescription &Target,
-                                               MachineAnalysisManager &) {
+                                               MachineFunctionAnalysisManager &) {
   if (Info == nullptr)
     return std::unexpected(passFailure("register-bank select has no target behavior interface",
                                        ErrorCode::InvalidArgument));
diff --git a/backend/lib/CodeGen/InlineSpiller.cpp b/backend/lib/CodeGen/InlineSpiller.cpp
index 14de321..1d5ba10 100644
--- a/backend/lib/CodeGen/InlineSpiller.cpp
+++ b/backend/lib/CodeGen/InlineSpiller.cpp
@@ -7,7 +7,7 @@
 #include "rcc/CodeGen/MachineIRBuilder.h"
 #include "rcc/CodeGen/MachineInstr.h"
 #include "rcc/CodeGen/MachineOperand.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/MachineRegisterInfo.h"
 #include "rcc/CodeGen/Spiller.h"
 #include "rcc/CodeGen/TargetDescription.h"
diff --git a/backend/lib/CodeGen/LiveIntervals.cpp b/backend/lib/CodeGen/LiveIntervals.cpp
index d8cb539..5a01693 100644
--- a/backend/lib/CodeGen/LiveIntervals.cpp
+++ b/backend/lib/CodeGen/LiveIntervals.cpp
@@ -307,12 +307,12 @@ Expected<void> LiveIntervalsAnalysis::Result::shrinkToUses(Register Reg,
 
 bool LiveIntervalsAnalysis::Result::invalidate(const MachineFunction &,
                                                const PreservedAnalyses &Preserved) const noexcept {
-  return !Preserved.preserves(MachineAnalysisManager::id<LiveIntervalsAnalysis>());
+  return !Preserved.preserves(MachineFunctionAnalysisManager::id<LiveIntervalsAnalysis>());
 }
 
 Expected<LiveIntervalsAnalysis::Result>
 LiveIntervalsAnalysis::run(MachineFunction &Function, const TargetDescription &Target,
-                           MachineAnalysisManager &Analyses) {
+                           MachineFunctionAnalysisManager &Analyses) {
   auto Indexes = Analyses.getResult<SlotIndexesAnalysis>(Function, Target);
   if (!Indexes)
     return std::unexpected(Indexes.error());
diff --git a/backend/lib/CodeGen/LiveVariables.cpp b/backend/lib/CodeGen/LiveVariables.cpp
index 7323e0d..201e09e 100644
--- a/backend/lib/CodeGen/LiveVariables.cpp
+++ b/backend/lib/CodeGen/LiveVariables.cpp
@@ -884,12 +884,12 @@ bool LiveVariablesAnalysis::Result::isUnitLiveOut(const MachineBasicBlock &Block
 
 bool LiveVariablesAnalysis::Result::invalidate(const MachineFunction &,
                                                const PreservedAnalyses &Preserved) const noexcept {
-  return !Preserved.preserves(MachineAnalysisManager::id<LiveVariablesAnalysis>());
+  return !Preserved.preserves(MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>());
 }
 
-Expected<LiveVariablesAnalysis::Result> LiveVariablesAnalysis::run(MachineFunction &Function,
-                                                                   const TargetDescription &Target,
-                                                                   MachineAnalysisManager &) {
+Expected<LiveVariablesAnalysis::Result>
+LiveVariablesAnalysis::run(MachineFunction &Function, const TargetDescription &Target,
+                           MachineFunctionAnalysisManager &) {
   return computeLiveVariables(Function, Target);
 }
 const MachinePassContract &RebuildMachineLivenessPass::contract() const noexcept {
@@ -911,7 +911,7 @@ const MachinePassContract &RebuildMachineLivenessPass::contract() const noexcept
 
 Expected<MachinePassResult> RebuildMachineLivenessPass::run(MachineFunction &Function,
                                                             const TargetDescription &Target,
-                                                            MachineAnalysisManager &) {
+                                                            MachineFunctionAnalysisManager &) {
   const MachineFunctionProperties Missing = contract().Requires.missingFrom(Function.properties());
   if (!Missing.empty()) {
     return makeUnexpected(ErrorCode::VerificationError,
@@ -976,11 +976,11 @@ Expected<void> verifyTrackedMachineLiveness(const MachineFunction &Function,
   return {};
 }
 
-Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses) {
+Expected<void> registerStage11MachineAnalyses(MachineFunctionAnalysisManager &Analyses) {
   const std::array IDs{
-      MachineAnalysisManager::id<SlotIndexesAnalysis>(),
-      MachineAnalysisManager::id<LiveVariablesAnalysis>(),
-      MachineAnalysisManager::id<LiveIntervalsAnalysis>(),
+      MachineFunctionAnalysisManager::id<SlotIndexesAnalysis>(),
+      MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>(),
+      MachineFunctionAnalysisManager::id<LiveIntervalsAnalysis>(),
   };
   const std::size_t Registered = static_cast<std::size_t>(
       std::ranges::count_if(IDs, [&Analyses](AnalysisID ID) { return Analyses.isRegistered(ID); }));
@@ -994,7 +994,7 @@ Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses)
   auto Candidate = Analyses.forkEmpty();
   if (!Candidate)
     return std::unexpected(Candidate.error());
-  MachineAnalysisManager &Staging = **Candidate;
+  MachineFunctionAnalysisManager &Staging = **Candidate;
   auto Slots = Staging.registerAnalysis<SlotIndexesAnalysis>({
       .Name = "SlotIndexes",
       .Dependencies = {},
@@ -1015,8 +1015,8 @@ Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses)
     return std::unexpected(Variables.error());
   auto Intervals = Staging.registerAnalysis<LiveIntervalsAnalysis>({
       .Name = "LiveIntervals",
-      .Dependencies = {MachineAnalysisManager::id<SlotIndexesAnalysis>(),
-                       MachineAnalysisManager::id<LiveVariablesAnalysis>()},
+      .Dependencies = {MachineFunctionAnalysisManager::id<SlotIndexesAnalysis>(),
+                       MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()},
       .InvalidatedBy = {MachinePassChange::Instructions, MachinePassChange::Operands,
                         MachinePassChange::Registers, MachinePassChange::CFG,
                         MachinePassChange::BlockLayout, MachinePassChange::TargetState},
@@ -1024,8 +1024,7 @@ Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses)
   });
   if (!Intervals)
     return std::unexpected(Intervals.error());
-  Analyses.Registry = std::move(Staging.Registry);
-  return {};
+  return Analyses.replaceRegistrations(std::move(Staging));
 }
 
 } // namespace rcc
diff --git a/backend/lib/CodeGen/MachineAnalyses.cpp b/backend/lib/CodeGen/MachineAnalyses.cpp
index 33dc14f..3f09636 100644
--- a/backend/lib/CodeGen/MachineAnalyses.cpp
+++ b/backend/lib/CodeGen/MachineAnalyses.cpp
@@ -263,7 +263,7 @@ const MachineBasicBlock *MachineDominatorTreeAnalysis::Result::nearestCommonDomi
 
 Expected<MachineDominatorTreeAnalysis::Result>
 MachineDominatorTreeAnalysis::run(MachineFunction &Function, const TargetDescription &,
-                                  MachineAnalysisManager &) {
+                                  MachineFunctionAnalysisManager &) {
   Result ResultValue;
   auto Built = ResultValue.build(Function);
   if (!Built)
@@ -287,9 +287,9 @@ bool MachineLoopAnalysis::Result::isIrreducible(const MachineBasicBlock &Block)
   return IrreducibleBlocks.contains(&Block);
 }
 
-Expected<MachineLoopAnalysis::Result> MachineLoopAnalysis::run(MachineFunction &Function,
-                                                               const TargetDescription &Target,
-                                                               MachineAnalysisManager &Analyses) {
+Expected<MachineLoopAnalysis::Result>
+MachineLoopAnalysis::run(MachineFunction &Function, const TargetDescription &Target,
+                         MachineFunctionAnalysisManager &Analyses) {
   auto Dominators = Analyses.getResult<MachineDominatorTreeAnalysis>(Function, Target);
   if (!Dominators)
     return std::unexpected(Dominators.error());
@@ -496,7 +496,7 @@ std::span<const MachineSuccessor> MachineBranchProbabilityAnalysis::Result::succ
 
 Expected<MachineBranchProbabilityAnalysis::Result>
 MachineBranchProbabilityAnalysis::run(MachineFunction &Function, const TargetDescription &,
-                                      MachineAnalysisManager &) {
+                                      MachineFunctionAnalysisManager &) {
   Result ResultValue;
   const std::vector<MachineBasicBlock *> Blocks = linkedBlocks(Function);
   const auto Order = blockOrder(Blocks);
@@ -522,7 +522,7 @@ MachineBlockFrequencyAnalysis::Result::frequency(const MachineBasicBlock &Block)
 
 Expected<MachineBlockFrequencyAnalysis::Result>
 MachineBlockFrequencyAnalysis::run(MachineFunction &Function, const TargetDescription &Target,
-                                   MachineAnalysisManager &Analyses) {
+                                   MachineFunctionAnalysisManager &Analyses) {
   auto Dominators = Analyses.getResult<MachineDominatorTreeAnalysis>(Function, Target);
   auto Loops = Analyses.getResult<MachineLoopAnalysis>(Function, Target);
   auto Probabilities = Analyses.getResult<MachineBranchProbabilityAnalysis>(Function, Target);
@@ -628,8 +628,9 @@ MachineAliasAnalysis::Result::alias(const MachineMemOperand &Left,
   return Distance >= LowerSize ? MachineAliasResult::NoAlias : MachineAliasResult::PartialAlias;
 }
 
-Expected<MachineAliasAnalysis::Result>
-MachineAliasAnalysis::run(MachineFunction &, const TargetDescription &, MachineAnalysisManager &) {
+Expected<MachineAliasAnalysis::Result> MachineAliasAnalysis::run(MachineFunction &,
+                                                                 const TargetDescription &,
+                                                                 MachineFunctionAnalysisManager &) {
   return Result{};
 }
 
@@ -659,7 +660,7 @@ std::span<const MachineMemoryDependency> MachineMemoryDependenceAnalysis::Result
 
 Expected<MachineMemoryDependenceAnalysis::Result>
 MachineMemoryDependenceAnalysis::run(MachineFunction &Function, const TargetDescription &Target,
-                                     MachineAnalysisManager &Analyses) {
+                                     MachineFunctionAnalysisManager &Analyses) {
   auto Alias = Analyses.getResult<MachineAliasAnalysis>(Function, Target);
   if (!Alias)
     return std::unexpected(Alias.error());
@@ -766,14 +767,14 @@ MachineMemoryDependenceAnalysis::run(MachineFunction &Function, const TargetDesc
   return ResultValue;
 }
 
-Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) {
+Expected<void> registerStage8MachineAnalyses(MachineFunctionAnalysisManager &Analyses) {
   const std::array IDs{
-      MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(),
-      MachineAnalysisManager::id<MachineLoopAnalysis>(),
-      MachineAnalysisManager::id<MachineBranchProbabilityAnalysis>(),
-      MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>(),
-      MachineAnalysisManager::id<MachineAliasAnalysis>(),
-      MachineAnalysisManager::id<MachineMemoryDependenceAnalysis>(),
+      MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(),
+      MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(),
+      MachineFunctionAnalysisManager::id<MachineBranchProbabilityAnalysis>(),
+      MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>(),
+      MachineFunctionAnalysisManager::id<MachineAliasAnalysis>(),
+      MachineFunctionAnalysisManager::id<MachineMemoryDependenceAnalysis>(),
   };
   const std::size_t Registered = static_cast<std::size_t>(
       std::ranges::count_if(IDs, [&Analyses](AnalysisID ID) { return Analyses.isRegistered(ID); }));
@@ -787,7 +788,7 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) {
   auto Candidate = Analyses.forkEmpty();
   if (!Candidate)
     return std::unexpected(Candidate.error());
-  MachineAnalysisManager &Staging = **Candidate;
+  MachineFunctionAnalysisManager &Staging = **Candidate;
 
   auto Dominators = Staging.registerAnalysis<MachineDominatorTreeAnalysis>({
       .Name = "MachineDominatorTree",
@@ -799,7 +800,7 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) {
     return std::unexpected(Dominators.error());
   auto Loops = Staging.registerAnalysis<MachineLoopAnalysis>({
       .Name = "MachineLoopInfo",
-      .Dependencies = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>()},
+      .Dependencies = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>()},
       .InvalidatedBy = {MachinePassChange::CFG, MachinePassChange::BlockLayout},
       .ThreadSafety = PassThreadSafety::ThreadSafe,
   });
@@ -815,9 +816,9 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) {
     return std::unexpected(Probabilities.error());
   auto Frequencies = Staging.registerAnalysis<MachineBlockFrequencyAnalysis>({
       .Name = "MachineBlockFrequency",
-      .Dependencies = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(),
-                       MachineAnalysisManager::id<MachineLoopAnalysis>(),
-                       MachineAnalysisManager::id<MachineBranchProbabilityAnalysis>()},
+      .Dependencies = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(),
+                       MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(),
+                       MachineFunctionAnalysisManager::id<MachineBranchProbabilityAnalysis>()},
       .InvalidatedBy = {MachinePassChange::CFG, MachinePassChange::BlockLayout},
       .ThreadSafety = PassThreadSafety::ThreadSafe,
   });
@@ -835,7 +836,7 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) {
     return std::unexpected(Alias.error());
   auto MemoryDependence = Staging.registerAnalysis<MachineMemoryDependenceAnalysis>({
       .Name = "MachineMemoryDependence",
-      .Dependencies = {MachineAnalysisManager::id<MachineAliasAnalysis>()},
+      .Dependencies = {MachineFunctionAnalysisManager::id<MachineAliasAnalysis>()},
       .InvalidatedBy = {MachinePassChange::Instructions, MachinePassChange::Operands,
                         MachinePassChange::CFG, MachinePassChange::BlockLayout,
                         MachinePassChange::Frame, MachinePassChange::ConstantPool,
@@ -844,8 +845,7 @@ Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses) {
   });
   if (!MemoryDependence)
     return std::unexpected(MemoryDependence.error());
-  Analyses.Registry = std::move(Staging.Registry);
-  return {};
+  return Analyses.replaceRegistrations(std::move(Staging));
 }
 
 } // namespace rcc
diff --git a/backend/lib/CodeGen/MachineBlockPlacement.cpp b/backend/lib/CodeGen/MachineBlockPlacement.cpp
index daccba0..1e563e1 100644
--- a/backend/lib/CodeGen/MachineBlockPlacement.cpp
+++ b/backend/lib/CodeGen/MachineBlockPlacement.cpp
@@ -37,10 +37,10 @@ enum class PlacementClass : std::uint8_t {
         .Clears = {},
         .RequiredAnalyses =
             {
-                MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(),
-                MachineAnalysisManager::id<MachineBranchProbabilityAnalysis>(),
-                MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>(),
-                MachineAnalysisManager::id<MachineLoopAnalysis>(),
+                MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(),
+                MachineFunctionAnalysisManager::id<MachineBranchProbabilityAnalysis>(),
+                MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>(),
+                MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(),
             },
         .VerificationStage = PipelineStage::Selected,
     };
@@ -101,9 +101,9 @@ const MachinePassContract &MachineBlockPlacementPass::contract() const noexcept
   return placementContract();
 }
 
-Expected<MachinePassResult> MachineBlockPlacementPass::run(MachineFunction &Function,
-                                                           const TargetDescription &Target,
-                                                           MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+MachineBlockPlacementPass::run(MachineFunction &Function, const TargetDescription &Target,
+                               MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "machine block placement requires selected PHI-free MachineIR");
@@ -113,7 +113,7 @@ Expected<MachinePassResult> MachineBlockPlacementPass::run(MachineFunction &Func
       MachineFunctionCloneOptions{.NewStableID = Function.stableID(), .NewName = std::nullopt});
   if (!Trial)
     return std::unexpected(prefixedError(Trial.error(), "block placement setup failed: "));
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   MachineActionReplay Actions(Analyses, Trial->InstructionStableIDs);
   auto TrialResult = runImplementation(*Trial->ClonedFunction, Target, TrialAnalyses, Actions);
   if (!TrialResult)
@@ -131,8 +131,8 @@ Expected<MachinePassResult> MachineBlockPlacementPass::run(MachineFunction &Func
 }
 
 Expected<MachinePassResult> MachineBlockPlacementPass::runImplementation(
-    MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses,
-    MachineActionReplay &Actions) const {
+    MachineFunction &Function, const TargetDescription &Target,
+    MachineFunctionAnalysisManager &Analyses, MachineActionReplay &Actions) const {
   auto Probabilities = Analyses.getResult<MachineBranchProbabilityAnalysis>(Function, Target);
   if (!Probabilities)
     return std::unexpected(Probabilities.error());
diff --git a/backend/lib/CodeGen/MachineBranchOptimization.cpp b/backend/lib/CodeGen/MachineBranchOptimization.cpp
index 5880dbc..c102931 100644
--- a/backend/lib/CodeGen/MachineBranchOptimization.cpp
+++ b/backend/lib/CodeGen/MachineBranchOptimization.cpp
@@ -301,7 +301,7 @@ const MachinePassContract &MachineBranchOptimizationPass::contract() const noexc
 
 Expected<MachinePassResult> MachineBranchOptimizationPass::run(MachineFunction &Function,
                                                                const TargetDescription &Target,
-                                                               MachineAnalysisManager &) {
+                                                               MachineFunctionAnalysisManager &) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "branch optimization requires selected PHI-free MachineIR");
diff --git a/backend/lib/CodeGen/MachineBranchRelaxation.cpp b/backend/lib/CodeGen/MachineBranchRelaxation.cpp
index 78640f1..c11ed8e 100644
--- a/backend/lib/CodeGen/MachineBranchRelaxation.cpp
+++ b/backend/lib/CodeGen/MachineBranchRelaxation.cpp
@@ -107,9 +107,9 @@ const MachinePassContract &MachineBranchRelaxationPass::contract() const noexcep
   return relaxationContract();
 }
 
-Expected<MachinePassResult> MachineBranchRelaxationPass::run(MachineFunction &Function,
-                                                             const TargetDescription &Target,
-                                                             MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+MachineBranchRelaxationPass::run(MachineFunction &Function, const TargetDescription &Target,
+                                 MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "branch relaxation requires finalized frame and tracked liveness");
diff --git a/backend/lib/CodeGen/MachineCSE.cpp b/backend/lib/CodeGen/MachineCSE.cpp
index 9d80b4e..92fe1bd 100644
--- a/backend/lib/CodeGen/MachineCSE.cpp
+++ b/backend/lib/CodeGen/MachineCSE.cpp
@@ -33,7 +33,7 @@ namespace {
         .Requires = {MachineFunctionProperty::IsSSA, MachineFunctionProperty::Selected},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>()},
         .VerificationStage = PipelineStage::Selected,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -314,7 +314,7 @@ const MachinePassContract &MachineCSEPass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineCSEPass::run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &Analyses) {
+                                                MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "machine CSE requires selected SSA MachineIR");
@@ -325,7 +325,7 @@ Expected<MachinePassResult> MachineCSEPass::run(MachineFunction &Function,
   if (!Trial) {
     return std::unexpected(prefixedError(Trial.error(), "machine CSE transaction setup failed: "));
   }
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto TrialResult = runImplementation(*Trial->ClonedFunction, Target, TrialAnalyses);
   if (!TrialResult)
     return std::unexpected(TrialResult.error());
@@ -338,9 +338,9 @@ Expected<MachinePassResult> MachineCSEPass::run(MachineFunction &Function,
   return Result;
 }
 
-Expected<MachinePassResult> MachineCSEPass::runImplementation(MachineFunction &Function,
-                                                              const TargetDescription &Target,
-                                                              MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+MachineCSEPass::runImplementation(MachineFunction &Function, const TargetDescription &Target,
+                                  MachineFunctionAnalysisManager &Analyses) {
   auto Dominators = Analyses.getResult<MachineDominatorTreeAnalysis>(Function, Target);
   if (!Dominators)
     return std::unexpected(Dominators.error());
diff --git a/backend/lib/CodeGen/MachineCombiner.cpp b/backend/lib/CodeGen/MachineCombiner.cpp
index df9c002..c3e9795 100644
--- a/backend/lib/CodeGen/MachineCombiner.cpp
+++ b/backend/lib/CodeGen/MachineCombiner.cpp
@@ -295,7 +295,7 @@ const MachinePassContract &MachineCombinerPass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineCombinerPass::run(MachineFunction &Function,
                                                      const TargetDescription &Target,
-                                                     MachineAnalysisManager &Analyses) {
+                                                     MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "machine combiner input does not satisfy its stage contract");
diff --git a/backend/lib/CodeGen/MachineCopyPropagation.cpp b/backend/lib/CodeGen/MachineCopyPropagation.cpp
index 581cb4f..9725399 100644
--- a/backend/lib/CodeGen/MachineCopyPropagation.cpp
+++ b/backend/lib/CodeGen/MachineCopyPropagation.cpp
@@ -290,9 +290,9 @@ const MachinePassContract &MachineCopyPropagationPass::contract() const noexcept
   return copyPropagationContract(Stage);
 }
 
-Expected<MachinePassResult> MachineCopyPropagationPass::run(MachineFunction &Function,
-                                                            const TargetDescription &Target,
-                                                            MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+MachineCopyPropagationPass::run(MachineFunction &Function, const TargetDescription &Target,
+                                MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "machine COPY propagation has unmet stage properties");
diff --git a/backend/lib/CodeGen/MachineDCE.cpp b/backend/lib/CodeGen/MachineDCE.cpp
index 4dd0e59..1c53c31 100644
--- a/backend/lib/CodeGen/MachineDCE.cpp
+++ b/backend/lib/CodeGen/MachineDCE.cpp
@@ -115,7 +115,7 @@ const MachinePassContract &MachineDCEPass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineDCEPass::run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &) {
+                                                MachineFunctionAnalysisManager &) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "machine DCE requires a selected machine function");
diff --git a/backend/lib/CodeGen/MachineFallthrough.cpp b/backend/lib/CodeGen/MachineFallthrough.cpp
index 5c58e67..608b703 100644
--- a/backend/lib/CodeGen/MachineFallthrough.cpp
+++ b/backend/lib/CodeGen/MachineFallthrough.cpp
@@ -26,7 +26,7 @@ namespace {
                      MachineFunctionProperty::NoVRegs, MachineFunctionProperty::TracksLiveness},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<LiveVariablesAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()},
         .VerificationStage = PipelineStage::RegisterAllocated,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -120,7 +120,7 @@ const MachinePassContract &MachineFallthroughPass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineFallthroughPass::run(MachineFunction &Function,
                                                         const TargetDescription &Target,
-                                                        MachineAnalysisManager &Analyses) {
+                                                        MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "fallthrough normalization requires allocated tracked-liveness MIR");
@@ -130,7 +130,7 @@ Expected<MachinePassResult> MachineFallthroughPass::run(MachineFunction &Functio
       MachineFunctionCloneOptions{.NewStableID = Function.stableID(), .NewName = std::nullopt});
   if (!Trial)
     return std::unexpected(prefixedError(Trial.error(), "fallthrough setup failed: "));
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto TrialLiveness =
       TrialAnalyses.getResult<LiveVariablesAnalysis>(*Trial->ClonedFunction, Target);
   if (!TrialLiveness)
diff --git a/backend/lib/CodeGen/MachineFinalization.cpp b/backend/lib/CodeGen/MachineFinalization.cpp
index 8947b86..c33d857 100644
--- a/backend/lib/CodeGen/MachineFinalization.cpp
+++ b/backend/lib/CodeGen/MachineFinalization.cpp
@@ -91,7 +91,7 @@ const MachinePassContract &FinalizeEmissionPseudosPass::contract() const noexcep
 
 Expected<MachinePassResult> FinalizeEmissionPseudosPass::run(MachineFunction &Function,
                                                              const TargetDescription &Target,
-                                                             MachineAnalysisManager &) {
+                                                             MachineFunctionAnalysisManager &) {
   if (!Function.properties().containsAll(contract().Requires))
     return makeUnexpected(ErrorCode::VerificationError,
                           "emission-pseudo finalization requires finalized allocated MIR");
@@ -124,7 +124,7 @@ const MachinePassContract &FinalEncodabilityVerifierPass::contract() const noexc
 
 Expected<MachinePassResult> FinalEncodabilityVerifierPass::run(MachineFunction &Function,
                                                                const TargetDescription &Target,
-                                                               MachineAnalysisManager &) {
+                                                               MachineFunctionAnalysisManager &) {
   if (!Function.properties().containsAll(contract().Requires))
     return makeUnexpected(ErrorCode::FinalEncodabilityFailed,
                           "final encodability requires NoExecutablePseudos and finalized MIR");
diff --git a/backend/lib/CodeGen/MachineLICM.cpp b/backend/lib/CodeGen/MachineLICM.cpp
index 758e13c..31d792b 100644
--- a/backend/lib/CodeGen/MachineLICM.cpp
+++ b/backend/lib/CodeGen/MachineLICM.cpp
@@ -33,9 +33,9 @@ namespace {
         .Requires = {MachineFunctionProperty::IsSSA, MachineFunctionProperty::Selected},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(),
-                             MachineAnalysisManager::id<MachineLoopAnalysis>(),
-                             MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(),
+                             MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(),
+                             MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()},
         .VerificationStage = PipelineStage::Selected,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -50,9 +50,9 @@ namespace {
                      MachineFunctionProperty::TracksLiveness},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(),
-                             MachineAnalysisManager::id<MachineLoopAnalysis>(),
-                             MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(),
+                             MachineFunctionAnalysisManager::id<MachineLoopAnalysis>(),
+                             MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()},
         .VerificationStage = PipelineStage::RegisterAllocated,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -332,7 +332,7 @@ const MachinePassContract &MachineLICMPass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineLICMPass::run(MachineFunction &Function,
                                                  const TargetDescription &Target,
-                                                 MachineAnalysisManager &Analyses) {
+                                                 MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(
         ErrorCode::VerificationError,
@@ -346,7 +346,7 @@ Expected<MachinePassResult> MachineLICMPass::run(MachineFunction &Function,
   if (!Trial) {
     return std::unexpected(prefixedError(Trial.error(), "machine LICM transaction setup failed: "));
   }
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto TrialResult = runImplementation(*Trial->ClonedFunction, Target, TrialAnalyses);
   if (!TrialResult)
     return std::unexpected(TrialResult.error());
@@ -359,9 +359,9 @@ Expected<MachinePassResult> MachineLICMPass::run(MachineFunction &Function,
   return Result;
 }
 
-Expected<MachinePassResult> MachineLICMPass::runImplementation(MachineFunction &Function,
-                                                               const TargetDescription &Target,
-                                                               MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+MachineLICMPass::runImplementation(MachineFunction &Function, const TargetDescription &Target,
+                                   MachineFunctionAnalysisManager &Analyses) {
   auto Loops = Analyses.getResult<MachineLoopAnalysis>(Function, Target);
   if (!Loops)
     return std::unexpected(Loops.error());
diff --git a/backend/lib/CodeGen/MachineMemoryFolding.cpp b/backend/lib/CodeGen/MachineMemoryFolding.cpp
index 0e15146..e3d796a 100644
--- a/backend/lib/CodeGen/MachineMemoryFolding.cpp
+++ b/backend/lib/CodeGen/MachineMemoryFolding.cpp
@@ -185,7 +185,7 @@ const MachinePassContract &MachineMemoryFoldingPass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineMemoryFoldingPass::run(MachineFunction &Function,
                                                           const TargetDescription &Target,
-                                                          MachineAnalysisManager &) {
+                                                          MachineFunctionAnalysisManager &) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "memory folding requires selected SSA MachineIR");
diff --git a/backend/lib/CodeGen/MachineOptimizationPipeline.cpp b/backend/lib/CodeGen/MachineOptimizationPipeline.cpp
index 4f116f0..4a9d7f5 100644
--- a/backend/lib/CodeGen/MachineOptimizationPipeline.cpp
+++ b/backend/lib/CodeGen/MachineOptimizationPipeline.cpp
@@ -32,13 +32,13 @@ namespace rcc {
 namespace {
 
 template <typename Pass, typename... Arguments>
-[[nodiscard]] Expected<void> addPass(MachinePassManager &Pipeline, Arguments &&...Values) {
+[[nodiscard]] Expected<void> addPass(MachineFunctionPassManager &Pipeline, Arguments &&...Values) {
   return Pipeline.addPass(std::make_unique<Pass>(std::forward<Arguments>(Values)...));
 }
 
 } // namespace
 
-Expected<void> registerMachineOptimizationAnalyses(MachineAnalysisManager &Analyses) {
+Expected<void> registerMachineOptimizationAnalyses(MachineFunctionAnalysisManager &Analyses) {
   auto Registered = registerStage8MachineAnalyses(Analyses);
   if (!Registered)
     return std::unexpected(Registered.error());
@@ -46,7 +46,7 @@ Expected<void> registerMachineOptimizationAnalyses(MachineAnalysisManager &Analy
 }
 
 Expected<void>
-addSelectedSSAOptimizationPipeline(MachinePassManager &Pipeline,
+addSelectedSSAOptimizationPipeline(MachineFunctionPassManager &Pipeline,
                                    const MachineOptimizationPipelineTargetInfo &TargetInfo) {
   auto Added = addPass<MachineCombinerPass>(Pipeline, TargetInfo.Combiner,
                                             MachineCombinerStage::SelectedSSA);
@@ -68,7 +68,7 @@ addSelectedSSAOptimizationPipeline(MachinePassManager &Pipeline,
 }
 
 Expected<void> addPreRegisterAllocationOptimizationPipeline(
-    MachinePassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo) {
+    MachineFunctionPassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo) {
   auto Added = addPass<MachineBranchOptimizationPass>(Pipeline, TargetInfo.InstrInfo);
   if (!Added)
     return std::unexpected(Added.error());
@@ -87,7 +87,7 @@ Expected<void> addPreRegisterAllocationOptimizationPipeline(
 }
 
 Expected<void>
-addPostRegisterAllocationPipeline(MachinePassManager &Pipeline,
+addPostRegisterAllocationPipeline(MachineFunctionPassManager &Pipeline,
                                   const MachineOptimizationPipelineTargetInfo &TargetInfo) {
   auto Added = addPass<MachineStackSlotColoringPass>(Pipeline);
   if (!Added)
diff --git a/backend/lib/CodeGen/MachinePass.cpp b/backend/lib/CodeGen/MachinePassManager.cpp
index 0ce6f70..0810965 100644
--- a/backend/lib/CodeGen/MachinePass.cpp
+++ b/backend/lib/CodeGen/MachinePassManager.cpp
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include "rcc/CodeGen/CompilationUnit.h"
 #include "rcc/CodeGen/MachineBasicBlock.h"
@@ -141,6 +141,56 @@ void combineFingerprint(std::uint64_t &State, std::uint64_t Value) noexcept {
 
 } // namespace
 
+void AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::beforeAnalysis(
+    MachinePassInstrumentation *Instrumentation, std::string_view Name,
+    const MachineFunction &Function) {
+  Instrumentation->beforeAnalysis(Name, Function);
+}
+
+void AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::afterAnalysis(
+    MachinePassInstrumentation *Instrumentation, std::string_view Name,
+    const MachineFunction &Function, bool CacheHit, std::uint64_t Nanoseconds) {
+  Instrumentation->afterAnalysis(Name, Function, CacheHit, Nanoseconds);
+}
+
+void AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::analysisFailure(
+    MachinePassInstrumentation *Instrumentation, std::string_view Name,
+    const MachineFunction &Function, const Error &Failure, std::uint64_t Nanoseconds) {
+  Instrumentation->analysisFailure(Name, Function, Failure, Nanoseconds);
+}
+
+Expected<bool>
+AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::requestAction(
+    MachinePassInstrumentation *Instrumentation, std::string_view Pass, std::string_view Rule,
+    const MachineFunction &Function, MachineInstrStableID Instruction, std::uint64_t Cost) {
+  return Instrumentation->requestAction(Pass, Rule, Function, Instruction, Cost);
+}
+
+Expected<bool>
+AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation>::requestAction(
+    MachinePassInstrumentation *Instrumentation, std::string_view Pass, std::string_view Rule,
+    const MachineFunction &Function, std::nullptr_t, std::uint64_t Cost) {
+  return Instrumentation->requestAction(Pass, Rule, Function, nullptr, Cost);
+}
+
+void AnalysisManagerInstrumentation<CompilationUnit, MachinePassInstrumentation>::beforeAnalysis(
+    MachinePassInstrumentation *Instrumentation, std::string_view Name,
+    const CompilationUnit &Unit) {
+  Instrumentation->beforeAnalysis(Name, Unit);
+}
+
+void AnalysisManagerInstrumentation<CompilationUnit, MachinePassInstrumentation>::afterAnalysis(
+    MachinePassInstrumentation *Instrumentation, std::string_view Name, const CompilationUnit &Unit,
+    bool CacheHit, std::uint64_t Nanoseconds) {
+  Instrumentation->afterAnalysis(Name, Unit, CacheHit, Nanoseconds);
+}
+
+void AnalysisManagerInstrumentation<CompilationUnit, MachinePassInstrumentation>::analysisFailure(
+    MachinePassInstrumentation *Instrumentation, std::string_view Name, const CompilationUnit &Unit,
+    const Error &Failure, std::uint64_t Nanoseconds) {
+  Instrumentation->analysisFailure(Name, Unit, Failure, Nanoseconds);
+}
+
 std::string MachineActionID::toString() const {
   std::string Result;
   Result.reserve(Pass.size() + Rule.size() + 48U);
@@ -160,7 +210,7 @@ Expected<bool> MachineActionReplay::request(std::string_view Rule, const Machine
     const auto Position = RecordingInstructionIDs.find(Instruction);
     const MachineInstrStableID CanonicalInstruction =
         Position == RecordingInstructionIDs.end() ? Instruction : Position->second;
-    auto Accepted = Analyses->requestAction(Rule, Function, CanonicalInstruction, Cost);
+    auto Accepted = Request(Rule, Function, CanonicalInstruction, Cost);
     if (!Accepted)
       return std::unexpected(Accepted.error());
     Decisions.push_back({
@@ -214,452 +264,6 @@ Expected<void> MachineActionReplay::finishReplay() const {
   return {};
 }
 
-Expected<void>
-MachineAnalysisManager::registerAnalysisImpl(MachineAnalysisRegistration Registration,
-                                             ErasedRunner Runner, ErasedInvalidator Invalidator) {
-  if (Registration.ID == nullptr || Registration.Name.empty() || !Runner || !Invalidator) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "machine analysis registration is incomplete");
-  }
-  if (hasDuplicateAnalysisIDs(Registration.Dependencies)) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "machine analysis dependencies must be non-null and unique");
-  }
-  if (std::ranges::find(Registration.Dependencies, Registration.ID) !=
-      Registration.Dependencies.end()) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "machine analysis cannot directly depend on itself");
-  }
-  if (Registry.contains(Registration.ID))
-    return makeUnexpected(ErrorCode::InvalidArgument, "machine analysis ID is already registered");
-  if (std::ranges::any_of(Registry, [&Registration](const auto &Entry) {
-        return Entry.second.Info.Name == Registration.Name;
-      })) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "machine analysis name is already registered");
-  }
-  const AnalysisID RegistrationID = Registration.ID;
-  Registry.emplace(RegistrationID, RegisteredAnalysis{std::move(Registration), std::move(Runner),
-                                                      std::move(Invalidator)});
-  return {};
-}
-
-bool MachineAnalysisManager::isRegistered(AnalysisID ID) const noexcept {
-  return ID != nullptr && Registry.contains(ID);
-}
-
-bool MachineAnalysisManager::hasCached(const MachineFunction &Function,
-                                       AnalysisID ID) const noexcept {
-  const auto FunctionPosition = Cache.find(const_cast<MachineFunction *>(&Function));
-  if (FunctionPosition == Cache.end())
-    return false;
-  const auto AnalysisPosition = FunctionPosition->second.find(ID);
-  return AnalysisPosition != FunctionPosition->second.end() && AnalysisPosition->second.Value;
-}
-
-std::size_t
-MachineAnalysisManager::cachedResultCount(const MachineFunction &Function) const noexcept {
-  const auto Position = Cache.find(const_cast<MachineFunction *>(&Function));
-  return Position == Cache.end() ? 0 : Position->second.size();
-}
-
-Expected<void>
-MachineAnalysisManager::materializeDependencies(const RegisteredAnalysis &Registration,
-                                                MachineFunction &Function,
-                                                const TargetDescription &Target) {
-  for (const AnalysisID Dependency : Registration.Info.Dependencies) {
-    if (!Registry.contains(Dependency)) {
-      return makeUnexpected(ErrorCode::InvalidArgument,
-                            "machine analysis depends on an unregistered analysis");
-    }
-    auto Result = getResultImpl(Dependency, Function, Target);
-    if (!Result)
-      return std::unexpected(Result.error());
-  }
-  return {};
-}
-
-Expected<void *> MachineAnalysisManager::getResultImpl(AnalysisID ID, MachineFunction &Function,
-                                                       const TargetDescription &Target) {
-  if (ID == nullptr)
-    return makeUnexpected(ErrorCode::InvalidArgument, "machine analysis ID cannot be null");
-
-  auto &FunctionCache = Cache[&Function];
-  if (const auto Cached = FunctionCache.find(ID);
-      Cached != FunctionCache.end() && Cached->second.Value) {
-    const auto Registration = Registry.find(ID);
-    const std::string_view Name = Registration == Registry.end()
-                                      ? std::string_view{"unknown-machine-analysis"}
-                                      : std::string_view{Registration->second.Info.Name};
-    if (Instrumentation != nullptr)
-      Instrumentation->afterAnalysis(Name, Function, true, 0);
-    return Cached->second.Value.get();
-  }
-
-  const auto RegistrationPosition = Registry.find(ID);
-  if (RegistrationPosition == Registry.end())
-    return makeUnexpected(ErrorCode::InvalidArgument, "machine analysis ID is not registered");
-  const RegisteredAnalysis &Registration = RegistrationPosition->second;
-
-  auto &Stack = ActiveComputations[&Function];
-  if (std::ranges::find(Stack, ID) != Stack.end()) {
-    Error Failure(ErrorCode::InvalidArgument,
-                  "machine analysis dependency cycle reaches '" + Registration.Info.Name + "'");
-    if (Instrumentation != nullptr)
-      Instrumentation->analysisFailure(Registration.Info.Name, Function, Failure, 0);
-    return std::unexpected(std::move(Failure));
-  }
-
-  if (Instrumentation != nullptr)
-    Instrumentation->beforeAnalysis(Registration.Info.Name, Function);
-  const Clock::time_point Start = Clock::now();
-  Stack.push_back(ID);
-  auto Dependencies = materializeDependencies(Registration, Function, Target);
-  if (!Dependencies) {
-    Stack.pop_back();
-    if (Stack.empty())
-      ActiveComputations.erase(&Function);
-    Error Failure = prefixedError(Dependencies.error(),
-                                  "machine analysis '" + Registration.Info.Name + "' failed: ");
-    if (Instrumentation != nullptr) {
-      Instrumentation->analysisFailure(Registration.Info.Name, Function, Failure,
-                                       elapsedNanoseconds(Start));
-    }
-    return std::unexpected(std::move(Failure));
-  }
-
-  auto Computed = Registration.Runner(Function, Target, *this);
-  Stack.pop_back();
-  if (Stack.empty())
-    ActiveComputations.erase(&Function);
-  const std::uint64_t Duration = elapsedNanoseconds(Start);
-  if (!Computed) {
-    Error Failure = prefixedError(Computed.error(),
-                                  "machine analysis '" + Registration.Info.Name + "' failed: ");
-    if (Instrumentation != nullptr)
-      Instrumentation->analysisFailure(Registration.Info.Name, Function, Failure, Duration);
-    return std::unexpected(std::move(Failure));
-  }
-  if (!*Computed) {
-    Error Failure(ErrorCode::InternalError,
-                  "machine analysis '" + Registration.Info.Name + "' returned a null result");
-    if (Instrumentation != nullptr)
-      Instrumentation->analysisFailure(Registration.Info.Name, Function, Failure, Duration);
-    return std::unexpected(std::move(Failure));
-  }
-
-  void *Result = Computed->get();
-  FunctionCache.emplace(ID, CacheEntry{std::move(*Computed), ID});
-  if (Instrumentation != nullptr)
-    Instrumentation->afterAnalysis(Registration.Info.Name, Function, false, Duration);
-  return Result;
-}
-
-void MachineAnalysisManager::invalidate(MachineFunction &Function,
-                                        const PreservedAnalyses &Preserved,
-                                        MachinePassChanges Changes) noexcept {
-  const auto FunctionPosition = Cache.find(&Function);
-  if (FunctionPosition == Cache.end() || Preserved.preservesAll() || Changes.empty())
-    return;
-
-  std::set<AnalysisID> Invalid;
-  for (auto &[ID, Entry] : FunctionPosition->second) {
-    if (Preserved.preserves(ID))
-      continue;
-    const auto Registration = Registry.find(ID);
-    if (Registration == Registry.end() ||
-        Registration->second.Info.InvalidatedBy.intersects(Changes)) {
-      const bool ShouldInvalidate =
-          Registration == Registry.end() || !Entry.Value || !Registration->second.Invalidator ||
-          Registration->second.Invalidator(Entry.Value.get(), Function, Preserved);
-      if (ShouldInvalidate)
-        Invalid.insert(ID);
-    }
-  }
-
-  bool Added = true;
-  while (Added) {
-    Added = false;
-    for (const auto &[ID, Entry] : FunctionPosition->second) {
-      (void)Entry;
-      if (Invalid.contains(ID) || Preserved.preserves(ID))
-        continue;
-      const auto Registration = Registry.find(ID);
-      if (Registration != Registry.end() &&
-          std::ranges::any_of(
-              Registration->second.Info.Dependencies,
-              [&Invalid](AnalysisID Dependency) { return Invalid.contains(Dependency); })) {
-        Added = Invalid.insert(ID).second || Added;
-      }
-    }
-  }
-
-  for (const AnalysisID ID : Invalid)
-    FunctionPosition->second.erase(ID);
-  if (FunctionPosition->second.empty())
-    Cache.erase(FunctionPosition);
-}
-
-void MachineAnalysisManager::clear(MachineFunction &Function) noexcept {
-  Cache.erase(&Function);
-  ActiveComputations.erase(&Function);
-}
-
-void MachineAnalysisManager::clearAll() noexcept {
-  Cache.clear();
-  ActiveComputations.clear();
-}
-
-Expected<std::unique_ptr<MachineAnalysisManager>> MachineAnalysisManager::forkEmpty() const {
-  if (!ActiveComputations.empty()) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "cannot fork a machine analysis manager during analysis computation");
-  }
-  auto Result = std::make_unique<MachineAnalysisManager>();
-  Result->Registry = Registry;
-  return Result;
-}
-
-Expected<void> MachineAnalysisManager::validateParallelRequirements(
-    std::span<const AnalysisID> RequiredAnalyses) const {
-  std::vector<AnalysisID> Worklist(RequiredAnalyses.begin(), RequiredAnalyses.end());
-  std::unordered_set<AnalysisID> Visited;
-  for (std::size_t Index = 0; Index < Worklist.size(); ++Index) {
-    const AnalysisID ID = Worklist[Index];
-    if (ID == nullptr || !Visited.insert(ID).second)
-      continue;
-    const auto Position = Registry.find(ID);
-    if (Position == Registry.end()) {
-      return makeUnexpected(ErrorCode::InvalidArgument,
-                            "parallel machine pass requires an unregistered analysis");
-    }
-    if (Position->second.Info.ThreadSafety != PassThreadSafety::ThreadSafe) {
-      return makeUnexpected(ErrorCode::InvalidArgument,
-                            "parallel machine pipeline requires analysis '" +
-                                Position->second.Info.Name + "' to be marked thread-safe");
-    }
-    Worklist.insert(Worklist.end(), Position->second.Info.Dependencies.begin(),
-                    Position->second.Info.Dependencies.end());
-  }
-  return {};
-}
-
-Expected<bool> MachineAnalysisManager::requestAction(std::string_view Action,
-                                                     const MachineFunction &Function,
-                                                     std::uint64_t Cost) {
-  return requestAction(Action, Function, MachineInstrStableID{}, Cost);
-}
-
-Expected<bool> MachineAnalysisManager::requestAction(std::string_view Rule,
-                                                     const MachineFunction &Function,
-                                                     MachineInstrStableID Instruction,
-                                                     std::uint64_t Cost) {
-  if (Rule.empty() || Cost == 0)
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "machine action requires a name and nonzero cost");
-  if (Instrumentation == nullptr)
-    return true;
-  MachineActionID ID{
-      .Pass = ActivePass.empty() ? "unscoped" : ActivePass,
-      .Rule = std::string(Rule),
-      .Function = Function.stableID(),
-      .Instruction = Instruction,
-  };
-  return Instrumentation->requestAction(ID, Function, Cost);
-}
-
-Expected<void> CompilationUnitAnalysisManager::registerAnalysisImpl(
-    CompilationUnitAnalysisRegistration Registration, ErasedRunner Runner,
-    ErasedInvalidator Invalidator) {
-  if (Registration.ID == nullptr || Registration.Name.empty() || !Runner || !Invalidator) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "compilation-unit analysis registration is incomplete");
-  }
-  if (hasDuplicateAnalysisIDs(Registration.Dependencies)) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "compilation-unit analysis dependencies must be non-null and unique");
-  }
-  if (std::ranges::find(Registration.Dependencies, Registration.ID) !=
-      Registration.Dependencies.end()) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "compilation-unit analysis cannot directly depend on itself");
-  }
-  if (Registry.contains(Registration.ID)) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "compilation-unit analysis ID is already registered");
-  }
-  if (std::ranges::any_of(Registry, [&Registration](const auto &Entry) {
-        return Entry.second.Info.Name == Registration.Name;
-      })) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "compilation-unit analysis name is already registered");
-  }
-  const AnalysisID RegistrationID = Registration.ID;
-  Registry.emplace(RegistrationID, RegisteredAnalysis{std::move(Registration), std::move(Runner),
-                                                      std::move(Invalidator)});
-  return {};
-}
-
-bool CompilationUnitAnalysisManager::isRegistered(AnalysisID ID) const noexcept {
-  return ID != nullptr && Registry.contains(ID);
-}
-
-bool CompilationUnitAnalysisManager::hasCached(const CompilationUnit &Unit,
-                                               AnalysisID ID) const noexcept {
-  const auto UnitPosition = Cache.find(const_cast<CompilationUnit *>(&Unit));
-  if (UnitPosition == Cache.end())
-    return false;
-  const auto AnalysisPosition = UnitPosition->second.find(ID);
-  return AnalysisPosition != UnitPosition->second.end() && AnalysisPosition->second.Value;
-}
-
-Expected<void>
-CompilationUnitAnalysisManager::materializeDependencies(const RegisteredAnalysis &Registration,
-                                                        CompilationUnit &Unit,
-                                                        const TargetDescription &Target) {
-  for (const AnalysisID Dependency : Registration.Info.Dependencies) {
-    if (!Registry.contains(Dependency)) {
-      return makeUnexpected(ErrorCode::InvalidArgument,
-                            "compilation-unit analysis depends on an unregistered analysis");
-    }
-    auto Result = getResultImpl(Dependency, Unit, Target);
-    if (!Result)
-      return std::unexpected(Result.error());
-  }
-  return {};
-}
-
-Expected<void *> CompilationUnitAnalysisManager::getResultImpl(AnalysisID ID, CompilationUnit &Unit,
-                                                               const TargetDescription &Target) {
-  if (ID == nullptr)
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "compilation-unit analysis ID cannot be null");
-  auto &UnitCache = Cache[&Unit];
-  if (const auto Cached = UnitCache.find(ID); Cached != UnitCache.end() && Cached->second.Value) {
-    const auto Registration = Registry.find(ID);
-    const std::string_view Name = Registration == Registry.end()
-                                      ? std::string_view{"unknown-compilation-unit-analysis"}
-                                      : std::string_view{Registration->second.Info.Name};
-    if (Instrumentation != nullptr)
-      Instrumentation->afterUnitAnalysis(Name, Unit, true, 0);
-    return Cached->second.Value.get();
-  }
-
-  const auto RegistrationPosition = Registry.find(ID);
-  if (RegistrationPosition == Registry.end()) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "compilation-unit analysis ID is not registered");
-  }
-  const RegisteredAnalysis &Registration = RegistrationPosition->second;
-  auto &Stack = ActiveComputations[&Unit];
-  if (std::ranges::find(Stack, ID) != Stack.end()) {
-    Error Failure(ErrorCode::InvalidArgument,
-                  "compilation-unit analysis dependency cycle reaches '" + Registration.Info.Name +
-                      "'");
-    if (Instrumentation != nullptr)
-      Instrumentation->unitAnalysisFailure(Registration.Info.Name, Unit, Failure, 0);
-    return std::unexpected(std::move(Failure));
-  }
-
-  if (Instrumentation != nullptr)
-    Instrumentation->beforeUnitAnalysis(Registration.Info.Name, Unit);
-  const Clock::time_point Start = Clock::now();
-  Stack.push_back(ID);
-  auto Dependencies = materializeDependencies(Registration, Unit, Target);
-  if (!Dependencies) {
-    Stack.pop_back();
-    if (Stack.empty())
-      ActiveComputations.erase(&Unit);
-    Error Failure = prefixedError(Dependencies.error(), "compilation-unit analysis '" +
-                                                            Registration.Info.Name + "' failed: ");
-    if (Instrumentation != nullptr) {
-      Instrumentation->unitAnalysisFailure(Registration.Info.Name, Unit, Failure,
-                                           elapsedNanoseconds(Start));
-    }
-    return std::unexpected(std::move(Failure));
-  }
-
-  auto Computed = Registration.Runner(Unit, Target, *this);
-  Stack.pop_back();
-  if (Stack.empty())
-    ActiveComputations.erase(&Unit);
-  const std::uint64_t Duration = elapsedNanoseconds(Start);
-  if (!Computed) {
-    Error Failure = prefixedError(Computed.error(), "compilation-unit analysis '" +
-                                                        Registration.Info.Name + "' failed: ");
-    if (Instrumentation != nullptr)
-      Instrumentation->unitAnalysisFailure(Registration.Info.Name, Unit, Failure, Duration);
-    return std::unexpected(std::move(Failure));
-  }
-  if (!*Computed) {
-    Error Failure(ErrorCode::InternalError, "compilation-unit analysis '" + Registration.Info.Name +
-                                                "' returned a null result");
-    if (Instrumentation != nullptr)
-      Instrumentation->unitAnalysisFailure(Registration.Info.Name, Unit, Failure, Duration);
-    return std::unexpected(std::move(Failure));
-  }
-
-  void *Result = Computed->get();
-  UnitCache.emplace(ID, CacheEntry{std::move(*Computed), ID});
-  if (Instrumentation != nullptr)
-    Instrumentation->afterUnitAnalysis(Registration.Info.Name, Unit, false, Duration);
-  return Result;
-}
-
-void CompilationUnitAnalysisManager::invalidate(CompilationUnit &Unit,
-                                                const PreservedAnalyses &Preserved,
-                                                MachinePassChanges Changes) noexcept {
-  const auto UnitPosition = Cache.find(&Unit);
-  if (UnitPosition == Cache.end() || Preserved.preservesAll() || Changes.empty())
-    return;
-
-  std::set<AnalysisID> Invalid;
-  for (auto &[ID, Entry] : UnitPosition->second) {
-    if (Preserved.preserves(ID))
-      continue;
-    const auto Registration = Registry.find(ID);
-    if (Registration == Registry.end() ||
-        Registration->second.Info.InvalidatedBy.intersects(Changes)) {
-      const bool ShouldInvalidate =
-          Registration == Registry.end() || !Entry.Value || !Registration->second.Invalidator ||
-          Registration->second.Invalidator(Entry.Value.get(), Unit, Preserved);
-      if (ShouldInvalidate)
-        Invalid.insert(ID);
-    }
-  }
-
-  bool Added = true;
-  while (Added) {
-    Added = false;
-    for (const auto &[ID, Entry] : UnitPosition->second) {
-      (void)Entry;
-      if (Invalid.contains(ID) || Preserved.preserves(ID))
-        continue;
-      const auto Registration = Registry.find(ID);
-      if (Registration != Registry.end() &&
-          std::ranges::any_of(
-              Registration->second.Info.Dependencies,
-              [&Invalid](AnalysisID Dependency) { return Invalid.contains(Dependency); })) {
-        Added = Invalid.insert(ID).second || Added;
-      }
-    }
-  }
-  for (const AnalysisID InvalidID : Invalid)
-    UnitPosition->second.erase(InvalidID);
-  if (UnitPosition->second.empty())
-    Cache.erase(UnitPosition);
-}
-
-void CompilationUnitAnalysisManager::clear(CompilationUnit &Unit) noexcept {
-  Cache.erase(&Unit);
-  ActiveComputations.erase(&Unit);
-}
-
-void CompilationUnitAnalysisManager::clearAll() noexcept {
-  Cache.clear();
-  ActiveComputations.clear();
-}
-
 void MachinePassInstrumentation::addBeforeCallback(BeforeCallback Callback) {
   if (!Callback)
     return;
@@ -966,9 +570,17 @@ void MachinePassInstrumentation::change(std::string_view Name, const MachineFunc
     Callback(Name, Function, Changes, FingerprintChanged);
 }
 
-Expected<bool> MachinePassInstrumentation::requestAction(const MachineActionID &Action,
+Expected<bool> MachinePassInstrumentation::requestAction(std::string_view Pass,
+                                                         std::string_view Rule,
                                                          const MachineFunction &Function,
+                                                         MachineInstrStableID Instruction,
                                                          std::uint64_t Cost) {
+  MachineActionID Action{
+      .Pass = std::string(Pass),
+      .Rule = std::string(Rule),
+      .Function = Function.stableID(),
+      .Instruction = Instruction,
+  };
   if (Action.Pass.empty() || Action.Rule.empty() || Action.Function != Function.stableID() ||
       Cost == 0) {
     return makeUnexpected(ErrorCode::InvalidArgument, "machine action identity is invalid");
@@ -1000,6 +612,13 @@ Expected<bool> MachinePassInstrumentation::requestAction(const MachineActionID &
   return true;
 }
 
+Expected<bool> MachinePassInstrumentation::requestAction(std::string_view Pass,
+                                                         std::string_view Rule,
+                                                         const MachineFunction &Function,
+                                                         std::nullptr_t, std::uint64_t Cost) {
+  return requestAction(Pass, Rule, Function, MachineInstrStableID{}, Cost);
+}
+
 void MachinePassInstrumentation::beforeUnit(std::string_view Name,
                                             const CompilationUnit &Unit) const {
   std::vector<BeforeUnitCallback> Callbacks;
@@ -1043,8 +662,8 @@ void MachinePassInstrumentation::unitFailure(std::string_view Name, const Compil
     Callback(Name, Unit, ErrorValue);
 }
 
-void MachinePassInstrumentation::beforeUnitAnalysis(std::string_view Name,
-                                                    const CompilationUnit &Unit) const {
+void MachinePassInstrumentation::beforeAnalysis(std::string_view Name,
+                                                const CompilationUnit &Unit) const {
   std::vector<BeforeUnitAnalysisCallback> Callbacks;
   {
     std::scoped_lock Lock(Mutex);
@@ -1054,9 +673,8 @@ void MachinePassInstrumentation::beforeUnitAnalysis(std::string_view Name,
     Callback(Name, Unit);
 }
 
-void MachinePassInstrumentation::afterUnitAnalysis(std::string_view Name,
-                                                   const CompilationUnit &Unit, bool CacheHit,
-                                                   std::uint64_t Nanoseconds) const {
+void MachinePassInstrumentation::afterAnalysis(std::string_view Name, const CompilationUnit &Unit,
+                                               bool CacheHit, std::uint64_t Nanoseconds) const {
   std::vector<AfterUnitAnalysisCallback> Callbacks;
   {
     std::scoped_lock Lock(Mutex);
@@ -1070,10 +688,9 @@ void MachinePassInstrumentation::afterUnitAnalysis(std::string_view Name,
     Callback(Name, Unit, CacheHit, Nanoseconds);
 }
 
-void MachinePassInstrumentation::unitAnalysisFailure(std::string_view Name,
-                                                     const CompilationUnit &Unit,
-                                                     const Error &ErrorValue,
-                                                     std::uint64_t Nanoseconds) const {
+void MachinePassInstrumentation::analysisFailure(std::string_view Name, const CompilationUnit &Unit,
+                                                 const Error &ErrorValue,
+                                                 std::uint64_t Nanoseconds) const {
   std::vector<UnitAnalysisFailureCallback> Callbacks;
   {
     std::scoped_lock Lock(Mutex);
@@ -1128,14 +745,10 @@ std::vector<MachineActionEvent> MachinePassInstrumentation::actionEvents() const
   return Result;
 }
 
-void MachinePassInstrumentation::clearStatistics() {
-  std::scoped_lock Lock(Mutex);
-  Statistics.clear();
-  ConsumedFuel.clear();
-  ActionEvents.clear();
-}
-
-Expected<void> MachinePassManager::validateContract(const MachinePassContract &Contract) const {
+Expected<void>
+PassManagerCallbacks<MachineFunction, MachineFunctionPass, MachinePassManagerOptions>::validate(
+    const MachineFunctionPass &Pass) {
+  const MachinePassContract &Contract = Pass.contract();
   if (Contract.Name.empty())
     return makeUnexpected(ErrorCode::InvalidArgument, "machine pass must have a non-empty name");
   if (Contract.Sets.intersects(Contract.Clears)) {
@@ -1149,20 +762,11 @@ Expected<void> MachinePassManager::validateContract(const MachinePassContract &C
   return validateParameters(Contract.Parameters);
 }
 
-Expected<void> MachinePassManager::addPass(std::unique_ptr<MachineFunctionPass> Pass) {
-  if (!Pass)
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "machine pass manager cannot add a null pass");
-  auto Validation = validateContract(Pass->contract());
-  if (!Validation)
-    return std::unexpected(Validation.error());
-  Passes.push_back(std::move(Pass));
-  return {};
-}
-
-Expected<void> MachinePassManager::run(MachineFunction &Function, const TargetDescription &Target,
-                                       MachineAnalysisManager &Analyses,
-                                       MachinePassInstrumentation *Instrumentation) const {
+Expected<void>
+PassManagerCallbacks<MachineFunction, MachineFunctionPass, MachinePassManagerOptions>::run(
+    const PassList &Passes, const MachinePassManagerOptions &Options, MachineFunction &Function,
+    const TargetDescription &Target, MachineFunctionAnalysisManager &Analyses,
+    MachinePassInstrumentation *Instrumentation) {
   Analyses.setInstrumentation(Instrumentation);
   for (const std::unique_ptr<MachineFunctionPass> &Pass : Passes) {
     const MachinePassContract &Contract = Pass->contract();
@@ -1192,7 +796,7 @@ Expected<void> MachinePassManager::run(MachineFunction &Function, const TargetDe
     }
 
     for (const AnalysisID Required : Contract.RequiredAnalyses) {
-      auto Result = Analyses.getResultImpl(Required, Function, Target);
+      auto Result = Analyses.getResultByID(Required, Function, Target);
       if (!Result) {
         Error Failure =
             prefixedError(Result.error(), "pass '" + std::string(Name) +
@@ -1209,9 +813,9 @@ Expected<void> MachinePassManager::run(MachineFunction &Function, const TargetDe
     if (Instrumentation != nullptr)
       Instrumentation->before(Name, Function);
     const Clock::time_point Start = Clock::now();
-    Analyses.ActivePass = std::string(Name);
+    Analyses.setActivePass(std::string(Name));
     auto PassResult = Pass->run(Function, Target, Analyses);
-    Analyses.ActivePass.clear();
+    Analyses.setActivePass({});
     const std::uint64_t Duration = elapsedNanoseconds(Start);
     if (!PassResult) {
       Error Failure =
@@ -1296,11 +900,11 @@ Expected<void> MachinePassManager::run(MachineFunction &Function, const TargetDe
   return {};
 }
 
-Expected<void> MachinePassManager::runFunctions(CompilationUnit &Unit,
-                                                const TargetDescription &Target,
-                                                const MachineAnalysisManager &AnalysisPrototype,
-                                                std::size_t ThreadCount,
-                                                MachinePassInstrumentation *Instrumentation) const {
+Expected<void>
+PassManagerCallbacks<MachineFunction, MachineFunctionPass, MachinePassManagerOptions>::runFunctions(
+    const PassList &Passes, const MachinePassManagerOptions &Options, CompilationUnit &Unit,
+    const TargetDescription &Target, const MachineFunctionAnalysisManager &AnalysisPrototype,
+    std::size_t ThreadCount, MachinePassInstrumentation *Instrumentation) {
   if (ThreadCount == 0)
     return makeUnexpected(ErrorCode::InvalidArgument, "machine pass thread count must be nonzero");
   auto UnitVerification = verifyCompilationUnit(Unit, Target);
@@ -1322,7 +926,7 @@ Expected<void> MachinePassManager::runFunctions(CompilationUnit &Unit,
         return std::unexpected(AnalysisSafety.error());
     }
   }
-  std::vector<std::unique_ptr<MachineAnalysisManager>> Managers;
+  std::vector<std::unique_ptr<MachineFunctionAnalysisManager>> Managers;
   Managers.reserve(FunctionCount);
   for (std::size_t Index = 0; Index < FunctionCount; ++Index) {
     auto Manager = AnalysisPrototype.forkEmpty();
@@ -1347,7 +951,8 @@ Expected<void> MachinePassManager::runFunctions(CompilationUnit &Unit,
       }
       if (Instrumentation != nullptr)
         Instrumentation->beginBuffering(EventBuffers[Index], Target);
-      auto Result = run(*Function, Target, *Managers[Index], Instrumentation);
+      auto Result = PassManagerCallbacks::run(Passes, Options, *Function, Target, *Managers[Index],
+                                              Instrumentation);
       if (Instrumentation != nullptr)
         Instrumentation->endBuffering();
       if (!Result)
@@ -1374,12 +979,10 @@ Expected<void> MachinePassManager::runFunctions(CompilationUnit &Unit,
   return {};
 }
 
-Expected<void> CompilationUnitPassManager::addPass(std::unique_ptr<CompilationUnitPass> Pass) {
-  if (!Pass) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "compilation-unit pass manager cannot add a null pass");
-  }
-  const CompilationUnitPassContract &Contract = Pass->contract();
+Expected<void>
+PassManagerCallbacks<CompilationUnit, CompilationUnitPass,
+                     CompilationUnitPassManagerOptions>::validate(const CompilationUnitPass &Pass) {
+  const CompilationUnitPassContract &Contract = Pass.contract();
   if (Contract.Name.empty()) {
     return makeUnexpected(ErrorCode::InvalidArgument,
                           "compilation-unit pass must have a non-empty name");
@@ -1391,15 +994,14 @@ Expected<void> CompilationUnitPassManager::addPass(std::unique_ptr<CompilationUn
   auto Parameters = validateParameters(Contract.Parameters);
   if (!Parameters)
     return std::unexpected(Parameters.error());
-  Passes.push_back(std::move(Pass));
   return {};
 }
 
-Expected<void> CompilationUnitPassManager::run(CompilationUnit &Unit,
-                                               const TargetDescription &Target,
-                                               CompilationUnitAnalysisManager &UnitAnalyses,
-                                               MachineAnalysisManager &FunctionAnalyses,
-                                               MachinePassInstrumentation *Instrumentation) const {
+Expected<void>
+PassManagerCallbacks<CompilationUnit, CompilationUnitPass, CompilationUnitPassManagerOptions>::run(
+    const PassList &Passes, const CompilationUnitPassManagerOptions &Options, CompilationUnit &Unit,
+    const TargetDescription &Target, CompilationUnitAnalysisManager &UnitAnalyses,
+    MachineFunctionAnalysisManager &FunctionAnalyses, MachinePassInstrumentation *Instrumentation) {
   UnitAnalyses.setInstrumentation(Instrumentation);
   FunctionAnalyses.setInstrumentation(Instrumentation);
   for (const std::unique_ptr<CompilationUnitPass> &Pass : Passes) {
@@ -1421,7 +1023,7 @@ Expected<void> CompilationUnitPassManager::run(CompilationUnit &Unit,
     }
 
     for (const AnalysisID Required : Contract.RequiredAnalyses) {
-      auto Result = UnitAnalyses.getResultImpl(Required, Unit, Target);
+      auto Result = UnitAnalyses.getResultByID(Required, Unit, Target);
       if (!Result) {
         Error Failure =
             prefixedError(Result.error(), "compilation-unit pass '" + std::string(Name) +
diff --git a/backend/lib/CodeGen/MachinePseudoExpansion.cpp b/backend/lib/CodeGen/MachinePseudoExpansion.cpp
index b5afe8e..663b148 100644
--- a/backend/lib/CodeGen/MachinePseudoExpansion.cpp
+++ b/backend/lib/CodeGen/MachinePseudoExpansion.cpp
@@ -355,7 +355,8 @@ expandImplementation(MachineFunction &Function, const TargetDescription &Target,
 
 [[nodiscard]] Expected<MachinePassResult>
 runPreparationTransaction(MachineFunction &Function, const TargetDescription &Target,
-                          const TargetPseudoExpansionInfo &Info, MachineAnalysisManager &Analyses) {
+                          const TargetPseudoExpansionInfo &Info,
+                          MachineFunctionAnalysisManager &Analyses) {
   auto Trial = cloneMachineFunction(
       Function, Target,
       MachineFunctionCloneOptions{.NewStableID = Function.stableID(), .NewName = std::nullopt});
@@ -380,7 +381,8 @@ runPreparationTransaction(MachineFunction &Function, const TargetDescription &Ta
 [[nodiscard]] Expected<MachinePassResult>
 runExpansionTransaction(MachineFunction &Function, const TargetDescription &Target,
                         const TargetPseudoExpansionInfo &Info, MachinePseudoExpansionPhase Phase,
-                        const TargetInstrInfo *BranchInfo, MachineAnalysisManager &Analyses) {
+                        const TargetInstrInfo *BranchInfo,
+                        MachineFunctionAnalysisManager &Analyses) {
   auto Trial = cloneMachineFunction(
       Function, Target,
       MachineFunctionCloneOptions{.NewStableID = Function.stableID(), .NewName = std::nullopt});
@@ -409,9 +411,9 @@ const MachinePassContract &PreparePostRAPseudosPass::contract() const noexcept {
   return preparationContract();
 }
 
-Expected<MachinePassResult> PreparePostRAPseudosPass::run(MachineFunction &Function,
-                                                          const TargetDescription &Target,
-                                                          MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+PreparePostRAPseudosPass::run(MachineFunction &Function, const TargetDescription &Target,
+                              MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires))
     return makeUnexpected(ErrorCode::VerificationError,
                           "post-RA pseudo preparation requires selected MachineIR");
@@ -422,9 +424,9 @@ const MachinePassContract &PrePEITargetPseudoExpansionPass::contract() const noe
   return phaseContract(MachinePseudoExpansionPhase::PrePEI);
 }
 
-Expected<MachinePassResult> PrePEITargetPseudoExpansionPass::run(MachineFunction &Function,
-                                                                 const TargetDescription &Target,
-                                                                 MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+PrePEITargetPseudoExpansionPass::run(MachineFunction &Function, const TargetDescription &Target,
+                                     MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires))
     return makeUnexpected(ErrorCode::VerificationError,
                           "pre-PEI pseudo expansion requires allocated tracked-liveness MIR");
@@ -438,7 +440,7 @@ const MachinePassContract &ExpandPostRAPseudosPass::contract() const noexcept {
 
 Expected<MachinePassResult> ExpandPostRAPseudosPass::run(MachineFunction &Function,
                                                          const TargetDescription &Target,
-                                                         MachineAnalysisManager &Analyses) {
+                                                         MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires))
     return makeUnexpected(ErrorCode::VerificationError,
                           "post-RA pseudo expansion requires finalized frame and liveness");
@@ -450,9 +452,9 @@ const MachinePassContract &TargetLatePseudoExpansionPass::contract() const noexc
   return phaseContract(MachinePseudoExpansionPhase::TargetLate);
 }
 
-Expected<MachinePassResult> TargetLatePseudoExpansionPass::run(MachineFunction &Function,
-                                                               const TargetDescription &Target,
-                                                               MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+TargetLatePseudoExpansionPass::run(MachineFunction &Function, const TargetDescription &Target,
+                                   MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires))
     return makeUnexpected(ErrorCode::VerificationError,
                           "target-late pseudo expansion requires finalized allocated MIR");
diff --git a/backend/lib/CodeGen/MachineScheduler.cpp b/backend/lib/CodeGen/MachineScheduler.cpp
index e589675..82f0c91 100644
--- a/backend/lib/CodeGen/MachineScheduler.cpp
+++ b/backend/lib/CodeGen/MachineScheduler.cpp
@@ -37,10 +37,11 @@ namespace {
                      MachineFunctionProperty::TiedOpsRewritten},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<LiveVariablesAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()},
         .VerificationStage = PipelineStage::TiedOpsRewritten,
     };
-    Value.RequiredAnalyses.push_back(MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>());
+    Value.RequiredAnalyses.push_back(
+        MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>());
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
     Value.DeclaredChanges = {MachinePassChange::Instructions, MachinePassChange::Operands};
     return Value;
@@ -395,7 +396,7 @@ const MachinePassContract &MachineSchedulerPass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineSchedulerPass::run(MachineFunction &Function,
                                                       const TargetDescription &Target,
-                                                      MachineAnalysisManager &Analyses) {
+                                                      MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "pre-RA machine scheduler requires selected, SSA-exited MachineIR");
@@ -407,7 +408,7 @@ Expected<MachinePassResult> MachineSchedulerPass::run(MachineFunction &Function,
     return std::unexpected(
         prefixedError(Trial.error(), "machine scheduler transaction setup failed: "));
   }
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto TrialLiveness =
       TrialAnalyses.getResult<LiveVariablesAnalysis>(*Trial->ClonedFunction, Target);
   if (!TrialLiveness)
diff --git a/backend/lib/CodeGen/MachineShrinkWrapping.cpp b/backend/lib/CodeGen/MachineShrinkWrapping.cpp
index aee3323..7c7bc3a 100644
--- a/backend/lib/CodeGen/MachineShrinkWrapping.cpp
+++ b/backend/lib/CodeGen/MachineShrinkWrapping.cpp
@@ -32,8 +32,8 @@ namespace {
                      MachineFunctionProperty::TracksLiveness},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(),
-                             MachineAnalysisManager::id<MachineLoopAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(),
+                             MachineFunctionAnalysisManager::id<MachineLoopAnalysis>()},
         .VerificationStage = PipelineStage::RegisterAllocated,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -66,9 +66,9 @@ const MachinePassContract &MachineShrinkWrappingPass::contract() const noexcept
   return shrinkWrappingContract();
 }
 
-Expected<MachinePassResult> MachineShrinkWrappingPass::run(MachineFunction &Function,
-                                                           const TargetDescription &Target,
-                                                           MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+MachineShrinkWrappingPass::run(MachineFunction &Function, const TargetDescription &Target,
+                               MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "shrink wrapping requires allocated tracked-liveness MachineIR");
diff --git a/backend/lib/CodeGen/MachineSink.cpp b/backend/lib/CodeGen/MachineSink.cpp
index 21b17f8..176b75a 100644
--- a/backend/lib/CodeGen/MachineSink.cpp
+++ b/backend/lib/CodeGen/MachineSink.cpp
@@ -34,8 +34,8 @@ namespace {
         .Requires = {MachineFunctionProperty::IsSSA, MachineFunctionProperty::Selected},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(),
-                             MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(),
+                             MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()},
         .VerificationStage = PipelineStage::Selected,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -50,8 +50,8 @@ namespace {
                      MachineFunctionProperty::TracksLiveness},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<MachineDominatorTreeAnalysis>(),
-                             MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<MachineDominatorTreeAnalysis>(),
+                             MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>()},
         .VerificationStage = PipelineStage::RegisterAllocated,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -354,7 +354,7 @@ const MachinePassContract &MachineSinkPass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineSinkPass::run(MachineFunction &Function,
                                                  const TargetDescription &Target,
-                                                 MachineAnalysisManager &Analyses) {
+                                                 MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(
         ErrorCode::VerificationError,
@@ -368,7 +368,7 @@ Expected<MachinePassResult> MachineSinkPass::run(MachineFunction &Function,
   if (!Trial) {
     return std::unexpected(prefixedError(Trial.error(), "machine sink transaction setup failed: "));
   }
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto TrialResult = runImplementation(*Trial->ClonedFunction, Target, TrialAnalyses);
   if (!TrialResult)
     return std::unexpected(TrialResult.error());
@@ -381,9 +381,9 @@ Expected<MachinePassResult> MachineSinkPass::run(MachineFunction &Function,
   return Result;
 }
 
-Expected<MachinePassResult> MachineSinkPass::runImplementation(MachineFunction &Function,
-                                                               const TargetDescription &Target,
-                                                               MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+MachineSinkPass::runImplementation(MachineFunction &Function, const TargetDescription &Target,
+                                   MachineFunctionAnalysisManager &Analyses) {
   auto Dominators = Analyses.getResult<MachineDominatorTreeAnalysis>(Function, Target);
   if (!Dominators)
     return std::unexpected(Dominators.error());
diff --git a/backend/lib/CodeGen/MachineStackSlotColoring.cpp b/backend/lib/CodeGen/MachineStackSlotColoring.cpp
index e60a7a2..005872b 100644
--- a/backend/lib/CodeGen/MachineStackSlotColoring.cpp
+++ b/backend/lib/CodeGen/MachineStackSlotColoring.cpp
@@ -228,7 +228,7 @@ const MachinePassContract &MachineStackSlotColoringPass::contract() const noexce
 
 Expected<MachinePassResult> MachineStackSlotColoringPass::run(MachineFunction &Function,
                                                               const TargetDescription &Target,
-                                                              MachineAnalysisManager &) {
+                                                              MachineFunctionAnalysisManager &) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "stack-slot coloring requires allocated PHI-free MachineIR");
diff --git a/backend/lib/CodeGen/MachineTailDuplication.cpp b/backend/lib/CodeGen/MachineTailDuplication.cpp
index 5abd473..8be1eb5 100644
--- a/backend/lib/CodeGen/MachineTailDuplication.cpp
+++ b/backend/lib/CodeGen/MachineTailDuplication.cpp
@@ -248,7 +248,7 @@ const MachinePassContract &MachineTailDuplicationPass::contract() const noexcept
 
 Expected<MachinePassResult> MachineTailDuplicationPass::run(MachineFunction &Function,
                                                             const TargetDescription &Target,
-                                                            MachineAnalysisManager &) {
+                                                            MachineFunctionAnalysisManager &) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "tail duplication requires finalized allocated tracked-liveness MIR");
diff --git a/backend/lib/CodeGen/MachineTailMerge.cpp b/backend/lib/CodeGen/MachineTailMerge.cpp
index c4d6de9..dc07950 100644
--- a/backend/lib/CodeGen/MachineTailMerge.cpp
+++ b/backend/lib/CodeGen/MachineTailMerge.cpp
@@ -298,7 +298,7 @@ const MachinePassContract &MachineTailMergePass::contract() const noexcept {
 
 Expected<MachinePassResult> MachineTailMergePass::run(MachineFunction &Function,
                                                       const TargetDescription &Target,
-                                                      MachineAnalysisManager &) {
+                                                      MachineFunctionAnalysisManager &) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "tail merge requires finalized allocated tracked-liveness MIR");
diff --git a/backend/lib/CodeGen/PHIElimination.cpp b/backend/lib/CodeGen/PHIElimination.cpp
index 75472f2..6de449f 100644
--- a/backend/lib/CodeGen/PHIElimination.cpp
+++ b/backend/lib/CodeGen/PHIElimination.cpp
@@ -490,7 +490,7 @@ const MachinePassContract &PHIEliminationPass::contract() const noexcept {
 
 Expected<MachinePassResult> PHIEliminationPass::run(MachineFunction &Function,
                                                     const TargetDescription &Target,
-                                                    MachineAnalysisManager &Analyses) {
+                                                    MachineFunctionAnalysisManager &Analyses) {
   auto Required = requireProperties(Function, contract());
   if (!Required)
     return std::unexpected(Required.error());
diff --git a/backend/lib/CodeGen/PostRAScheduler.cpp b/backend/lib/CodeGen/PostRAScheduler.cpp
index f7d6181..b5f7ae9 100644
--- a/backend/lib/CodeGen/PostRAScheduler.cpp
+++ b/backend/lib/CodeGen/PostRAScheduler.cpp
@@ -37,10 +37,11 @@ namespace {
                      MachineFunctionProperty::TracksLiveness},
         .Sets = {},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<LiveVariablesAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()},
         .VerificationStage = PipelineStage::RegisterAllocated,
     };
-    Value.RequiredAnalyses.push_back(MachineAnalysisManager::id<MachineBlockFrequencyAnalysis>());
+    Value.RequiredAnalyses.push_back(
+        MachineFunctionAnalysisManager::id<MachineBlockFrequencyAnalysis>());
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
     Value.DeclaredChanges = {MachinePassChange::Instructions, MachinePassChange::Operands};
     return Value;
@@ -61,7 +62,7 @@ const MachinePassContract &PostRASchedulerPass::contract() const noexcept {
 
 Expected<MachinePassResult> PostRASchedulerPass::run(MachineFunction &Function,
                                                      const TargetDescription &Target,
-                                                     MachineAnalysisManager &Analyses) {
+                                                     MachineFunctionAnalysisManager &Analyses) {
   if (!Function.properties().containsAll(contract().Requires)) {
     return makeUnexpected(ErrorCode::VerificationError,
                           "post-RA scheduler requires allocated tracked-liveness MachineIR");
@@ -73,7 +74,7 @@ Expected<MachinePassResult> PostRASchedulerPass::run(MachineFunction &Function,
     return std::unexpected(
         prefixedError(Trial.error(), "post-RA scheduler transaction setup failed: "));
   }
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto TrialLiveness =
       TrialAnalyses.getResult<LiveVariablesAnalysis>(*Trial->ClonedFunction, Target);
   if (!TrialLiveness)
diff --git a/backend/lib/CodeGen/PrologueEpilogueInsertion.cpp b/backend/lib/CodeGen/PrologueEpilogueInsertion.cpp
index 47b74f6..c935d6a 100644
--- a/backend/lib/CodeGen/PrologueEpilogueInsertion.cpp
+++ b/backend/lib/CodeGen/PrologueEpilogueInsertion.cpp
@@ -49,7 +49,7 @@ const MachinePassContract &PrologueEpilogueInsertionPass::contract() const noexc
 
 Expected<MachinePassResult> PrologueEpilogueInsertionPass::run(MachineFunction &Function,
                                                                const TargetDescription &Target,
-                                                               MachineAnalysisManager &) {
+                                                               MachineFunctionAnalysisManager &) {
   if (Info == nullptr)
     return makeUnexpected(ErrorCode::InvalidArgument,
                           "PrologueEpilogueInsertion requires target frame lowering");
diff --git a/backend/lib/CodeGen/RegAllocBase.h b/backend/lib/CodeGen/RegAllocBase.h
index 318a82d..4ef0bb7 100644
--- a/backend/lib/CodeGen/RegAllocBase.h
+++ b/backend/lib/CodeGen/RegAllocBase.h
@@ -27,8 +27,9 @@ public:
 
 protected:
   RegAllocBase(MachineFunction &Function, const TargetDescription &Target,
-               const TargetRegisterAllocationInfo &TargetInfo, MachineAnalysisManager &Analyses,
-               RegisterAllocationOptions Options, MachineActionReplay *Actions = nullptr) noexcept
+               const TargetRegisterAllocationInfo &TargetInfo,
+               MachineFunctionAnalysisManager &Analyses, RegisterAllocationOptions Options,
+               MachineActionReplay *Actions = nullptr) noexcept
       : Function(Function), Target(Target), TargetInfo(TargetInfo), Analyses(Analyses),
         Options(Options), Actions(Actions) {}
 
@@ -38,7 +39,7 @@ protected:
   MachineFunction &Function;
   const TargetDescription &Target;
   const TargetRegisterAllocationInfo &TargetInfo;
-  MachineAnalysisManager &Analyses;
+  MachineFunctionAnalysisManager &Analyses;
   RegisterAllocationOptions Options;
   MachineActionReplay *Actions = nullptr;
 };
diff --git a/backend/lib/CodeGen/RegAllocBasic.cpp b/backend/lib/CodeGen/RegAllocBasic.cpp
index 9d14d15..7f730ca 100644
--- a/backend/lib/CodeGen/RegAllocBasic.cpp
+++ b/backend/lib/CodeGen/RegAllocBasic.cpp
@@ -18,7 +18,7 @@ class BasicAllocatorEngine final : public RegAllocBase {
 public:
   BasicAllocatorEngine(MachineFunction &Function, const TargetDescription &Target,
                        const TargetRegisterAllocationInfo &TargetInfo,
-                       MachineAnalysisManager &Analyses, RegisterAllocationOptions Options)
+                       MachineFunctionAnalysisManager &Analyses, RegisterAllocationOptions Options)
       : RegAllocBase(Function, Target, TargetInfo, Analyses, Options) {}
 
 private:
@@ -80,7 +80,7 @@ private:
                      MachineFunctionProperty::TracksLiveness},
         .Sets = {MachineFunctionProperty::NoVRegs},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<LiveIntervalsAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveIntervalsAnalysis>()},
         .VerificationStage = PipelineStage::RegisterAllocated,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -97,7 +97,7 @@ const MachinePassContract &BasicAllocatorPass::contract() const noexcept {
 
 Expected<MachinePassResult> BasicAllocatorPass::run(MachineFunction &Function,
                                                     const TargetDescription &Target,
-                                                    MachineAnalysisManager &Analyses) {
+                                                    MachineFunctionAnalysisManager &Analyses) {
   if (Info == nullptr)
     return makeUnexpected(ErrorCode::InvalidArgument, "BasicAllocator requires target behavior");
   auto Required = regalloc_detail::requireAllocationProperties(Function, contract());
@@ -112,7 +112,7 @@ Expected<MachinePassResult> BasicAllocatorPass::run(MachineFunction &Function,
       regalloc_detail::reserveFunctionRegisters(*Trial->ClonedFunction, FunctionReserved);
   if (!TrialReserved)
     return std::unexpected(TrialReserved.error());
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto Registered = registerStage11MachineAnalyses(TrialAnalyses);
   if (!Registered)
     return std::unexpected(Registered.error());
diff --git a/backend/lib/CodeGen/RegAllocBasic.h b/backend/lib/CodeGen/RegAllocBasic.h
index 8a68f5f..f88c977 100644
--- a/backend/lib/CodeGen/RegAllocBasic.h
+++ b/backend/lib/CodeGen/RegAllocBasic.h
@@ -19,7 +19,7 @@ public:
   [[nodiscard]] const MachinePassContract &contract() const noexcept override;
   [[nodiscard]] Expected<MachinePassResult> run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &Analyses) override;
+                                                MachineFunctionAnalysisManager &Analyses) override;
 
 private:
   const TargetRegisterAllocationInfo *Info;
diff --git a/backend/lib/CodeGen/RegAllocFast.cpp b/backend/lib/CodeGen/RegAllocFast.cpp
index 1399f10..73c3e1a 100644
--- a/backend/lib/CodeGen/RegAllocFast.cpp
+++ b/backend/lib/CodeGen/RegAllocFast.cpp
@@ -557,7 +557,7 @@ const MachinePassContract &FastAllocatorPass::contract() const noexcept {
                      MachineFunctionProperty::TracksLiveness},
         .Sets = {MachineFunctionProperty::NoVRegs},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<LiveVariablesAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveVariablesAnalysis>()},
         .VerificationStage = PipelineStage::RegisterAllocated,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -568,7 +568,7 @@ const MachinePassContract &FastAllocatorPass::contract() const noexcept {
 
 Expected<MachinePassResult> FastAllocatorPass::run(MachineFunction &Function,
                                                    const TargetDescription &Target,
-                                                   MachineAnalysisManager &Analyses) {
+                                                   MachineFunctionAnalysisManager &Analyses) {
   if (Info == nullptr)
     return makeUnexpected(ErrorCode::InvalidArgument, "FastAllocator requires target behavior");
   auto Required = regalloc_detail::requireAllocationProperties(Function, contract());
@@ -583,7 +583,7 @@ Expected<MachinePassResult> FastAllocatorPass::run(MachineFunction &Function,
       regalloc_detail::reserveFunctionRegisters(*Trial->ClonedFunction, FunctionReserved);
   if (!TrialReserved)
     return std::unexpected(TrialReserved.error());
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto Registered = registerStage11MachineAnalyses(TrialAnalyses);
   if (!Registered)
     return std::unexpected(Registered.error());
diff --git a/backend/lib/CodeGen/RegAllocPBQP.cpp b/backend/lib/CodeGen/RegAllocPBQP.cpp
index 3b0e684..6706cd5 100644
--- a/backend/lib/CodeGen/RegAllocPBQP.cpp
+++ b/backend/lib/CodeGen/RegAllocPBQP.cpp
@@ -86,7 +86,7 @@ class PBQPAllocatorEngine final : public RegAllocBase {
 public:
   PBQPAllocatorEngine(MachineFunction &Function, const TargetDescription &Target,
                       const TargetRegisterAllocationInfo &TargetInfo,
-                      MachineAnalysisManager &Analyses, RegisterAllocationOptions Options,
+                      MachineFunctionAnalysisManager &Analyses, RegisterAllocationOptions Options,
                       MachineActionReplay *Actions)
       : RegAllocBase(Function, Target, TargetInfo, Analyses, Options, Actions) {}
 
@@ -277,7 +277,7 @@ private:
                      MachineFunctionProperty::TracksLiveness},
         .Sets = {MachineFunctionProperty::NoVRegs},
         .Clears = {},
-        .RequiredAnalyses = {MachineAnalysisManager::id<LiveIntervalsAnalysis>()},
+        .RequiredAnalyses = {MachineFunctionAnalysisManager::id<LiveIntervalsAnalysis>()},
         .VerificationStage = PipelineStage::RegisterAllocated,
     };
     Value.ThreadSafety = PassThreadSafety::ThreadSafe;
@@ -294,7 +294,7 @@ const MachinePassContract &PBQPAllocatorPass::contract() const noexcept {
 
 Expected<MachinePassResult> PBQPAllocatorPass::run(MachineFunction &Function,
                                                    const TargetDescription &Target,
-                                                   MachineAnalysisManager &Analyses) {
+                                                   MachineFunctionAnalysisManager &Analyses) {
   if (Info == nullptr)
     return makeUnexpected(ErrorCode::InvalidArgument, "PBQPAllocator requires target behavior");
   auto Required = regalloc_detail::requireAllocationProperties(Function, contract());
@@ -309,7 +309,7 @@ Expected<MachinePassResult> PBQPAllocatorPass::run(MachineFunction &Function,
       regalloc_detail::reserveFunctionRegisters(*Trial->ClonedFunction, FunctionReserved);
   if (!TrialReserved)
     return std::unexpected(TrialReserved.error());
-  MachineAnalysisManager TrialAnalyses;
+  MachineFunctionAnalysisManager TrialAnalyses;
   auto Registered = registerStage11MachineAnalyses(TrialAnalyses);
   if (!Registered)
     return std::unexpected(Registered.error());
diff --git a/backend/lib/CodeGen/SlotIndexes.cpp b/backend/lib/CodeGen/SlotIndexes.cpp
index 57e35b5..4fe753a 100644
--- a/backend/lib/CodeGen/SlotIndexes.cpp
+++ b/backend/lib/CodeGen/SlotIndexes.cpp
@@ -143,12 +143,12 @@ Expected<void> SlotIndexesAnalysis::Result::renumber(MachineFunction &Function)
 
 bool SlotIndexesAnalysis::Result::invalidate(const MachineFunction &,
                                              const PreservedAnalyses &Preserved) const noexcept {
-  return !Preserved.preserves(MachineAnalysisManager::id<SlotIndexesAnalysis>());
+  return !Preserved.preserves(MachineFunctionAnalysisManager::id<SlotIndexesAnalysis>());
 }
 
 Expected<SlotIndexesAnalysis::Result> SlotIndexesAnalysis::run(MachineFunction &Function,
                                                                const TargetDescription &,
-                                                               MachineAnalysisManager &) {
+                                                               MachineFunctionAnalysisManager &) {
   Result ResultValue;
   auto Numbered = ResultValue.renumber(Function);
   if (!Numbered)
diff --git a/backend/lib/CodeGen/TwoAddressInstructionPass.cpp b/backend/lib/CodeGen/TwoAddressInstructionPass.cpp
index be4db82..b6f2a25 100644
--- a/backend/lib/CodeGen/TwoAddressInstructionPass.cpp
+++ b/backend/lib/CodeGen/TwoAddressInstructionPass.cpp
@@ -459,9 +459,9 @@ const MachinePassContract &TwoAddressInstructionPass::contract() const noexcept
   return Contract;
 }
 
-Expected<MachinePassResult> TwoAddressInstructionPass::run(MachineFunction &Function,
-                                                           const TargetDescription &Target,
-                                                           MachineAnalysisManager &Analyses) {
+Expected<MachinePassResult>
+TwoAddressInstructionPass::run(MachineFunction &Function, const TargetDescription &Target,
+                               MachineFunctionAnalysisManager &Analyses) {
   auto Required = requireProperties(Function, contract());
   if (!Required)
     return std::unexpected(Required.error());
diff --git a/backend/lib/CodeGen/VirtRegMap.cpp b/backend/lib/CodeGen/VirtRegMap.cpp
index a55a486..4f3ae45 100644
--- a/backend/lib/CodeGen/VirtRegMap.cpp
+++ b/backend/lib/CodeGen/VirtRegMap.cpp
@@ -169,7 +169,7 @@ Expected<bool> rewriteVirtualRegisters(MachineFunction &Function, const TargetDe
   if (!MappingVerification)
     return std::unexpected(MappingVerification.error());
 
-  MachineAnalysisManager ValidationAnalyses;
+  MachineFunctionAnalysisManager ValidationAnalyses;
   auto Registered = registerStage11MachineAnalyses(ValidationAnalyses);
   if (!Registered)
     return std::unexpected(Registered.error());
@@ -282,7 +282,7 @@ const MachinePassContract &VirtualRegisterRewritePass::contract() const noexcept
 
 Expected<MachinePassResult> VirtualRegisterRewritePass::run(MachineFunction &Function,
                                                             const TargetDescription &Target,
-                                                            MachineAnalysisManager &) {
+                                                            MachineFunctionAnalysisManager &) {
   if (Mapping == nullptr)
     return makeUnexpected(ErrorCode::InvalidArgument,
                           "VirtualRegisterRewrite requires a VirtRegMap");