Make metadata(), parse_u16() and view() generic (#775)

#46

---------

Co-authored-by: Zhou Fang <[email protected]>
Co-authored-by: Julien Cretin <[email protected]>

Author: zhouwfang

crates/interpreter/src/exec.rs

@@ -1045,7 +1045,8 @@ impl<'m> Thread<'m> {
             return self.exit_frame();
         }
         frame.labels_cnt = i;
-        let BranchTableEntryView { val_cnt, pop_cnt, .. } = frame.side_table[offset].view();
+        let Ok(BranchTableEntryView { val_cnt, pop_cnt, .. }) =
+            frame.side_table[offset].view::<Use>();
         let val_pos = self.values().len() - val_cnt as usize;
         self.values().drain(val_pos - pop_cnt as usize .. val_pos);
         self.take_jump(offset);
@@ -1413,7 +1414,7 @@ impl<'m> Frame<'m> {
 
     fn take_jump(&mut self, parser_pos: &'m [u8], offset: usize) -> Parser<'m> {
         self.side_table = offset_front(self.side_table, offset as isize);
-        let entry = self.side_table[0].view();
+        let entry = self.side_table[0].view::<Use>().into_ok();
         self.side_table = offset_front(self.side_table, entry.delta_stp as isize);
         unsafe { Parser::new(offset_front(parser_pos, entry.delta_ip as isize)) }
     }

crates/interpreter/src/module.rs

@@ -112,7 +112,7 @@ impl<'m> Module<'m> {
     }
 
     pub(crate) fn func_type(&self, x: FuncIdx) -> FuncType<'m> {
-        self.types[self.side_table.metadata(x as usize).type_idx()]
+        self.types[self.side_table.metadata::<Use>(x as usize).into_ok().type_idx()]
     }
 
     pub(crate) fn table_type(&self, x: TableIdx) -> TableType {
@@ -173,7 +173,7 @@ impl<'m> Module<'m> {
     }
 
     pub(crate) fn func(&self, x: FuncIdx) -> (Parser<'m>, &'m [BranchTableEntry]) {
-        let metadata = self.side_table.metadata(x as usize);
+        let metadata = self.side_table.metadata::<Use>(x as usize).into_ok();
         (unsafe { Parser::new(&self.binary[metadata.parser_range()]) }, metadata.branch_table())
     }
 

crates/interpreter/src/side_table.rs

@@ -16,7 +16,7 @@ use alloc::vec::Vec;
 use core::ops::Range;
 
 use crate::error::*;
-use crate::module::Parser;
+use crate::toctou::*;
 
 pub const SECTION_NAME: &str = "wasefire-sidetable";
 
@@ -27,13 +27,12 @@ pub struct SideTableView<'m> {
 }
 
 impl<'m> SideTableView<'m> {
-    // TODO(dev/fast-interp): Make it generic since it will be used in both `Check` and `Use` modes.
-    // (Returns `MResult<Metadata<'m>, M>` instead.)
-    pub fn metadata(&self, func_idx: usize) -> Metadata<'m> {
-        Metadata(
-            &self.metadata[parse_u16(self.indices, func_idx * 2) as usize
-                .. parse_u16(self.indices, (func_idx + 1) * 2) as usize],
-        )
+    pub fn metadata<M: Mode>(&self, func_idx: usize) -> MResult<Metadata<'m>, M> {
+        let start_idx = M::open(|| func_idx.checked_mul(2))?;
+        let end_idx = M::open(|| start_idx.checked_add(2))?;
+        let start = parse_u16::<M>(self.indices, start_idx)? as usize;
+        let end = parse_u16::<M>(self.indices, end_idx)? as usize;
+        Ok(Metadata(M::open(|| self.metadata.get(start .. end))?))
     }
 }
 
@@ -42,12 +41,7 @@ pub struct Metadata<'m>(&'m [u8]);
 
 impl<'m> Metadata<'m> {
     pub fn type_idx(&self) -> usize {
-        parse_u16(self.0, 0) as usize
-    }
-
-    #[allow(dead_code)]
-    pub fn parser(&self, module: &'m [u8]) -> Parser<'m> {
-        unsafe { Parser::new(&module[self.parser_range()]) }
+        parse_u16::<Use>(self.0, 0).into_ok() as usize
     }
 
     pub fn branch_table(&self) -> &'m [BranchTableEntry] {
@@ -137,14 +131,14 @@ impl BranchTableEntry {
         ]))
     }
 
-    pub fn view(self) -> BranchTableEntryView {
-        let pop_val_counts = parse_u16(&self.0, 4);
-        BranchTableEntryView {
-            delta_ip: (parse_u16(&self.0, 0) as i16) as i32,
-            delta_stp: (parse_u16(&self.0, 2) as i16) as i32,
+    pub fn view<M: Mode>(self) -> MResult<BranchTableEntryView, M> {
+        let pop_val_counts = parse_u16::<M>(&self.0, 4)?;
+        Ok(BranchTableEntryView {
+            delta_ip: (parse_u16::<M>(&self.0, 0)? as i16) as i32,
+            delta_stp: (parse_u16::<M>(&self.0, 2)? as i16) as i32,
             val_cnt: (pop_val_counts & 0xf) as u32,
             pop_cnt: (pop_val_counts >> 4) as u32,
-        }
+        })
     }
 
     pub fn is_invalid(self) -> bool {
@@ -156,8 +150,9 @@ impl BranchTableEntry {
     }
 }
 
-fn parse_u16(data: &[u8], offset: usize) -> u16 {
-    u16::from_le_bytes(data[offset ..][.. 2].try_into().unwrap())
+fn parse_u16<M: Mode>(data: &[u8], offset: usize) -> MResult<u16, M> {
+    let bytes = M::open(|| try { data.get(offset .. offset.checked_add(2)?)? })?;
+    Ok(u16::from_le_bytes(bytes.try_into().unwrap()))
 }
 
 fn parse_u32(data: &[u8], offset: usize) -> u32 {

crates/interpreter/src/valid.rs

@@ -164,7 +164,7 @@ impl ValidMode for Verify {
     fn next_branch_table<'a, 'm>(
         side_table: &'a mut Self::SideTable<'m>, type_idx: usize, parser_range: Range<usize>,
     ) -> Result<Self::BranchTable<'a, 'm>, Error> {
-        let metadata = side_table.view.metadata(side_table.func_idx);
+        let metadata = side_table.view.metadata::<Check>(side_table.func_idx)?;
         side_table.func_idx += 1;
         check(metadata.type_idx() == type_idx)?;
         check(metadata.parser_range() == parser_range)?;
@@ -190,7 +190,7 @@ impl<'m> BranchTableApi<'m> for MetadataView<'m> {
     }
 
     fn patch_branch(&self, mut source: SideTableBranch<'m>) -> Result<SideTableBranch<'m>, Error> {
-        let entry = self.metadata.branch_table()[source.branch_table].view();
+        let entry = self.metadata.branch_table()[source.branch_table].view::<Check>()?;
         // TODO(dev/fast-interp): We want a safe version of offset_front.
         source.parser = offset_front(source.parser, entry.delta_ip as isize);
         source.branch_table =