[CodeGen] Align pass manager ownership

42 files changed, 1142 insertions, 826 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"