[2/3] fix: prune spills by reachability, not dominance

dialects/hir/src/transforms/spill.rs

@@ -1,4 +1,4 @@
-use alloc::rc::Rc;
+use alloc::{format, rc::Rc};
 
 use midenc_hir::{
     BlockRef, BuilderExt, EntityMut, Op, OpBuilder, OperationName, OperationRef, Report, Rewriter,
@@ -8,11 +8,16 @@ use midenc_hir::{
     pass::{Pass, PassExecutionState, PostPassStatus},
 };
 use midenc_hir_analysis::analyses::SpillAnalysis;
-use midenc_hir_transform::{self as transforms, ReloadLike, SpillLike, TransformSpillsInterface};
+use midenc_hir_transform::{self as transforms, SpillLike, TransformSpillsInterface};
 
 #[derive(Default)]
 pub struct TransformSpills;
 
+midenc_hir::inventory::submit!(::midenc_hir::pass::registry::PassInfo::new::<TransformSpills>(
+    "transform-spills",
+    "materialize operand stack spills as stores/loads of procedure locals"
+));
+
 impl Pass for TransformSpills {
     type Target = Function;
 
@@ -129,14 +134,18 @@ impl TransformSpillsInterface for TransformSpillsImpl {
         &mut self,
         rewriter: &mut dyn Rewriter,
         spill: OperationRef,
+        value: ValueRef,
     ) -> Result<(), Report> {
         use crate::HirOpBuilder;
 
+        // The local is keyed by the analysis's identity of the spilled value; the stored operand
+        // is the op's current one, which SSA reconstruction may have rewritten (e.g. to a
+        // preceding reload's result), but always carries the same runtime value.
         let spilled = spill.borrow().as_trait::<dyn SpillLike>().unwrap().spilled_value();
         let mut function = self.function;
-        let local = *self.locals.entry(spilled).or_insert_with(|| {
+        let local = *self.locals.entry(value).or_insert_with(|| {
             let mut function = function.borrow_mut();
-            function.alloc_local(spilled.borrow().ty().clone())
+            function.alloc_local(value.borrow().ty().clone())
         });
 
         let store = rewriter.store_local(local, spilled, spill.span())?;
@@ -150,11 +159,18 @@ impl TransformSpillsInterface for TransformSpillsImpl {
         &mut self,
         rewriter: &mut dyn Rewriter,
         reload: OperationRef,
+        value: ValueRef,
     ) -> Result<(), Report> {
         use crate::HirOpBuilder;
 
-        let spilled = reload.borrow().as_trait::<dyn ReloadLike>().unwrap().spilled_value();
-        let local = self.locals[&spilled];
+        let Some(local) = self.locals.get(&value).copied() else {
+            let function = self.function.borrow();
+            let function = function.get_name();
+            return Err(Report::msg(format!(
+                "internal error: live reload of {value} in {function} has no corresponding spill: \
+                 every kept reload must be covered by at least one spill of the same value"
+            )));
+        };
         let reloaded = rewriter.load_local(local, reload.span())?;
 
         rewriter.replace_op_with_values(reload, &[Some(reloaded)]);