[CodeGen] Align pass manager ownership

108 files changed, 2435 insertions, 2534 deletions

diff --git a/backend/include/rcc/CodeGen/GlobalISel/InstructionSelect.h b/backend/include/rcc/CodeGen/GlobalISel/InstructionSelect.h
index 0c034cd..f342cdc 100644
--- a/backend/include/rcc/CodeGen/GlobalISel/InstructionSelect.h
+++ b/backend/include/rcc/CodeGen/GlobalISel/InstructionSelect.h
@@ -4,7 +4,7 @@
 #define RCC_CODEGEN_GLOBALISEL_INSTRUCTIONSELECT_H
 
 #include "rcc/CodeGen/GlobalISel/InstructionSelector.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -16,7 +16,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
diff --git a/backend/include/rcc/CodeGen/GlobalISel/Legalizer.h b/backend/include/rcc/CodeGen/GlobalISel/Legalizer.h
index 7f86d16..dfeda22 100644
--- a/backend/include/rcc/CodeGen/GlobalISel/Legalizer.h
+++ b/backend/include/rcc/CodeGen/GlobalISel/Legalizer.h
@@ -4,7 +4,7 @@
 #define RCC_CODEGEN_GLOBALISEL_LEGALIZER_H
 
 #include "rcc/CodeGen/GlobalISel/LegalizerInfo.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <memory>
 
@@ -20,7 +20,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
diff --git a/backend/include/rcc/CodeGen/GlobalISel/RegBankSelect.h b/backend/include/rcc/CodeGen/GlobalISel/RegBankSelect.h
index 256d748..a7fc6bf 100644
--- a/backend/include/rcc/CodeGen/GlobalISel/RegBankSelect.h
+++ b/backend/include/rcc/CodeGen/GlobalISel/RegBankSelect.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_GLOBALISEL_REGBANKSELECT_H
 #define RCC_CODEGEN_GLOBALISEL_REGBANKSELECT_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/RegisterBankInfo.h"
 
 namespace rcc {
@@ -16,7 +16,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 RegisterBankInfo *Info;
diff --git a/backend/include/rcc/CodeGen/LiveIntervals.h b/backend/include/rcc/CodeGen/LiveIntervals.h
index a45c593..b5ba05a 100644
--- a/backend/include/rcc/CodeGen/LiveIntervals.h
+++ b/backend/include/rcc/CodeGen/LiveIntervals.h
@@ -4,7 +4,7 @@
 #define RCC_CODEGEN_LIVEINTERVALS_H
 
 #include "rcc/CodeGen/LiveInterval.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/RegisterMask.h"
 
 #include <cstdint>
@@ -64,8 +64,9 @@ public:
     return "LiveIntervals";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
 } // namespace rcc
diff --git a/backend/include/rcc/CodeGen/LiveVariables.h b/backend/include/rcc/CodeGen/LiveVariables.h
index 28a66c1..c95e7d8 100644
--- a/backend/include/rcc/CodeGen/LiveVariables.h
+++ b/backend/include/rcc/CodeGen/LiveVariables.h
@@ -4,7 +4,7 @@
 #define RCC_CODEGEN_LIVEVARIABLES_H
 
 #include "rcc/CodeGen/LiveRegUnits.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/Register.h"
 #include "rcc/Support/Error.h"
 
@@ -82,8 +82,9 @@ public:
     return "LiveVariables";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
 class RebuildMachineLivenessPass final : public MachineFunctionPass {
@@ -91,14 +92,15 @@ public:
   [[nodiscard]] const MachinePassContract &contract() const noexcept override;
   [[nodiscard]] Expected<MachinePassResult> run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &Analyses) override;
+                                                MachineFunctionAnalysisManager &Analyses) override;
 };
 
 [[nodiscard]] Expected<void> verifyTrackedMachineLiveness(const MachineFunction &Function,
                                                           const TargetDescription &Target);
 [[nodiscard]] Expected<bool> rebuildMachineLiveness(MachineFunction &Function,
                                                     const TargetDescription &Target);
-[[nodiscard]] Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses);
+[[nodiscard]] Expected<void>
+registerStage11MachineAnalyses(MachineFunctionAnalysisManager &Analyses);
 
 } // namespace rcc
 
diff --git a/backend/include/rcc/CodeGen/MachineAnalyses.h b/backend/include/rcc/CodeGen/MachineAnalyses.h
index eda550d..4adb300 100644
--- a/backend/include/rcc/CodeGen/MachineAnalyses.h
+++ b/backend/include/rcc/CodeGen/MachineAnalyses.h
@@ -5,7 +5,7 @@
 
 #include "rcc/CodeGen/MachineBasicBlock.h"
 #include "rcc/CodeGen/MachineIRTypes.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/StableID.h"
 #include "rcc/Support/Error.h"
 
@@ -62,8 +62,9 @@ public:
     return "MachineDominatorTree";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
 struct MachineLoop final {
@@ -107,8 +108,9 @@ public:
     return "MachineLoopInfo";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
 class MachineBranchProbabilityAnalysis final {
@@ -130,8 +132,9 @@ public:
     return "MachineBranchProbability";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
 class MachineBlockFrequencyAnalysis final {
@@ -152,8 +155,9 @@ public:
     return "MachineBlockFrequency";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
 enum class MachineAliasResult : std::uint8_t {
@@ -175,8 +179,9 @@ public:
     return "MachineAliasAnalysis";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
 enum class MachineMemoryDependencyKind : std::uint8_t {
@@ -233,11 +238,13 @@ public:
     return "MachineMemoryDependence";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
-[[nodiscard]] Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses);
+[[nodiscard]] Expected<void>
+registerStage8MachineAnalyses(MachineFunctionAnalysisManager &Analyses);
 
 } // namespace rcc
 
diff --git a/backend/include/rcc/CodeGen/MachineBlockPlacement.h b/backend/include/rcc/CodeGen/MachineBlockPlacement.h
index 52ddafd..41d5f2d 100644
--- a/backend/include/rcc/CodeGen/MachineBlockPlacement.h
+++ b/backend/include/rcc/CodeGen/MachineBlockPlacement.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEBLOCKPLACEMENT_H
 #define RCC_CODEGEN_MACHINEBLOCKPLACEMENT_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -12,13 +12,12 @@ public:
   [[nodiscard]] const MachinePassContract &contract() const noexcept override;
   [[nodiscard]] Expected<MachinePassResult> run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &Analyses) override;
+                                                MachineFunctionAnalysisManager &Analyses) override;
 
 private:
-  [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
-                                                              const TargetDescription &Target,
-                                                              MachineAnalysisManager &Analyses,
-                                                              MachineActionReplay &Actions) const;
+  [[nodiscard]] Expected<MachinePassResult>
+  runImplementation(MachineFunction &Function, const TargetDescription &Target,
+                    MachineFunctionAnalysisManager &Analyses, MachineActionReplay &Actions) const;
 };
 
 } // namespace rcc
diff --git a/backend/include/rcc/CodeGen/MachineBranchOptimization.h b/backend/include/rcc/CodeGen/MachineBranchOptimization.h
index 9f120dc..e578d72 100644
--- a/backend/include/rcc/CodeGen/MachineBranchOptimization.h
+++ b/backend/include/rcc/CodeGen/MachineBranchOptimization.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEBRANCHOPTIMIZATION_H
 #define RCC_CODEGEN_MACHINEBRANCHOPTIMIZATION_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -24,7 +24,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:
   [[nodiscard]] Expected<MachinePassResult>
diff --git a/backend/include/rcc/CodeGen/MachineBranchRelaxation.h b/backend/include/rcc/CodeGen/MachineBranchRelaxation.h
index 03c7fa7..5b359b4 100644
--- a/backend/include/rcc/CodeGen/MachineBranchRelaxation.h
+++ b/backend/include/rcc/CodeGen/MachineBranchRelaxation.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEBRANCHRELAXATION_H
 #define RCC_CODEGEN_MACHINEBRANCHRELAXATION_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -24,7 +24,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
diff --git a/backend/include/rcc/CodeGen/MachineCSE.h b/backend/include/rcc/CodeGen/MachineCSE.h
index 1c2057b..dc10b62 100644
--- a/backend/include/rcc/CodeGen/MachineCSE.h
+++ b/backend/include/rcc/CodeGen/MachineCSE.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINECSE_H
 #define RCC_CODEGEN_MACHINECSE_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -20,12 +20,12 @@ public:
   [[nodiscard]] const MachinePassContract &contract() const noexcept override;
   [[nodiscard]] Expected<MachinePassResult> run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &Analyses) override;
+                                                MachineFunctionAnalysisManager &Analyses) override;
 
 private:
-  [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
-                                                              const TargetDescription &Target,
-                                                              MachineAnalysisManager &Analyses);
+  [[nodiscard]] Expected<MachinePassResult>
+  runImplementation(MachineFunction &Function, const TargetDescription &Target,
+                    MachineFunctionAnalysisManager &Analyses);
 
   MachineCSEOptions Options;
 };
diff --git a/backend/include/rcc/CodeGen/MachineCombiner.h b/backend/include/rcc/CodeGen/MachineCombiner.h
index ef7f432..3850b91 100644
--- a/backend/include/rcc/CodeGen/MachineCombiner.h
+++ b/backend/include/rcc/CodeGen/MachineCombiner.h
@@ -4,7 +4,7 @@
 #define RCC_CODEGEN_MACHINECOMBINER_H
 
 #include "rcc/CodeGen/MachineCombinerPattern.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -24,7 +24,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
diff --git a/backend/include/rcc/CodeGen/MachineCopyPropagation.h b/backend/include/rcc/CodeGen/MachineCopyPropagation.h
index 43baa7e..ab8b23f 100644
--- a/backend/include/rcc/CodeGen/MachineCopyPropagation.h
+++ b/backend/include/rcc/CodeGen/MachineCopyPropagation.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINECOPYPROPAGATION_H
 #define RCC_CODEGEN_MACHINECOPYPROPAGATION_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -30,7 +30,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
diff --git a/backend/include/rcc/CodeGen/MachineDCE.h b/backend/include/rcc/CodeGen/MachineDCE.h
index 893108d..8860b0f 100644
--- a/backend/include/rcc/CodeGen/MachineDCE.h
+++ b/backend/include/rcc/CodeGen/MachineDCE.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEDCE_H
 #define RCC_CODEGEN_MACHINEDCE_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -12,7 +12,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
diff --git a/backend/include/rcc/CodeGen/MachineFallthrough.h b/backend/include/rcc/CodeGen/MachineFallthrough.h
index 5793330..bb62e8a 100644
--- a/backend/include/rcc/CodeGen/MachineFallthrough.h
+++ b/backend/include/rcc/CodeGen/MachineFallthrough.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEFALLTHROUGH_H
 #define RCC_CODEGEN_MACHINEFALLTHROUGH_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -16,7 +16,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 TargetInstrInfo *Info;
diff --git a/backend/include/rcc/CodeGen/MachineFinalization.h b/backend/include/rcc/CodeGen/MachineFinalization.h
index 1927691..d12ee0b 100644
--- a/backend/include/rcc/CodeGen/MachineFinalization.h
+++ b/backend/include/rcc/CodeGen/MachineFinalization.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEFINALIZATION_H
 #define RCC_CODEGEN_MACHINEFINALIZATION_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -14,7 +14,7 @@ public:
   [[nodiscard]] const MachinePassContract &contract() const noexcept override;
   [[nodiscard]] Expected<MachinePassResult> run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &Analyses) override;
+                                                MachineFunctionAnalysisManager &Analyses) override;
 };
 
 class FinalEncodabilityVerifierPass final : public MachineFunctionPass {
@@ -25,7 +25,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 TargetInstrInfo *BranchInfo;
diff --git a/backend/include/rcc/CodeGen/MachineFunctionAnalysisManager.h b/backend/include/rcc/CodeGen/MachineFunctionAnalysisManager.h
new file mode 100644
index 0000000..9685e45
--- /dev/null
+++ b/backend/include/rcc/CodeGen/MachineFunctionAnalysisManager.h
@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef RCC_CODEGEN_MACHINEFUNCTIONANALYSISMANAGER_H
+#define RCC_CODEGEN_MACHINEFUNCTIONANALYSISMANAGER_H
+
+#include "rcc/CodeGen/StableID.h"
+#include "rcc/IR/PassManager.h"
+
+#include <cstdint>
+#include <initializer_list>
+
+namespace rcc {
+
+class CompilationUnit;
+class MachineFunction;
+class MachinePassInstrumentation;
+
+enum class MachinePassChange : std::uint32_t {
+  None = 0,
+  Instructions = 1U << 0U,
+  Operands = 1U << 1U,
+  Registers = 1U << 2U,
+  CFG = 1U << 3U,
+  BlockLayout = 1U << 4U,
+  Frame = 1U << 5U,
+  ConstantPool = 1U << 6U,
+  JumpTable = 1U << 7U,
+  TargetState = 1U << 8U,
+};
+
+class MachinePassChanges final {
+public:
+  constexpr MachinePassChanges() noexcept = default;
+  constexpr MachinePassChanges(std::initializer_list<MachinePassChange> Changes) noexcept {
+    for (const MachinePassChange Change : Changes)
+      add(Change);
+  }
+
+  [[nodiscard]] static constexpr MachinePassChanges all() noexcept {
+    return fromRaw((1U << 9U) - 1U);
+  }
+
+  [[nodiscard]] static constexpr MachinePassChanges fromRaw(std::uint32_t Bits) noexcept {
+    MachinePassChanges Result;
+    Result.Bits = Bits & rawMask();
+    return Result;
+  }
+
+  constexpr void add(MachinePassChange Change) noexcept {
+    Bits |= static_cast<std::uint32_t>(Change);
+  }
+
+  [[nodiscard]] constexpr bool has(MachinePassChange Change) const noexcept {
+    return (Bits & static_cast<std::uint32_t>(Change)) != 0;
+  }
+
+  [[nodiscard]] constexpr bool contains(MachinePassChanges Other) const noexcept {
+    return (Bits & Other.Bits) == Other.Bits;
+  }
+
+  [[nodiscard]] constexpr bool intersects(MachinePassChanges Other) const noexcept {
+    return (Bits & Other.Bits) != 0;
+  }
+
+  [[nodiscard]] constexpr bool empty() const noexcept {
+    return Bits == 0;
+  }
+
+  [[nodiscard]] constexpr std::uint32_t rawValue() const noexcept {
+    return Bits;
+  }
+
+  friend constexpr bool operator==(MachinePassChanges Left,
+                                   MachinePassChanges Right) noexcept = default;
+
+private:
+  [[nodiscard]] static constexpr std::uint32_t rawMask() noexcept {
+    return (1U << 9U) - 1U;
+  }
+
+  std::uint32_t Bits = 0;
+};
+
+template <>
+struct AnalysisManagerInstrumentation<MachineFunction, MachinePassInstrumentation> final {
+  static void beforeAnalysis(MachinePassInstrumentation *Instrumentation, std::string_view Name,
+                             const MachineFunction &Function);
+  static void afterAnalysis(MachinePassInstrumentation *Instrumentation, std::string_view Name,
+                            const MachineFunction &Function, bool CacheHit,
+                            std::uint64_t Nanoseconds);
+  static void analysisFailure(MachinePassInstrumentation *Instrumentation, std::string_view Name,
+                              const MachineFunction &Function, const Error &Failure,
+                              std::uint64_t Nanoseconds);
+  [[nodiscard]] static Expected<bool> requestAction(MachinePassInstrumentation *Instrumentation,
+                                                    std::string_view Pass, std::string_view Rule,
+                                                    const MachineFunction &Function,
+                                                    MachineInstrStableID Instruction,
+                                                    std::uint64_t Cost);
+  [[nodiscard]] static Expected<bool> requestAction(MachinePassInstrumentation *Instrumentation,
+                                                    std::string_view Pass, std::string_view Rule,
+                                                    const MachineFunction &Function, std::nullptr_t,
+                                                    std::uint64_t Cost);
+};
+
+template <>
+struct AnalysisManagerInstrumentation<CompilationUnit, MachinePassInstrumentation> final {
+  static void beforeAnalysis(MachinePassInstrumentation *Instrumentation, std::string_view Name,
+                             const CompilationUnit &Unit);
+  static void afterAnalysis(MachinePassInstrumentation *Instrumentation, std::string_view Name,
+                            const CompilationUnit &Unit, bool CacheHit, std::uint64_t Nanoseconds);
+  static void analysisFailure(MachinePassInstrumentation *Instrumentation, std::string_view Name,
+                              const CompilationUnit &Unit, const Error &Failure,
+                              std::uint64_t Nanoseconds);
+};
+
+using MachineAnalysisRegistration = AnalysisRegistration<MachinePassChanges>;
+using CompilationUnitAnalysisRegistration = AnalysisRegistration<MachinePassChanges>;
+
+using MachineFunctionAnalysisManager =
+    AnalysisManager<MachineFunction, MachineAnalysisRegistration, MachinePassChanges,
+                    MachinePassInstrumentation>;
+using CompilationUnitAnalysisManager =
+    AnalysisManager<CompilationUnit, CompilationUnitAnalysisRegistration, MachinePassChanges,
+                    MachinePassInstrumentation>;
+
+[[nodiscard]] Expected<void>
+registerStage8MachineAnalyses(MachineFunctionAnalysisManager &Analyses);
+[[nodiscard]] Expected<void>
+registerStage11MachineAnalyses(MachineFunctionAnalysisManager &Analyses);
+
+} // namespace rcc
+
+#endif // RCC_CODEGEN_MACHINEFUNCTIONANALYSISMANAGER_H
diff --git a/backend/include/rcc/CodeGen/MachineLICM.h b/backend/include/rcc/CodeGen/MachineLICM.h
index 66b7ef8..5efaf20 100644
--- a/backend/include/rcc/CodeGen/MachineLICM.h
+++ b/backend/include/rcc/CodeGen/MachineLICM.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINELICM_H
 #define RCC_CODEGEN_MACHINELICM_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -29,12 +29,12 @@ public:
   [[nodiscard]] const MachinePassContract &contract() const noexcept override;
   [[nodiscard]] Expected<MachinePassResult> run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &Analyses) override;
+                                                MachineFunctionAnalysisManager &Analyses) override;
 
 private:
-  [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
-                                                              const TargetDescription &Target,
-                                                              MachineAnalysisManager &Analyses);
+  [[nodiscard]] Expected<MachinePassResult>
+  runImplementation(MachineFunction &Function, const TargetDescription &Target,
+                    MachineFunctionAnalysisManager &Analyses);
 
   MachineCodeMotionStage Stage = MachineCodeMotionStage::SelectedSSA;
   MachineLICMOptions Options;
diff --git a/backend/include/rcc/CodeGen/MachineMemoryFolding.h b/backend/include/rcc/CodeGen/MachineMemoryFolding.h
index 9a5b47a..9f415d7 100644
--- a/backend/include/rcc/CodeGen/MachineMemoryFolding.h
+++ b/backend/include/rcc/CodeGen/MachineMemoryFolding.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEMEMORYFOLDING_H
 #define RCC_CODEGEN_MACHINEMEMORYFOLDING_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -24,7 +24,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:
   [[nodiscard]] Expected<MachinePassResult>
diff --git a/backend/include/rcc/CodeGen/MachineOptimizationPipeline.h b/backend/include/rcc/CodeGen/MachineOptimizationPipeline.h
index 10bcbc6..51b4ed2 100644
--- a/backend/include/rcc/CodeGen/MachineOptimizationPipeline.h
+++ b/backend/include/rcc/CodeGen/MachineOptimizationPipeline.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEOPTIMIZATIONPIPELINE_H
 #define RCC_CODEGEN_MACHINEOPTIMIZATIONPIPELINE_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -23,17 +23,18 @@ struct MachineOptimizationPipelineTargetInfo final {
   const TargetSchedulingModel &SchedulingModel;
 };
 
-[[nodiscard]] Expected<void> registerMachineOptimizationAnalyses(MachineAnalysisManager &Analyses);
+[[nodiscard]] Expected<void>
+registerMachineOptimizationAnalyses(MachineFunctionAnalysisManager &Analyses);
 
 [[nodiscard]] Expected<void>
-addSelectedSSAOptimizationPipeline(MachinePassManager &Pipeline,
+addSelectedSSAOptimizationPipeline(MachineFunctionPassManager &Pipeline,
                                    const MachineOptimizationPipelineTargetInfo &TargetInfo);
 
 [[nodiscard]] Expected<void> addPreRegisterAllocationOptimizationPipeline(
-    MachinePassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo);
+    MachineFunctionPassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo);
 
 [[nodiscard]] Expected<void>
-addPostRegisterAllocationPipeline(MachinePassManager &Pipeline,
+addPostRegisterAllocationPipeline(MachineFunctionPassManager &Pipeline,
                                   const MachineOptimizationPipelineTargetInfo &TargetInfo);
 
 } // namespace rcc
diff --git a/backend/include/rcc/CodeGen/MachinePass.h b/backend/include/rcc/CodeGen/MachinePass.h
deleted file mode 100644
index ee67924..0000000
--- a/backend/include/rcc/CodeGen/MachinePass.h
+++ /dev/null
@@ -1,720 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#ifndef RCC_CODEGEN_MACHINEPASS_H
-#define RCC_CODEGEN_MACHINEPASS_H
-
-#include "rcc/CodeGen/InstructionDescriptor.h"
-#include "rcc/CodeGen/MachineFunctionProperties.h"
-#include "rcc/CodeGen/StableID.h"
-#include "rcc/Support/Error.h"
-
-#include <concepts>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <initializer_list>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <span>
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-namespace rcc {
-
-class CompilationUnit;
-class MachineFunction;
-class MachineVerifier;
-class TargetDescription;
-
-using AnalysisID = const void *;
-
-enum class MachinePassChange : std::uint32_t {
-  None = 0,
-  Instructions = 1U << 0U,
-  Operands = 1U << 1U,
-  Registers = 1U << 2U,
-  CFG = 1U << 3U,
-  BlockLayout = 1U << 4U,
-  Frame = 1U << 5U,
-  ConstantPool = 1U << 6U,
-  JumpTable = 1U << 7U,
-  TargetState = 1U << 8U,
-};
-
-class MachinePassChanges final {
-public:
-  constexpr MachinePassChanges() noexcept = default;
-  constexpr MachinePassChanges(std::initializer_list<MachinePassChange> Changes) noexcept {
-    for (const MachinePassChange Change : Changes)
-      add(Change);
-  }
-
-  [[nodiscard]] static constexpr MachinePassChanges all() noexcept {
-    return fromRaw((1U << 9U) - 1U);
-  }
-
-  [[nodiscard]] static constexpr MachinePassChanges fromRaw(std::uint32_t Bits) noexcept {
-    MachinePassChanges Result;
-    Result.Bits = Bits & rawMask();
-    return Result;
-  }
-
-  constexpr void add(MachinePassChange Change) noexcept {
-    Bits |= static_cast<std::uint32_t>(Change);
-  }
-
-  [[nodiscard]] constexpr bool has(MachinePassChange Change) const noexcept {
-    return (Bits & static_cast<std::uint32_t>(Change)) != 0;
-  }
-
-  [[nodiscard]] constexpr bool contains(MachinePassChanges Other) const noexcept {
-    return (Bits & Other.Bits) == Other.Bits;
-  }
-
-  [[nodiscard]] constexpr bool intersects(MachinePassChanges Other) const noexcept {
-    return (Bits & Other.Bits) != 0;
-  }
-
-  [[nodiscard]] constexpr bool empty() const noexcept {
-    return Bits == 0;
-  }
-
-  [[nodiscard]] constexpr std::uint32_t rawValue() const noexcept {
-    return Bits;
-  }
-
-  friend constexpr bool operator==(MachinePassChanges Left,
-                                   MachinePassChanges Right) noexcept = default;
-
-private:
-  [[nodiscard]] static constexpr std::uint32_t rawMask() noexcept {
-    return (1U << 9U) - 1U;
-  }
-
-  std::uint32_t Bits = 0;
-};
-
-class PreservedAnalyses final {
-public:
-  [[nodiscard]] static PreservedAnalyses all() noexcept {
-    PreservedAnalyses Result;
-    Result.PreserveAll = true;
-    return Result;
-  }
-
-  [[nodiscard]] static PreservedAnalyses none() noexcept {
-    return {};
-  }
-
-  void preserve(AnalysisID ID) {
-    if (ID != nullptr)
-      Preserved.insert(ID);
-  }
-
-  template <typename AnalysisT> void preserve() {
-    preserve(analysisID<AnalysisT>());
-  }
-
-  [[nodiscard]] bool preserves(AnalysisID ID) const noexcept {
-    return PreserveAll || (ID != nullptr && Preserved.contains(ID));
-  }
-
-  [[nodiscard]] bool preservesAll() const noexcept {
-    return PreserveAll;
-  }
-
-  template <typename AnalysisT> [[nodiscard]] static AnalysisID analysisID() noexcept {
-    static const std::uint8_t Token = 0;
-    return &Token;
-  }
-
-private:
-  bool PreserveAll = false;
-  std::unordered_set<AnalysisID> Preserved;
-};
-
-enum class PassThreadSafety : std::uint8_t {
-  NotThreadSafe,
-  ThreadSafe,
-};
-
-struct PassParameter final {
-  std::string Name;
-  std::string Description;
-  std::optional<std::string> DefaultValue;
-  bool Required = false;
-};
-
-struct MachinePassRegistrationMetadata {
-  std::vector<PassParameter> Parameters;
-  PassThreadSafety ThreadSafety = PassThreadSafety::NotThreadSafe;
-  MachinePassChanges DeclaredChanges = MachinePassChanges::all();
-};
-
-struct MachinePassContract final : MachinePassRegistrationMetadata {
-  std::string Name;
-  MachineFunctionProperties Requires;
-  MachineFunctionProperties Sets;
-  MachineFunctionProperties Clears;
-  std::vector<AnalysisID> RequiredAnalyses;
-  std::optional<PipelineStage> VerificationStage;
-};
-
-struct MachinePassResult final {
-  bool Changed = false;
-  MachinePassChanges Changes;
-  PreservedAnalyses Preserved = PreservedAnalyses::none();
-};
-
-struct CompilationUnitPassContract final {
-  std::string Name;
-  std::vector<AnalysisID> RequiredAnalyses;
-  std::vector<PassParameter> Parameters;
-  MachinePassChanges DeclaredChanges = MachinePassChanges::all();
-};
-
-struct CompilationUnitPassResult final {
-  bool Changed = false;
-  MachinePassChanges Changes;
-  PreservedAnalyses PreservedUnitAnalyses = PreservedAnalyses::none();
-  PreservedAnalyses PreservedFunctionAnalyses = PreservedAnalyses::none();
-};
-
-struct MachineAnalysisRegistration final {
-  AnalysisID ID = nullptr;
-  std::string Name;
-  std::vector<AnalysisID> Dependencies;
-  MachinePassChanges InvalidatedBy = MachinePassChanges::all();
-  PassThreadSafety ThreadSafety = PassThreadSafety::NotThreadSafe;
-};
-
-struct CompilationUnitAnalysisRegistration final {
-  AnalysisID ID = nullptr;
-  std::string Name;
-  std::vector<AnalysisID> Dependencies;
-  MachinePassChanges InvalidatedBy = MachinePassChanges::all();
-};
-
-class MachinePassInstrumentation;
-
-class MachineAnalysisManager final {
-public:
-  MachineAnalysisManager() = default;
-  MachineAnalysisManager(const MachineAnalysisManager &) = delete;
-  MachineAnalysisManager &operator=(const MachineAnalysisManager &) = delete;
-  MachineAnalysisManager(MachineAnalysisManager &&) = delete;
-  MachineAnalysisManager &operator=(MachineAnalysisManager &&) = delete;
-  ~MachineAnalysisManager() = default;
-
-  template <typename AnalysisT> [[nodiscard]] static AnalysisID id() noexcept {
-    return PreservedAnalyses::analysisID<AnalysisT>();
-  }
-
-  template <typename AnalysisT>
-  [[nodiscard]] Expected<void> registerAnalysis(MachineAnalysisRegistration Registration = {}) {
-    using ResultT = typename AnalysisT::Result;
-    if (Registration.ID == nullptr)
-      Registration.ID = id<AnalysisT>();
-    if (Registration.Name.empty()) {
-      if constexpr (requires {
-                      { AnalysisT::name() } -> std::convertible_to<std::string_view>;
-                    }) {
-        Registration.Name = std::string(AnalysisT::name());
-      } else {
-        Registration.Name = "unnamed-machine-analysis";
-      }
-    }
-
-    ErasedRunner Runner = [](MachineFunction &Function, const TargetDescription &Target,
-                             MachineAnalysisManager &Manager) -> Expected<std::shared_ptr<void>> {
-      auto Computed = AnalysisT::run(Function, Target, Manager);
-      if (!Computed)
-        return std::unexpected(Computed.error());
-      return std::shared_ptr<void>(new ResultT(std::move(*Computed)),
-                                   [](void *Value) { delete static_cast<ResultT *>(Value); });
-    };
-    ErasedInvalidator Invalidator = [](void *Value, const MachineFunction &Function,
-                                       const PreservedAnalyses &Preserved) -> bool {
-      if constexpr (requires(ResultT &Result, const MachineFunction &InputFunction,
-                             const PreservedAnalyses &Analyses) {
-                      { Result.invalidate(InputFunction, Analyses) } -> std::convertible_to<bool>;
-                    }) {
-        return static_cast<ResultT *>(Value)->invalidate(Function, Preserved);
-      }
-      return true;
-    };
-    return registerAnalysisImpl(std::move(Registration), std::move(Runner), std::move(Invalidator));
-  }
-
-  template <typename AnalysisT>
-  [[nodiscard]] Expected<typename AnalysisT::Result *> getResult(MachineFunction &Function,
-                                                                 const TargetDescription &Target) {
-    const AnalysisID Key = id<AnalysisT>();
-    if (!isRegistered(Key)) {
-      auto Registered = registerAnalysis<AnalysisT>();
-      if (!Registered)
-        return std::unexpected(Registered.error());
-    }
-    auto Result = getResultImpl(Key, Function, Target);
-    if (!Result)
-      return std::unexpected(Result.error());
-    return static_cast<typename AnalysisT::Result *>(*Result);
-  }
-
-  void invalidate(MachineFunction &Function, const PreservedAnalyses &Preserved,
-                  MachinePassChanges Changes) noexcept;
-  void invalidate(MachineFunction &Function, const PreservedAnalyses &Preserved) noexcept {
-    invalidate(Function, Preserved, MachinePassChanges::all());
-  }
-  [[nodiscard]] bool hasCached(const MachineFunction &Function, AnalysisID ID) const noexcept;
-  [[nodiscard]] bool isRegistered(AnalysisID ID) const noexcept;
-  [[nodiscard]] std::size_t cachedResultCount(const MachineFunction &Function) const noexcept;
-  void clear(MachineFunction &Function) noexcept;
-  void clearAll() noexcept;
-
-  [[nodiscard]] Expected<std::unique_ptr<MachineAnalysisManager>> forkEmpty() const;
-  [[nodiscard]] Expected<bool>
-  requestAction(std::string_view Action, const MachineFunction &Function, std::uint64_t Cost = 1);
-  [[nodiscard]] Expected<bool> requestAction(std::string_view Rule, const MachineFunction &Function,
-                                             MachineInstrStableID Instruction,
-                                             std::uint64_t Cost = 1);
-
-private:
-  using ErasedRunner = std::function<Expected<std::shared_ptr<void>>(
-      MachineFunction &, const TargetDescription &, MachineAnalysisManager &)>;
-  using ErasedInvalidator =
-      std::function<bool(void *, const MachineFunction &, const PreservedAnalyses &)>;
-
-  struct RegisteredAnalysis final {
-    MachineAnalysisRegistration Info;
-    ErasedRunner Runner;
-    ErasedInvalidator Invalidator;
-  };
-
-  struct CacheEntry final {
-    std::shared_ptr<void> Value;
-    AnalysisID ID = nullptr;
-  };
-
-  [[nodiscard]] Expected<void> registerAnalysisImpl(MachineAnalysisRegistration Registration,
-                                                    ErasedRunner Runner,
-                                                    ErasedInvalidator Invalidator);
-  [[nodiscard]] Expected<void *> getResultImpl(AnalysisID ID, MachineFunction &Function,
-                                               const TargetDescription &Target);
-  [[nodiscard]] Expected<void> materializeDependencies(const RegisteredAnalysis &Registration,
-                                                       MachineFunction &Function,
-                                                       const TargetDescription &Target);
-  [[nodiscard]] Expected<void>
-  validateParallelRequirements(std::span<const AnalysisID> RequiredAnalyses) const;
-  void setInstrumentation(MachinePassInstrumentation *NewInstrumentation) noexcept {
-    Instrumentation = NewInstrumentation;
-  }
-
-  std::unordered_map<AnalysisID, RegisteredAnalysis> Registry;
-  std::unordered_map<MachineFunction *, std::unordered_map<AnalysisID, CacheEntry>> Cache;
-  std::unordered_map<MachineFunction *, std::vector<AnalysisID>> ActiveComputations;
-  MachinePassInstrumentation *Instrumentation = nullptr;
-  std::string ActivePass;
-
-  friend class MachinePassManager;
-  friend class CompilationUnitPassManager;
-  friend Expected<void> registerStage8MachineAnalyses(MachineAnalysisManager &Analyses);
-  friend Expected<void> registerStage11MachineAnalyses(MachineAnalysisManager &Analyses);
-};
-
-class CompilationUnitAnalysisManager final {
-public:
-  CompilationUnitAnalysisManager() = default;
-  CompilationUnitAnalysisManager(const CompilationUnitAnalysisManager &) = delete;
-  CompilationUnitAnalysisManager &operator=(const CompilationUnitAnalysisManager &) = delete;
-  CompilationUnitAnalysisManager(CompilationUnitAnalysisManager &&) = delete;
-  CompilationUnitAnalysisManager &operator=(CompilationUnitAnalysisManager &&) = delete;
-  ~CompilationUnitAnalysisManager() = default;
-
-  template <typename AnalysisT> [[nodiscard]] static AnalysisID id() noexcept {
-    return PreservedAnalyses::analysisID<AnalysisT>();
-  }
-
-  template <typename AnalysisT>
-  [[nodiscard]] Expected<void>
-  registerAnalysis(CompilationUnitAnalysisRegistration Registration = {}) {
-    using ResultT = typename AnalysisT::Result;
-    if (Registration.ID == nullptr)
-      Registration.ID = id<AnalysisT>();
-    if (Registration.Name.empty()) {
-      if constexpr (requires {
-                      { AnalysisT::name() } -> std::convertible_to<std::string_view>;
-                    }) {
-        Registration.Name = std::string(AnalysisT::name());
-      } else {
-        Registration.Name = "unnamed-compilation-unit-analysis";
-      }
-    }
-
-    ErasedRunner Runner =
-        [](CompilationUnit &Unit, const TargetDescription &Target,
-           CompilationUnitAnalysisManager &Manager) -> Expected<std::shared_ptr<void>> {
-      auto Computed = AnalysisT::run(Unit, Target, Manager);
-      if (!Computed)
-        return std::unexpected(Computed.error());
-      return std::shared_ptr<void>(new ResultT(std::move(*Computed)),
-                                   [](void *Value) { delete static_cast<ResultT *>(Value); });
-    };
-    ErasedInvalidator Invalidator = [](void *Value, const CompilationUnit &Unit,
-                                       const PreservedAnalyses &Preserved) -> bool {
-      if constexpr (requires(ResultT &Result, const CompilationUnit &InputUnit,
-                             const PreservedAnalyses &Analyses) {
-                      { Result.invalidate(InputUnit, Analyses) } -> std::convertible_to<bool>;
-                    }) {
-        return static_cast<ResultT *>(Value)->invalidate(Unit, Preserved);
-      }
-      return true;
-    };
-    return registerAnalysisImpl(std::move(Registration), std::move(Runner), std::move(Invalidator));
-  }
-
-  template <typename AnalysisT>
-  [[nodiscard]] Expected<typename AnalysisT::Result *> getResult(CompilationUnit &Unit,
-                                                                 const TargetDescription &Target) {
-    const AnalysisID Key = id<AnalysisT>();
-    if (!isRegistered(Key)) {
-      auto Registered = registerAnalysis<AnalysisT>();
-      if (!Registered)
-        return std::unexpected(Registered.error());
-    }
-    auto Result = getResultImpl(Key, Unit, Target);
-    if (!Result)
-      return std::unexpected(Result.error());
-    return static_cast<typename AnalysisT::Result *>(*Result);
-  }
-
-  void invalidate(CompilationUnit &Unit, const PreservedAnalyses &Preserved,
-                  MachinePassChanges Changes) noexcept;
-  [[nodiscard]] bool hasCached(const CompilationUnit &Unit, AnalysisID ID) const noexcept;
-  [[nodiscard]] bool isRegistered(AnalysisID ID) const noexcept;
-  void clear(CompilationUnit &Unit) noexcept;
-  void clearAll() noexcept;
-
-private:
-  using ErasedRunner = std::function<Expected<std::shared_ptr<void>>(
-      CompilationUnit &, const TargetDescription &, CompilationUnitAnalysisManager &)>;
-  using ErasedInvalidator =
-      std::function<bool(void *, const CompilationUnit &, const PreservedAnalyses &)>;
-
-  struct RegisteredAnalysis final {
-    CompilationUnitAnalysisRegistration Info;
-    ErasedRunner Runner;
-    ErasedInvalidator Invalidator;
-  };
-
-  struct CacheEntry final {
-    std::shared_ptr<void> Value;
-    AnalysisID ID = nullptr;
-  };
-
-  [[nodiscard]] Expected<void>
-  registerAnalysisImpl(CompilationUnitAnalysisRegistration Registration, ErasedRunner Runner,
-                       ErasedInvalidator Invalidator);
-  [[nodiscard]] Expected<void *> getResultImpl(AnalysisID ID, CompilationUnit &Unit,
-                                               const TargetDescription &Target);
-  [[nodiscard]] Expected<void> materializeDependencies(const RegisteredAnalysis &Registration,
-                                                       CompilationUnit &Unit,
-                                                       const TargetDescription &Target);
-  void setInstrumentation(MachinePassInstrumentation *NewInstrumentation) noexcept {
-    Instrumentation = NewInstrumentation;
-  }
-
-  std::unordered_map<AnalysisID, RegisteredAnalysis> Registry;
-  std::unordered_map<CompilationUnit *, std::unordered_map<AnalysisID, CacheEntry>> Cache;
-  std::unordered_map<CompilationUnit *, std::vector<AnalysisID>> ActiveComputations;
-  MachinePassInstrumentation *Instrumentation = nullptr;
-
-  friend class CompilationUnitPassManager;
-};
-
-class MachineFunctionPass {
-public:
-  MachineFunctionPass() = default;
-  MachineFunctionPass(const MachineFunctionPass &) = delete;
-  MachineFunctionPass &operator=(const MachineFunctionPass &) = delete;
-  virtual ~MachineFunctionPass() = default;
-
-  [[nodiscard]] virtual const MachinePassContract &contract() const noexcept = 0;
-  [[nodiscard]] virtual Expected<MachinePassResult> run(MachineFunction &Function,
-                                                        const TargetDescription &Target,
-                                                        MachineAnalysisManager &Analyses) = 0;
-};
-
-class CompilationUnitPass {
-public:
-  CompilationUnitPass() = default;
-  CompilationUnitPass(const CompilationUnitPass &) = delete;
-  CompilationUnitPass &operator=(const CompilationUnitPass &) = delete;
-  virtual ~CompilationUnitPass() = default;
-
-  [[nodiscard]] virtual const CompilationUnitPassContract &contract() const noexcept = 0;
-  [[nodiscard]] virtual Expected<CompilationUnitPassResult>
-  run(CompilationUnit &Unit, const TargetDescription &Target,
-      CompilationUnitAnalysisManager &UnitAnalyses, MachineAnalysisManager &FunctionAnalyses) = 0;
-};
-
-enum class InstrumentationPhase : std::uint8_t {
-  Before,
-  After,
-};
-
-struct InstrumentationStatistic final {
-  std::string Name;
-  bool IsAnalysis = false;
-  std::uint64_t Invocations = 0;
-  std::uint64_t CacheHits = 0;
-  std::uint64_t Changes = 0;
-  std::uint64_t Failures = 0;
-  std::uint64_t TotalNanoseconds = 0;
-};
-
-struct MachineActionID final {
-  std::string Pass;
-  std::string Rule;
-  MachineFunctionStableID Function;
-  MachineInstrStableID Instruction;
-
-  [[nodiscard]] std::string toString() const;
-
-  friend bool operator==(const MachineActionID &, const MachineActionID &) = default;
-};
-
-struct MachineActionEvent final {
-  MachineActionID ID;
-  std::uint64_t Cost = 0;
-  bool Accepted = false;
-
-  friend bool operator==(const MachineActionEvent &, const MachineActionEvent &) = default;
-};
-
-class MachineActionReplay final {
-public:
-  explicit MachineActionReplay(MachineAnalysisManager &Analyses) noexcept : Analyses(&Analyses) {}
-  MachineActionReplay(
-      MachineAnalysisManager &Analyses,
-      const std::unordered_map<MachineInstrStableID, MachineInstrStableID> &SourceToClone)
-      : Analyses(&Analyses) {
-    for (const auto &[Source, Clone] : SourceToClone)
-      RecordingInstructionIDs.try_emplace(Clone, Source);
-  }
-
-  [[nodiscard]] Expected<bool> request(std::string_view Rule, const MachineFunction &Function,
-                                       MachineInstrStableID Instruction = {},
-                                       std::uint64_t Cost = 1);
-  void beginReplay() noexcept;
-  [[nodiscard]] Expected<void> finishReplay() const;
-
-private:
-  struct Decision final {
-    std::string Rule;
-    MachineFunctionStableID Function;
-    MachineInstrStableID Instruction;
-    std::uint64_t Cost = 0;
-    bool Accepted = false;
-  };
-
-  MachineAnalysisManager *Analyses = nullptr;
-  std::unordered_map<MachineInstrStableID, MachineInstrStableID> RecordingInstructionIDs;
-  std::vector<Decision> Decisions;
-  std::size_t NextDecision = 0;
-  bool IsReplaying = false;
-};
-
-class MachinePassInstrumentation final {
-public:
-  using BeforeCallback = std::function<void(std::string_view, const MachineFunction &)>;
-  using AfterCallback =
-      std::function<void(std::string_view, const MachineFunction &, const MachinePassResult &)>;
-  using FailureCallback =
-      std::function<void(std::string_view, const MachineFunction &, const Error &)>;
-  using BeforeAnalysisCallback = std::function<void(std::string_view, const MachineFunction &)>;
-  using AfterAnalysisCallback =
-      std::function<void(std::string_view, const MachineFunction &, bool, std::uint64_t)>;
-  using AnalysisFailureCallback =
-      std::function<void(std::string_view, const MachineFunction &, const Error &)>;
-  using IRPrintCallback =
-      std::function<void(InstrumentationPhase, std::string_view, const MachineFunction &)>;
-  using ChangeCallback =
-      std::function<void(std::string_view, const MachineFunction &, MachinePassChanges, bool)>;
-  using ActionFilter = std::function<bool(const MachineActionID &, std::uint64_t)>;
-
-  using BeforeUnitCallback = std::function<void(std::string_view, const CompilationUnit &)>;
-  using AfterUnitCallback = std::function<void(std::string_view, const CompilationUnit &,
-                                               const CompilationUnitPassResult &)>;
-  using UnitFailureCallback =
-      std::function<void(std::string_view, const CompilationUnit &, const Error &)>;
-  using BeforeUnitAnalysisCallback = std::function<void(std::string_view, const CompilationUnit &)>;
-  using AfterUnitAnalysisCallback =
-      std::function<void(std::string_view, const CompilationUnit &, bool, std::uint64_t)>;
-  using UnitAnalysisFailureCallback =
-      std::function<void(std::string_view, const CompilationUnit &, const Error &)>;
-
-  void addBeforeCallback(BeforeCallback Callback);
-  void addAfterCallback(AfterCallback Callback);
-  void addFailureCallback(FailureCallback Callback);
-  void addBeforeAnalysisCallback(BeforeAnalysisCallback Callback);
-  void addAfterAnalysisCallback(AfterAnalysisCallback Callback);
-  void addAnalysisFailureCallback(AnalysisFailureCallback Callback);
-  void addIRPrintCallback(IRPrintCallback Callback);
-  void addChangeCallback(ChangeCallback Callback);
-  void setActionFilter(ActionFilter Filter);
-  void setPerFunctionFuel(std::optional<std::uint64_t> Fuel);
-
-  void addBeforeUnitCallback(BeforeUnitCallback Callback);
-  void addAfterUnitCallback(AfterUnitCallback Callback);
-  void addUnitFailureCallback(UnitFailureCallback Callback);
-  void addBeforeUnitAnalysisCallback(BeforeUnitAnalysisCallback Callback);
-  void addAfterUnitAnalysisCallback(AfterUnitAnalysisCallback Callback);
-  void addUnitAnalysisFailureCallback(UnitAnalysisFailureCallback Callback);
-
-  [[nodiscard]] std::vector<InstrumentationStatistic> statistics() const;
-  [[nodiscard]] std::vector<MachineActionEvent> actionEvents() const;
-  void clearStatistics();
-
-private:
-  struct BufferedEvents final {
-    const TargetDescription *Target = nullptr;
-    std::vector<std::function<void()>> Events;
-  };
-
-  [[nodiscard]] bool bufferFunctionEvent(const MachineFunction &Function,
-                                         std::function<void(const MachineFunction &)> Replay) const;
-  void beginBuffering(BufferedEvents &Buffer, const TargetDescription &Target) const noexcept;
-  void endBuffering() const noexcept;
-  void replayBufferedEvents(BufferedEvents &Buffer) const;
-
-  void before(std::string_view Name, const MachineFunction &Function) const;
-  void after(std::string_view Name, const MachineFunction &Function,
-             const MachinePassResult &Result, std::uint64_t Nanoseconds) const;
-  void failure(std::string_view Name, const MachineFunction &Function, const Error &ErrorValue,
-               std::uint64_t Nanoseconds = 0) const;
-  void beforeAnalysis(std::string_view Name, const MachineFunction &Function) const;
-  void afterAnalysis(std::string_view Name, const MachineFunction &Function, bool CacheHit,
-                     std::uint64_t Nanoseconds) const;
-  void analysisFailure(std::string_view Name, const MachineFunction &Function,
-                       const Error &ErrorValue, std::uint64_t Nanoseconds) const;
-  void change(std::string_view Name, const MachineFunction &Function, MachinePassChanges Changes,
-              bool FingerprintChanged) const;
-  [[nodiscard]] Expected<bool> requestAction(const MachineActionID &Action,
-                                             const MachineFunction &Function, std::uint64_t Cost);
-
-  void beforeUnit(std::string_view Name, const CompilationUnit &Unit) const;
-  void afterUnit(std::string_view Name, const CompilationUnit &Unit,
-                 const CompilationUnitPassResult &Result, std::uint64_t Nanoseconds) const;
-  void unitFailure(std::string_view Name, const CompilationUnit &Unit, const Error &ErrorValue,
-                   std::uint64_t Nanoseconds = 0) const;
-  void beforeUnitAnalysis(std::string_view Name, const CompilationUnit &Unit) const;
-  void afterUnitAnalysis(std::string_view Name, const CompilationUnit &Unit, bool CacheHit,
-                         std::uint64_t Nanoseconds) const;
-  void unitAnalysisFailure(std::string_view Name, const CompilationUnit &Unit,
-                           const Error &ErrorValue, std::uint64_t Nanoseconds) const;
-
-  [[nodiscard]] InstrumentationStatistic &statistic(std::string_view Name, bool IsAnalysis) const;
-
-  mutable std::mutex Mutex;
-  mutable std::mutex ActionMutex;
-  std::vector<BeforeCallback> Before;
-  std::vector<AfterCallback> After;
-  std::vector<FailureCallback> Failure;
-  std::vector<BeforeAnalysisCallback> BeforeAnalysis;
-  std::vector<AfterAnalysisCallback> AfterAnalysis;
-  std::vector<AnalysisFailureCallback> AnalysisFailure;
-  std::vector<IRPrintCallback> IRPrint;
-  std::vector<ChangeCallback> Change;
-  ActionFilter Filter;
-  std::optional<std::uint64_t> PerFunctionFuel;
-  std::unordered_map<std::uint64_t, std::uint64_t> ConsumedFuel;
-  std::vector<MachineActionEvent> ActionEvents;
-
-  std::vector<BeforeUnitCallback> BeforeUnit;
-  std::vector<AfterUnitCallback> AfterUnit;
-  std::vector<UnitFailureCallback> UnitFailure;
-  std::vector<BeforeUnitAnalysisCallback> BeforeUnitAnalysis;
-  std::vector<AfterUnitAnalysisCallback> AfterUnitAnalysis;
-  std::vector<UnitAnalysisFailureCallback> UnitAnalysisFailure;
-  mutable std::unordered_map<std::string, InstrumentationStatistic> Statistics;
-
-  static thread_local BufferedEvents *ActiveBuffer;
-
-  friend class CompilationUnitAnalysisManager;
-  friend class CompilationUnitPassManager;
-  friend class MachineAnalysisManager;
-  friend class MachinePassManager;
-};
-
-struct MachinePassManagerOptions final {
-  bool VerifyBefore = true;
-  bool VerifyEach = true;
-  bool DetectUnreportedChanges = false;
-};
-
-class MachinePassManager final {
-public:
-  using PassList = std::vector<std::unique_ptr<MachineFunctionPass>>;
-
-  explicit MachinePassManager(MachinePassManagerOptions Options = {}) : Options(Options) {}
-
-  MachinePassManager(const MachinePassManager &) = delete;
-  MachinePassManager &operator=(const MachinePassManager &) = delete;
-
-  [[nodiscard]] Expected<void> addPass(std::unique_ptr<MachineFunctionPass> Pass);
-  [[nodiscard]] Expected<void> run(MachineFunction &Function, const TargetDescription &Target,
-                                   MachineAnalysisManager &Analyses,
-                                   MachinePassInstrumentation *Instrumentation = nullptr) const;
-  [[nodiscard]] Expected<void>
-  runFunctions(CompilationUnit &Unit, const TargetDescription &Target,
-               const MachineAnalysisManager &AnalysisPrototype, std::size_t ThreadCount,
-               MachinePassInstrumentation *Instrumentation = nullptr) const;
-
-  [[nodiscard]] std::size_t size() const noexcept {
-    return Passes.size();
-  }
-
-  [[nodiscard]] PassList takePasses() && noexcept {
-    return std::move(Passes);
-  }
-
-private:
-  [[nodiscard]] Expected<void> validateContract(const MachinePassContract &Contract) const;
-
-  MachinePassManagerOptions Options;
-  PassList Passes;
-};
-
-struct CompilationUnitPassManagerOptions final {
-  bool VerifyBefore = true;
-  bool VerifyEach = true;
-};
-
-class CompilationUnitPassManager final {
-public:
-  explicit CompilationUnitPassManager(CompilationUnitPassManagerOptions Options = {})
-      : Options(Options) {}
-
-  CompilationUnitPassManager(const CompilationUnitPassManager &) = delete;
-  CompilationUnitPassManager &operator=(const CompilationUnitPassManager &) = delete;
-
-  [[nodiscard]] Expected<void> addPass(std::unique_ptr<CompilationUnitPass> Pass);
-  [[nodiscard]] Expected<void> run(CompilationUnit &Unit, const TargetDescription &Target,
-                                   CompilationUnitAnalysisManager &UnitAnalyses,
-                                   MachineAnalysisManager &FunctionAnalyses,
-                                   MachinePassInstrumentation *Instrumentation = nullptr) const;
-
-private:
-  CompilationUnitPassManagerOptions Options;
-  std::vector<std::unique_ptr<CompilationUnitPass>> Passes;
-};
-
-} // namespace rcc
-
-#endif // RCC_CODEGEN_MACHINEPASS_H
diff --git a/backend/include/rcc/CodeGen/MachinePassManager.h b/backend/include/rcc/CodeGen/MachinePassManager.h
new file mode 100644
index 0000000..3587395
--- /dev/null
+++ b/backend/include/rcc/CodeGen/MachinePassManager.h
@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef RCC_CODEGEN_MACHINEPASSMANAGER_H
+#define RCC_CODEGEN_MACHINEPASSMANAGER_H
+
+#include "rcc/CodeGen/InstructionDescriptor.h"
+#include "rcc/CodeGen/MachineFunctionAnalysisManager.h"
+#include "rcc/CodeGen/MachineFunctionProperties.h"
+#include "rcc/IR/PassInstrumentation.h"
+
+#include <cstddef>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace rcc {
+
+class CompilationUnit;
+class MachineFunction;
+class TargetDescription;
+
+struct MachinePassRegistrationMetadata {
+  std::vector<PassParameter> Parameters;
+  PassThreadSafety ThreadSafety = PassThreadSafety::NotThreadSafe;
+  MachinePassChanges DeclaredChanges = MachinePassChanges::all();
+};
+
+struct MachinePassContract final : MachinePassRegistrationMetadata {
+  std::string Name;
+  MachineFunctionProperties Requires;
+  MachineFunctionProperties Sets;
+  MachineFunctionProperties Clears;
+  std::vector<AnalysisID> RequiredAnalyses;
+  std::optional<PipelineStage> VerificationStage;
+};
+
+struct MachinePassResult final {
+  bool Changed = false;
+  MachinePassChanges Changes;
+  PreservedAnalyses Preserved = PreservedAnalyses::none();
+};
+
+struct CompilationUnitPassContract final {
+  std::string Name;
+  std::vector<AnalysisID> RequiredAnalyses;
+  std::vector<PassParameter> Parameters;
+  MachinePassChanges DeclaredChanges = MachinePassChanges::all();
+};
+
+struct CompilationUnitPassResult final {
+  bool Changed = false;
+  MachinePassChanges Changes;
+  PreservedAnalyses PreservedUnitAnalyses = PreservedAnalyses::none();
+  PreservedAnalyses PreservedFunctionAnalyses = PreservedAnalyses::none();
+};
+
+class MachineFunctionPass {
+public:
+  MachineFunctionPass() = default;
+  MachineFunctionPass(const MachineFunctionPass &) = delete;
+  MachineFunctionPass &operator=(const MachineFunctionPass &) = delete;
+  virtual ~MachineFunctionPass() = default;
+
+  [[nodiscard]] virtual const MachinePassContract &contract() const noexcept = 0;
+  [[nodiscard]] virtual Expected<MachinePassResult>
+  run(MachineFunction &Function, const TargetDescription &Target,
+      MachineFunctionAnalysisManager &Analyses) = 0;
+};
+
+class CompilationUnitPass {
+public:
+  CompilationUnitPass() = default;
+  CompilationUnitPass(const CompilationUnitPass &) = delete;
+  CompilationUnitPass &operator=(const CompilationUnitPass &) = delete;
+  virtual ~CompilationUnitPass() = default;
+
+  [[nodiscard]] virtual const CompilationUnitPassContract &contract() const noexcept = 0;
+  [[nodiscard]] virtual Expected<CompilationUnitPassResult>
+  run(CompilationUnit &Unit, const TargetDescription &Target,
+      CompilationUnitAnalysisManager &UnitAnalyses,
+      MachineFunctionAnalysisManager &FunctionAnalyses) = 0;
+};
+
+struct MachinePassManagerOptions final {
+  bool VerifyBefore = true;
+  bool VerifyEach = true;
+  bool DetectUnreportedChanges = false;
+};
+
+template <>
+struct PassManagerCallbacks<MachineFunction, MachineFunctionPass, MachinePassManagerOptions> final {
+  using PassList = std::vector<std::unique_ptr<MachineFunctionPass>>;
+
+  [[nodiscard]] static Expected<void> validate(const MachineFunctionPass &Pass);
+  [[nodiscard]] static Expected<void>
+  run(const PassList &Passes, const MachinePassManagerOptions &Options, MachineFunction &Function,
+      const TargetDescription &Target, MachineFunctionAnalysisManager &Analyses,
+      MachinePassInstrumentation *Instrumentation = nullptr);
+  [[nodiscard]] static Expected<void>
+  runFunctions(const PassList &Passes, const MachinePassManagerOptions &Options,
+               CompilationUnit &Unit, const TargetDescription &Target,
+               const MachineFunctionAnalysisManager &AnalysisPrototype, std::size_t ThreadCount,
+               MachinePassInstrumentation *Instrumentation = nullptr);
+};
+
+using MachineFunctionPassManager =
+    PassManager<MachineFunction, MachineFunctionPass, MachinePassManagerOptions>;
+
+struct CompilationUnitPassManagerOptions final {
+  bool VerifyBefore = true;
+  bool VerifyEach = true;
+};
+
+template <>
+struct PassManagerCallbacks<CompilationUnit, CompilationUnitPass, CompilationUnitPassManagerOptions>
+    final {
+  using PassList = std::vector<std::unique_ptr<CompilationUnitPass>>;
+
+  [[nodiscard]] static Expected<void> validate(const CompilationUnitPass &Pass);
+  [[nodiscard]] static Expected<void> run(const PassList &Passes,
+                                          const CompilationUnitPassManagerOptions &Options,
+                                          CompilationUnit &Unit, const TargetDescription &Target,
+                                          CompilationUnitAnalysisManager &UnitAnalyses,
+                                          MachineFunctionAnalysisManager &FunctionAnalyses,
+                                          MachinePassInstrumentation *Instrumentation = nullptr);
+};
+
+using CompilationUnitPassManager =
+    PassManager<CompilationUnit, CompilationUnitPass, CompilationUnitPassManagerOptions>;
+
+} // namespace rcc
+
+#endif // RCC_CODEGEN_MACHINEPASSMANAGER_H
diff --git a/backend/include/rcc/CodeGen/MachinePseudoExpansion.h b/backend/include/rcc/CodeGen/MachinePseudoExpansion.h
index 8c47441..7d4b309 100644
--- a/backend/include/rcc/CodeGen/MachinePseudoExpansion.h
+++ b/backend/include/rcc/CodeGen/MachinePseudoExpansion.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINEPSEUDOEXPANSION_H
 #define RCC_CODEGEN_MACHINEPSEUDOEXPANSION_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/TargetPseudoExpansion.h"
 
 namespace rcc {
@@ -18,7 +18,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 TargetPseudoExpansionInfo *Info;
@@ -32,7 +32,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 TargetPseudoExpansionInfo *Info;
@@ -45,7 +45,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 TargetPseudoExpansionInfo *Info;
@@ -60,7 +60,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 TargetPseudoExpansionInfo *Info;
diff --git a/backend/include/rcc/CodeGen/MachineScheduler.h b/backend/include/rcc/CodeGen/MachineScheduler.h
index 2b48fe7..bfe9265 100644
--- a/backend/include/rcc/CodeGen/MachineScheduler.h
+++ b/backend/include/rcc/CodeGen/MachineScheduler.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINESCHEDULER_H
 #define RCC_CODEGEN_MACHINESCHEDULER_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -25,7 +25,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 TargetSchedulingModel *Model;
diff --git a/backend/include/rcc/CodeGen/MachineShrinkWrapping.h b/backend/include/rcc/CodeGen/MachineShrinkWrapping.h
index ec295cd..14edeb7 100644
--- a/backend/include/rcc/CodeGen/MachineShrinkWrapping.h
+++ b/backend/include/rcc/CodeGen/MachineShrinkWrapping.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINESHRINKWRAPPING_H
 #define RCC_CODEGEN_MACHINESHRINKWRAPPING_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -24,7 +24,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 TargetFrameLowering *Info;
diff --git a/backend/include/rcc/CodeGen/MachineSink.h b/backend/include/rcc/CodeGen/MachineSink.h
index 92aceba..5b47f9b 100644
--- a/backend/include/rcc/CodeGen/MachineSink.h
+++ b/backend/include/rcc/CodeGen/MachineSink.h
@@ -22,12 +22,12 @@ public:
   [[nodiscard]] const MachinePassContract &contract() const noexcept override;
   [[nodiscard]] Expected<MachinePassResult> run(MachineFunction &Function,
                                                 const TargetDescription &Target,
-                                                MachineAnalysisManager &Analyses) override;
+                                                MachineFunctionAnalysisManager &Analyses) override;
 
 private:
-  [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
-                                                              const TargetDescription &Target,
-                                                              MachineAnalysisManager &Analyses);
+  [[nodiscard]] Expected<MachinePassResult>
+  runImplementation(MachineFunction &Function, const TargetDescription &Target,
+                    MachineFunctionAnalysisManager &Analyses);
 
   MachineCodeMotionStage Stage = MachineCodeMotionStage::SelectedSSA;
   MachineSinkOptions Options;
diff --git a/backend/include/rcc/CodeGen/MachineStackSlotColoring.h b/backend/include/rcc/CodeGen/MachineStackSlotColoring.h
index 19c1c70..9aae710 100644
--- a/backend/include/rcc/CodeGen/MachineStackSlotColoring.h
+++ b/backend/include/rcc/CodeGen/MachineStackSlotColoring.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINESTACKSLOTCOLORING_H
 #define RCC_CODEGEN_MACHINESTACKSLOTCOLORING_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -21,7 +21,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function) const;
diff --git a/backend/include/rcc/CodeGen/MachineTailDuplication.h b/backend/include/rcc/CodeGen/MachineTailDuplication.h
index 1c21bdf..f52f638 100644
--- a/backend/include/rcc/CodeGen/MachineTailDuplication.h
+++ b/backend/include/rcc/CodeGen/MachineTailDuplication.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINETAILDUPLICATION_H
 #define RCC_CODEGEN_MACHINETAILDUPLICATION_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -25,7 +25,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:
   [[nodiscard]] Expected<MachinePassResult>
diff --git a/backend/include/rcc/CodeGen/MachineTailMerge.h b/backend/include/rcc/CodeGen/MachineTailMerge.h
index 7237d58..0b9938e 100644
--- a/backend/include/rcc/CodeGen/MachineTailMerge.h
+++ b/backend/include/rcc/CodeGen/MachineTailMerge.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_MACHINETAILMERGE_H
 #define RCC_CODEGEN_MACHINETAILMERGE_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <cstddef>
 
@@ -24,7 +24,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:
   [[nodiscard]] Expected<MachinePassResult>
diff --git a/backend/include/rcc/CodeGen/PHIElimination.h b/backend/include/rcc/CodeGen/PHIElimination.h
index 3d69152..1443303 100644
--- a/backend/include/rcc/CodeGen/PHIElimination.h
+++ b/backend/include/rcc/CodeGen/PHIElimination.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_PHIELIMINATION_H
 #define RCC_CODEGEN_PHIELIMINATION_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -16,7 +16,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
diff --git a/backend/include/rcc/CodeGen/PostRAScheduler.h b/backend/include/rcc/CodeGen/PostRAScheduler.h
index 13b08df..3254d1e 100644
--- a/backend/include/rcc/CodeGen/PostRAScheduler.h
+++ b/backend/include/rcc/CodeGen/PostRAScheduler.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_POSTRASCHEDULER_H
 #define RCC_CODEGEN_POSTRASCHEDULER_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/MachineScheduler.h"
 
 namespace rcc {
@@ -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 TargetSchedulingModel *Model;
diff --git a/backend/include/rcc/CodeGen/PrologueEpilogueInsertion.h b/backend/include/rcc/CodeGen/PrologueEpilogueInsertion.h
index b94715a..a5d0028 100644
--- a/backend/include/rcc/CodeGen/PrologueEpilogueInsertion.h
+++ b/backend/include/rcc/CodeGen/PrologueEpilogueInsertion.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_PROLOGUEEPILOGUEINSERTION_H
 #define RCC_CODEGEN_PROLOGUEEPILOGUEINSERTION_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -16,7 +16,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:
   [[nodiscard]] Expected<MachinePassResult>
diff --git a/backend/include/rcc/CodeGen/RegAllocCommon.h b/backend/include/rcc/CodeGen/RegAllocCommon.h
index 0df9799..ac3aa56 100644
--- a/backend/include/rcc/CodeGen/RegAllocCommon.h
+++ b/backend/include/rcc/CodeGen/RegAllocCommon.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_REGALLOCCOMMON_H
 #define RCC_CODEGEN_REGALLOCCOMMON_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 #include <memory>
 
diff --git a/backend/include/rcc/CodeGen/RegAllocFast.h b/backend/include/rcc/CodeGen/RegAllocFast.h
index 84cf30c..6ee2881 100644
--- a/backend/include/rcc/CodeGen/RegAllocFast.h
+++ b/backend/include/rcc/CodeGen/RegAllocFast.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_REGALLOCFAST_H
 #define RCC_CODEGEN_REGALLOCFAST_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/TargetRegisterAllocationInfo.h"
 
 namespace rcc {
@@ -15,7 +15,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/include/rcc/CodeGen/RegAllocPBQP.h b/backend/include/rcc/CodeGen/RegAllocPBQP.h
index 368cbee..0ae0088 100644
--- a/backend/include/rcc/CodeGen/RegAllocPBQP.h
+++ b/backend/include/rcc/CodeGen/RegAllocPBQP.h
@@ -17,7 +17,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/include/rcc/CodeGen/SlotIndexes.h b/backend/include/rcc/CodeGen/SlotIndexes.h
index 1767596..423cc64 100644
--- a/backend/include/rcc/CodeGen/SlotIndexes.h
+++ b/backend/include/rcc/CodeGen/SlotIndexes.h
@@ -4,7 +4,7 @@
 #define RCC_CODEGEN_SLOTINDEXES_H
 
 #include "rcc/CodeGen/MachineIRTypes.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/StableID.h"
 #include "rcc/Support/Error.h"
 
@@ -115,8 +115,9 @@ public:
     return "SlotIndexes";
   }
 
-  [[nodiscard]] static Expected<Result>
-  run(MachineFunction &Function, const TargetDescription &Target, MachineAnalysisManager &Analyses);
+  [[nodiscard]] static Expected<Result> run(MachineFunction &Function,
+                                            const TargetDescription &Target,
+                                            MachineFunctionAnalysisManager &Analyses);
 };
 
 } // namespace rcc
diff --git a/backend/include/rcc/CodeGen/TwoAddressInstructionPass.h b/backend/include/rcc/CodeGen/TwoAddressInstructionPass.h
index 696b46c..3c9e9dc 100644
--- a/backend/include/rcc/CodeGen/TwoAddressInstructionPass.h
+++ b/backend/include/rcc/CodeGen/TwoAddressInstructionPass.h
@@ -3,7 +3,7 @@
 #ifndef RCC_CODEGEN_TWOADDRESSINSTRUCTIONPASS_H
 #define RCC_CODEGEN_TWOADDRESSINSTRUCTIONPASS_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 
 namespace rcc {
 
@@ -16,7 +16,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:
   [[nodiscard]] Expected<MachinePassResult> runImplementation(MachineFunction &Function,
diff --git a/backend/include/rcc/CodeGen/VirtRegMap.h b/backend/include/rcc/CodeGen/VirtRegMap.h
index f37af84..30ef450 100644
--- a/backend/include/rcc/CodeGen/VirtRegMap.h
+++ b/backend/include/rcc/CodeGen/VirtRegMap.h
@@ -4,7 +4,7 @@
 #define RCC_CODEGEN_VIRTREGMAP_H
 
 #include "rcc/CodeGen/MachineFrameInfo.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/TargetRegisterInfo.h"
 
 #include <cstdint>
@@ -82,7 +82,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 VirtRegMap *Mapping;
diff --git a/backend/include/rcc/IR/PassInstrumentation.h b/backend/include/rcc/IR/PassInstrumentation.h
new file mode 100644
index 0000000..082ec81
--- /dev/null
+++ b/backend/include/rcc/IR/PassInstrumentation.h
@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef RCC_IR_PASSINSTRUMENTATION_H
+#define RCC_IR_PASSINSTRUMENTATION_H
+
+#include "rcc/CodeGen/MachineFunctionAnalysisManager.h"
+
+#include <cstdint>
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace rcc {
+
+class CompilationUnit;
+class MachineFunction;
+class TargetDescription;
+struct MachinePassResult;
+struct CompilationUnitPassResult;
+
+enum class InstrumentationPhase : std::uint8_t {
+  Before,
+  After,
+};
+
+struct InstrumentationStatistic final {
+  std::string Name;
+  bool IsAnalysis = false;
+  std::uint64_t Invocations = 0;
+  std::uint64_t CacheHits = 0;
+  std::uint64_t Changes = 0;
+  std::uint64_t Failures = 0;
+  std::uint64_t TotalNanoseconds = 0;
+};
+
+struct MachineActionID final {
+  std::string Pass;
+  std::string Rule;
+  MachineFunctionStableID Function;
+  MachineInstrStableID Instruction;
+
+  [[nodiscard]] std::string toString() const;
+
+  friend bool operator==(const MachineActionID &, const MachineActionID &) = default;
+};
+
+struct MachineActionEvent final {
+  MachineActionID ID;
+  std::uint64_t Cost = 0;
+  bool Accepted = false;
+
+  friend bool operator==(const MachineActionEvent &, const MachineActionEvent &) = default;
+};
+
+class MachinePassInstrumentation final {
+public:
+  using BeforeCallback = std::function<void(std::string_view, const MachineFunction &)>;
+  using AfterCallback =
+      std::function<void(std::string_view, const MachineFunction &, const MachinePassResult &)>;
+  using FailureCallback =
+      std::function<void(std::string_view, const MachineFunction &, const Error &)>;
+  using BeforeAnalysisCallback = std::function<void(std::string_view, const MachineFunction &)>;
+  using AfterAnalysisCallback =
+      std::function<void(std::string_view, const MachineFunction &, bool, std::uint64_t)>;
+  using AnalysisFailureCallback =
+      std::function<void(std::string_view, const MachineFunction &, const Error &)>;
+  using IRPrintCallback =
+      std::function<void(InstrumentationPhase, std::string_view, const MachineFunction &)>;
+  using ChangeCallback =
+      std::function<void(std::string_view, const MachineFunction &, MachinePassChanges, bool)>;
+  using ActionFilter = std::function<bool(const MachineActionID &, std::uint64_t)>;
+
+  using BeforeUnitCallback = std::function<void(std::string_view, const CompilationUnit &)>;
+  using AfterUnitCallback = std::function<void(std::string_view, const CompilationUnit &,
+                                               const CompilationUnitPassResult &)>;
+  using UnitFailureCallback =
+      std::function<void(std::string_view, const CompilationUnit &, const Error &)>;
+  using BeforeUnitAnalysisCallback = std::function<void(std::string_view, const CompilationUnit &)>;
+  using AfterUnitAnalysisCallback =
+      std::function<void(std::string_view, const CompilationUnit &, bool, std::uint64_t)>;
+  using UnitAnalysisFailureCallback =
+      std::function<void(std::string_view, const CompilationUnit &, const Error &)>;
+
+  void addBeforeCallback(BeforeCallback Callback);
+  void addAfterCallback(AfterCallback Callback);
+  void addFailureCallback(FailureCallback Callback);
+  void addBeforeAnalysisCallback(BeforeAnalysisCallback Callback);
+  void addAfterAnalysisCallback(AfterAnalysisCallback Callback);
+  void addAnalysisFailureCallback(AnalysisFailureCallback Callback);
+  void addIRPrintCallback(IRPrintCallback Callback);
+  void addChangeCallback(ChangeCallback Callback);
+  void setActionFilter(ActionFilter Filter);
+  void setPerFunctionFuel(std::optional<std::uint64_t> Fuel);
+
+  void addBeforeUnitCallback(BeforeUnitCallback Callback);
+  void addAfterUnitCallback(AfterUnitCallback Callback);
+  void addUnitFailureCallback(UnitFailureCallback Callback);
+  void addBeforeUnitAnalysisCallback(BeforeUnitAnalysisCallback Callback);
+  void addAfterUnitAnalysisCallback(AfterUnitAnalysisCallback Callback);
+  void addUnitAnalysisFailureCallback(UnitAnalysisFailureCallback Callback);
+
+  [[nodiscard]] std::vector<InstrumentationStatistic> statistics() const;
+  [[nodiscard]] std::vector<MachineActionEvent> actionEvents() const;
+
+  [[nodiscard]] Expected<bool> requestAction(std::string_view Pass, std::string_view Rule,
+                                             const MachineFunction &Function,
+                                             MachineInstrStableID Instruction, std::uint64_t Cost);
+  [[nodiscard]] Expected<bool> requestAction(std::string_view Pass, std::string_view Rule,
+                                             const MachineFunction &Function, std::nullptr_t,
+                                             std::uint64_t Cost);
+
+private:
+  struct BufferedEvents final {
+    const TargetDescription *Target = nullptr;
+    std::vector<std::function<void()>> Events;
+  };
+
+  [[nodiscard]] bool bufferFunctionEvent(const MachineFunction &Function,
+                                         std::function<void(const MachineFunction &)> Replay) const;
+  void beginBuffering(BufferedEvents &Buffer, const TargetDescription &Target) const noexcept;
+  void endBuffering() const noexcept;
+  void replayBufferedEvents(BufferedEvents &Buffer) const;
+
+  void before(std::string_view Name, const MachineFunction &Function) const;
+  void after(std::string_view Name, const MachineFunction &Function,
+             const MachinePassResult &Result, std::uint64_t Nanoseconds) const;
+  void failure(std::string_view Name, const MachineFunction &Function, const Error &ErrorValue,
+               std::uint64_t Nanoseconds = 0) const;
+  void beforeAnalysis(std::string_view Name, const MachineFunction &Function) const;
+  void afterAnalysis(std::string_view Name, const MachineFunction &Function, bool CacheHit,
+                     std::uint64_t Nanoseconds) const;
+  void analysisFailure(std::string_view Name, const MachineFunction &Function,
+                       const Error &ErrorValue, std::uint64_t Nanoseconds) const;
+  void change(std::string_view Name, const MachineFunction &Function, MachinePassChanges Changes,
+              bool FingerprintChanged) const;
+
+  void beforeUnit(std::string_view Name, const CompilationUnit &Unit) const;
+  void afterUnit(std::string_view Name, const CompilationUnit &Unit,
+                 const CompilationUnitPassResult &Result, std::uint64_t Nanoseconds) const;
+  void unitFailure(std::string_view Name, const CompilationUnit &Unit, const Error &ErrorValue,
+                   std::uint64_t Nanoseconds = 0) const;
+  void beforeAnalysis(std::string_view Name, const CompilationUnit &Unit) const;
+  void afterAnalysis(std::string_view Name, const CompilationUnit &Unit, bool CacheHit,
+                     std::uint64_t Nanoseconds) const;
+  void analysisFailure(std::string_view Name, const CompilationUnit &Unit, const Error &ErrorValue,
+                       std::uint64_t Nanoseconds) const;
+
+  [[nodiscard]] InstrumentationStatistic &statistic(std::string_view Name, bool IsAnalysis) const;
+
+  mutable std::mutex Mutex;
+  mutable std::mutex ActionMutex;
+  std::vector<BeforeCallback> Before;
+  std::vector<AfterCallback> After;
+  std::vector<FailureCallback> Failure;
+  std::vector<BeforeAnalysisCallback> BeforeAnalysis;
+  std::vector<AfterAnalysisCallback> AfterAnalysis;
+  std::vector<AnalysisFailureCallback> AnalysisFailure;
+  std::vector<IRPrintCallback> IRPrint;
+  std::vector<ChangeCallback> Change;
+  ActionFilter Filter;
+  std::optional<std::uint64_t> PerFunctionFuel;
+  std::unordered_map<std::uint64_t, std::uint64_t> ConsumedFuel;
+  std::vector<MachineActionEvent> ActionEvents;
+
+  std::vector<BeforeUnitCallback> BeforeUnit;
+  std::vector<AfterUnitCallback> AfterUnit;
+  std::vector<UnitFailureCallback> UnitFailure;
+  std::vector<BeforeUnitAnalysisCallback> BeforeUnitAnalysis;
+  std::vector<AfterUnitAnalysisCallback> AfterUnitAnalysis;
+  std::vector<UnitAnalysisFailureCallback> UnitAnalysisFailure;
+  mutable std::unordered_map<std::string, InstrumentationStatistic> Statistics;
+
+  static thread_local BufferedEvents *ActiveBuffer;
+
+  template <typename, typename> friend struct AnalysisManagerInstrumentation;
+  template <typename, typename, typename> friend struct PassManagerCallbacks;
+};
+
+class MachineActionReplay final {
+public:
+  template <typename AnalysisManagerT>
+  explicit MachineActionReplay(AnalysisManagerT &Analyses)
+      : Request([&Analyses](std::string_view Rule, const MachineFunction &Function,
+                            MachineInstrStableID Instruction, std::uint64_t Cost) {
+          return Analyses.requestAction(Rule, Function, Instruction, Cost);
+        }) {}
+
+  template <typename AnalysisManagerT>
+  MachineActionReplay(
+      AnalysisManagerT &Analyses,
+      const std::unordered_map<MachineInstrStableID, MachineInstrStableID> &SourceToClone)
+      : MachineActionReplay(Analyses) {
+    for (const auto &[Source, Clone] : SourceToClone)
+      RecordingInstructionIDs.try_emplace(Clone, Source);
+  }
+
+  [[nodiscard]] Expected<bool> request(std::string_view Rule, const MachineFunction &Function,
+                                       MachineInstrStableID Instruction = {},
+                                       std::uint64_t Cost = 1);
+  void beginReplay() noexcept;
+  [[nodiscard]] Expected<void> finishReplay() const;
+
+private:
+  struct Decision final {
+    std::string Rule;
+    MachineFunctionStableID Function;
+    MachineInstrStableID Instruction;
+    std::uint64_t Cost = 0;
+    bool Accepted = false;
+  };
+
+  std::function<Expected<bool>(std::string_view, const MachineFunction &, MachineInstrStableID,
+                               std::uint64_t)>
+      Request;
+  std::unordered_map<MachineInstrStableID, MachineInstrStableID> RecordingInstructionIDs;
+  std::vector<Decision> Decisions;
+  std::size_t NextDecision = 0;
+  bool IsReplaying = false;
+};
+
+} // namespace rcc
+
+#endif // RCC_IR_PASSINSTRUMENTATION_H
diff --git a/backend/include/rcc/IR/PassManager.h b/backend/include/rcc/IR/PassManager.h
new file mode 100644
index 0000000..b3ab088
--- /dev/null
+++ b/backend/include/rcc/IR/PassManager.h
@@ -0,0 +1,531 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef RCC_IR_PASSMANAGER_H
+#define RCC_IR_PASSMANAGER_H
+
+#include "rcc/Support/Error.h"
+
+#include <algorithm>
+#include <chrono>
+#include <concepts>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <set>
+#include <span>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace rcc {
+
+class TargetDescription;
+
+using AnalysisID = const void *;
+
+class PreservedAnalyses final {
+public:
+  [[nodiscard]] static PreservedAnalyses all() noexcept {
+    PreservedAnalyses Result;
+    Result.PreserveAll = true;
+    return Result;
+  }
+
+  [[nodiscard]] static PreservedAnalyses none() noexcept {
+    return {};
+  }
+
+  void preserve(AnalysisID ID) {
+    if (ID != nullptr)
+      Preserved.insert(ID);
+  }
+
+  template <typename AnalysisT> void preserve() {
+    preserve(analysisID<AnalysisT>());
+  }
+
+  [[nodiscard]] bool preserves(AnalysisID ID) const noexcept {
+    return PreserveAll || (ID != nullptr && Preserved.contains(ID));
+  }
+
+  [[nodiscard]] bool preservesAll() const noexcept {
+    return PreserveAll;
+  }
+
+  template <typename AnalysisT> [[nodiscard]] static AnalysisID analysisID() noexcept {
+    static const std::uint8_t Token = 0;
+    return &Token;
+  }
+
+private:
+  bool PreserveAll = false;
+  std::unordered_set<AnalysisID> Preserved;
+};
+
+enum class PassThreadSafety : std::uint8_t {
+  NotThreadSafe,
+  ThreadSafe,
+};
+
+struct PassParameter final {
+  std::string Name;
+  std::string Description;
+  std::optional<std::string> DefaultValue;
+  bool Required = false;
+};
+
+template <typename IRUnitT, typename InstrumentationT> struct AnalysisManagerInstrumentation {
+  static void beforeAnalysis(InstrumentationT *, std::string_view, const IRUnitT &) {}
+  static void afterAnalysis(InstrumentationT *, std::string_view, const IRUnitT &, bool,
+                            std::uint64_t) {}
+  static void analysisFailure(InstrumentationT *, std::string_view, const IRUnitT &, const Error &,
+                              std::uint64_t) {}
+
+  template <typename InstructionT>
+  [[nodiscard]] static Expected<bool> requestAction(InstrumentationT *, std::string_view,
+                                                    std::string_view, const IRUnitT &, InstructionT,
+                                                    std::uint64_t) {
+    return true;
+  }
+};
+
+template <typename ChangeT> struct AnalysisRegistration final {
+  AnalysisID ID = nullptr;
+  std::string Name;
+  std::vector<AnalysisID> Dependencies;
+  ChangeT InvalidatedBy = ChangeT::all();
+  PassThreadSafety ThreadSafety = PassThreadSafety::NotThreadSafe;
+};
+
+template <typename IRUnitT, typename PassT, typename OptionsT> struct PassManagerCallbacks;
+
+template <typename IRUnitT, typename PassT, typename OptionsT> class PassManager {
+public:
+  using PassList = std::vector<std::unique_ptr<PassT>>;
+  using Callbacks = PassManagerCallbacks<IRUnitT, PassT, OptionsT>;
+
+  explicit PassManager(OptionsT Options = {}) : Options(Options) {}
+  PassManager(const PassManager &) = delete;
+  PassManager &operator=(const PassManager &) = delete;
+  PassManager(PassManager &&) = default;
+  PassManager &operator=(PassManager &&) = default;
+  ~PassManager() = default;
+
+  [[nodiscard]] Expected<void> addPass(std::unique_ptr<PassT> Pass) {
+    if (!Pass)
+      return makeUnexpected(ErrorCode::InvalidArgument, "pass manager cannot add a null pass");
+    auto Validation = Callbacks::validate(*Pass);
+    if (!Validation)
+      return std::unexpected(Validation.error());
+    Passes.push_back(std::move(Pass));
+    return {};
+  }
+
+  template <typename... Args>
+  [[nodiscard]] Expected<void> run(IRUnitT &Unit, Args &&...Arguments) const {
+    return Callbacks::run(Passes, Options, Unit, std::forward<Args>(Arguments)...);
+  }
+
+  template <typename... Args>
+  [[nodiscard]] Expected<void> runFunctions(Args &&...Arguments) const
+    requires requires(const PassList &InputPasses, const OptionsT &InputOptions,
+                      Args &&...InputArguments) {
+      Callbacks::runFunctions(InputPasses, InputOptions, std::forward<Args>(InputArguments)...);
+    }
+  {
+    return Callbacks::runFunctions(Passes, Options, std::forward<Args>(Arguments)...);
+  }
+
+  [[nodiscard]] std::size_t size() const noexcept {
+    return Passes.size();
+  }
+
+  [[nodiscard]] PassList takePasses() && noexcept {
+    return std::move(Passes);
+  }
+
+private:
+  PassList Passes;
+  OptionsT Options;
+};
+
+template <typename IRUnitT, typename RegistrationT, typename ChangeT, typename InstrumentationT>
+class AnalysisManager {
+public:
+  using Self = AnalysisManager<IRUnitT, RegistrationT, ChangeT, InstrumentationT>;
+
+  AnalysisManager() = default;
+  AnalysisManager(const AnalysisManager &) = delete;
+  AnalysisManager &operator=(const AnalysisManager &) = delete;
+  AnalysisManager(AnalysisManager &&) = delete;
+  AnalysisManager &operator=(AnalysisManager &&) = delete;
+  ~AnalysisManager() = default;
+
+  template <typename AnalysisT> [[nodiscard]] static AnalysisID id() noexcept {
+    return PreservedAnalyses::analysisID<AnalysisT>();
+  }
+
+  template <typename AnalysisT>
+  [[nodiscard]] Expected<void> registerAnalysis(RegistrationT Registration = {}) {
+    using ResultT = typename AnalysisT::Result;
+    if (Registration.ID == nullptr)
+      Registration.ID = id<AnalysisT>();
+    if (Registration.Name.empty()) {
+      if constexpr (requires {
+                      { AnalysisT::name() } -> std::convertible_to<std::string_view>;
+                    })
+        Registration.Name = std::string(AnalysisT::name());
+      else
+        Registration.Name = "unnamed-analysis";
+    }
+
+    ErasedRunner Runner = [](IRUnitT &Unit, const TargetDescription &Target,
+                             Self &Manager) -> Expected<std::shared_ptr<void>> {
+      auto Computed = AnalysisT::run(Unit, Target, Manager);
+      if (!Computed)
+        return std::unexpected(Computed.error());
+      return std::shared_ptr<void>(new ResultT(std::move(*Computed)),
+                                   [](void *Value) { delete static_cast<ResultT *>(Value); });
+    };
+    ErasedInvalidator Invalidator = [](void *Value, const IRUnitT &Unit,
+                                       const PreservedAnalyses &Preserved) -> bool {
+      if constexpr (requires(ResultT &Result, const IRUnitT &InputUnit,
+                             const PreservedAnalyses &Analyses) {
+                      { Result.invalidate(InputUnit, Analyses) } -> std::convertible_to<bool>;
+                    })
+        return static_cast<ResultT *>(Value)->invalidate(Unit, Preserved);
+      return true;
+    };
+    return registerAnalysisImpl(std::move(Registration), std::move(Runner), std::move(Invalidator));
+  }
+
+  template <typename AnalysisT>
+  [[nodiscard]] Expected<typename AnalysisT::Result *> getResult(IRUnitT &Unit,
+                                                                 const TargetDescription &Target) {
+    const AnalysisID Key = id<AnalysisT>();
+    if (!isRegistered(Key)) {
+      auto Registered = registerAnalysis<AnalysisT>();
+      if (!Registered)
+        return std::unexpected(Registered.error());
+    }
+    auto Result = getResultImpl(Key, Unit, Target);
+    if (!Result)
+      return std::unexpected(Result.error());
+    return static_cast<typename AnalysisT::Result *>(*Result);
+  }
+
+  [[nodiscard]] Expected<void *> getResultByID(AnalysisID ID, IRUnitT &Unit,
+                                               const TargetDescription &Target) {
+    return getResultImpl(ID, Unit, Target);
+  }
+
+  void invalidate(IRUnitT &Unit, const PreservedAnalyses &Preserved, ChangeT 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 ID : Invalid)
+      UnitPosition->second.erase(ID);
+    if (UnitPosition->second.empty())
+      Cache.erase(UnitPosition);
+  }
+
+  void invalidate(IRUnitT &Unit, const PreservedAnalyses &Preserved) noexcept {
+    invalidate(Unit, Preserved, ChangeT::all());
+  }
+
+  [[nodiscard]] bool hasCached(const IRUnitT &Unit, AnalysisID ID) const noexcept {
+    const auto UnitPosition = Cache.find(const_cast<IRUnitT *>(&Unit));
+    if (UnitPosition == Cache.end())
+      return false;
+    const auto AnalysisPosition = UnitPosition->second.find(ID);
+    return AnalysisPosition != UnitPosition->second.end() && AnalysisPosition->second.Value;
+  }
+
+  [[nodiscard]] std::size_t cachedResultCount(const IRUnitT &Unit) const noexcept {
+    const auto Position = Cache.find(const_cast<IRUnitT *>(&Unit));
+    return Position == Cache.end() ? 0 : Position->second.size();
+  }
+
+  [[nodiscard]] bool isRegistered(AnalysisID ID) const noexcept {
+    return ID != nullptr && Registry.contains(ID);
+  }
+
+  void clear(IRUnitT &Unit) noexcept {
+    Cache.erase(&Unit);
+    ActiveComputations.erase(&Unit);
+  }
+
+  void clearAll() noexcept {
+    Cache.clear();
+    ActiveComputations.clear();
+  }
+
+  [[nodiscard]] Expected<std::unique_ptr<Self>> forkEmpty() const {
+    if (!ActiveComputations.empty())
+      return makeUnexpected(ErrorCode::InvalidArgument,
+                            "cannot fork an analysis manager during analysis computation");
+    auto Result = std::make_unique<Self>();
+    Result->Registry = Registry;
+    return Result;
+  }
+
+  [[nodiscard]] Expected<void> replaceRegistrations(Self &&Source) {
+    if (!Cache.empty() || !ActiveComputations.empty() || !Source.Cache.empty() ||
+        !Source.ActiveComputations.empty())
+      return makeUnexpected(ErrorCode::InvalidArgument,
+                            "analysis registrations can only be replaced on empty managers");
+    Registry = std::move(Source.Registry);
+    return {};
+  }
+
+  [[nodiscard]] Expected<void>
+  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 pass requires an unregistered analysis");
+      if (Position->second.Info.ThreadSafety != PassThreadSafety::ThreadSafe)
+        return makeUnexpected(ErrorCode::InvalidArgument, "parallel 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 {};
+  }
+
+  void setInstrumentation(InstrumentationT *NewInstrumentation) noexcept {
+    Instrumentation = NewInstrumentation;
+  }
+
+  void setActivePass(std::string Name) {
+    ActivePass = std::move(Name);
+  }
+
+  template <typename InstructionT>
+  [[nodiscard]] Expected<bool> requestAction(std::string_view Rule, const IRUnitT &Unit,
+                                             InstructionT Instruction, std::uint64_t Cost = 1) {
+    if (Rule.empty() || Cost == 0)
+      return makeUnexpected(ErrorCode::InvalidArgument,
+                            "pass action requires a name and nonzero cost");
+    if (Instrumentation == nullptr)
+      return true;
+    return AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::requestAction(
+        Instrumentation, ActivePass.empty() ? "unscoped" : ActivePass, Rule, Unit, Instruction,
+        Cost);
+  }
+
+  [[nodiscard]] Expected<bool> requestAction(std::string_view Rule, const IRUnitT &Unit,
+                                             std::uint64_t Cost = 1) {
+    if (Rule.empty() || Cost == 0)
+      return makeUnexpected(ErrorCode::InvalidArgument,
+                            "pass action requires a name and nonzero cost");
+    if (Instrumentation == nullptr)
+      return true;
+    return AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::requestAction(
+        Instrumentation, ActivePass.empty() ? "unscoped" : ActivePass, Rule, Unit, nullptr, Cost);
+  }
+
+  [[nodiscard]] const std::string &activePass() const noexcept {
+    return ActivePass;
+  }
+
+private:
+  using ErasedRunner =
+      std::function<Expected<std::shared_ptr<void>>(IRUnitT &, const TargetDescription &, Self &)>;
+  using ErasedInvalidator = std::function<bool(void *, const IRUnitT &, const PreservedAnalyses &)>;
+
+  struct RegisteredAnalysis final {
+    RegistrationT Info;
+    ErasedRunner Runner;
+    ErasedInvalidator Invalidator;
+  };
+
+  struct CacheEntry final {
+    std::shared_ptr<void> Value;
+    AnalysisID ID = nullptr;
+  };
+
+  [[nodiscard]] static bool hasDuplicateAnalysisIDs(std::span<const AnalysisID> IDs) {
+    std::unordered_set<AnalysisID> Unique;
+    for (const AnalysisID ID : IDs) {
+      if (ID == nullptr || !Unique.insert(ID).second)
+        return true;
+    }
+    return false;
+  }
+
+  [[nodiscard]] Expected<void> registerAnalysisImpl(RegistrationT Registration, ErasedRunner Runner,
+                                                    ErasedInvalidator Invalidator) {
+    if (Registration.ID == nullptr || Registration.Name.empty() || !Runner || !Invalidator)
+      return makeUnexpected(ErrorCode::InvalidArgument, "analysis registration is incomplete");
+    if (hasDuplicateAnalysisIDs(Registration.Dependencies))
+      return makeUnexpected(ErrorCode::InvalidArgument,
+                            "analysis dependencies must be non-null and unique");
+    if (std::ranges::find(Registration.Dependencies, Registration.ID) !=
+        Registration.Dependencies.end())
+      return makeUnexpected(ErrorCode::InvalidArgument,
+                            "analysis cannot directly depend on itself");
+    if (Registry.contains(Registration.ID))
+      return makeUnexpected(ErrorCode::InvalidArgument, "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, "analysis name is already registered");
+    Registry.emplace(Registration.ID, RegisteredAnalysis{std::move(Registration), std::move(Runner),
+                                                         std::move(Invalidator)});
+    return {};
+  }
+
+  [[nodiscard]] Expected<void *> getResultImpl(AnalysisID ID, IRUnitT &Unit,
+                                               const TargetDescription &Target) {
+    if (ID == nullptr)
+      return makeUnexpected(ErrorCode::InvalidArgument, "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-analysis"}
+                                        : std::string_view{Registration->second.Info.Name};
+      if (Instrumentation != nullptr)
+        AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::afterAnalysis(
+            Instrumentation, Name, Unit, true, 0);
+      return Cached->second.Value.get();
+    }
+
+    const auto RegistrationPosition = Registry.find(ID);
+    if (RegistrationPosition == Registry.end())
+      return makeUnexpected(ErrorCode::InvalidArgument, "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,
+                    "analysis dependency cycle reaches '" + Registration.Info.Name + "'");
+      if (Instrumentation != nullptr)
+        AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::analysisFailure(
+            Instrumentation, Registration.Info.Name, Unit, Failure, 0);
+      return std::unexpected(std::move(Failure));
+    }
+
+    if (Instrumentation != nullptr)
+      AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::beforeAnalysis(
+          Instrumentation, Registration.Info.Name, Unit);
+    const auto Start = std::chrono::steady_clock::now();
+    Stack.push_back(ID);
+    for (const AnalysisID Dependency : Registration.Info.Dependencies) {
+      if (!Registry.contains(Dependency)) {
+        Stack.pop_back();
+        if (Stack.empty())
+          ActiveComputations.erase(&Unit);
+        return makeUnexpected(ErrorCode::InvalidArgument,
+                              "analysis depends on an unregistered analysis");
+      }
+      auto DependencyResult = getResultImpl(Dependency, Unit, Target);
+      if (!DependencyResult) {
+        Stack.pop_back();
+        if (Stack.empty())
+          ActiveComputations.erase(&Unit);
+        Error Failure = DependencyResult.error();
+        std::string Message = "analysis '" + Registration.Info.Name + "' failed: ";
+        Message.append(Failure.message());
+        Failure = Error(Failure.code(), std::move(Message));
+        if (Instrumentation != nullptr)
+          AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::analysisFailure(
+              Instrumentation, 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 = Computed.error();
+      std::string Message = "analysis '" + Registration.Info.Name + "' failed: ";
+      Message.append(Failure.message());
+      Failure = Error(Failure.code(), std::move(Message));
+      if (Instrumentation != nullptr)
+        AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::analysisFailure(
+            Instrumentation, Registration.Info.Name, Unit, Failure, Duration);
+      return std::unexpected(std::move(Failure));
+    }
+    if (!*Computed) {
+      Error Failure(ErrorCode::InternalError,
+                    "analysis '" + Registration.Info.Name + "' returned a null result");
+      if (Instrumentation != nullptr)
+        AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::analysisFailure(
+            Instrumentation, 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)
+      AnalysisManagerInstrumentation<IRUnitT, InstrumentationT>::afterAnalysis(
+          Instrumentation, Registration.Info.Name, Unit, false, Duration);
+    return Result;
+  }
+
+  [[nodiscard]] static std::uint64_t
+  elapsedNanoseconds(std::chrono::steady_clock::time_point Start) noexcept {
+    const auto Elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(
+        std::chrono::steady_clock::now() - Start);
+    return Elapsed.count() <= 0 ? 0 : static_cast<std::uint64_t>(Elapsed.count());
+  }
+
+  std::unordered_map<AnalysisID, RegisteredAnalysis> Registry;
+  std::unordered_map<IRUnitT *, std::unordered_map<AnalysisID, CacheEntry>> Cache;
+  std::unordered_map<IRUnitT *, std::vector<AnalysisID>> ActiveComputations;
+  InstrumentationT *Instrumentation = nullptr;
+  std::string ActivePass;
+};
+
+} // namespace rcc
+
+#endif // RCC_IR_PASSMANAGER_H
diff --git a/backend/include/rcc/Target/RISCV/RISCVPipeline.h b/backend/include/rcc/Target/RISCV/RISCVPipeline.h
index ba0428b..8b27032 100644
--- a/backend/include/rcc/Target/RISCV/RISCVPipeline.h
+++ b/backend/include/rcc/Target/RISCV/RISCVPipeline.h
@@ -3,7 +3,7 @@
 #ifndef RCC_TARGET_RISCV_RISCVPIPELINE_H
 #define RCC_TARGET_RISCV_RISCVPIPELINE_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/Support/Error.h"
 #include "rcc/Target/RISCV/RISCVSubtarget.h"
 
@@ -19,7 +19,7 @@ class TargetDescription;
 
 namespace riscv {
 
-[[nodiscard]] Expected<void> addCanonicalPipeline(MachinePassManager &Pipeline,
+[[nodiscard]] Expected<void> addCanonicalPipeline(MachineFunctionPassManager &Pipeline,
                                                   const MachineFunction &Function,
                                                   const RISCVSubtarget &Subtarget);
 [[nodiscard]] Expected<std::unique_ptr<MachineFunctionPass>>
diff --git a/backend/include/rcc/Tooling/BackendDriver.h b/backend/include/rcc/Tooling/BackendDriver.h
index 7b62b6d..6b04de9 100644
--- a/backend/include/rcc/Tooling/BackendDriver.h
+++ b/backend/include/rcc/Tooling/BackendDriver.h
@@ -3,7 +3,7 @@
 #ifndef RCC_TOOLING_BACKENDDRIVER_H
 #define RCC_TOOLING_BACKENDDRIVER_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/Support/Error.h"
 #include "rcc/Tooling/ArtifactStore.h"
 #include "rcc/Tooling/PipelineDriver.h"
diff --git a/backend/include/rcc/Tooling/PipelineDriver.h b/backend/include/rcc/Tooling/PipelineDriver.h
index 5d2dc45..849b2f7 100644
--- a/backend/include/rcc/Tooling/PipelineDriver.h
+++ b/backend/include/rcc/Tooling/PipelineDriver.h
@@ -3,7 +3,7 @@
 #ifndef RCC_TOOLING_PIPELINEDRIVER_H
 #define RCC_TOOLING_PIPELINEDRIVER_H
 
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/MIR/MIRDocument.h"
 #include "rcc/Tooling/BackendInvocation.h"
 
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");
diff --git a/backend/lib/Target/RISCV/RISCVPipeline.cpp b/backend/lib/Target/RISCV/RISCVPipeline.cpp
index c5601ef..60f798c 100644
--- a/backend/lib/Target/RISCV/RISCVPipeline.cpp
+++ b/backend/lib/Target/RISCV/RISCVPipeline.cpp
@@ -27,11 +27,12 @@ namespace rcc::riscv {
 namespace {
 
 template <typename PassT, typename... ArgumentT>
-[[nodiscard]] Expected<void> addPass(MachinePassManager &Pipeline, ArgumentT &&...Arguments) {
+[[nodiscard]] Expected<void> addPass(MachineFunctionPassManager &Pipeline,
+                                     ArgumentT &&...Arguments) {
   return Pipeline.addPass(std::make_unique<PassT>(std::forward<ArgumentT>(Arguments)...));
 }
 
-[[nodiscard]] Expected<void> addInitialPipeline(MachinePassManager &Pipeline,
+[[nodiscard]] Expected<void> addInitialPipeline(MachineFunctionPassManager &Pipeline,
                                                 const RISCVSubtarget &Subtarget) {
   auto Added = addPass<MachineCombinerPass>(Pipeline, machineCombinerInfo(),
                                             MachineCombinerStage::PreLegalizer);
@@ -46,7 +47,7 @@ template <typename PassT, typename... ArgumentT>
   return addPass<InstructionSelect>(Pipeline, Subtarget.getInstructionSelector());
 }
 
-[[nodiscard]] Expected<void> addSSAExitPipeline(MachinePassManager &Pipeline) {
+[[nodiscard]] Expected<void> addSSAExitPipeline(MachineFunctionPassManager &Pipeline) {
   auto Added = addSelectedSSAOptimizationPipeline(Pipeline, optimizationPipelineInfo());
   if (!Added)
     return std::unexpected(Added.error());
@@ -56,14 +57,14 @@ template <typename PassT, typename... ArgumentT>
   return addPass<TwoAddressInstructionPass>(Pipeline, instrInfo());
 }
 
-[[nodiscard]] Expected<void> addRegisterAllocationPipeline(MachinePassManager &Pipeline) {
+[[nodiscard]] Expected<void> addRegisterAllocationPipeline(MachineFunctionPassManager &Pipeline) {
   auto Added = addPreRegisterAllocationOptimizationPipeline(Pipeline, optimizationPipelineInfo());
   if (!Added)
     return std::unexpected(Added.error());
   return addPass<PBQPAllocatorPass>(Pipeline, registerAllocationInfo());
 }
 
-[[nodiscard]] Expected<void> addCompleteRegistry(MachinePassManager &Pipeline,
+[[nodiscard]] Expected<void> addCompleteRegistry(MachineFunctionPassManager &Pipeline,
                                                  const RISCVSubtarget &Subtarget) {
   auto Added = addInitialPipeline(Pipeline, Subtarget);
   if (!Added)
@@ -79,7 +80,8 @@ template <typename PassT, typename... ArgumentT>
 
 } // namespace
 
-Expected<void> addCanonicalPipeline(MachinePassManager &Pipeline, const MachineFunction &Function,
+Expected<void> addCanonicalPipeline(MachineFunctionPassManager &Pipeline,
+                                    const MachineFunction &Function,
                                     const RISCVSubtarget &Subtarget) {
   if (!Function.properties().has(MachineFunctionProperty::Legalized)) {
     auto Added = addPass<MachineCombinerPass>(Pipeline, machineCombinerInfo(),
@@ -132,11 +134,11 @@ Expected<std::unique_ptr<MachineFunctionPass>>
 createCanonicalPipelinePass(std::string_view Name, const RISCVSubtarget &Subtarget) {
   if (Name.empty())
     return makeUnexpected(ErrorCode::InvalidArgument, "pipeline pass name cannot be empty");
-  MachinePassManager Registry;
+  MachineFunctionPassManager Registry;
   auto Added = addCompleteRegistry(Registry, Subtarget);
   if (!Added)
     return std::unexpected(Added.error());
-  MachinePassManager::PassList Passes = std::move(Registry).takePasses();
+  MachineFunctionPassManager::PassList Passes = std::move(Registry).takePasses();
   auto Position = std::ranges::find_if(Passes, [Name](const auto &Pass) {
     return Pass != nullptr && Pass->contract().Name == Name;
   });
@@ -149,11 +151,11 @@ createCanonicalPipelinePass(std::string_view Name, const RISCVSubtarget &Subtarg
 
 Expected<std::vector<std::string>> canonicalPipelinePassNames(const MachineFunction &Function,
                                                               const RISCVSubtarget &Subtarget) {
-  MachinePassManager Pipeline;
+  MachineFunctionPassManager Pipeline;
   auto Added = addCanonicalPipeline(Pipeline, Function, Subtarget);
   if (!Added)
     return std::unexpected(Added.error());
-  MachinePassManager::PassList Passes = std::move(Pipeline).takePasses();
+  MachineFunctionPassManager::PassList Passes = std::move(Pipeline).takePasses();
   std::vector<std::string> Result;
   Result.reserve(Passes.size());
   for (const std::unique_ptr<MachineFunctionPass> &Pass : Passes) {
diff --git a/backend/lib/Tooling/PipelineDriver.cpp b/backend/lib/Tooling/PipelineDriver.cpp
index 495842a..d7a7d16 100644
--- a/backend/lib/Tooling/PipelineDriver.cpp
+++ b/backend/lib/Tooling/PipelineDriver.cpp
@@ -79,10 +79,10 @@ struct FunctionRunResult final {
   return std::nullopt;
 }
 
-[[nodiscard]] Expected<MachinePassManager::PassList>
+[[nodiscard]] Expected<MachineFunctionPassManager::PassList>
 createPasses(const MachineFunction &Function, const BackendInvocation &Invocation,
              const riscv::RISCVSubtarget &Subtarget, MachinePassManagerOptions Options) {
-  MachinePassManager Pipeline(Options);
+  MachineFunctionPassManager Pipeline(Options);
   if (Invocation.PassPipeline.size() == 1 && Invocation.PassPipeline.front() == "default") {
     auto Added = riscv::addCanonicalPipeline(Pipeline, Function, Subtarget);
     if (!Added)
@@ -212,7 +212,7 @@ runFunction(MachineFunction &Function, mir::MIRDocument &Document, const TargetD
   auto Passes = createPasses(Function, Invocation, Subtarget, ManagerOptions);
   if (!Passes)
     return std::unexpected(Passes.error());
-  MachineAnalysisManager Analyses;
+  MachineFunctionAnalysisManager Analyses;
   auto Registered = registerMachineOptimizationAnalyses(Analyses);
   if (!Registered)
     return std::unexpected(Registered.error());
@@ -257,7 +257,7 @@ runFunction(MachineFunction &Function, mir::MIRDocument &Document, const TargetD
         return std::unexpected(Captured.error());
     }
 
-    MachinePassManager SinglePass(ManagerOptions);
+    MachineFunctionPassManager SinglePass(ManagerOptions);
     auto Added = SinglePass.addPass(std::move(Pass));
     if (!Added)
       return std::unexpected(Added.error());
diff --git a/backend/unittests/CodeGen/CMakeLists.txt b/backend/unittests/CodeGen/CMakeLists.txt
index 0715def..ac6ab36 100644
--- a/backend/unittests/CodeGen/CMakeLists.txt
+++ b/backend/unittests/CodeGen/CMakeLists.txt
@@ -27,7 +27,9 @@ set(
   MachineMetadataTest.cpp
   MachineOperandTest.cpp
   MachineOptimizationTest.cpp
-  MachinePassTest.cpp
+  PassManagerTest.cpp
+  PassInstrumentationTest.cpp
+  MachinePassManagerTest.cpp
   MachineSchedulingTest.cpp
   PBQPTest.cpp
   RegisterAllocationTest.cpp
@@ -343,14 +345,35 @@ add_test(
   COMMAND RCCBackendCodeGenMachineOperandTests
 )
 
-add_executable(RCCBackendCodeGenMachinePassTests MachinePassTest.cpp)
-rcc_backend_configure_target(RCCBackendCodeGenMachinePassTests)
+add_executable(RCCBackendCodeGenPassManagerTests PassManagerTest.cpp)
+rcc_backend_configure_target(RCCBackendCodeGenPassManagerTests)
 target_link_libraries(
-  RCCBackendCodeGenMachinePassTests
+  RCCBackendCodeGenPassManagerTests
   PRIVATE RCCBackend::CodeGen RCCBackend::TestTarget
 )
+add_test(NAME RCCBackend.CodeGen.PassManager COMMAND RCCBackendCodeGenPassManagerTests)
 
-add_test(NAME RCCBackend.CodeGen.MachinePass COMMAND RCCBackendCodeGenMachinePassTests)
+add_executable(RCCBackendCodeGenPassInstrumentationTests PassInstrumentationTest.cpp)
+rcc_backend_configure_target(RCCBackendCodeGenPassInstrumentationTests)
+target_link_libraries(
+  RCCBackendCodeGenPassInstrumentationTests
+  PRIVATE RCCBackend::CodeGen RCCBackend::TestTarget
+)
+add_test(
+  NAME RCCBackend.CodeGen.PassInstrumentation
+  COMMAND RCCBackendCodeGenPassInstrumentationTests
+)
+
+add_executable(RCCBackendCodeGenMachinePassManagerTests MachinePassManagerTest.cpp)
+rcc_backend_configure_target(RCCBackendCodeGenMachinePassManagerTests)
+target_link_libraries(
+  RCCBackendCodeGenMachinePassManagerTests
+  PRIVATE RCCBackend::CodeGen RCCBackend::TestTarget
+)
+add_test(
+  NAME RCCBackend.CodeGen.MachinePassManager
+  COMMAND RCCBackendCodeGenMachinePassManagerTests
+)
 
 add_subdirectory(GlobalISel)
 
@@ -495,7 +518,9 @@ rcc_backend_register_format_files(
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineMetadataTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineOperandTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineOptimizationTest.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/MachinePassTest.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/PassManagerTest.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/PassInstrumentationTest.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/MachinePassManagerTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineSchedulingTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/PBQPTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/RegisterAllocationTest.cpp"
@@ -544,7 +569,9 @@ rcc_backend_register_tidy_files(
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineMetadataTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineOperandTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineOptimizationTest.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/MachinePassTest.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/PassManagerTest.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/PassInstrumentationTest.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/MachinePassManagerTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/MachineSchedulingTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/PBQPTest.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/RegisterAllocationTest.cpp"
diff --git a/backend/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp b/backend/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp
index e98f121..30c2b89 100644
--- a/backend/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp
+++ b/backend/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp
@@ -120,7 +120,7 @@ void testPipeline(TestContext &Context) {
   Fixture.Function->properties() = {rcc::MachineFunctionProperty::IsSSA,
                                     rcc::MachineFunctionProperty::TracksLiveness};
   const rcc::riscv::RISCVSubtarget Subtarget(rcc::riscv::RISCVSubtargetFeatures::rv64gc());
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   Context.expect(
       Pipeline.addPass(std::make_unique<rcc::Legalizer>(Subtarget.getLegalizerInfo())).has_value(),
       "legalizer must be accepted by the pass manager");
@@ -131,7 +131,7 @@ void testPipeline(TestContext &Context) {
       Pipeline.addPass(std::make_unique<rcc::InstructionSelect>(Subtarget.getInstructionSelector()))
           .has_value(),
       "instruction selector must be accepted by the pass manager");
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Pipeline.run(*Fixture.Function, *Target, Analyses);
   Context.expect(Run.has_value(), "RV64GC generic pipeline must complete");
   Context.expect(Fixture.Function->properties().has(rcc::MachineFunctionProperty::Selected),
@@ -167,7 +167,7 @@ void testInstructionSelectionTransaction(TestContext &Context) {
                                     rcc::MachineFunctionProperty::RegBankSelected};
   MutatingFailingSelector Selector;
   rcc::InstructionSelect Pass(Selector);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Pass.run(*Fixture.Function, *Target, Analyses);
   Context.expect(!Run && Run.error().code() == rcc::ErrorCode::Unsupported,
                  "a renderer failure must be reported before publication");
@@ -203,7 +203,7 @@ void testInstructionSelectionOrder(TestContext &Context) {
   const rcc::riscv::RISCVSubtarget Subtarget(rcc::riscv::RISCVSubtargetFeatures::rv64gc());
   RecordingSelector Selector(*Subtarget.getInstructionSelector());
   rcc::InstructionSelect Pass(Selector);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Pass.run(*Fixture.Function, *Target, Analyses);
   Context.expect(Run.has_value(), "recorded instruction selection must complete");
   std::ranges::reverse(LayoutIDs);
@@ -233,7 +233,7 @@ void testInstructionSelectionWorklist(TestContext &Context) {
                                     rcc::MachineFunctionProperty::RegBankSelected};
   TwoStepSelector Selector;
   rcc::InstructionSelect Pass(Selector);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Pass.run(*Fixture.Function, *Target, Analyses);
   Context.expect(Run.has_value(), "a progressing multi-step selection must complete");
   Context.expect(Selector.selections() == 4,
@@ -326,7 +326,7 @@ void testExtendedRV64GCPipeline(TestContext &Context) {
   Fixture.Function->properties() = {rcc::MachineFunctionProperty::IsSSA,
                                     rcc::MachineFunctionProperty::TracksLiveness};
   const rcc::riscv::RISCVSubtarget Subtarget(rcc::riscv::RISCVSubtargetFeatures::rv64gc());
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   if (!Pipeline.addPass(std::make_unique<rcc::Legalizer>(Subtarget.getLegalizerInfo())) ||
       !Pipeline.addPass(std::make_unique<rcc::RegBankSelect>(Subtarget.getRegBankInfo())) ||
       !Pipeline.addPass(
@@ -334,7 +334,7 @@ void testExtendedRV64GCPipeline(TestContext &Context) {
     Context.expect(false, "extended RV64GC pipeline construction must succeed");
     return;
   }
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Pipeline.run(*Fixture.Function, *Target, Analyses);
   Context.expect(Run.has_value(), "extended RV64GC pipeline must complete");
   Context.expect(Run && Fixture.Function->properties().has(rcc::MachineFunctionProperty::Selected),
diff --git a/backend/unittests/CodeGen/GlobalISel/LegalizerTest.cpp b/backend/unittests/CodeGen/GlobalISel/LegalizerTest.cpp
index 9cb8a67..b191a3f 100644
--- a/backend/unittests/CodeGen/GlobalISel/LegalizerTest.cpp
+++ b/backend/unittests/CodeGen/GlobalISel/LegalizerTest.cpp
@@ -73,7 +73,7 @@ void testNullAndMissingContracts(TestContext &Context) {
     return;
 
   rcc::Legalizer NullPass(nullptr);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto NullResult = NullPass.run(*Fixture.Function, *Target, Analyses);
   Context.expect(!NullResult && NullResult.error().code() == rcc::ErrorCode::InvalidArgument,
                  "a null legalizer interface must be rejected");
@@ -117,12 +117,12 @@ void testUnsupportedRollback(TestContext &Context) {
   Unsupported.Function->properties() = {rcc::MachineFunctionProperty::IsSSA,
                                         rcc::MachineFunctionProperty::TracksLiveness};
   const rcc::riscv::RISCVSubtarget Subtarget(rcc::riscv::RISCVSubtargetFeatures::rv64gc());
-  rcc::MachinePassManager OnlyLegalizer;
+  rcc::MachineFunctionPassManager OnlyLegalizer;
   Context.expect(
       OnlyLegalizer.addPass(std::make_unique<rcc::Legalizer>(Subtarget.getLegalizerInfo()))
           .has_value(),
       "standalone legalizer must be accepted");
-  rcc::MachineAnalysisManager UnsupportedAnalyses;
+  rcc::MachineFunctionAnalysisManager UnsupportedAnalyses;
   auto Failure = OnlyLegalizer.run(*Unsupported.Function, *Target, UnsupportedAnalyses);
   Context.expect(!Failure && Failure.error().code() == rcc::ErrorCode::Unsupported,
                  "unsupported generic instructions must produce a target diagnostic");
@@ -152,7 +152,7 @@ void testLegalizerCycleDiagnostic(TestContext &Context) {
                                     rcc::MachineFunctionProperty::TracksLiveness};
   TogglingLegalizer Legalizer;
   rcc::Legalizer StablePass(Legalizer);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto ResultRun = StablePass.run(*Fixture.Function, *Target, Analyses);
   Context.expect(!ResultRun && ResultRun.error().code() == rcc::ErrorCode::InternalError,
                  "repeated legalization states must report InternalError");
@@ -188,7 +188,7 @@ void testLegalizerRevisitsInvalidatedInstructions(TestContext &Context) {
                                     rcc::MachineFunctionProperty::TracksLiveness};
   BackwardInvalidatingLegalizer Legalizer;
   rcc::Legalizer Pass(Legalizer);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Pass.run(*Fixture.Function, *Target, Analyses);
   const rcc::Opcode LegalOpcode =
       rcc::Opcode::fromValue(static_cast<std::uint32_t>(rcc::riscv::InstructionOpcode::ADD));
diff --git a/backend/unittests/CodeGen/GlobalISel/RegBankSelectTest.cpp b/backend/unittests/CodeGen/GlobalISel/RegBankSelectTest.cpp
index d4925eb..833435f 100644
--- a/backend/unittests/CodeGen/GlobalISel/RegBankSelectTest.cpp
+++ b/backend/unittests/CodeGen/GlobalISel/RegBankSelectTest.cpp
@@ -33,7 +33,7 @@ void testBankConflict(TestContext &Context) {
   Fixture.Function->properties() = {rcc::MachineFunctionProperty::Legalized};
   const rcc::riscv::RISCVSubtarget Subtarget(rcc::riscv::RISCVSubtargetFeatures::rv64gc());
   rcc::RegBankSelect Pass(Subtarget.getRegBankInfo());
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Result = Pass.run(*Fixture.Function, *Target, Analyses);
   Context.expect(!Result && Result.error().code() == rcc::ErrorCode::VerificationError,
                  "bank selection must reject a conflicting pre-existing bank");
@@ -66,7 +66,7 @@ void testBankClassOnlyChange(TestContext &Context) {
   Fixture.Function->properties() = {rcc::MachineFunctionProperty::Legalized};
   const rcc::riscv::RISCVSubtarget Subtarget(rcc::riscv::RISCVSubtargetFeatures::rv64gc());
   rcc::RegBankSelect Pass(Subtarget.getRegBankInfo());
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Result = Pass.run(*Fixture.Function, *Target, Analyses);
   Context.expect(Result.has_value() && Result->Changed &&
                      Result->Changes.has(rcc::MachinePassChange::Registers),
diff --git a/backend/unittests/CodeGen/LiveIntervalTest.cpp b/backend/unittests/CodeGen/LiveIntervalTest.cpp
index 7e48b05..34ebd76 100644
--- a/backend/unittests/CodeGen/LiveIntervalTest.cpp
+++ b/backend/unittests/CodeGen/LiveIntervalTest.cpp
@@ -74,7 +74,7 @@ void testLaneSubrangesAndEarlyClobber(TestContext &Context, const rcc::TargetDes
     return;
   }
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage11MachineAnalyses(Analyses);
   auto Intervals = Registered
                        ? Analyses.getResult<rcc::LiveIntervalsAnalysis>(*Fixture->Function, Target)
diff --git a/backend/unittests/CodeGen/LiveIntervalsTest.cpp b/backend/unittests/CodeGen/LiveIntervalsTest.cpp
index 5c127a2..a080e4d 100644
--- a/backend/unittests/CodeGen/LiveIntervalsTest.cpp
+++ b/backend/unittests/CodeGen/LiveIntervalsTest.cpp
@@ -64,7 +64,7 @@ void testCFGAndValueNumbers(TestContext &Context, const rcc::TargetDescription &
     return;
   }
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage11MachineAnalyses(Analyses);
   auto Variables = Registered ? Analyses.getResult<rcc::LiveVariablesAnalysis>(Function, Target)
                               : rcc::Expected<rcc::LiveVariablesAnalysis::Result *>{
@@ -133,7 +133,7 @@ void testPhysicalUnitsAndRegMasks(TestContext &Context, const rcc::TargetDescrip
     Context.expect(false, "physical-alias instructions must be built");
     return;
   }
-  rcc::MachineAnalysisManager AliasAnalyses;
+  rcc::MachineFunctionAnalysisManager AliasAnalyses;
   auto AliasRegistered = rcc::registerStage11MachineAnalyses(AliasAnalyses);
   auto AliasIntervals =
       AliasRegistered
@@ -167,7 +167,7 @@ void testPhysicalUnitsAndRegMasks(TestContext &Context, const rcc::TargetDescrip
     Context.expect(false, "RegMask instructions must be built");
     return;
   }
-  rcc::MachineAnalysisManager MaskAnalyses;
+  rcc::MachineFunctionAnalysisManager MaskAnalyses;
   auto MaskRegistered = rcc::registerStage11MachineAnalyses(MaskAnalyses);
   auto MaskIntervals =
       MaskRegistered
@@ -237,7 +237,7 @@ void testRISCVLiveness(TestContext &Context) {
     Context.expect(false, "RV64GC ADDI instructions must be built");
     return;
   }
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage11MachineAnalyses(Analyses);
   auto Intervals = Registered
                        ? Analyses.getResult<rcc::LiveIntervalsAnalysis>(*Fixture->Function, *Target)
diff --git a/backend/unittests/CodeGen/LivePhysRegsTest.cpp b/backend/unittests/CodeGen/LivePhysRegsTest.cpp
index ee579be..6eea796 100644
--- a/backend/unittests/CodeGen/LivePhysRegsTest.cpp
+++ b/backend/unittests/CodeGen/LivePhysRegsTest.cpp
@@ -24,7 +24,7 @@ void testPostRALivenessRepair(TestContext &Context, const rcc::TargetDescription
     return;
   }
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage11MachineAnalyses(Analyses);
   auto Liveness = Registered
                       ? Analyses.getResult<rcc::LiveVariablesAnalysis>(*Fixture->Function, Target)
diff --git a/backend/unittests/CodeGen/LiveRegMatrixTest.cpp b/backend/unittests/CodeGen/LiveRegMatrixTest.cpp
index 21c0778..423da50 100644
--- a/backend/unittests/CodeGen/LiveRegMatrixTest.cpp
+++ b/backend/unittests/CodeGen/LiveRegMatrixTest.cpp
@@ -26,7 +26,7 @@ void testLaneAndAssignment(TestContext &Context, const TargetDescription &Target
       !buildUse(*Fixture->Function, Target, *Fixture->Block, *Low, TestSubReg::Low32))
     return;
 
-  MachineAnalysisManager Analyses;
+  MachineFunctionAnalysisManager Analyses;
   if (!registerStage11MachineAnalyses(Analyses))
     return;
   auto Intervals = Analyses.getResult<LiveIntervalsAnalysis>(*Fixture->Function, Target);
@@ -55,7 +55,7 @@ void testFixedAndMaskInterference(TestContext &Context, const TargetDescription
       !buildUse(*Fixture->Function, Target, *Fixture->Block, *Value))
     return;
 
-  MachineAnalysisManager Analyses;
+  MachineFunctionAnalysisManager Analyses;
   if (!registerStage11MachineAnalyses(Analyses))
     return;
   auto Intervals = Analyses.getResult<LiveIntervalsAnalysis>(*Fixture->Function, Target);
diff --git a/backend/unittests/CodeGen/LiveVariablesTest.cpp b/backend/unittests/CodeGen/LiveVariablesTest.cpp
index 577ecde..1cc4e91 100644
--- a/backend/unittests/CodeGen/LiveVariablesTest.cpp
+++ b/backend/unittests/CodeGen/LiveVariablesTest.cpp
@@ -36,9 +36,9 @@ void testLivenessRebuildAndVerifier(TestContext &Context, const rcc::TargetDescr
   Context.expect(StaleLiveIn.has_value(), "stale live-in setup must succeed");
   setRebuildProperties(Function);
 
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   auto Added = Pipeline.addPass(std::make_unique<rcc::RebuildMachineLivenessPass>());
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Added ? Pipeline.run(Function, Target, Analyses)
                    : rcc::Expected<void>{std::unexpected(Added.error())};
   if (!Run)
@@ -169,8 +169,9 @@ class DummyAnalysis final {
 public:
   struct Result final {};
 
-  [[nodiscard]] static rcc::Expected<Result>
-  run(rcc::MachineFunction &, const rcc::TargetDescription &, rcc::MachineAnalysisManager &) {
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
     return Result{};
   }
 };
@@ -192,7 +193,7 @@ void testAnalysisRegistrationAndInvalidation(TestContext &Context,
     return;
   }
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto FirstRegistration = rcc::registerStage11MachineAnalyses(Analyses);
   auto SecondRegistration = rcc::registerStage11MachineAnalyses(Analyses);
   auto Intervals = FirstRegistration
@@ -211,7 +212,7 @@ void testAnalysisRegistrationAndInvalidation(TestContext &Context,
   Context.expect(
       Analyses.cachedResultCount(*Fixture->Function) == 1 &&
           Analyses.hasCached(*Fixture->Function,
-                             rcc::MachineAnalysisManager::id<rcc::SlotIndexesAnalysis>()),
+                             rcc::MachineFunctionAnalysisManager::id<rcc::SlotIndexesAnalysis>()),
       "operand changes must retain SlotIndexes while invalidating liveness dependents");
   auto Recomputed = Analyses.getResult<rcc::LiveIntervalsAnalysis>(*Fixture->Function, Target);
   Context.expect(Recomputed && Analyses.cachedResultCount(*Fixture->Function) == 3,
@@ -221,18 +222,21 @@ void testAnalysisRegistrationAndInvalidation(TestContext &Context,
   Context.expect(
       Analyses.cachedResultCount(*Fixture->Function) == 1 &&
           Analyses.hasCached(*Fixture->Function,
-                             rcc::MachineAnalysisManager::id<rcc::LiveVariablesAnalysis>()),
+                             rcc::MachineFunctionAnalysisManager::id<rcc::LiveVariablesAnalysis>()),
       "layout changes must invalidate SlotIndexes and LiveIntervals only");
 
-  rcc::MachineAnalysisManager Atomic;
+  rcc::MachineFunctionAnalysisManager Atomic;
   rcc::MachineAnalysisRegistration DummyRegistration;
   DummyRegistration.Name = "SlotIndexes";
   auto Dummy = Atomic.registerAnalysis<DummyAnalysis>(std::move(DummyRegistration));
   auto Rejected = rcc::registerStage11MachineAnalyses(Atomic);
   Context.expect(
-      Dummy && !Rejected && Atomic.isRegistered(rcc::MachineAnalysisManager::id<DummyAnalysis>()) &&
-          !Atomic.isRegistered(rcc::MachineAnalysisManager::id<rcc::SlotIndexesAnalysis>()) &&
-          !Atomic.isRegistered(rcc::MachineAnalysisManager::id<rcc::LiveVariablesAnalysis>()),
+      Dummy && !Rejected &&
+          Atomic.isRegistered(rcc::MachineFunctionAnalysisManager::id<DummyAnalysis>()) &&
+          !Atomic.isRegistered(
+              rcc::MachineFunctionAnalysisManager::id<rcc::SlotIndexesAnalysis>()) &&
+          !Atomic.isRegistered(
+              rcc::MachineFunctionAnalysisManager::id<rcc::LiveVariablesAnalysis>()),
       "failed standard-analysis registration must leave the manager unchanged");
 }
 
diff --git a/backend/unittests/CodeGen/MachineAnalysesTest.cpp b/backend/unittests/CodeGen/MachineAnalysesTest.cpp
index 1c9f255..997d031 100644
--- a/backend/unittests/CodeGen/MachineAnalysesTest.cpp
+++ b/backend/unittests/CodeGen/MachineAnalysesTest.cpp
@@ -86,7 +86,7 @@ void testCFGAnalyses(TestContext &Context, const rcc::TargetDescription &Target)
                      Updater.addSuccessor(**Body, **Header, rcc::BranchProbability::one()),
                  "reducible loop CFG construction must succeed");
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   Context.expect(rcc::registerStage8MachineAnalyses(Analyses).has_value(),
                  "standard Stage 8 analyses must register atomically");
   auto Dominators = Analyses.getResult<rcc::MachineDominatorTreeAnalysis>(**Function, Target);
@@ -129,7 +129,7 @@ void testCFGAnalyses(TestContext &Context, const rcc::TargetDescription &Target)
   Context.expect(
       Analyses.cachedResultCount(**Function) == 1 &&
           Analyses.hasCached(**Function,
-                             rcc::MachineAnalysisManager::id<rcc::MachineAliasAnalysis>()),
+                             rcc::MachineFunctionAnalysisManager::id<rcc::MachineAliasAnalysis>()),
       "CFG changes must invalidate CFG dependents and memory dependence but preserve aliasing");
 
   auto RefreshedDominators =
@@ -167,7 +167,7 @@ void testIrreducibleCFG(TestContext &Context, const rcc::TargetDescription &Targ
                      Updater.addSuccessor(**Right, **Exit, *Half),
                  "irreducible CFG construction must succeed");
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage8MachineAnalyses(Analyses);
   auto Loops =
       Registered
@@ -317,7 +317,7 @@ void testMemoryDependence(TestContext &Context, const rcc::TargetDescription &Ta
       !VolatileStoreInstruction || !VolatileLoadInstruction || !OtherBlockLoadInstruction)
     return;
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage8MachineAnalyses(Analyses);
   auto Dependencies =
       Registered ? Analyses.getResult<rcc::MachineMemoryDependenceAnalysis>(**Function, Target)
@@ -352,14 +352,15 @@ void testMemoryDependence(TestContext &Context, const rcc::TargetDescription &Ta
 class ConflictingAnalysis final {
 public:
   struct Result final {};
-  [[nodiscard]] static rcc::Expected<Result>
-  run(rcc::MachineFunction &, const rcc::TargetDescription &, rcc::MachineAnalysisManager &) {
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
     return Result{};
   }
 };
 
 void testAtomicStandardRegistration(TestContext &Context) {
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   Context.expect(Analyses
                      .registerAnalysis<ConflictingAnalysis>({
                          .Name = "MachineLoopInfo",
@@ -367,10 +368,11 @@ void testAtomicStandardRegistration(TestContext &Context) {
                      })
                      .has_value(),
                  "analysis-name conflict setup must succeed");
-  Context.expect(!rcc::registerStage8MachineAnalyses(Analyses) &&
-                     !Analyses.isRegistered(
-                         rcc::MachineAnalysisManager::id<rcc::MachineDominatorTreeAnalysis>()),
-                 "failed standard-analysis registration must not publish a partial set");
+  Context.expect(
+      !rcc::registerStage8MachineAnalyses(Analyses) &&
+          !Analyses.isRegistered(
+              rcc::MachineFunctionAnalysisManager::id<rcc::MachineDominatorTreeAnalysis>()),
+      "failed standard-analysis registration must not publish a partial set");
 }
 
 void testCFGUpdaterPHIs(TestContext &Context, const rcc::TargetDescription &Target) {
diff --git a/backend/unittests/CodeGen/MachineOptimizationTest.cpp b/backend/unittests/CodeGen/MachineOptimizationTest.cpp
index d246e39..bb2c0e1 100644
--- a/backend/unittests/CodeGen/MachineOptimizationTest.cpp
+++ b/backend/unittests/CodeGen/MachineOptimizationTest.cpp
@@ -321,7 +321,7 @@ void testDCEFixedPointAndDebugUses(TestContext &Context, const rcc::TargetDescri
   }
   const std::size_t Before = Fixture.Entry->instructionCount();
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineDCEPass Pass;
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
   if (!Result)
@@ -369,7 +369,7 @@ void testMachineCombinerIdentityRules(TestContext &Context, const rcc::TargetDes
     return;
   (void)buildStore(Context, Builder, Consumer, X2, *Memory);
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineCombinerPass Pass(rcc::riscv::machineCombinerInfo(),
                                 rcc::MachineCombinerStage::SelectedSSA);
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
@@ -404,7 +404,7 @@ void testPostRAMachineCombinerIdentity(TestContext &Context, const rcc::TargetDe
                                                rcc::Register::fromPhysical(X10), 0);
   if (FrameIdentity != nullptr)
     FrameIdentity->setFlags({rcc::MachineInstrFlag::FrameDestroy});
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineCombinerPass Pass(rcc::riscv::machineCombinerInfo(),
                                 rcc::MachineCombinerStage::PostRegisterAllocation);
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
@@ -450,7 +450,7 @@ void testCSERegisterAndMemoryRules(TestContext &Context, const rcc::TargetDescri
   rcc::MachineInstr *InvariantTwo =
       buildLoad(Context, Builder, InvariantLoadTwo, Seed, *InvariantMemory);
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineCSEPass Pass;
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
   if (!Result)
@@ -490,7 +490,7 @@ void testCSEBudgetPreservesLegalMIR(TestContext &Context, const rcc::TargetDescr
   (void)buildADDI(Context, Builder, First, Seed, 2);
   rcc::MachineInstr *SecondInstruction = buildADDI(Context, Builder, Second, Seed, 2);
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineCSEPass Pass({.MaximumComparisons = 0});
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
   if (!Result)
@@ -545,7 +545,7 @@ void testLICMHoistsOnlyInvariantInstructions(TestContext &Context,
   rcc::MachineInstr *Load =
       Memory == nullptr ? nullptr : buildLoad(Context, Builder, MutableLoad, Seed, *Memory);
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineLICMPass Pass;
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
   if (!Result)
@@ -597,7 +597,7 @@ void testMachineSinkUsesColdUniqueSuccessor(TestContext &Context,
   const rcc::Register Consumer = makeGPR(Context, *Fixture.Function);
   rcc::MachineInstr *Use = buildADD(Context, Builder, Consumer, SunkValue, Seed);
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineSinkPass Pass;
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
   if (!Result)
@@ -664,7 +664,7 @@ void testPostRACodeMotion(TestContext &Context, const rcc::TargetDescription &Ta
   setPostRAProperties(*LICMFixture.Function);
   Context.expect(rcc::rebuildMachineLiveness(*LICMFixture.Function, Target).has_value(),
                  "post-RA LICM fixture liveness must be built");
-  rcc::MachineAnalysisManager LICMAnalyses;
+  rcc::MachineFunctionAnalysisManager LICMAnalyses;
   rcc::MachineLICMPass PostRALICM(rcc::MachineCodeMotionStage::PostRegisterAllocation);
   auto LICMResult = PostRALICM.run(*LICMFixture.Function, Target, LICMAnalyses);
   Context.expect(LICMResult && LICMResult->Changed && Hoisted->parent() == LICMFixture.Entry &&
@@ -703,7 +703,7 @@ void testPostRACodeMotion(TestContext &Context, const rcc::TargetDescription &Ta
   setPostRAProperties(*SinkFixture.Function);
   Context.expect(rcc::rebuildMachineLiveness(*SinkFixture.Function, Target).has_value(),
                  "post-RA sink fixture liveness must be built");
-  rcc::MachineAnalysisManager SinkAnalyses;
+  rcc::MachineFunctionAnalysisManager SinkAnalyses;
   rcc::MachineSinkPass PostRASink(rcc::MachineCodeMotionStage::PostRegisterAllocation);
   auto SinkResult = PostRASink.run(*SinkFixture.Function, Target, SinkAnalyses);
   Context.expect(SinkResult && SinkResult->Changed && Sunk->parent() == *Cold &&
@@ -742,7 +742,7 @@ void testMemoryFoldingContract(TestContext &Context, const rcc::TargetDescriptio
   if (!Folded.Function || Folded.Entry == nullptr)
     return;
   TestMemoryFoldingInfo GoodInfo;
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineMemoryFoldingPass Pass(GoodInfo);
   auto Result = Pass.run(*Folded.Function, Target, Analyses);
   if (!Result)
diff --git a/backend/unittests/CodeGen/MachinePassManagerTest.cpp b/backend/unittests/CodeGen/MachinePassManagerTest.cpp
new file mode 100644
index 0000000..6e6c44d
--- /dev/null
+++ b/backend/unittests/CodeGen/MachinePassManagerTest.cpp
@@ -0,0 +1,426 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "rcc/CodeGen/MachinePassManager.h"
+
+#include "Target/TestTarget.h"
+#include "rcc/CodeGen/CompilationUnit.h"
+#include "rcc/CodeGen/GenericOpcodes.h"
+#include "rcc/CodeGen/MachineFunction.h"
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace {
+
+class TestContext final {
+public:
+  void expect(bool Condition, std::string_view Message) {
+    if (Condition)
+      return;
+    std::cerr << Message << '\n';
+    ++Failures;
+  }
+
+  [[nodiscard]] int result() const noexcept {
+    return Failures == 0 ? 0 : 1;
+  }
+
+private:
+  int Failures = 0;
+};
+
+[[nodiscard]] rcc::Expected<rcc::TargetDescription> createTarget() {
+  std::vector<rcc::InstructionDescriptor> Descriptors;
+  std::vector<rcc::ImmediatePredicate> Predicates;
+  auto Appended = rcc::appendGenericInstructionInfo(Descriptors, Predicates);
+  if (!Appended)
+    return std::unexpected(Appended.error());
+  auto Instructions = rcc::InstructionSet::create(std::move(Descriptors), std::move(Predicates));
+  if (!Instructions)
+    return std::unexpected(Instructions.error());
+  return rcc::test::createTestTargetDescription(std::move(*Instructions));
+}
+
+class BlockCountAnalysis final {
+public:
+  struct Result final {
+    std::size_t Count = 0;
+  };
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "BlockCount";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &Function,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
+    return Result{Function.blockCount()};
+  }
+};
+
+class NonThreadSafeAnalysis final {
+public:
+  struct Result final {};
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "NonThreadSafe";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
+    return Result{};
+  }
+};
+
+class RequiredAnalysisPass final : public rcc::MachineFunctionPass {
+public:
+  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
+    static const rcc::MachinePassContract Contract{
+        .Name = "RequiredAnalysis",
+        .Requires = {},
+        .Sets = {},
+        .Clears = {},
+        .RequiredAnalyses = {rcc::MachineFunctionAnalysisManager::id<BlockCountAnalysis>()},
+        .VerificationStage = std::nullopt,
+    };
+    return Contract;
+  }
+
+  [[nodiscard]] rcc::Expected<rcc::MachinePassResult>
+  run(rcc::MachineFunction &Function, const rcc::TargetDescription &Target,
+      rcc::MachineFunctionAnalysisManager &Analyses) override {
+    auto Blocks = Analyses.getResult<BlockCountAnalysis>(Function, Target);
+    if (!Blocks)
+      return std::unexpected(Blocks.error());
+    rcc::MachinePassResult Result;
+    Result.Preserved = rcc::PreservedAnalyses::all();
+    return Result;
+  }
+};
+
+class UnreportedChangePass final : public rcc::MachineFunctionPass {
+public:
+  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
+    static const rcc::MachinePassContract Contract{
+        .Name = "UnreportedChange",
+        .Requires = {},
+        .Sets = {},
+        .Clears = {},
+        .RequiredAnalyses = {},
+        .VerificationStage = std::nullopt,
+    };
+    return Contract;
+  }
+
+  [[nodiscard]] rcc::Expected<rcc::MachinePassResult>
+  run(rcc::MachineFunction &Function, const rcc::TargetDescription &,
+      rcc::MachineFunctionAnalysisManager &) override {
+    auto Block = Function.createBasicBlock();
+    if (!Block)
+      return std::unexpected(Block.error());
+    auto Appended = Function.appendBlock(**Block);
+    if (!Appended)
+      return std::unexpected(Appended.error());
+    return rcc::MachinePassResult{};
+  }
+};
+
+class MutatingFailurePass final : public rcc::MachineFunctionPass {
+public:
+  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
+    static const rcc::MachinePassContract Contract{
+        .Name = "MutatingFailure",
+        .Requires = {},
+        .Sets = {},
+        .Clears = {},
+        .RequiredAnalyses = {rcc::MachineFunctionAnalysisManager::id<BlockCountAnalysis>()},
+        .VerificationStage = std::nullopt,
+    };
+    return Contract;
+  }
+
+  [[nodiscard]] rcc::Expected<rcc::MachinePassResult>
+  run(rcc::MachineFunction &Function, const rcc::TargetDescription &,
+      rcc::MachineFunctionAnalysisManager &) override {
+    auto Block = Function.createBasicBlock();
+    if (!Block)
+      return std::unexpected(Block.error());
+    auto Appended = Function.appendBlock(**Block);
+    if (!Appended)
+      return std::unexpected(Appended.error());
+    return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
+                               "intentional mutating pass failure");
+  }
+};
+
+class ParallelCountingPass final : public rcc::MachineFunctionPass {
+public:
+  explicit ParallelCountingPass(std::atomic<std::uint32_t> &Count) : Count(&Count) {}
+
+  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
+    static const rcc::MachinePassContract Contract = [] {
+      rcc::MachinePassContract Value{
+          .Name = "ParallelCounting",
+          .Requires = {},
+          .Sets = {},
+          .Clears = {},
+          .RequiredAnalyses = {},
+          .VerificationStage = std::nullopt,
+      };
+      Value.ThreadSafety = rcc::PassThreadSafety::ThreadSafe;
+      return Value;
+    }();
+    return Contract;
+  }
+
+  [[nodiscard]] rcc::Expected<rcc::MachinePassResult>
+  run(rcc::MachineFunction &, const rcc::TargetDescription &,
+      rcc::MachineFunctionAnalysisManager &) override {
+    Count->fetch_add(1, std::memory_order_relaxed);
+    return rcc::MachinePassResult{};
+  }
+
+private:
+  std::atomic<std::uint32_t> *Count;
+};
+
+class RequiresNonThreadSafeAnalysisPass final : public rcc::MachineFunctionPass {
+public:
+  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
+    static const rcc::MachinePassContract Contract = [] {
+      rcc::MachinePassContract Value{
+          .Name = "RequiresNonThreadSafe",
+          .Requires = {},
+          .Sets = {},
+          .Clears = {},
+          .RequiredAnalyses =
+              {
+                  rcc::MachineFunctionAnalysisManager::id<NonThreadSafeAnalysis>(),
+              },
+          .VerificationStage = std::nullopt,
+      };
+      Value.ThreadSafety = rcc::PassThreadSafety::ThreadSafe;
+      return Value;
+    }();
+    return Contract;
+  }
+
+  [[nodiscard]] rcc::Expected<rcc::MachinePassResult>
+  run(rcc::MachineFunction &, const rcc::TargetDescription &,
+      rcc::MachineFunctionAnalysisManager &) override {
+    return rcc::MachinePassResult{};
+  }
+};
+
+class UnitFunctionCountAnalysis final {
+public:
+  struct Result final {
+    std::size_t Count = 0;
+  };
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "UnitFunctionCount";
+  }
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::CompilationUnit &Unit,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::CompilationUnitAnalysisManager &) {
+    return Result{Unit.functionCount()};
+  }
+};
+
+class ObserveUnitPass final : public rcc::CompilationUnitPass {
+public:
+  [[nodiscard]] const rcc::CompilationUnitPassContract &contract() const noexcept override {
+    static const rcc::CompilationUnitPassContract Contract{
+        .Name = "ObserveUnit",
+        .RequiredAnalyses = {rcc::CompilationUnitAnalysisManager::id<UnitFunctionCountAnalysis>()},
+        .Parameters = {},
+        .DeclaredChanges = {},
+    };
+    return Contract;
+  }
+
+  [[nodiscard]] rcc::Expected<rcc::CompilationUnitPassResult>
+  run(rcc::CompilationUnit &Unit, const rcc::TargetDescription &Target,
+      rcc::CompilationUnitAnalysisManager &Analyses,
+      rcc::MachineFunctionAnalysisManager &) override {
+    auto Count = Analyses.getResult<UnitFunctionCountAnalysis>(Unit, Target);
+    if (!Count)
+      return std::unexpected(Count.error());
+    if ((*Count)->Count != Unit.functionCount()) {
+      return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
+                                 "unit analysis returned a stale function count");
+    }
+    return rcc::CompilationUnitPassResult{};
+  }
+};
+
+class MutatingUnitFailurePass final : public rcc::CompilationUnitPass {
+public:
+  [[nodiscard]] const rcc::CompilationUnitPassContract &contract() const noexcept override {
+    static const rcc::CompilationUnitPassContract Contract{
+        .Name = "MutatingUnitFailure",
+        .RequiredAnalyses = {rcc::CompilationUnitAnalysisManager::id<UnitFunctionCountAnalysis>()},
+        .Parameters = {},
+        .DeclaredChanges = {rcc::MachinePassChange::BlockLayout},
+    };
+    return Contract;
+  }
+
+  [[nodiscard]] rcc::Expected<rcc::CompilationUnitPassResult>
+  run(rcc::CompilationUnit &Unit, const rcc::TargetDescription &,
+      rcc::CompilationUnitAnalysisManager &, rcc::MachineFunctionAnalysisManager &) override {
+    auto Created = Unit.createMachineFunction("added-before-failure");
+    if (!Created)
+      return std::unexpected(Created.error());
+    return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
+                               "intentional compilation-unit pass failure");
+  }
+};
+
+void testMachinePassManager(TestContext &Context, const rcc::TargetDescription &Target) {
+  auto Function = rcc::MachineFunction::create("pass", rcc::MachineFunctionStableID::fromValue(2));
+  Context.expect(Function.has_value(), "pass function creation must succeed");
+  if (!Function)
+    return;
+
+  rcc::MachineFunctionAnalysisManager Analyses;
+  Context.expect(Analyses
+                     .registerAnalysis<BlockCountAnalysis>({
+                         .Name = "BlockCount",
+                         .Dependencies = {},
+                         .InvalidatedBy = rcc::MachinePassChanges::all(),
+                         .ThreadSafety = rcc::PassThreadSafety::ThreadSafe,
+                     })
+                     .has_value(),
+                 "pass analysis registration must succeed");
+
+  rcc::MachineFunctionPassManager Pipeline;
+  Context.expect(Pipeline.addPass(std::make_unique<RequiredAnalysisPass>()).has_value(),
+                 "a valid pass must be accepted");
+  auto Run = Pipeline.run(**Function, Target, Analyses);
+  Context.expect(Run.has_value(), "a pass with a materialized required analysis must run");
+
+  auto ChangedFunction =
+      rcc::MachineFunction::create("unreported", rcc::MachineFunctionStableID::fromValue(3));
+  rcc::MachineFunctionAnalysisManager EmptyAnalyses;
+  rcc::MachineFunctionPassManager Detecting(
+      {.VerifyBefore = true, .VerifyEach = true, .DetectUnreportedChanges = true});
+  Context.expect(ChangedFunction &&
+                     Detecting.addPass(std::make_unique<UnreportedChangePass>()).has_value() &&
+                     !Detecting.run(**ChangedFunction, Target, EmptyAnalyses),
+                 "change detection must reject an unreported MachineIR mutation");
+
+  auto FailedFunction =
+      rcc::MachineFunction::create("failed", rcc::MachineFunctionStableID::fromValue(4));
+  rcc::MachineFunctionAnalysisManager FailureAnalyses;
+  Context.expect(FailedFunction && FailureAnalyses
+                                       .registerAnalysis<BlockCountAnalysis>({
+                                           .Name = "BlockCount",
+                                           .Dependencies = {},
+                                           .InvalidatedBy = rcc::MachinePassChanges::all(),
+                                       })
+                                       .has_value(),
+                 "mutating failure analysis fixtures must be valid");
+  rcc::MachineFunctionPassManager FailingPipeline;
+  Context.expect(
+      FailedFunction &&
+          FailingPipeline.addPass(std::make_unique<MutatingFailurePass>()).has_value() &&
+          !FailingPipeline.run(**FailedFunction, Target, FailureAnalyses) &&
+          !FailureAnalyses.hasCached(**FailedFunction,
+                                     rcc::MachineFunctionAnalysisManager::id<BlockCountAnalysis>()),
+      "a pass that mutates and fails must not leave stale function analyses cached");
+}
+
+void testCompilationUnitAndParallelism(TestContext &Context, const rcc::TargetDescription &Target) {
+  rcc::CompilationUnit Unit;
+  for (std::size_t Index = 0; Index < 8; ++Index) {
+    auto Function = Unit.createMachineFunction("f" + std::to_string(Index));
+    Context.expect(Function.has_value(), "parallel test function creation must succeed");
+  }
+
+  std::atomic<std::uint32_t> Runs = 0;
+  rcc::MachineFunctionPassManager Parallel;
+  Context.expect(Parallel.addPass(std::make_unique<ParallelCountingPass>(Runs)).has_value(),
+                 "thread-safe pass registration must succeed");
+  rcc::MachineFunctionAnalysisManager Prototype;
+  auto ParallelRun = Parallel.runFunctions(Unit, Target, Prototype, std::size_t{4});
+  Context.expect(ParallelRun.has_value() && Runs == Unit.functionCount(),
+                 "parallel function execution must visit every function exactly once");
+
+  rcc::MachineFunctionAnalysisManager UnsafePrototype;
+  Context.expect(UnsafePrototype
+                     .registerAnalysis<NonThreadSafeAnalysis>({
+                         .Name = "NonThreadSafe",
+                         .Dependencies = {},
+                         .InvalidatedBy = rcc::MachinePassChanges::all(),
+                         .ThreadSafety = rcc::PassThreadSafety::NotThreadSafe,
+                     })
+                     .has_value(),
+                 "non-thread-safe analysis registration must be explicit");
+  rcc::MachineFunctionPassManager UnsafeParallel;
+  Context.expect(
+      UnsafeParallel.addPass(std::make_unique<RequiresNonThreadSafeAnalysisPass>()).has_value() &&
+          !UnsafeParallel.runFunctions(Unit, Target, UnsafePrototype, std::size_t{4}),
+      "parallel pipelines must reject a required analysis not marked thread-safe");
+
+  rcc::CompilationUnitAnalysisManager UnitAnalyses;
+  Context.expect(UnitAnalyses
+                     .registerAnalysis<UnitFunctionCountAnalysis>({
+                         .Name = "UnitFunctionCount",
+                         .Dependencies = {},
+                         .InvalidatedBy = rcc::MachinePassChanges::all(),
+                     })
+                     .has_value(),
+                 "compilation-unit analysis registration must succeed");
+  rcc::MachineFunctionAnalysisManager FunctionAnalyses;
+  rcc::CompilationUnitPassManager UnitPipeline;
+  Context.expect(UnitPipeline.addPass(std::make_unique<ObserveUnitPass>()).has_value(),
+                 "compilation-unit pass registration must succeed");
+  Context.expect(UnitPipeline.run(Unit, Target, UnitAnalyses, FunctionAnalyses).has_value(),
+                 "compilation-unit pass and analysis must run through their own manager");
+
+  rcc::MachineFunction *FirstFunction = Unit.functionAt(0);
+  Context.expect(
+      FirstFunction != nullptr &&
+          FunctionAnalyses
+              .registerAnalysis<BlockCountAnalysis>({
+                  .Name = "BlockCount",
+                  .Dependencies = {},
+                  .InvalidatedBy = rcc::MachinePassChanges::all(),
+              })
+              .has_value() &&
+          FunctionAnalyses.getResult<BlockCountAnalysis>(*FirstFunction, Target).has_value(),
+      "compilation-unit failure cache fixtures must materialize");
+  rcc::CompilationUnitPassManager FailingUnitPipeline;
+  Context.expect(
+      FirstFunction != nullptr &&
+          FailingUnitPipeline.addPass(std::make_unique<MutatingUnitFailurePass>()).has_value() &&
+          !FailingUnitPipeline.run(Unit, Target, UnitAnalyses, FunctionAnalyses) &&
+          !UnitAnalyses.hasCached(
+              Unit, rcc::CompilationUnitAnalysisManager::id<UnitFunctionCountAnalysis>()) &&
+          !FunctionAnalyses.hasCached(
+              *FirstFunction, rcc::MachineFunctionAnalysisManager::id<BlockCountAnalysis>()),
+      "a mutating compilation-unit failure must clear unit and function analysis caches");
+}
+
+} // namespace
+
+int main() {
+  TestContext Context;
+  auto Target = createTarget();
+  Context.expect(Target.has_value(), "machine pass tests require a valid target description");
+  if (!Target)
+    return Context.result();
+
+  testMachinePassManager(Context, *Target);
+  testCompilationUnitAndParallelism(Context, *Target);
+  return Context.result();
+}
diff --git a/backend/unittests/CodeGen/MachinePassTest.cpp b/backend/unittests/CodeGen/MachinePassTest.cpp
deleted file mode 100644
index fb125a4..0000000
--- a/backend/unittests/CodeGen/MachinePassTest.cpp
+++ /dev/null
@@ -1,918 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "rcc/CodeGen/MachinePass.h"
-
-#include "Target/TestTarget.h"
-#include "rcc/CodeGen/CompilationUnit.h"
-#include "rcc/CodeGen/GenericOpcodes.h"
-#include "rcc/CodeGen/MachineFunction.h"
-
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <cstddef>
-#include <cstdint>
-#include <iostream>
-#include <memory>
-#include <ranges>
-#include <string>
-#include <string_view>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace {
-
-class TestContext final {
-public:
-  void expect(bool Condition, std::string_view Message) {
-    if (Condition)
-      return;
-    std::cerr << Message << '\n';
-    ++Failures;
-  }
-
-  [[nodiscard]] int result() const noexcept {
-    return Failures == 0 ? 0 : 1;
-  }
-
-private:
-  int Failures = 0;
-};
-
-[[nodiscard]] rcc::Expected<rcc::TargetDescription> createTarget() {
-  std::vector<rcc::InstructionDescriptor> Descriptors;
-  std::vector<rcc::ImmediatePredicate> Predicates;
-  auto Appended = rcc::appendGenericInstructionInfo(Descriptors, Predicates);
-  if (!Appended)
-    return std::unexpected(Appended.error());
-  auto Instructions = rcc::InstructionSet::create(std::move(Descriptors), std::move(Predicates));
-  if (!Instructions)
-    return std::unexpected(Instructions.error());
-  return rcc::test::createTestTargetDescription(std::move(*Instructions));
-}
-
-class BlockCountAnalysis final {
-public:
-  struct Result final {
-    std::size_t Count = 0;
-  };
-
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "BlockCount";
-  }
-
-  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &Function,
-                                                 const rcc::TargetDescription &,
-                                                 rcc::MachineAnalysisManager &) {
-    ++Runs;
-    return Result{Function.blockCount()};
-  }
-
-  static inline std::atomic<std::uint32_t> Runs = 0;
-};
-
-class DependentAnalysis final {
-public:
-  struct Result final {
-    std::size_t Count = 0;
-  };
-
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "Dependent";
-  }
-
-  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &Function,
-                                                 const rcc::TargetDescription &Target,
-                                                 rcc::MachineAnalysisManager &Analyses) {
-    auto Blocks = Analyses.getResult<BlockCountAnalysis>(Function, Target);
-    if (!Blocks)
-      return std::unexpected(Blocks.error());
-    return Result{(*Blocks)->Count};
-  }
-};
-
-class NonThreadSafeAnalysis final {
-public:
-  struct Result final {};
-
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "NonThreadSafe";
-  }
-
-  [[nodiscard]] static rcc::Expected<Result>
-  run(rcc::MachineFunction &, const rcc::TargetDescription &, rcc::MachineAnalysisManager &) {
-    return Result{};
-  }
-};
-
-class FailingAnalysis final {
-public:
-  struct Result final {};
-
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "Failing";
-  }
-
-  [[nodiscard]] static rcc::Expected<Result>
-  run(rcc::MachineFunction &, const rcc::TargetDescription &, rcc::MachineAnalysisManager &) {
-    return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
-                               "intentional machine analysis failure");
-  }
-};
-
-class StickyAnalysis final {
-public:
-  struct Result final {
-    [[nodiscard]] bool invalidate(const rcc::MachineFunction &,
-                                  const rcc::PreservedAnalyses &) noexcept {
-      return false;
-    }
-  };
-
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "Sticky";
-  }
-  [[nodiscard]] static rcc::Expected<Result>
-  run(rcc::MachineFunction &, const rcc::TargetDescription &, rcc::MachineAnalysisManager &) {
-    return Result{};
-  }
-};
-
-class ExpiringAnalysis final {
-public:
-  struct Result final {
-    [[nodiscard]] bool invalidate(const rcc::MachineFunction &,
-                                  const rcc::PreservedAnalyses &) noexcept {
-      return true;
-    }
-  };
-
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "Expiring";
-  }
-  [[nodiscard]] static rcc::Expected<Result>
-  run(rcc::MachineFunction &, const rcc::TargetDescription &, rcc::MachineAnalysisManager &) {
-    return Result{};
-  }
-};
-
-class CycleA final {
-public:
-  struct Result final {};
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "CycleA";
-  }
-  [[nodiscard]] static rcc::Expected<Result>
-  run(rcc::MachineFunction &, const rcc::TargetDescription &, rcc::MachineAnalysisManager &) {
-    return Result{};
-  }
-};
-
-class CycleB final {
-public:
-  struct Result final {};
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "CycleB";
-  }
-  [[nodiscard]] static rcc::Expected<Result>
-  run(rcc::MachineFunction &, const rcc::TargetDescription &, rcc::MachineAnalysisManager &) {
-    return Result{};
-  }
-};
-
-class RequiredAnalysisPass final : public rcc::MachineFunctionPass {
-public:
-  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
-    static const rcc::MachinePassContract Contract{
-        .Name = "RequiredAnalysis",
-        .Requires = {},
-        .Sets = {},
-        .Clears = {},
-        .RequiredAnalyses = {rcc::MachineAnalysisManager::id<DependentAnalysis>()},
-        .VerificationStage = std::nullopt,
-    };
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::MachinePassResult>
-  run(rcc::MachineFunction &Function, const rcc::TargetDescription &Target,
-      rcc::MachineAnalysisManager &Analyses) override {
-    auto Dependent = Analyses.getResult<DependentAnalysis>(Function, Target);
-    if (!Dependent)
-      return std::unexpected(Dependent.error());
-    auto FirstAction = Analyses.requestAction("first", Function);
-    auto SecondAction = Analyses.requestAction("second", Function);
-    if (!FirstAction || !SecondAction || !*FirstAction || *SecondAction) {
-      return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
-                                 "per-function action fuel was not enforced");
-    }
-    rcc::MachinePassResult Result;
-    Result.Preserved = rcc::PreservedAnalyses::all();
-    return Result;
-  }
-};
-
-class UnreportedChangePass final : public rcc::MachineFunctionPass {
-public:
-  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
-    static const rcc::MachinePassContract Contract{
-        .Name = "UnreportedChange",
-        .Requires = {},
-        .Sets = {},
-        .Clears = {},
-        .RequiredAnalyses = {},
-        .VerificationStage = std::nullopt,
-    };
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::MachinePassResult> run(rcc::MachineFunction &Function,
-                                                          const rcc::TargetDescription &,
-                                                          rcc::MachineAnalysisManager &) override {
-    auto Block = Function.createBasicBlock();
-    if (!Block)
-      return std::unexpected(Block.error());
-    auto Appended = Function.appendBlock(**Block);
-    if (!Appended)
-      return std::unexpected(Appended.error());
-    return rcc::MachinePassResult{};
-  }
-};
-
-class RequiresFailingAnalysisPass final : public rcc::MachineFunctionPass {
-public:
-  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
-    static const rcc::MachinePassContract Contract{
-        .Name = "RequiresFailingAnalysis",
-        .Requires = {},
-        .Sets = {},
-        .Clears = {},
-        .RequiredAnalyses = {rcc::MachineAnalysisManager::id<FailingAnalysis>()},
-        .VerificationStage = std::nullopt,
-    };
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::MachinePassResult> run(rcc::MachineFunction &,
-                                                          const rcc::TargetDescription &,
-                                                          rcc::MachineAnalysisManager &) override {
-    return rcc::MachinePassResult{};
-  }
-};
-
-class MutatingFailurePass final : public rcc::MachineFunctionPass {
-public:
-  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
-    static const rcc::MachinePassContract Contract{
-        .Name = "MutatingFailure",
-        .Requires = {},
-        .Sets = {},
-        .Clears = {},
-        .RequiredAnalyses = {rcc::MachineAnalysisManager::id<BlockCountAnalysis>()},
-        .VerificationStage = std::nullopt,
-    };
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::MachinePassResult> run(rcc::MachineFunction &Function,
-                                                          const rcc::TargetDescription &,
-                                                          rcc::MachineAnalysisManager &) override {
-    auto Block = Function.createBasicBlock();
-    if (!Block)
-      return std::unexpected(Block.error());
-    auto Appended = Function.appendBlock(**Block);
-    if (!Appended)
-      return std::unexpected(Appended.error());
-    return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
-                               "intentional mutating pass failure");
-  }
-};
-
-class ParallelCountingPass final : public rcc::MachineFunctionPass {
-public:
-  explicit ParallelCountingPass(std::atomic<std::uint32_t> &Count) : Count(&Count) {}
-
-  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
-    static const rcc::MachinePassContract Contract = [] {
-      rcc::MachinePassContract Value{
-          .Name = "ParallelCounting",
-          .Requires = {},
-          .Sets = {},
-          .Clears = {},
-          .RequiredAnalyses = {},
-          .VerificationStage = std::nullopt,
-      };
-      Value.ThreadSafety = rcc::PassThreadSafety::ThreadSafe;
-      return Value;
-    }();
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::MachinePassResult> run(rcc::MachineFunction &,
-                                                          const rcc::TargetDescription &,
-                                                          rcc::MachineAnalysisManager &) override {
-    Count->fetch_add(1, std::memory_order_relaxed);
-    return rcc::MachinePassResult{};
-  }
-
-private:
-  std::atomic<std::uint32_t> *Count;
-};
-
-class InstrumentedParallelPass final : public rcc::MachineFunctionPass {
-public:
-  InstrumentedParallelPass(std::atomic<std::uint32_t> &Runs, std::atomic<std::uint32_t> &Active,
-                           std::atomic<std::uint32_t> &MaximumActive)
-      : Runs(&Runs), Active(&Active), MaximumActive(&MaximumActive) {}
-
-  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
-    static const rcc::MachinePassContract Contract = [] {
-      rcc::MachinePassContract Value{
-          .Name = "InstrumentedParallel",
-          .Requires = {},
-          .Sets = {},
-          .Clears = {},
-          .RequiredAnalyses = {},
-          .VerificationStage = std::nullopt,
-      };
-      Value.ThreadSafety = rcc::PassThreadSafety::ThreadSafe;
-      Value.DeclaredChanges = {rcc::MachinePassChange::BlockLayout};
-      return Value;
-    }();
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::MachinePassResult> run(rcc::MachineFunction &Function,
-                                                          const rcc::TargetDescription &,
-                                                          rcc::MachineAnalysisManager &) override {
-    const std::uint32_t Current = Active->fetch_add(1, std::memory_order_acq_rel) + 1U;
-    std::uint32_t Maximum = MaximumActive->load(std::memory_order_relaxed);
-    while (Maximum < Current &&
-           !MaximumActive->compare_exchange_weak(Maximum, Current, std::memory_order_relaxed)) {
-    }
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-    auto Block = Function.createBasicBlock();
-    if (!Block) {
-      Active->fetch_sub(1, std::memory_order_acq_rel);
-      return std::unexpected(Block.error());
-    }
-    auto Appended = Function.appendBlock(**Block);
-    Active->fetch_sub(1, std::memory_order_acq_rel);
-    if (!Appended)
-      return std::unexpected(Appended.error());
-    Runs->fetch_add(1, std::memory_order_relaxed);
-    rcc::MachinePassResult Result;
-    Result.Changed = true;
-    Result.Changes.add(rcc::MachinePassChange::BlockLayout);
-    return Result;
-  }
-
-private:
-  std::atomic<std::uint32_t> *Runs;
-  std::atomic<std::uint32_t> *Active;
-  std::atomic<std::uint32_t> *MaximumActive;
-};
-
-class RequiresNonThreadSafeAnalysisPass final : public rcc::MachineFunctionPass {
-public:
-  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
-    static const rcc::MachinePassContract Contract = [] {
-      rcc::MachinePassContract Value{
-          .Name = "RequiresNonThreadSafe",
-          .Requires = {},
-          .Sets = {},
-          .Clears = {},
-          .RequiredAnalyses =
-              {
-                  rcc::MachineAnalysisManager::id<NonThreadSafeAnalysis>(),
-              },
-          .VerificationStage = std::nullopt,
-      };
-      Value.ThreadSafety = rcc::PassThreadSafety::ThreadSafe;
-      return Value;
-    }();
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::MachinePassResult> run(rcc::MachineFunction &,
-                                                          const rcc::TargetDescription &,
-                                                          rcc::MachineAnalysisManager &) override {
-    return rcc::MachinePassResult{};
-  }
-};
-
-class UnitFunctionCountAnalysis final {
-public:
-  struct Result final {
-    std::size_t Count = 0;
-  };
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "UnitFunctionCount";
-  }
-  [[nodiscard]] static rcc::Expected<Result> run(rcc::CompilationUnit &Unit,
-                                                 const rcc::TargetDescription &,
-                                                 rcc::CompilationUnitAnalysisManager &) {
-    return Result{Unit.functionCount()};
-  }
-};
-
-class FailingUnitAnalysis final {
-public:
-  struct Result final {};
-
-  [[nodiscard]] static constexpr std::string_view name() noexcept {
-    return "FailingUnit";
-  }
-
-  [[nodiscard]] static rcc::Expected<Result> run(rcc::CompilationUnit &,
-                                                 const rcc::TargetDescription &,
-                                                 rcc::CompilationUnitAnalysisManager &) {
-    return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
-                               "intentional compilation-unit analysis failure");
-  }
-};
-
-class RequiresFailingUnitAnalysisPass final : public rcc::CompilationUnitPass {
-public:
-  [[nodiscard]] const rcc::CompilationUnitPassContract &contract() const noexcept override {
-    static const rcc::CompilationUnitPassContract Contract{
-        .Name = "RequiresFailingUnitAnalysis",
-        .RequiredAnalyses =
-            {
-                rcc::CompilationUnitAnalysisManager::id<FailingUnitAnalysis>(),
-            },
-        .Parameters = {},
-        .DeclaredChanges = {},
-    };
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::CompilationUnitPassResult>
-  run(rcc::CompilationUnit &, const rcc::TargetDescription &, rcc::CompilationUnitAnalysisManager &,
-      rcc::MachineAnalysisManager &) override {
-    return rcc::CompilationUnitPassResult{};
-  }
-};
-
-class ObserveUnitPass final : public rcc::CompilationUnitPass {
-public:
-  [[nodiscard]] const rcc::CompilationUnitPassContract &contract() const noexcept override {
-    static const rcc::CompilationUnitPassContract Contract{
-        .Name = "ObserveUnit",
-        .RequiredAnalyses = {rcc::CompilationUnitAnalysisManager::id<UnitFunctionCountAnalysis>()},
-        .Parameters = {},
-        .DeclaredChanges = {},
-    };
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::CompilationUnitPassResult>
-  run(rcc::CompilationUnit &Unit, const rcc::TargetDescription &Target,
-      rcc::CompilationUnitAnalysisManager &Analyses, rcc::MachineAnalysisManager &) override {
-    auto Count = Analyses.getResult<UnitFunctionCountAnalysis>(Unit, Target);
-    if (!Count)
-      return std::unexpected(Count.error());
-    if ((*Count)->Count != Unit.functionCount()) {
-      return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
-                                 "unit analysis returned a stale function count");
-    }
-    return rcc::CompilationUnitPassResult{};
-  }
-};
-
-class MutatingUnitFailurePass final : public rcc::CompilationUnitPass {
-public:
-  [[nodiscard]] const rcc::CompilationUnitPassContract &contract() const noexcept override {
-    static const rcc::CompilationUnitPassContract Contract{
-        .Name = "MutatingUnitFailure",
-        .RequiredAnalyses = {rcc::CompilationUnitAnalysisManager::id<UnitFunctionCountAnalysis>()},
-        .Parameters = {},
-        .DeclaredChanges = {rcc::MachinePassChange::BlockLayout},
-    };
-    return Contract;
-  }
-
-  [[nodiscard]] rcc::Expected<rcc::CompilationUnitPassResult>
-  run(rcc::CompilationUnit &Unit, const rcc::TargetDescription &,
-      rcc::CompilationUnitAnalysisManager &, rcc::MachineAnalysisManager &) override {
-    auto Created = Unit.createMachineFunction("added-before-failure");
-    if (!Created)
-      return std::unexpected(Created.error());
-    return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
-                               "intentional compilation-unit pass failure");
-  }
-};
-
-void testAnalysisInfrastructure(TestContext &Context, const rcc::TargetDescription &Target) {
-  auto Function =
-      rcc::MachineFunction::create("analysis", rcc::MachineFunctionStableID::fromValue(1));
-  Context.expect(Function.has_value(), "analysis function creation must succeed");
-  if (!Function)
-    return;
-
-  rcc::MachineAnalysisManager Analyses;
-  Context.expect(Analyses
-                     .registerAnalysis<BlockCountAnalysis>({
-                         .Name = "BlockCount",
-                         .Dependencies = {},
-                         .InvalidatedBy = {rcc::MachinePassChange::CFG},
-                     })
-                     .has_value(),
-                 "base analysis registration must succeed");
-  Context.expect(Analyses
-                     .registerAnalysis<DependentAnalysis>({
-                         .Name = "Dependent",
-                         .Dependencies = {rcc::MachineAnalysisManager::id<BlockCountAnalysis>()},
-                         .InvalidatedBy = {rcc::MachinePassChange::Operands},
-                     })
-                     .has_value(),
-                 "dependent analysis registration must succeed");
-
-  BlockCountAnalysis::Runs = 0;
-  auto First = Analyses.getResult<DependentAnalysis>(**Function, Target);
-  auto Second = Analyses.getResult<DependentAnalysis>(**Function, Target);
-  Context.expect(First && Second && *First == *Second && BlockCountAnalysis::Runs == 1,
-                 "analysis dependencies must materialize once and then use the cache");
-
-  Analyses.invalidate(**Function, rcc::PreservedAnalyses::none(),
-                      {rcc::MachinePassChange::Registers});
-  Context.expect(Analyses.cachedResultCount(**Function) == 2,
-                 "unrelated changes must preserve cached analyses precisely");
-  Analyses.invalidate(**Function, rcc::PreservedAnalyses::none(), {rcc::MachinePassChange::CFG});
-  Context.expect(Analyses.cachedResultCount(**Function) == 0,
-                 "invalidating a dependency must invalidate its dependent analysis");
-
-  rcc::MachineAnalysisManager Cyclic;
-  Context.expect(Cyclic
-                         .registerAnalysis<CycleA>({
-                             .Name = "CycleA",
-                             .Dependencies = {rcc::MachineAnalysisManager::id<CycleB>()},
-                         })
-                         .has_value() &&
-                     Cyclic
-                         .registerAnalysis<CycleB>({
-                             .Name = "CycleB",
-                             .Dependencies = {rcc::MachineAnalysisManager::id<CycleA>()},
-                         })
-                         .has_value(),
-                 "cyclic analysis registrations must be accepted until requested");
-  Context.expect(!Cyclic.getResult<CycleA>(**Function, Target),
-                 "analysis dependency cycles must produce a structured error");
-
-  rcc::MachineAnalysisManager CustomInvalidation;
-  Context.expect(CustomInvalidation
-                         .registerAnalysis<StickyAnalysis>({
-                             .Name = "Sticky",
-                             .Dependencies = {},
-                             .InvalidatedBy = {rcc::MachinePassChange::CFG},
-                         })
-                         .has_value() &&
-                     CustomInvalidation
-                         .registerAnalysis<ExpiringAnalysis>({
-                             .Name = "Expiring",
-                             .Dependencies = {},
-                             .InvalidatedBy = {rcc::MachinePassChange::CFG},
-                         })
-                         .has_value() &&
-                     CustomInvalidation.getResult<StickyAnalysis>(**Function, Target) &&
-                     CustomInvalidation.getResult<ExpiringAnalysis>(**Function, Target),
-                 "custom invalidation analyses must materialize");
-  CustomInvalidation.invalidate(**Function, rcc::PreservedAnalyses::none(),
-                                {rcc::MachinePassChange::CFG});
-  Context.expect(
-      CustomInvalidation.hasCached(**Function, rcc::MachineAnalysisManager::id<StickyAnalysis>()) &&
-          !CustomInvalidation.hasCached(**Function,
-                                        rcc::MachineAnalysisManager::id<ExpiringAnalysis>()),
-      "analysis invalidate() must return false to preserve and true to invalidate");
-}
-
-void testPassAndInstrumentation(TestContext &Context, const rcc::TargetDescription &Target) {
-  auto Function = rcc::MachineFunction::create("pass", rcc::MachineFunctionStableID::fromValue(2));
-  Context.expect(Function.has_value(), "pass function creation must succeed");
-  if (!Function)
-    return;
-
-  rcc::MachineAnalysisManager Analyses;
-  Context.expect(
-      Analyses
-              .registerAnalysis<BlockCountAnalysis>({
-                  .Name = "BlockCount",
-                  .Dependencies = {},
-                  .InvalidatedBy = rcc::MachinePassChanges::all(),
-                  .ThreadSafety = rcc::PassThreadSafety::ThreadSafe,
-              })
-              .has_value() &&
-          Analyses
-              .registerAnalysis<DependentAnalysis>({
-                  .Name = "Dependent",
-                  .Dependencies = {rcc::MachineAnalysisManager::id<BlockCountAnalysis>()},
-              })
-              .has_value(),
-      "pass analysis registrations must succeed");
-
-  rcc::MachinePassInstrumentation Instrumentation;
-  Instrumentation.setPerFunctionFuel(1);
-  std::uint32_t BeforePass = 0;
-  std::uint32_t AfterPass = 0;
-  std::uint32_t BeforeAnalysis = 0;
-  std::uint32_t AfterAnalysis = 0;
-  std::uint32_t AnalysisCacheHits = 0;
-  std::uint32_t Printed = 0;
-  std::uint32_t ChangeEvents = 0;
-  std::uint32_t FailureEvents = 0;
-  Instrumentation.addBeforeCallback(
-      [&BeforePass](std::string_view, const rcc::MachineFunction &) { ++BeforePass; });
-  Instrumentation.addAfterCallback([&AfterPass](std::string_view, const rcc::MachineFunction &,
-                                                const rcc::MachinePassResult &) { ++AfterPass; });
-  Instrumentation.addBeforeAnalysisCallback(
-      [&BeforeAnalysis](std::string_view, const rcc::MachineFunction &) { ++BeforeAnalysis; });
-  Instrumentation.addAfterAnalysisCallback(
-      [&AfterAnalysis, &AnalysisCacheHits](std::string_view, const rcc::MachineFunction &,
-                                           bool CacheHit, std::uint64_t) {
-        ++AfterAnalysis;
-        AnalysisCacheHits += CacheHit ? 1U : 0U;
-      });
-  Instrumentation.addIRPrintCallback([&Printed](rcc::InstrumentationPhase, std::string_view,
-                                                const rcc::MachineFunction &) { ++Printed; });
-  Instrumentation.addChangeCallback([&ChangeEvents](std::string_view, const rcc::MachineFunction &,
-                                                    rcc::MachinePassChanges Changes,
-                                                    bool FingerprintChanged) {
-    if (Changes.empty() && !FingerprintChanged)
-      ++ChangeEvents;
-  });
-  Instrumentation.addFailureCallback([&FailureEvents](std::string_view,
-                                                      const rcc::MachineFunction &,
-                                                      const rcc::Error &) { ++FailureEvents; });
-
-  rcc::MachinePassManager Pipeline;
-  Context.expect(Pipeline.addPass(std::make_unique<RequiredAnalysisPass>()).has_value(),
-                 "a valid pass must be accepted");
-  auto Run = Pipeline.run(**Function, Target, Analyses, &Instrumentation);
-  Context.expect(Run.has_value(), "a pass with a materialized required analysis must run");
-  Context.expect(BeforePass == 1 && AfterPass == 1 && BeforeAnalysis == 2 && AfterAnalysis == 4 &&
-                     AnalysisCacheHits == 2 && Printed == 2 && ChangeEvents == 1,
-                 "pass, analysis, cache-hit, IR-print, and change callbacks must all run");
-  const auto Statistics = Instrumentation.statistics();
-  Context.expect(Statistics.size() == 3,
-                 "instrumentation must collect one pass and two analysis statistics");
-
-  auto ChangedFunction =
-      rcc::MachineFunction::create("unreported", rcc::MachineFunctionStableID::fromValue(3));
-  rcc::MachineAnalysisManager EmptyAnalyses;
-  rcc::MachinePassManager Detecting(
-      {.VerifyBefore = true, .VerifyEach = true, .DetectUnreportedChanges = true});
-  Context.expect(ChangedFunction &&
-                     Detecting.addPass(std::make_unique<UnreportedChangePass>()).has_value() &&
-                     !Detecting.run(**ChangedFunction, Target, EmptyAnalyses, &Instrumentation) &&
-                     FailureEvents == 1,
-                 "change detection must reject an unreported MachineIR mutation");
-
-  auto FailedFunction =
-      rcc::MachineFunction::create("failed", rcc::MachineFunctionStableID::fromValue(4));
-  rcc::MachineAnalysisManager FailureAnalyses;
-  Context.expect(FailedFunction && FailureAnalyses
-                                       .registerAnalysis<BlockCountAnalysis>({
-                                           .Name = "BlockCount",
-                                           .Dependencies = {},
-                                           .InvalidatedBy = rcc::MachinePassChanges::all(),
-                                       })
-                                       .has_value(),
-                 "mutating failure analysis fixtures must be valid");
-  rcc::MachinePassManager FailingPipeline;
-  Context.expect(FailedFunction &&
-                     FailingPipeline.addPass(std::make_unique<MutatingFailurePass>()).has_value() &&
-                     !FailingPipeline.run(**FailedFunction, Target, FailureAnalyses) &&
-                     !FailureAnalyses.hasCached(
-                         **FailedFunction, rcc::MachineAnalysisManager::id<BlockCountAnalysis>()),
-                 "a pass that mutates and fails must not leave stale function analyses cached");
-
-  rcc::MachineAnalysisManager FailingAnalyses;
-  Context.expect(FailingAnalyses
-                     .registerAnalysis<FailingAnalysis>({
-                         .Name = "Failing",
-                         .Dependencies = {},
-                     })
-                     .has_value(),
-                 "failing analysis registration must succeed");
-  rcc::MachinePassInstrumentation FailureInstrumentation;
-  std::uint32_t BeforeFailingAnalysis = 0;
-  std::uint32_t FailingAnalysisEvents = 0;
-  std::uint32_t RequiredAnalysisPassFailures = 0;
-  FailureInstrumentation.addBeforeAnalysisCallback(
-      [&BeforeFailingAnalysis](std::string_view, const rcc::MachineFunction &) {
-        ++BeforeFailingAnalysis;
-      });
-  FailureInstrumentation.addAnalysisFailureCallback(
-      [&FailingAnalysisEvents](std::string_view, const rcc::MachineFunction &, const rcc::Error &) {
-        ++FailingAnalysisEvents;
-      });
-  FailureInstrumentation.addFailureCallback(
-      [&RequiredAnalysisPassFailures](std::string_view, const rcc::MachineFunction &,
-                                      const rcc::Error &) { ++RequiredAnalysisPassFailures; });
-  rcc::MachinePassManager RequiredAnalysisFailurePipeline;
-  Context.expect(
-      RequiredAnalysisFailurePipeline.addPass(std::make_unique<RequiresFailingAnalysisPass>())
-              .has_value() &&
-          !RequiredAnalysisFailurePipeline.run(**Function, Target, FailingAnalyses,
-                                               &FailureInstrumentation) &&
-          BeforeFailingAnalysis == 1 && FailingAnalysisEvents == 1 &&
-          RequiredAnalysisPassFailures == 1,
-      "analysis and pass failure instrumentation must report required-analysis failures");
-}
-
-void testCompilationUnitAndParallelism(TestContext &Context, const rcc::TargetDescription &Target) {
-  rcc::CompilationUnit Unit;
-  for (std::size_t Index = 0; Index < 8; ++Index) {
-    auto Function = Unit.createMachineFunction("f" + std::to_string(Index));
-    Context.expect(Function.has_value(), "parallel test function creation must succeed");
-  }
-
-  std::atomic<std::uint32_t> Runs = 0;
-  rcc::MachinePassManager Parallel;
-  Context.expect(Parallel.addPass(std::make_unique<ParallelCountingPass>(Runs)).has_value(),
-                 "thread-safe pass registration must succeed");
-  rcc::MachineAnalysisManager Prototype;
-  auto ParallelRun = Parallel.runFunctions(Unit, Target, Prototype, 4);
-  Context.expect(ParallelRun.has_value() && Runs == Unit.functionCount(),
-                 "parallel function execution must visit every function exactly once");
-
-  std::atomic<std::uint32_t> DuplicateRuns = 0;
-  rcc::MachinePassManager Repeated;
-  Context.expect(
-      Repeated.addPass(std::make_unique<ParallelCountingPass>(DuplicateRuns)).has_value() &&
-          Repeated.addPass(std::make_unique<ParallelCountingPass>(DuplicateRuns)).has_value() &&
-          Repeated.runFunctions(Unit, Target, Prototype, 4).has_value() &&
-          DuplicateRuns == Unit.functionCount() * 2,
-      "a pipeline must allow the same named pass to run more than once");
-
-  rcc::MachinePassInstrumentation Instrumentation;
-  std::vector<std::string> ObservedFunctions;
-  std::vector<std::size_t> BeforeBlockCounts;
-  std::vector<std::size_t> AfterBlockCounts;
-  Instrumentation.addBeforeCallback([&ObservedFunctions, &BeforeBlockCounts](
-                                        std::string_view, const rcc::MachineFunction &Function) {
-    ObservedFunctions.emplace_back(Function.name());
-    BeforeBlockCounts.push_back(Function.blockCount());
-  });
-  Instrumentation.addAfterCallback([&AfterBlockCounts](std::string_view,
-                                                       const rcc::MachineFunction &Function,
-                                                       const rcc::MachinePassResult &) {
-    AfterBlockCounts.push_back(Function.blockCount());
-  });
-  std::atomic<std::uint32_t> InstrumentedRuns = 0;
-  std::atomic<std::uint32_t> ActiveRuns = 0;
-  std::atomic<std::uint32_t> MaximumActiveRuns = 0;
-  rcc::MachinePassManager Instrumented;
-  Context.expect(
-      Instrumented
-              .addPass(std::make_unique<InstrumentedParallelPass>(InstrumentedRuns, ActiveRuns,
-                                                                  MaximumActiveRuns))
-              .has_value() &&
-          Instrumented.runFunctions(Unit, Target, Prototype, 4, &Instrumentation).has_value() &&
-          InstrumentedRuns == Unit.functionCount() && MaximumActiveRuns > 1,
-      "instrumented function pipelines must execute concurrently with a parallel request");
-  bool StableCallbackOrder = ObservedFunctions.size() == Unit.functionCount();
-  for (std::size_t Index = 0; StableCallbackOrder && Index < ObservedFunctions.size(); ++Index)
-    StableCallbackOrder = ObservedFunctions[Index] == "f" + std::to_string(Index);
-  Context.expect(StableCallbackOrder,
-                 "instrumentation callbacks must commit in stable compilation-unit order");
-  Context.expect(
-      BeforeBlockCounts.size() == Unit.functionCount() &&
-          AfterBlockCounts.size() == Unit.functionCount() &&
-          std::ranges::all_of(BeforeBlockCounts, [](std::size_t Count) { return Count == 0; }) &&
-          std::ranges::all_of(AfterBlockCounts, [](std::size_t Count) { return Count == 1; }),
-      "buffered instrumentation must retain distinct before/after IR snapshots");
-
-  rcc::MachineAnalysisManager UnsafePrototype;
-  Context.expect(UnsafePrototype
-                     .registerAnalysis<NonThreadSafeAnalysis>({
-                         .Name = "NonThreadSafe",
-                         .Dependencies = {},
-                         .InvalidatedBy = rcc::MachinePassChanges::all(),
-                         .ThreadSafety = rcc::PassThreadSafety::NotThreadSafe,
-                     })
-                     .has_value(),
-                 "non-thread-safe analysis registration must be explicit");
-  rcc::MachinePassManager UnsafeParallel;
-  Context.expect(
-      UnsafeParallel.addPass(std::make_unique<RequiresNonThreadSafeAnalysisPass>()).has_value() &&
-          !UnsafeParallel.runFunctions(Unit, Target, UnsafePrototype, 4),
-      "parallel pipelines must reject a required analysis not marked thread-safe");
-
-  rcc::CompilationUnitAnalysisManager UnitAnalyses;
-  Context.expect(UnitAnalyses
-                     .registerAnalysis<UnitFunctionCountAnalysis>({
-                         .Name = "UnitFunctionCount",
-                         .Dependencies = {},
-                         .InvalidatedBy = rcc::MachinePassChanges::all(),
-                     })
-                     .has_value(),
-                 "compilation-unit analysis registration must succeed");
-  rcc::MachineAnalysisManager FunctionAnalyses;
-  rcc::CompilationUnitPassManager UnitPipeline;
-  Context.expect(UnitPipeline.addPass(std::make_unique<ObserveUnitPass>()).has_value(),
-                 "compilation-unit pass registration must succeed");
-  rcc::MachinePassInstrumentation UnitInstrumentation;
-  std::uint32_t BeforeUnit = 0;
-  std::uint32_t AfterUnit = 0;
-  std::uint32_t BeforeUnitAnalysis = 0;
-  std::uint32_t AfterUnitAnalysis = 0;
-  std::uint32_t UnitAnalysisCacheHits = 0;
-  UnitInstrumentation.addBeforeUnitCallback(
-      [&BeforeUnit](std::string_view, const rcc::CompilationUnit &) { ++BeforeUnit; });
-  UnitInstrumentation.addAfterUnitCallback(
-      [&AfterUnit](std::string_view, const rcc::CompilationUnit &,
-                   const rcc::CompilationUnitPassResult &) { ++AfterUnit; });
-  UnitInstrumentation.addBeforeUnitAnalysisCallback(
-      [&BeforeUnitAnalysis](std::string_view, const rcc::CompilationUnit &) {
-        ++BeforeUnitAnalysis;
-      });
-  UnitInstrumentation.addAfterUnitAnalysisCallback(
-      [&AfterUnitAnalysis, &UnitAnalysisCacheHits](std::string_view, const rcc::CompilationUnit &,
-                                                   bool CacheHit, std::uint64_t) {
-        ++AfterUnitAnalysis;
-        UnitAnalysisCacheHits += CacheHit ? 1U : 0U;
-      });
-  Context.expect(
-      UnitPipeline.run(Unit, Target, UnitAnalyses, FunctionAnalyses, &UnitInstrumentation)
-          .has_value(),
-      "compilation-unit pass and analysis must run through their own manager");
-  Context.expect(BeforeUnit == 1 && AfterUnit == 1 && BeforeUnitAnalysis == 1 &&
-                     AfterUnitAnalysis == 2 && UnitAnalysisCacheHits == 1,
-                 "compilation-unit instrumentation must report pass and analysis cache events");
-
-  rcc::CompilationUnitAnalysisManager FailingUnitAnalyses;
-  Context.expect(FailingUnitAnalyses
-                     .registerAnalysis<FailingUnitAnalysis>({
-                         .Name = "FailingUnit",
-                         .Dependencies = {},
-                     })
-                     .has_value(),
-                 "failing compilation-unit analysis registration must succeed");
-  rcc::CompilationUnitPassManager FailingUnitAnalysisPipeline;
-  Context.expect(
-      FailingUnitAnalysisPipeline.addPass(std::make_unique<RequiresFailingUnitAnalysisPass>())
-          .has_value(),
-      "a pass requiring a failing unit analysis must register");
-  rcc::MachinePassInstrumentation FailingUnitInstrumentation;
-  std::uint32_t BeforeFailingUnitAnalysis = 0;
-  std::uint32_t FailingUnitAnalysisEvents = 0;
-  std::uint32_t RequiredUnitAnalysisPassFailures = 0;
-  FailingUnitInstrumentation.addBeforeUnitAnalysisCallback(
-      [&BeforeFailingUnitAnalysis](std::string_view, const rcc::CompilationUnit &) {
-        ++BeforeFailingUnitAnalysis;
-      });
-  FailingUnitInstrumentation.addUnitAnalysisFailureCallback(
-      [&FailingUnitAnalysisEvents](std::string_view, const rcc::CompilationUnit &,
-                                   const rcc::Error &) { ++FailingUnitAnalysisEvents; });
-  FailingUnitInstrumentation.addUnitFailureCallback(
-      [&RequiredUnitAnalysisPassFailures](std::string_view, const rcc::CompilationUnit &,
-                                          const rcc::Error &) {
-        ++RequiredUnitAnalysisPassFailures;
-      });
-  Context.expect(
-      !FailingUnitAnalysisPipeline.run(Unit, Target, FailingUnitAnalyses, FunctionAnalyses,
-                                       &FailingUnitInstrumentation) &&
-          BeforeFailingUnitAnalysis == 1 && FailingUnitAnalysisEvents == 1 &&
-          RequiredUnitAnalysisPassFailures == 1,
-      "unit analysis and pass failure instrumentation must report required-analysis failures");
-
-  rcc::MachineFunction *FirstFunction = Unit.functionAt(0);
-  Context.expect(
-      FirstFunction != nullptr &&
-          FunctionAnalyses
-              .registerAnalysis<BlockCountAnalysis>({
-                  .Name = "BlockCount",
-                  .Dependencies = {},
-                  .InvalidatedBy = rcc::MachinePassChanges::all(),
-              })
-              .has_value() &&
-          FunctionAnalyses.getResult<BlockCountAnalysis>(*FirstFunction, Target).has_value(),
-      "compilation-unit failure cache fixtures must materialize");
-  rcc::CompilationUnitPassManager FailingUnitPipeline;
-  Context.expect(
-      FirstFunction != nullptr &&
-          FailingUnitPipeline.addPass(std::make_unique<MutatingUnitFailurePass>()).has_value() &&
-          !FailingUnitPipeline.run(Unit, Target, UnitAnalyses, FunctionAnalyses) &&
-          !UnitAnalyses.hasCached(
-              Unit, rcc::CompilationUnitAnalysisManager::id<UnitFunctionCountAnalysis>()) &&
-          !FunctionAnalyses.hasCached(*FirstFunction,
-                                      rcc::MachineAnalysisManager::id<BlockCountAnalysis>()),
-      "a mutating compilation-unit failure must clear unit and function analysis caches");
-}
-
-} // namespace
-
-int main() {
-  TestContext Context;
-  auto Target = createTarget();
-  Context.expect(Target.has_value(), "machine pass tests require a valid target description");
-  if (!Target)
-    return Context.result();
-
-  testAnalysisInfrastructure(Context, *Target);
-  testPassAndInstrumentation(Context, *Target);
-  testCompilationUnitAndParallelism(Context, *Target);
-  return Context.result();
-}
diff --git a/backend/unittests/CodeGen/MachineSchedulingTest.cpp b/backend/unittests/CodeGen/MachineSchedulingTest.cpp
index bcd4100..5162fb8 100644
--- a/backend/unittests/CodeGen/MachineSchedulingTest.cpp
+++ b/backend/unittests/CodeGen/MachineSchedulingTest.cpp
@@ -386,7 +386,7 @@ void testTargetSchedulingHooks(TestContext &Context, const rcc::TargetDescriptio
     Context.expect(false, "target scheduling preference model must be created");
     return;
   }
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineSchedulerPass PreferencePass(
       *PreferenceModel, {.MaximumRegionSize = 8, .EnableBidirectionalScheduling = false});
   auto Preferred = PreferencePass.run(*Fixture.Function, Target, Analyses);
@@ -408,7 +408,7 @@ void testTargetSchedulingHooks(TestContext &Context, const rcc::TargetDescriptio
   rcc::MachineInstr *BoundaryFirst =
       buildADDI(Context, BoundaryBuilder, makeGPR(Context, *BoundaryFixture.Function), X0, 1);
   (void)buildADDI(Context, BoundaryBuilder, makeGPR(Context, *BoundaryFixture.Function), X0, 2);
-  rcc::MachineAnalysisManager BoundaryAnalyses;
+  rcc::MachineFunctionAnalysisManager BoundaryAnalyses;
   rcc::MachineSchedulerPass BoundaryPass(
       *BoundaryModel, {.MaximumRegionSize = 8, .EnableBidirectionalScheduling = false});
   auto BoundaryResult = BoundaryPass.run(*BoundaryFixture.Function, Target, BoundaryAnalyses);
@@ -455,7 +455,7 @@ void testPreRAScheduler(TestContext &Context, const rcc::TargetDescription &Targ
   buildSchedulingChain(Context, Fixture, Target, false, Short, Long);
   Context.expect(Fixture.Block->firstInstruction() == Short,
                  "pre-RA fixture must begin in intentionally suboptimal order");
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineSchedulerPass Pass(rcc::riscv::schedulingModel(),
                                  {.MaximumRegionSize = 64, .EnableBidirectionalScheduling = false});
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
@@ -482,7 +482,7 @@ void testPostRASchedulerAndLivenessRepair(TestContext &Context,
   if (!Rebuilt)
     return;
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::PostRASchedulerPass Pass(rcc::riscv::schedulingModel(),
                                 {.MaximumRegionSize = 64, .EnableBidirectionalScheduling = false});
   auto Result = Pass.run(*Fixture.Function, Target, Analyses);
diff --git a/backend/unittests/CodeGen/PHIEliminationTest.cpp b/backend/unittests/CodeGen/PHIEliminationTest.cpp
index 00668e4..9bc9a57 100644
--- a/backend/unittests/CodeGen/PHIEliminationTest.cpp
+++ b/backend/unittests/CodeGen/PHIEliminationTest.cpp
@@ -4,7 +4,7 @@
 
 #include "SSAExitTestSupport.h"
 #include "rcc/CodeGen/MachineCFGUpdater.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/MachineVerifier.h"
 
 #include <array>
@@ -62,11 +62,11 @@ buildPhi(rcc::MachineFunction &Function, const rcc::TargetDescription &Target,
 [[nodiscard]] rcc::Expected<void> runPHIElimination(rcc::MachineFunction &Function,
                                                     const rcc::TargetDescription &Target,
                                                     const rcc::TargetInstrInfo &Info) {
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   auto Added = Pipeline.addPass(std::make_unique<rcc::PHIEliminationPass>(Info));
   if (!Added)
     return std::unexpected(Added.error());
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   return Pipeline.run(Function, Target, Analyses);
 }
 
@@ -391,7 +391,7 @@ void testUndefAndFailureAtomicity(TestContext &Context, const rcc::TargetDescrip
   const std::size_t RegistersBefore = Atomic.Function->registerInfo().virtualRegisters().size();
   const std::uint64_t PropertiesBefore = Atomic.Function->properties().rawValue();
   TestInstrInfo RejectingInfo(true);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::PHIEliminationPass FailingPass(RejectingInfo);
   auto Failed = FailingPass.run(*Atomic.Function, Target, Analyses);
   Context.expect(!Failed && Failed.error().code() == rcc::ErrorCode::Unsupported,
diff --git a/backend/unittests/CodeGen/PassInstrumentationTest.cpp b/backend/unittests/CodeGen/PassInstrumentationTest.cpp
new file mode 100644
index 0000000..97ce445
--- /dev/null
+++ b/backend/unittests/CodeGen/PassInstrumentationTest.cpp
@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "Target/TestTarget.h"
+#include "rcc/CodeGen/GenericOpcodes.h"
+#include "rcc/CodeGen/MachineFunction.h"
+#include "rcc/CodeGen/MachinePassManager.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace {
+
+class TestContext final {
+public:
+  void expect(bool Condition, std::string_view Message) {
+    if (Condition)
+      return;
+    std::cerr << Message << '\n';
+    ++Failures;
+  }
+
+  [[nodiscard]] int result() const noexcept {
+    return Failures == 0 ? 0 : 1;
+  }
+
+private:
+  int Failures = 0;
+};
+
+[[nodiscard]] rcc::Expected<rcc::TargetDescription> createTarget() {
+  std::vector<rcc::InstructionDescriptor> Descriptors;
+  std::vector<rcc::ImmediatePredicate> Predicates;
+  auto Appended = rcc::appendGenericInstructionInfo(Descriptors, Predicates);
+  if (!Appended)
+    return std::unexpected(Appended.error());
+  auto Instructions = rcc::InstructionSet::create(std::move(Descriptors), std::move(Predicates));
+  if (!Instructions)
+    return std::unexpected(Instructions.error());
+  return rcc::test::createTestTargetDescription(std::move(*Instructions));
+}
+
+class BlockCountAnalysis final {
+public:
+  struct Result final {
+    std::size_t Count = 0;
+  };
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "BlockCount";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &Function,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
+    return Result{Function.blockCount()};
+  }
+};
+
+class InstrumentedPass final : public rcc::MachineFunctionPass {
+public:
+  [[nodiscard]] const rcc::MachinePassContract &contract() const noexcept override {
+    static const rcc::MachinePassContract Contract{
+        .Name = "Instrumented",
+        .Requires = {},
+        .Sets = {},
+        .Clears = {},
+        .RequiredAnalyses =
+            {
+                rcc::MachineFunctionAnalysisManager::id<BlockCountAnalysis>(),
+            },
+        .VerificationStage = std::nullopt,
+    };
+    return Contract;
+  }
+
+  [[nodiscard]] rcc::Expected<rcc::MachinePassResult>
+  run(rcc::MachineFunction &Function, const rcc::TargetDescription &Target,
+      rcc::MachineFunctionAnalysisManager &Analyses) override {
+    auto First = Analyses.getResult<BlockCountAnalysis>(Function, Target);
+    auto Second = Analyses.getResult<BlockCountAnalysis>(Function, Target);
+    auto FirstAction = Analyses.requestAction("first", Function);
+    auto SecondAction = Analyses.requestAction("second", Function);
+    if (!First || !Second || !FirstAction || !SecondAction || !*FirstAction || *SecondAction)
+      return rcc::makeUnexpected(rcc::ErrorCode::VerificationError,
+                                 "instrumentation action policy was not enforced");
+    rcc::MachinePassResult Result;
+    Result.Preserved = rcc::PreservedAnalyses::all();
+    return Result;
+  }
+};
+
+void testInstrumentation(TestContext &Context, const rcc::TargetDescription &Target) {
+  auto Function =
+      rcc::MachineFunction::create("instrumentation", rcc::MachineFunctionStableID::fromValue(1));
+  Context.expect(Function.has_value(), "instrumentation function creation must succeed");
+  if (!Function)
+    return;
+
+  rcc::MachineFunctionAnalysisManager Analyses;
+  Context.expect(Analyses
+                     .registerAnalysis<BlockCountAnalysis>({
+                         .Name = "BlockCount",
+                         .Dependencies = {},
+                         .InvalidatedBy = rcc::MachinePassChanges::all(),
+                         .ThreadSafety = rcc::PassThreadSafety::ThreadSafe,
+                     })
+                     .has_value(),
+                 "instrumentation analysis registration must succeed");
+
+  rcc::MachinePassInstrumentation Instrumentation;
+  Instrumentation.setPerFunctionFuel(1);
+  std::uint32_t BeforePass = 0;
+  std::uint32_t AfterPass = 0;
+  std::uint32_t BeforeAnalysis = 0;
+  std::uint32_t AfterAnalysis = 0;
+  std::uint32_t CacheHits = 0;
+  std::uint32_t Printed = 0;
+  std::uint32_t Changes = 0;
+  Instrumentation.addBeforeCallback(
+      [&BeforePass](std::string_view, const rcc::MachineFunction &) { ++BeforePass; });
+  Instrumentation.addAfterCallback([&AfterPass](std::string_view, const rcc::MachineFunction &,
+                                                const rcc::MachinePassResult &) { ++AfterPass; });
+  Instrumentation.addBeforeAnalysisCallback(
+      [&BeforeAnalysis](std::string_view, const rcc::MachineFunction &) { ++BeforeAnalysis; });
+  Instrumentation.addAfterAnalysisCallback(
+      [&AfterAnalysis, &CacheHits](std::string_view, const rcc::MachineFunction &, bool CacheHit,
+                                   std::uint64_t) {
+        ++AfterAnalysis;
+        CacheHits += CacheHit ? 1U : 0U;
+      });
+  Instrumentation.addIRPrintCallback([&Printed](rcc::InstrumentationPhase, std::string_view,
+                                                const rcc::MachineFunction &) { ++Printed; });
+  Instrumentation.addChangeCallback([&Changes](std::string_view, const rcc::MachineFunction &,
+                                               rcc::MachinePassChanges ReportedChanges,
+                                               bool FingerprintChanged) {
+    if (ReportedChanges.empty() && !FingerprintChanged)
+      ++Changes;
+  });
+
+  rcc::MachineFunctionPassManager Pipeline;
+  Context.expect(Pipeline.addPass(std::make_unique<InstrumentedPass>()).has_value() &&
+                     Pipeline.run(**Function, Target, Analyses, &Instrumentation).has_value(),
+                 "instrumented pass must run");
+  Context.expect(BeforePass == 1 && AfterPass == 1 && BeforeAnalysis == 1 && AfterAnalysis == 3 &&
+                     CacheHits == 2 && Printed == 2 && Changes == 1,
+                 "all pass and analysis instrumentation points must run");
+
+  const auto Events = Instrumentation.actionEvents();
+  Context.expect(Events.size() == 2 && Events[0].Accepted && !Events[1].Accepted,
+                 "action instrumentation must record accepted and rejected decisions");
+  const auto Statistics = Instrumentation.statistics();
+  Context.expect(Statistics.size() == 2,
+                 "instrumentation must collect one pass and one analysis statistic");
+}
+
+} // namespace
+
+int main() {
+  TestContext Context;
+  auto Target = createTarget();
+  Context.expect(Target.has_value(),
+                 "pass instrumentation tests require a valid target description");
+  if (!Target)
+    return Context.result();
+
+  testInstrumentation(Context, *Target);
+  return Context.result();
+}
diff --git a/backend/unittests/CodeGen/PassManagerTest.cpp b/backend/unittests/CodeGen/PassManagerTest.cpp
new file mode 100644
index 0000000..56c30f3
--- /dev/null
+++ b/backend/unittests/CodeGen/PassManagerTest.cpp
@@ -0,0 +1,260 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "Target/TestTarget.h"
+#include "rcc/CodeGen/GenericOpcodes.h"
+#include "rcc/CodeGen/MachineFunction.h"
+#include "rcc/CodeGen/MachineFunctionAnalysisManager.h"
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace {
+
+class TestContext final {
+public:
+  void expect(bool Condition, std::string_view Message) {
+    if (Condition)
+      return;
+    std::cerr << Message << '\n';
+    ++Failures;
+  }
+
+  [[nodiscard]] int result() const noexcept {
+    return Failures == 0 ? 0 : 1;
+  }
+
+private:
+  int Failures = 0;
+};
+
+[[nodiscard]] rcc::Expected<rcc::TargetDescription> createTarget() {
+  std::vector<rcc::InstructionDescriptor> Descriptors;
+  std::vector<rcc::ImmediatePredicate> Predicates;
+  auto Appended = rcc::appendGenericInstructionInfo(Descriptors, Predicates);
+  if (!Appended)
+    return std::unexpected(Appended.error());
+  auto Instructions = rcc::InstructionSet::create(std::move(Descriptors), std::move(Predicates));
+  if (!Instructions)
+    return std::unexpected(Instructions.error());
+  return rcc::test::createTestTargetDescription(std::move(*Instructions));
+}
+
+class BlockCountAnalysis final {
+public:
+  struct Result final {
+    std::size_t Count = 0;
+  };
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "BlockCount";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &Function,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
+    ++Runs;
+    return Result{Function.blockCount()};
+  }
+
+  static inline std::atomic<std::uint32_t> Runs = 0;
+};
+
+class DependentAnalysis final {
+public:
+  struct Result final {
+    std::size_t Count = 0;
+  };
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "Dependent";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &Function,
+                                                 const rcc::TargetDescription &Target,
+                                                 rcc::MachineFunctionAnalysisManager &Analyses) {
+    auto Blocks = Analyses.getResult<BlockCountAnalysis>(Function, Target);
+    if (!Blocks)
+      return std::unexpected(Blocks.error());
+    return Result{(*Blocks)->Count};
+  }
+};
+
+class StickyAnalysis final {
+public:
+  struct Result final {
+    [[nodiscard]] bool invalidate(const rcc::MachineFunction &,
+                                  const rcc::PreservedAnalyses &) noexcept {
+      return false;
+    }
+  };
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "Sticky";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
+    return Result{};
+  }
+};
+
+class ExpiringAnalysis final {
+public:
+  struct Result final {
+    [[nodiscard]] bool invalidate(const rcc::MachineFunction &,
+                                  const rcc::PreservedAnalyses &) noexcept {
+      return true;
+    }
+  };
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "Expiring";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
+    return Result{};
+  }
+};
+
+class CycleA final {
+public:
+  struct Result final {};
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "CycleA";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
+    return Result{};
+  }
+};
+
+class CycleB final {
+public:
+  struct Result final {};
+
+  [[nodiscard]] static constexpr std::string_view name() noexcept {
+    return "CycleB";
+  }
+
+  [[nodiscard]] static rcc::Expected<Result> run(rcc::MachineFunction &,
+                                                 const rcc::TargetDescription &,
+                                                 rcc::MachineFunctionAnalysisManager &) {
+    return Result{};
+  }
+};
+
+void testAnalysisManager(TestContext &Context, const rcc::TargetDescription &Target) {
+  auto Function =
+      rcc::MachineFunction::create("analysis", rcc::MachineFunctionStableID::fromValue(1));
+  Context.expect(Function.has_value(), "analysis function creation must succeed");
+  if (!Function)
+    return;
+
+  rcc::MachineFunctionAnalysisManager Analyses;
+  Context.expect(Analyses
+                     .registerAnalysis<BlockCountAnalysis>({
+                         .Name = "BlockCount",
+                         .Dependencies = {},
+                         .InvalidatedBy = {rcc::MachinePassChange::CFG},
+                     })
+                     .has_value(),
+                 "base analysis registration must succeed");
+  Context.expect(Analyses
+                     .registerAnalysis<DependentAnalysis>({
+                         .Name = "Dependent",
+                         .Dependencies =
+                             {
+                                 rcc::MachineFunctionAnalysisManager::id<BlockCountAnalysis>(),
+                             },
+                         .InvalidatedBy = {rcc::MachinePassChange::Operands},
+                     })
+                     .has_value(),
+                 "dependent analysis registration must succeed");
+
+  BlockCountAnalysis::Runs = 0;
+  auto First = Analyses.getResult<DependentAnalysis>(**Function, Target);
+  auto Second = Analyses.getResult<DependentAnalysis>(**Function, Target);
+  Context.expect(First && Second && *First == *Second && BlockCountAnalysis::Runs == 1,
+                 "analysis dependencies must materialize once and then use the cache");
+
+  Analyses.invalidate(**Function, rcc::PreservedAnalyses::none(),
+                      {rcc::MachinePassChange::Registers});
+  Context.expect(Analyses.cachedResultCount(**Function) == 2,
+                 "unrelated changes must preserve cached analyses precisely");
+  Analyses.invalidate(**Function, rcc::PreservedAnalyses::none(), {rcc::MachinePassChange::CFG});
+  Context.expect(Analyses.cachedResultCount(**Function) == 0,
+                 "invalidating a dependency must invalidate its dependent analysis");
+
+  rcc::MachineFunctionAnalysisManager Cyclic;
+  Context.expect(
+      Cyclic.registerAnalysis<CycleA>({
+                                          .Name = "CycleA",
+                                          .Dependencies =
+                                              {
+                                                  rcc::MachineFunctionAnalysisManager::id<CycleB>(),
+                                              },
+                                      })
+              .has_value() &&
+          Cyclic
+              .registerAnalysis<CycleB>({
+                  .Name = "CycleB",
+                  .Dependencies =
+                      {
+                          rcc::MachineFunctionAnalysisManager::id<CycleA>(),
+                      },
+              })
+              .has_value(),
+      "cyclic analysis registrations must be accepted until requested");
+  Context.expect(!Cyclic.getResult<CycleA>(**Function, Target),
+                 "analysis dependency cycles must produce a structured error");
+
+  rcc::MachineFunctionAnalysisManager CustomInvalidation;
+  Context.expect(CustomInvalidation
+                         .registerAnalysis<StickyAnalysis>({
+                             .Name = "Sticky",
+                             .Dependencies = {},
+                             .InvalidatedBy = {rcc::MachinePassChange::CFG},
+                         })
+                         .has_value() &&
+                     CustomInvalidation
+                         .registerAnalysis<ExpiringAnalysis>({
+                             .Name = "Expiring",
+                             .Dependencies = {},
+                             .InvalidatedBy = {rcc::MachinePassChange::CFG},
+                         })
+                         .has_value() &&
+                     CustomInvalidation.getResult<StickyAnalysis>(**Function, Target) &&
+                     CustomInvalidation.getResult<ExpiringAnalysis>(**Function, Target),
+                 "custom invalidation analyses must materialize");
+  CustomInvalidation.invalidate(**Function, rcc::PreservedAnalyses::none(),
+                                {rcc::MachinePassChange::CFG});
+  Context.expect(CustomInvalidation.hasCached(
+                     **Function, rcc::MachineFunctionAnalysisManager::id<StickyAnalysis>()) &&
+                     !CustomInvalidation.hasCached(
+                         **Function, rcc::MachineFunctionAnalysisManager::id<ExpiringAnalysis>()),
+                 "analysis invalidate() must return false to preserve and true to invalidate");
+}
+
+} // namespace
+
+int main() {
+  TestContext Context;
+  auto Target = createTarget();
+  Context.expect(Target.has_value(), "pass manager tests require a valid target description");
+  if (!Target)
+    return Context.result();
+
+  testAnalysisManager(Context, *Target);
+  return Context.result();
+}
diff --git a/backend/unittests/CodeGen/RegisterAllocationTest.cpp b/backend/unittests/CodeGen/RegisterAllocationTest.cpp
index 1a7c5c7..7dd0dd0 100644
--- a/backend/unittests/CodeGen/RegisterAllocationTest.cpp
+++ b/backend/unittests/CodeGen/RegisterAllocationTest.cpp
@@ -14,7 +14,7 @@
 #include "rcc/CodeGen/MachineInstr.h"
 #include "rcc/CodeGen/MachineMemOperand.h"
 #include "rcc/CodeGen/MachineOperand.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/MachineRegisterInfo.h"
 #include "rcc/CodeGen/RegAllocCommon.h"
 #include "rcc/CodeGen/RegAllocFast.h"
@@ -496,7 +496,7 @@ enum class AllocatorKind : std::uint8_t {
                                                const rcc::TargetRegisterAllocationInfo &Info,
                                                AllocatorKind Kind,
                                                rcc::RegisterAllocationOptions Options = {}) {
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage11MachineAnalyses(Analyses);
   if (!Registered)
     return std::unexpected(Registered.error());
@@ -512,7 +512,7 @@ enum class AllocatorKind : std::uint8_t {
     Pass = std::make_unique<rcc::PBQPAllocatorPass>(Info, Options);
     break;
   }
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   auto Added = Pipeline.addPass(std::move(Pass));
   if (!Added)
     return std::unexpected(Added.error());
@@ -603,7 +603,7 @@ void testLiveRegMatrix(TestContext &Context, const rcc::TargetDescription &Targe
   }
   if (!rcc::rebuildMachineLiveness(*LaneFixture->Function, Target))
     return;
-  rcc::MachineAnalysisManager LaneAnalyses;
+  rcc::MachineFunctionAnalysisManager LaneAnalyses;
   if (!rcc::registerStage11MachineAnalyses(LaneAnalyses))
     return;
   auto LaneIntervals =
@@ -632,7 +632,7 @@ void testLiveRegMatrix(TestContext &Context, const rcc::TargetDescription &Targe
   }
   if (!rcc::rebuildMachineLiveness(*FixedFixture->Function, Target))
     return;
-  rcc::MachineAnalysisManager FixedAnalyses;
+  rcc::MachineFunctionAnalysisManager FixedAnalyses;
   if (!rcc::registerStage11MachineAnalyses(FixedAnalyses))
     return;
   auto FixedIntervals =
@@ -664,7 +664,7 @@ void testLiveRegMatrix(TestContext &Context, const rcc::TargetDescription &Targe
       !rcc::rebuildMachineLiveness(*FixedLaneFixture->Function, Target)) {
     return;
   }
-  rcc::MachineAnalysisManager FixedLaneAnalyses;
+  rcc::MachineFunctionAnalysisManager FixedLaneAnalyses;
   if (!rcc::registerStage11MachineAnalyses(FixedLaneAnalyses))
     return;
   auto FixedLaneIntervals =
@@ -694,7 +694,7 @@ void testSharedUnitLaneMatrix(TestContext &Context, const rcc::TargetDescription
       !rcc::rebuildMachineLiveness(*Fixture->Function, Target)) {
     return;
   }
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   if (!rcc::registerStage11MachineAnalyses(Analyses))
     return;
   auto Intervals = Analyses.getResult<rcc::LiveIntervalsAnalysis>(*Fixture->Function, Target);
diff --git a/backend/unittests/CodeGen/RegisterAllocationTestSupport.h b/backend/unittests/CodeGen/RegisterAllocationTestSupport.h
index 49c9e8a..d93b14e 100644
--- a/backend/unittests/CodeGen/RegisterAllocationTestSupport.h
+++ b/backend/unittests/CodeGen/RegisterAllocationTestSupport.h
@@ -436,7 +436,7 @@ public:
                                                  const TargetRegisterAllocationInfo &Info,
                                                  AllocatorKind Kind,
                                                  RegisterAllocationOptions Options = {}) {
-  MachineAnalysisManager Analyses;
+  MachineFunctionAnalysisManager Analyses;
   auto Registered = registerStage11MachineAnalyses(Analyses);
   if (!Registered)
     return std::unexpected(Registered.error());
@@ -452,7 +452,7 @@ public:
     Pass = std::make_unique<PBQPAllocatorPass>(Info, Options);
     break;
   }
-  MachinePassManager Pipeline;
+  MachineFunctionPassManager Pipeline;
   auto Added = Pipeline.addPass(std::move(Pass));
   if (!Added)
     return std::unexpected(Added.error());
diff --git a/backend/unittests/CodeGen/SlotIndexesTest.cpp b/backend/unittests/CodeGen/SlotIndexesTest.cpp
index d34ff84..9d3f54b 100644
--- a/backend/unittests/CodeGen/SlotIndexesTest.cpp
+++ b/backend/unittests/CodeGen/SlotIndexesTest.cpp
@@ -25,7 +25,7 @@ void testSlotIndexes(TestContext &Context, const rcc::TargetDescription &Target)
     return;
   }
 
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage11MachineAnalyses(Analyses);
   auto Indexes =
       Registered
diff --git a/backend/unittests/CodeGen/TwoAddressInstructionPassTest.cpp b/backend/unittests/CodeGen/TwoAddressInstructionPassTest.cpp
index 6853a36..e3ad4eb 100644
--- a/backend/unittests/CodeGen/TwoAddressInstructionPassTest.cpp
+++ b/backend/unittests/CodeGen/TwoAddressInstructionPassTest.cpp
@@ -3,7 +3,7 @@
 #include "rcc/CodeGen/TwoAddressInstructionPass.h"
 
 #include "SSAExitTestSupport.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/MachineVerifier.h"
 
 #include <array>
@@ -130,11 +130,11 @@ void testTwoAddressAndSubregisterPseudos(TestContext &Context, const rcc::Target
   if (!InitialLiveness)
     return;
   Function.properties().set(rcc::MachineFunctionProperty::NoPHIs);
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   Context.expect(
       Pipeline.addPass(std::make_unique<rcc::TwoAddressInstructionPass>(Info)).has_value(),
       "two-address pass must be registered");
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Pipeline.run(Function, Target, Analyses);
   Context.expect(Run.has_value(), "two-address rewrite must succeed");
   if (!Run)
@@ -238,7 +238,7 @@ void testTwoAddressAndSubregisterPseudos(TestContext &Context, const rcc::Target
   const std::uint64_t AtomicPropertiesBefore = AtomicFixture.Function->properties().rawValue();
 
   TestInstrInfo RejectingInfo(true);
-  rcc::MachineAnalysisManager AtomicAnalyses;
+  rcc::MachineFunctionAnalysisManager AtomicAnalyses;
   rcc::TwoAddressInstructionPass FailingPass(RejectingInfo);
   auto Failed = FailingPass.run(*AtomicFixture.Function, Target, AtomicAnalyses);
   Context.expect(!Failed && Failed.error().code() == rcc::ErrorCode::Unsupported,
diff --git a/backend/unittests/Target/RISCVFrameLoweringTest.cpp b/backend/unittests/Target/RISCVFrameLoweringTest.cpp
index 285e962..23f1b49 100644
--- a/backend/unittests/Target/RISCVFrameLoweringTest.cpp
+++ b/backend/unittests/Target/RISCVFrameLoweringTest.cpp
@@ -12,7 +12,7 @@
 #include "rcc/CodeGen/MachineInstr.h"
 #include "rcc/CodeGen/MachineMemOperand.h"
 #include "rcc/CodeGen/MachineOperand.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/PrologueEpilogueInsertion.h"
 #include "rcc/CodeGen/RegisterMask.h"
 #include "rcc/CodeGen/TargetDescription.h"
@@ -216,12 +216,12 @@ void setFramePassProperties(rcc::MachineFunction &Function) {
 runFrameLoweringWith(rcc::MachineFunction &Function, const rcc::TargetDescription &Target,
                      const rcc::TargetFrameLowering &FrameLowering) {
   setFramePassProperties(Function);
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   auto Added =
       Pipeline.addPass(std::make_unique<rcc::PrologueEpilogueInsertionPass>(FrameLowering));
   if (!Added)
     return std::unexpected(Added.error());
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   return Pipeline.run(Function, Target, Analyses);
 }
 
diff --git a/backend/unittests/Target/RISCVLateCodeGenTest.cpp b/backend/unittests/Target/RISCVLateCodeGenTest.cpp
index 702f058..868d18f 100644
--- a/backend/unittests/Target/RISCVLateCodeGenTest.cpp
+++ b/backend/unittests/Target/RISCVLateCodeGenTest.cpp
@@ -18,7 +18,7 @@
 #include "rcc/CodeGen/MachineMemoryFolding.h"
 #include "rcc/CodeGen/MachineOperand.h"
 #include "rcc/CodeGen/MachineOptimizationPipeline.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/MachinePseudoExpansion.h"
 #include "rcc/CodeGen/MachineShrinkWrapping.h"
 #include "rcc/CodeGen/MachineStackSlotColoring.h"
@@ -376,7 +376,7 @@ void testBlockPlacement(TestContext &Context, const rcc::TargetDescription &Targ
                      CFG.addSuccessor(*Entry, *Hot, *HotProbability).has_value(),
                  "placement CFG construction must succeed");
   setSelectedProperties(*Function);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineBlockPlacementPass Pass;
   auto Result = Pass.run(*Function, Target, Analyses);
   if (!Result)
@@ -410,7 +410,7 @@ void testFallthroughNormalization(TestContext &Context, const rcc::TargetDescrip
   setPostRAProperties(*Function);
   auto Liveness = rcc::rebuildMachineLiveness(*Function, Target);
   Context.expect(Liveness.has_value(), "fallthrough fixture liveness must be rebuilt");
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineFallthroughPass Pass(rcc::riscv::instrInfo());
   auto Result = Pass.run(*Function, Target, Analyses);
   if (!Result)
@@ -445,7 +445,7 @@ void testFallthroughMaterialization(TestContext &Context, const rcc::TargetDescr
   setPostRAProperties(*Function);
   Context.expect(rcc::rebuildMachineLiveness(*Function, Target).has_value(),
                  "materialized fallthrough liveness must be rebuilt");
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineFallthroughPass Pass(rcc::riscv::instrInfo());
   auto Result = Pass.run(*Function, Target, Analyses);
   if (!Result)
@@ -486,7 +486,7 @@ void testBranchOptimization(TestContext &Context, const rcc::TargetDescription &
     return;
   }
   setSelectedProperties(*Function);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineBranchOptimizationPass Pass(rcc::riscv::instrInfo());
   auto Result = Pass.run(*Function, Target, Analyses);
   if (!Result)
@@ -522,7 +522,7 @@ void testBranchOptimization(TestContext &Context, const rcc::TargetDescription &
     return;
   }
   setSelectedProperties(*ConstantFunction);
-  rcc::MachineAnalysisManager ConstantAnalyses;
+  rcc::MachineFunctionAnalysisManager ConstantAnalyses;
   auto ConstantResult = Pass.run(*ConstantFunction, Target, ConstantAnalyses);
   if (!ConstantResult)
     std::cerr << "constant branch folding failure: " << ConstantResult.error().message() << '\n';
@@ -566,7 +566,7 @@ void testTailDuplication(TestContext &Context, const rcc::TargetDescription &Tar
     return;
   }
   setRelaxationProperties(Context, *Function, Target);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineTailDuplicationPass Pass(rcc::riscv::instrInfo());
   Tail->attributes().set(rcc::MachineBasicBlockAttribute::MachineBlockAddressTaken);
   auto Protected = Pass.run(*Function, Target, Analyses);
@@ -617,7 +617,7 @@ void testTailMerge(TestContext &Context, const rcc::TargetDescription &Target) {
     return;
   }
   setRelaxationProperties(Context, *Function, Target);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineTailMergePass Pass(rcc::riscv::instrInfo());
   Second->attributes().set(rcc::MachineBasicBlockAttribute::MachineBlockAddressTaken);
   auto Protected = Pass.run(*Function, Target, Analyses);
@@ -662,7 +662,7 @@ void testCopyPropagation(TestContext &Context, const rcc::TargetDescription &Tar
   if (Add == nullptr)
     return;
   setSelectedProperties(*Function);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineCopyPropagationPass PreRA(rcc::riscv::instrInfo(),
                                         rcc::MachineCopyPropagationStage::PreRegisterAllocation);
   auto PreResult = PreRA.run(*Function, Target, Analyses);
@@ -702,7 +702,7 @@ void testCopyPropagation(TestContext &Context, const rcc::TargetDescription &Tar
   setPostRAProperties(*PostFunction);
   Context.expect(rcc::rebuildMachineLiveness(*PostFunction, Target).has_value(),
                  "post-RA COPY propagation liveness must be rebuilt");
-  rcc::MachineAnalysisManager PostAnalyses;
+  rcc::MachineFunctionAnalysisManager PostAnalyses;
   rcc::MachineCopyPropagationPass PostRA(rcc::riscv::instrInfo(),
                                          rcc::MachineCopyPropagationStage::PostRegisterAllocation);
   auto PostResult = PostRA.run(*PostFunction, Target, PostAnalyses);
@@ -752,7 +752,7 @@ void testStackSlotColoring(TestContext &Context, const rcc::TargetDescription &T
   setPostRAProperties(*Function);
   Context.expect(rcc::rebuildMachineLiveness(*Function, Target).has_value(),
                  "stack-slot coloring liveness must be rebuilt");
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineStackSlotColoringPass Pass;
   auto Result = Pass.run(*Function, Target, Analyses);
   if (!Result)
@@ -836,7 +836,7 @@ void testRISCVMemoryFoldingBoundary(TestContext &Context, const rcc::TargetDescr
     return;
   setSelectedProperties(*Function);
   Function->properties().set(rcc::MachineFunctionProperty::IsSSA);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineMemoryFoldingPass Pass(rcc::riscv::memoryFoldingInfo());
   auto Result = Pass.run(*Function, Target, Analyses);
   if (!Result)
@@ -894,7 +894,7 @@ void testShrinkWrappedFrameRegion(TestContext &Context, const rcc::TargetDescrip
   setPostRAProperties(*Function);
   Context.expect(rcc::rebuildMachineLiveness(*Function, Target).has_value(),
                  "shrink-wrapping fixture liveness must be rebuilt");
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineShrinkWrappingPass Shrink{rcc::riscv::frameLowering()};
   auto Shrunk = Shrink.run(*Function, Target, Analyses);
   Context.expect(Shrunk && Shrunk->Changed &&
@@ -906,7 +906,7 @@ void testShrinkWrappedFrameRegion(TestContext &Context, const rcc::TargetDescrip
   if (!Shrunk)
     return;
 
-  rcc::MachinePassManager FramePipeline;
+  rcc::MachineFunctionPassManager FramePipeline;
   Context.expect(FramePipeline
                      .addPass(std::make_unique<rcc::PrologueEpilogueInsertionPass>(
                          rcc::riscv::frameLowering()))
@@ -975,7 +975,7 @@ void testCompressedAndConditionalRelaxation(TestContext &Context,
   if (Conditional == nullptr)
     return;
   setRelaxationProperties(Context, *Function, Target);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::MachineBranchRelaxationPass Pass(rcc::riscv::instrInfo());
   auto Result = Pass.run(*Function, Target, Analyses);
   if (!Result)
@@ -1108,7 +1108,7 @@ void testPseudoPreparation(TestContext &Context, const rcc::TargetDescription &T
   if (!Copy)
     return;
   setSelectedProperties(*Function);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::PreparePostRAPseudosPass Pass(rcc::riscv::pseudoExpansionInfo());
   auto Result = Pass.run(*Function, Target, Analyses);
   Context.expect(Result && Result->Changed && (*Copy)->operandAt(0)->targetFlags() == 16 &&
@@ -1170,7 +1170,7 @@ void testPostRAPseudoExpansionAndFinalization(TestContext &Context,
 
   setRelaxationProperties(Context, *Function, Target);
   Function->properties().clear(rcc::MachineFunctionProperty::NoExecutablePseudos);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::ExpandPostRAPseudosPass Expansion(rcc::riscv::pseudoExpansionInfo());
   auto Expanded = Expansion.run(*Function, Target, Analyses);
   if (!Expanded)
@@ -1196,7 +1196,7 @@ void testPostRAPseudoExpansionAndFinalization(TestContext &Context,
   if (!Expanded)
     return;
 
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   Context.expect(Pipeline.addPass(std::make_unique<rcc::FinalizeEmissionPseudosPass>()) &&
                      Pipeline.addPass(std::make_unique<rcc::FinalEncodabilityVerifierPass>(
                          rcc::riscv::instrInfo())),
@@ -1213,8 +1213,8 @@ void testCanonicalOptimizationPipelines(TestContext &Context,
                                         const rcc::TargetDescription &Target) {
   const rcc::MachineOptimizationPipelineTargetInfo TargetInfo =
       rcc::riscv::optimizationPipelineInfo();
-  rcc::MachinePassManager SelectedPipeline;
-  rcc::MachinePassManager PreRAPipeline;
+  rcc::MachineFunctionPassManager SelectedPipeline;
+  rcc::MachineFunctionPassManager PreRAPipeline;
   Context.expect(rcc::addSelectedSSAOptimizationPipeline(SelectedPipeline, TargetInfo) &&
                      SelectedPipeline.size() == 6,
                  "canonical selected-SSA optimization pipeline must register completely");
@@ -1259,13 +1259,13 @@ void testCanonicalOptimizationPipelines(TestContext &Context,
     return;
   }
 
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   auto Added = rcc::addPostRegisterAllocationPipeline(Pipeline, TargetInfo);
   Context.expect(Added && Pipeline.size() == 20,
                  "canonical post-RA pipeline must register every required pass");
   if (!Added)
     return;
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerMachineOptimizationAnalyses(Analyses);
   Context.expect(Registered.has_value(),
                  "canonical optimization analyses must register completely");
@@ -1325,7 +1325,7 @@ void testTargetLateExpansionRejectsSizeGrowth(TestContext &Context) {
   GrowingLatePseudoInfo ExpansionInfo;
   FixedSizeInstrInfo InstrInfo;
   rcc::TargetLatePseudoExpansionPass Pass(ExpansionInfo, InstrInfo);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Result = Pass.run(*Function, *Target, Analyses);
   Context.expect(!Result && Result.error().code() == rcc::ErrorCode::PseudoExpansionFailed &&
                      (*Pseudo)->parent() == Block && Block->firstInstruction() == *Pseudo &&
@@ -1373,7 +1373,7 @@ void testTargetLateExpansionRejectsCompensatedGrowth(TestContext &Context) {
   GrowingLatePseudoInfo ExpansionInfo;
   FixedSizeInstrInfo InstrInfo;
   rcc::TargetLatePseudoExpansionPass Pass(ExpansionInfo, InstrInfo);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Result = Pass.run(*Function, *Target, Analyses);
   Context.expect(
       !Result && Result.error().code() == rcc::ErrorCode::PseudoExpansionFailed &&
@@ -1403,7 +1403,7 @@ void testFinalEncodabilityRejectsInvalidInstruction(TestContext &Context,
     return;
   }
   setRelaxationProperties(Context, *ImmediateFunction, Target);
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   rcc::FinalEncodabilityVerifierPass Verifier(rcc::riscv::instrInfo());
   auto ImmediateResult = Verifier.run(*ImmediateFunction, Target, Analyses);
   Context.expect(!ImmediateResult &&
diff --git a/backend/unittests/Target/RISCVRegisterAllocationTest.cpp b/backend/unittests/Target/RISCVRegisterAllocationTest.cpp
index 0e60e63..acd4b3a 100644
--- a/backend/unittests/Target/RISCVRegisterAllocationTest.cpp
+++ b/backend/unittests/Target/RISCVRegisterAllocationTest.cpp
@@ -11,7 +11,7 @@
 #include "rcc/CodeGen/MachineInstr.h"
 #include "rcc/CodeGen/MachineMemOperand.h"
 #include "rcc/CodeGen/MachineOperand.h"
-#include "rcc/CodeGen/MachinePass.h"
+#include "rcc/CodeGen/MachinePassManager.h"
 #include "rcc/CodeGen/MachineRegisterInfo.h"
 #include "rcc/CodeGen/RegAllocCommon.h"
 #include "rcc/CodeGen/RegAllocFast.h"
@@ -168,7 +168,7 @@ enum class AllocatorKind : std::uint8_t {
                                                const rcc::TargetDescription &Target,
                                                AllocatorKind Kind,
                                                rcc::RegisterAllocationOptions Options = {}) {
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Registered = rcc::registerStage11MachineAnalyses(Analyses);
   if (!Registered)
     return std::unexpected(Registered.error());
@@ -184,7 +184,7 @@ enum class AllocatorKind : std::uint8_t {
     Pass = std::make_unique<rcc::PBQPAllocatorPass>(rcc::riscv::registerAllocationInfo(), Options);
     break;
   }
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   auto Added = Pipeline.addPass(std::move(Pass));
   if (!Added)
     return std::unexpected(Added.error());
diff --git a/backend/unittests/Target/RISCVSSAExitTest.cpp b/backend/unittests/Target/RISCVSSAExitTest.cpp
index ab30572..ec98bd1 100644
--- a/backend/unittests/Target/RISCVSSAExitTest.cpp
+++ b/backend/unittests/Target/RISCVSSAExitTest.cpp
@@ -10,7 +10,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/MachineVerifier.h"
 #include "rcc/CodeGen/PHIElimination.h"
 #include "rcc/Target/RISCV/RISCVTarget.h"
@@ -352,12 +352,12 @@ void testRV64GCCriticalEdge(TestContext &Context, const rcc::TargetDescription &
   if (!InitialLiveness)
     return;
 
-  rcc::MachinePassManager Pipeline;
+  rcc::MachineFunctionPassManager Pipeline;
   Context.expect(
       Pipeline.addPass(std::make_unique<rcc::PHIEliminationPass>(rcc::riscv::instrInfo()))
           .has_value(),
       "RV64GC PHI-elimination pass must be registered");
-  rcc::MachineAnalysisManager Analyses;
+  rcc::MachineFunctionAnalysisManager Analyses;
   auto Run = Pipeline.run(**Function, Target, Analyses);
   Context.expect(Run.has_value(), "RV64GC critical-edge PHI elimination must succeed");
   if (!Run)