Return generalized side table from validation

crates/interpreter/src/module.rs

@@ -184,7 +184,6 @@ impl<'m> Module<'m> {
         unreachable!()
     }
 
-    // TODO(dev/fast-interp): Improve the performance of such accessor functions from O(n) to O(1).
     pub(crate) fn func(&self, x: FuncIdx) -> (Parser<'m>, &'m [BranchTableEntry]) {
         let mut parser = self.section(SectionId::Code).unwrap();
         for i in 0 .. parser.parse_vec().into_ok() {

crates/interpreter/src/valid.rs

@@ -129,13 +129,24 @@ impl<'m> Context<'m> {
         let mut side_tables = vec![];
         if let Some(mut parser) = self.check_section(parser, SectionId::Code)? {
             check(self.funcs.len() == imported_funcs + parser.parse_vec()?)?;
+            let saved = parser.save();
             for x in imported_funcs .. self.funcs.len() {
                 let size = parser.parse_u32()? as usize;
                 let mut parser = parser.split_at(size)?;
                 let t = self.functype(x as FuncIdx).unwrap();
                 let mut locals = t.params.to_vec();
                 parser.parse_locals(&mut locals)?;
-                side_tables.push(Expr::check_body(self, &mut parser, &refs, locals, t.results)?);
+                let parser_start =
+                    unsafe { parser.save().as_ptr().offset_from(saved.as_ptr()) as usize };
+                side_tables.push(Expr::check_body(
+                    self,
+                    &mut parser,
+                    &refs,
+                    locals,
+                    t.results,
+                    Some(self.funcs[x]),
+                    ParserRange { start: parser_start, end: parser_start + size },
+                )?);
                 check(parser.is_empty())?;
             }
             check(parser.is_empty())?;
@@ -412,31 +423,42 @@ struct Expr<'a, 'm> {
     side_table: SideTable,
 }
 
+#[allow(dead_code)]
+#[derive(Default)]
+struct ParserRange {
+    start: usize,
+    end: usize, // exclusive
+}
+
 #[derive(Default)]
 struct SideTable {
-    entries: Vec<BranchTableEntry>,
+    #[allow(dead_code)]
+    type_idx: usize,
+    #[allow(dead_code)]
+    parser_range: ParserRange,
+    branch_table: Vec<BranchTableEntry>,
 }
 
 impl SideTable {
     fn save(&self) -> usize {
-        self.entries.len()
+        self.branch_table.len()
     }
 
     fn branch(&mut self) {
-        self.entries.push(BranchTableEntry::invalid());
+        self.branch_table.push(BranchTableEntry::invalid());
     }
 
     fn stitch(&mut self, source: SideTableBranch, target: SideTableBranch) -> CheckResult {
         let delta_ip = Self::delta(source, target, |x| x.parser.as_ptr() as isize)?;
-        let delta_stp = Self::delta(source, target, |x| x.side_table as isize)?;
+        let delta_stp = Self::delta(source, target, |x| x.branch_table as isize)?;
         let val_cnt = u32::try_from(target.result).map_err(|_| {
             #[cfg(feature = "debug")]
             eprintln!("side-table val_cnt overflow {0}", target.result);
             unsupported(if_debug!(Unsupported::SideTable))
         })?;
         let pop_cnt = Self::pop_cnt(source, target)?;
-        debug_assert!(self.entries[source.side_table].is_invalid());
-        self.entries[source.side_table] =
+        debug_assert!(self.branch_table[source.branch_table].is_invalid());
+        self.branch_table[source.branch_table] =
             BranchTableEntry::new(BranchTableEntryView { delta_ip, delta_stp, val_cnt, pop_cnt })?;
         Ok(())
     }
@@ -477,15 +499,15 @@ impl SideTable {
     }
 
     fn persist(self) -> MResult<Vec<BranchTableEntry>, Check> {
-        debug_assert!(self.entries.iter().all(|x| !x.is_invalid()));
-        Ok(self.entries)
+        debug_assert!(self.branch_table.iter().all(|x| !x.is_invalid()));
+        Ok(self.branch_table)
     }
 }
 
 #[derive(Debug, Copy, Clone)]
 struct SideTableBranch<'m> {
     parser: &'m [u8],
-    side_table: usize,
+    branch_table: usize,
     stack: usize,
     result: usize, // unused (zero) for source branches
 }
@@ -514,7 +536,8 @@ enum LabelKind<'m> {
 impl<'a, 'm> Expr<'a, 'm> {
     fn new(
         context: &'a Context<'m>, parser: &'a mut Parser<'m>,
-        is_const: Result<&'a mut [bool], &'a [bool]>,
+        is_const: Result<&'a mut [bool], &'a [bool]>, type_idx: Option<TypeIdx>,
+        parser_range: ParserRange,
     ) -> Self {
         Self {
             context,
@@ -524,25 +547,30 @@ impl<'a, 'm> Expr<'a, 'm> {
             is_body: false,
             locals: vec![],
             labels: vec![Label::default()],
-            side_table: SideTable::default(),
+            side_table: type_idx.map_or_else(SideTable::default, |idx| SideTable {
+                type_idx: idx as usize,
+                parser_range,
+                branch_table: vec![],
+            }),
         }
     }
 
     fn check_const(
         context: &'a Context<'m>, parser: &'a mut Parser<'m>, refs: &'a mut [bool],
         num_global_imports: usize, expected: ResultType<'m>,
     ) -> CheckResult {
-        let mut expr = Expr::new(context, parser, Ok(refs));
+        let mut expr = Expr::new(context, parser, Ok(refs), None, ParserRange::default());
         expr.globals_len = num_global_imports;
         expr.label().type_.results = expected;
         expr.check()
     }
 
     fn check_body(
         context: &'a Context<'m>, parser: &'a mut Parser<'m>, refs: &'a [bool],
-        locals: Vec<ValType>, results: ResultType<'m>,
+        locals: Vec<ValType>, results: ResultType<'m>, type_idx: Option<TypeIdx>,
+        parser_range: ParserRange,
     ) -> MResult<Vec<BranchTableEntry>, Check> {
-        let mut expr = Expr::new(context, parser, Err(refs));
+        let mut expr = Expr::new(context, parser, Err(refs), type_idx, parser_range);
         expr.is_body = true;
         expr.locals = locals;
         expr.label().type_.results = results;
@@ -602,7 +630,7 @@ impl<'a, 'm> Expr<'a, 'm> {
                     LabelKind::If(source) => {
                         let result = self.label().type_.results.len();
                         let mut target = self.branch_target(result);
-                        target.side_table += 1;
+                        target.branch_table += 1;
                         self.side_table.stitch(source, target)?
                     }
                     _ => Err(invalid())?,
@@ -911,7 +939,7 @@ impl<'a, 'm> Expr<'a, 'm> {
     fn branch(&self) -> SideTableBranch<'m> {
         SideTableBranch {
             parser: self.parser.save(),
-            side_table: self.side_table.save(),
+            branch_table: self.side_table.save(),
             stack: self.immutable_label().prev_stack,
             result: 0,
         }