Remove unused wasmi_ir codegen and refactor VisitRegs trait (#1649)

* remove visit_input_reg[s] trait methods

* remove Res utility type

* rename HostVisitor and VisitRegs traits

* rename visit_regs -> visit_results

* fix broken doc links

Author: Robbepop

crates/ir/src/enum.rs

@@ -81,14 +81,13 @@ macro_rules! define_enum {
             )*
         }
 
-        impl<'a> $crate::visit_regs::HostVisitor for &'a mut Instruction {
-            fn host_visitor<V: VisitRegs>(self, visitor: &mut V) {
+        impl<'a> $crate::visit_results::ResultsVisitor for &'a mut Instruction {
+            fn host_visitor<V: VisitResults>(self, visitor: &mut V) {
                 match self {
                     $(
-                        Instruction::$name { $( $( $result_name, )? $( $field_name, )* )? } => {
+                        Instruction::$name { $( $( $result_name, )? .. )? } => {
                             $(
-                                $( $crate::visit_regs::Res($result_name).host_visitor(visitor); )?
-                                $( $field_name.host_visitor(visitor); )*
+                                $( $result_name.host_visitor(visitor); )?
                             )?
                         }
                     )*

crates/ir/src/lib.rs

@@ -12,7 +12,7 @@ mod immeditate;
 pub mod index;
 mod primitive;
 mod span;
-mod visit_regs;
+mod visit_results;
 
 #[cfg(test)]
 mod tests;
@@ -43,5 +43,5 @@ pub use self::{
     },
     r#enum::Instruction,
     span::{BoundedRegSpan, FixedRegSpan, RegSpan, RegSpanIter},
-    visit_regs::VisitRegs,
+    visit_results::VisitResults,
 };

crates/ir/src/visit_regs.rs

@@ -0,0 +1,54 @@
+use crate::{index::*, *};
+
+impl Instruction {
+    /// Visit result [`Reg`]s of `self` via the `visitor`.
+    pub fn visit_results<V: VisitResults>(&mut self, visitor: &mut V) {
+        ResultsVisitor::host_visitor(self, visitor)
+    }
+}
+
+/// Implemented by [`Reg`] visitors to visit result [`Reg`]s of an [`Instruction`] via [`Instruction::visit_results`].
+pub trait VisitResults {
+    /// Visits a [`Reg`] storing the result of an [`Instruction`].
+    fn visit_result_reg(&mut self, reg: &mut Reg);
+    /// Visits a [`RegSpan`] storing the results of an [`Instruction`].
+    fn visit_result_regs(&mut self, reg: &mut RegSpan, len: Option<u16>);
+}
+
+/// Internal trait used to dispatch to a [`VisitResults`] visitor.
+pub trait ResultsVisitor {
+    /// Host the [`VisitResults`] visitor in the appropriate way.
+    fn host_visitor<V: VisitResults>(self, visitor: &mut V);
+}
+
+impl ResultsVisitor for &'_ mut Reg {
+    fn host_visitor<V: VisitResults>(self, visitor: &mut V) {
+        visitor.visit_result_reg(self);
+    }
+}
+
+impl ResultsVisitor for &'_ mut [Reg; 2] {
+    fn host_visitor<V: VisitResults>(self, visitor: &mut V) {
+        visitor.visit_result_reg(&mut self[0]);
+        visitor.visit_result_reg(&mut self[1]);
+    }
+}
+
+impl ResultsVisitor for &'_ mut RegSpan {
+    fn host_visitor<V: VisitResults>(self, visitor: &mut V) {
+        visitor.visit_result_regs(self, None);
+    }
+}
+
+impl ResultsVisitor for &'_ mut BoundedRegSpan {
+    fn host_visitor<V: VisitResults>(self, visitor: &mut V) {
+        let len = self.len();
+        visitor.visit_result_regs(self.span_mut(), Some(len));
+    }
+}
+
+impl<const N: u16> ResultsVisitor for &'_ mut FixedRegSpan<N> {
+    fn host_visitor<V: VisitResults>(self, visitor: &mut V) {
+        visitor.visit_result_regs(self.span_mut(), Some(N));
+    }
+}

crates/ir/src/visit_results.rs

@@ -1,6 +1,6 @@
 use crate::{
     engine::EngineFunc,
-    ir::{index, Instruction, Reg, RegSpan, VisitRegs},
+    ir::{index, Instruction, Reg, RegSpan, VisitResults},
     module::ModuleHeader,
     Engine,
     Error,
@@ -47,7 +47,7 @@ impl Visitor {
     }
 }
 
-impl VisitRegs for Visitor {
+impl VisitResults for Visitor {
     #[inline]
     fn visit_result_reg(&mut self, reg: &mut Reg) {
         if self.replaced.is_err() {
@@ -58,12 +58,6 @@ impl VisitRegs for Visitor {
 
     #[inline(always)]
     fn visit_result_regs(&mut self, _reg: &mut RegSpan, _len: Option<u16>) {}
-
-    #[inline(always)]
-    fn visit_input_reg(&mut self, _reg: &mut Reg) {}
-
-    #[inline(always)]
-    fn visit_input_regs(&mut self, _regs: &mut RegSpan, _len: Option<u16>) {}
 }
 
 impl RelinkResult for Instruction {
@@ -97,7 +91,7 @@ impl RelinkResult for Instruction {
             instr => {
                 // Fallback: only relink results of instructions with statically known single results.
                 let mut visitor = Visitor::new(new_result, old_result);
-                instr.visit_regs(&mut visitor);
+                instr.visit_results(&mut visitor);
                 visitor.replaced
             }
         }