fix: borrow import names from bytecode instead of allocating them

Signed-off-by: Florian Hartung <florian.hartung@dlr.de>

Author: florianhartung

src/core/reader/types/import.rs

@@ -1,6 +1,3 @@
-use alloc::borrow::ToOwned;
-use alloc::string::String;
-
 use crate::core::indices::TypeIdx;
 use crate::core::reader::WasmReader;
 use crate::{ValidationError, ValidationInfo};
@@ -9,16 +6,16 @@ use super::global::GlobalType;
 use super::{ExternType, MemType, TableType};
 
 #[derive(Debug, Clone)]
-pub struct Import {
-    pub module_name: String,
-    pub name: String,
+pub struct Import<'wasm> {
+    pub module_name: &'wasm str,
+    pub name: &'wasm str,
     pub desc: ImportDesc,
 }
 
-impl Import {
-    pub fn read(wasm: &mut WasmReader) -> Result<Self, ValidationError> {
-        let module_name = wasm.read_name()?.to_owned();
-        let name = wasm.read_name()?.to_owned();
+impl<'wasm> Import<'wasm> {
+    pub fn read(wasm: &mut WasmReader<'wasm>) -> Result<Self, ValidationError> {
+        let module_name = wasm.read_name()?;
+        let name = wasm.read_name()?;
         let desc = ImportDesc::read(wasm)?;
 
         Ok(Self {

src/core/reader/types/values.rs

@@ -19,7 +19,7 @@ const CONTINUATION_BIT: u8 = 0b10000000;
 
 const INTEGER_BIT_FLAG: u8 = !CONTINUATION_BIT;
 
-impl WasmReader<'_> {
+impl<'wasm> WasmReader<'wasm> {
     /// Tries to read one byte and fails if the end of file is reached.
     pub fn read_u8(&mut self) -> Result<u8, ValidationError> {
         let byte = self.peek_u8()?;
@@ -351,7 +351,7 @@ impl WasmReader<'_> {
     }
 
     /// Note: If `Err`, the [WasmReader] object is no longer guaranteed to be in a valid state
-    pub fn read_name(&mut self) -> Result<&str, ValidationError> {
+    pub fn read_name(&mut self) -> Result<&'wasm str, ValidationError> {
         let len = self.read_var_u32()? as usize;
 
         let utf8_str = &self
@@ -369,7 +369,8 @@ impl WasmReader<'_> {
         mut read_element: F,
     ) -> Result<Vec<T>, ValidationError>
     where
-        F: FnMut(&mut WasmReader, usize) -> Result<T, ValidationError>,
+        T: 'wasm,
+        F: FnMut(&mut WasmReader<'wasm>, usize) -> Result<T, ValidationError>,
     {
         let mut idx = 0;
         self.read_vec(|wasm| {
@@ -382,7 +383,8 @@ impl WasmReader<'_> {
     /// Note: If `Err`, the [WasmReader] object is no longer guaranteed to be in a valid state
     pub fn read_vec<T, F>(&mut self, mut read_element: F) -> Result<Vec<T>, ValidationError>
     where
-        F: FnMut(&mut WasmReader) -> Result<T, ValidationError>,
+        T: 'wasm,
+        F: FnMut(&mut WasmReader<'wasm>) -> Result<T, ValidationError>,
     {
         let len = self.read_var_u32()?;
         core::iter::repeat_with(|| read_element(self))

src/execution/linker.rs

@@ -1,4 +1,5 @@
 use alloc::{
+    borrow::ToOwned,
     collections::btree_map::{BTreeMap, Entry},
     string::String,
     vec::Vec,
@@ -141,7 +142,7 @@ impl Linker {
             .imports
             .iter()
             .map(|import| {
-                self.get_unchecked(import.module_name.clone(), import.name.clone())
+                self.get_unchecked(import.module_name.to_owned(), import.name.to_owned())
                     .ok_or(RuntimeError::UnableToResolveExternLookup)
             })
             .collect()

src/validation/mod.rs

@@ -39,7 +39,7 @@ pub(crate) struct ImportsLength {
 pub struct ValidationInfo<'bytecode> {
     pub(crate) wasm: &'bytecode [u8],
     pub(crate) types: Vec<FuncType>,
-    pub(crate) imports: Vec<Import>,
+    pub(crate) imports: Vec<Import<'bytecode>>,
     pub(crate) functions: Vec<TypeIdx>,
     pub(crate) tables: Vec<TableType>,
     pub(crate) memories: Vec<MemType>,
@@ -488,12 +488,16 @@ fn read_next_header(
 }
 
 #[inline(always)]
-fn handle_section<T, F: FnOnce(&mut WasmReader, SectionHeader) -> Result<T, ValidationError>>(
-    wasm: &mut WasmReader,
+fn handle_section<'wasm, T, F>(
+    wasm: &mut WasmReader<'wasm>,
     header: &mut Option<SectionHeader>,
     section_ty: SectionTy,
     handler: F,
-) -> Result<Option<T>, ValidationError> {
+) -> Result<Option<T>, ValidationError>
+where
+    T: 'wasm,
+    F: FnOnce(&mut WasmReader<'wasm>, SectionHeader) -> Result<T, ValidationError>,
+{
     match &header {
         Some(SectionHeader { ty, .. }) if *ty == section_ty => {
             let h = header.take().unwrap();