Use instead of restoring side table for Loop

crates/interpreter/src/exec.rs

@@ -759,20 +759,13 @@ impl<'m> Thread<'m> {
 
     fn step(mut self, store: &mut Store<'m>) -> Result<ThreadResult<'m>, Error> {
         use Instr::*;
-        let saved = self.parser.save();
         let inst_id = self.frame().inst_id;
         let inst = &mut store.insts[inst_id];
         match self.parser.parse_instr().into_ok() {
             Unreachable => return Err(trap()),
             Nop => (),
             Block(b) => self.push_label(self.blocktype(inst, &b), LabelKind::Block),
-            Loop(b) => {
-                let side_table = self.frame().side_table;
-                self.push_label(
-                    self.blocktype(inst, &b),
-                    LabelKind::Loop(LoopState { parser_data: saved, side_table }),
-                )
-            }
+            Loop(b) => self.push_label(self.blocktype(inst, &b), LabelKind::Loop),
             If(b) => match self.pop_value().unwrap_i32() {
                 0 => {
                     self.take_jump(0);
@@ -988,11 +981,11 @@ impl<'m> Thread<'m> {
         self.frames.last_mut().unwrap()
     }
 
-    fn labels(&mut self) -> &mut Vec<Label<'m>> {
+    fn labels(&mut self) -> &mut Vec<Label> {
         &mut self.frame().labels
     }
 
-    fn label(&mut self) -> &mut Label<'m> {
+    fn label(&mut self) -> &mut Label {
         self.labels().last_mut().unwrap()
     }
 
@@ -1042,10 +1035,10 @@ impl<'m> Thread<'m> {
         self.values().split_off(len)
     }
 
-    fn push_label(&mut self, type_: FuncType<'m>, kind: LabelKind<'m>) {
+    fn push_label(&mut self, type_: FuncType<'m>, kind: LabelKind) {
         let arity = match kind {
             LabelKind::Block | LabelKind::If => type_.results.len(),
-            LabelKind::Loop(_) => type_.params.len(),
+            LabelKind::Loop => type_.params.len(),
         };
         let label = Label { arity, kind, values_cnt: type_.params.len() };
         self.label().values_cnt -= label.values_cnt;
@@ -1064,11 +1057,7 @@ impl<'m> Thread<'m> {
         self.values().drain(values_len - values_cnt .. values_len - arity);
         self.label().values_cnt += arity;
         match kind {
-            LabelKind::Loop(state) => unsafe {
-                self.frame().side_table = state.side_table;
-                self.parser.restore(state.parser_data)
-            },
-            LabelKind::Block | LabelKind::If => self.take_jump(offset),
+            LabelKind::Block | LabelKind::If | LabelKind::Loop => self.take_jump(offset),
         }
         ThreadResult::Continue(self)
     }
@@ -1422,7 +1411,7 @@ struct Frame<'m> {
     arity: usize,
     ret: &'m [u8],
     locals: Vec<Val>,
-    labels: Vec<Label<'m>>,
+    labels: Vec<Label>,
     side_table: &'m [SideTableEntry],
 }
 
@@ -1448,26 +1437,18 @@ impl<'m> Frame<'m> {
 }
 
 #[derive(Debug)]
-struct Label<'m> {
+struct Label {
     arity: usize,
-    kind: LabelKind<'m>,
+    kind: LabelKind,
     values_cnt: usize,
 }
 
 #[derive(Debug)]
-struct LoopState<'m> {
-    parser_data: &'m [u8],
-    side_table: &'m [SideTableEntry],
-}
-
-#[derive(Debug)]
-enum LabelKind<'m> {
+enum LabelKind {
     // TODO: If and Block can be merged and then we just have Option<NonNull<u8>> which is
     // optimized.
     Block,
-    // TODO: Could be just NonNull<u8> since we can reuse the end of current parser since it
-    // never changes.
-    Loop(LoopState<'m>),
+    Loop,
     If,
 }
 

crates/interpreter/src/valid.rs

@@ -586,7 +586,9 @@ impl<'a, 'm> Expr<'a, 'm> {
             Block(b) => self.push_label(self.blocktype(&b)?, LabelKind::Block)?,
             Loop(b) => {
                 let type_ = self.blocktype(&b)?;
-                self.push_label(type_, LabelKind::Loop(self.branch_target(type_.params.len())))?
+                let mut target = self.branch_target(type_.params.len());
+                target.parser = offset_parser(target, -2);
+                self.push_label(type_, LabelKind::Loop(target))?
             }
             If(b) => {
                 self.pop_check(ValType::I32)?;
@@ -859,12 +861,7 @@ impl<'a, 'm> Expr<'a, 'm> {
         if let LabelKind::If(source) = label.kind {
             check(label.type_.params == label.type_.results)?;
             // SAFETY: This function is only called after parsing an End instruction.
-            target.parser = unsafe {
-                core::slice::from_raw_parts(
-                    target.parser.as_ptr().offset(-1),
-                    target.parser.len() + 1,
-                )
-            };
+            target.parser = offset_parser(target, -1);
             self.side_table.stitch(source, target)?;
         }
         let results = self.label().type_.results;
@@ -979,3 +976,12 @@ impl<'a, 'm> Expr<'a, 'm> {
         }
     }
 }
+
+fn offset_parser(branch: SideTableBranch, off: isize) -> &[u8] {
+    unsafe {
+        core::slice::from_raw_parts(
+            branch.parser.as_ptr().offset(off),
+            (branch.parser.len() as isize - off) as usize,
+        )
+    }
+}