chore: update wasmparser

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

Cargo.lock

@@ -13,7 +13,7 @@ default-members = [".", "crates/parser", "crates/tinywasm", "crates/types"]
 [workspace.package]
 version = "0.11.0-pre.0"
 edition = "2024"
-rust-version = "1.95"
+rust-version = "1.98"
 repository = "https://github.com/explodingcamera/tinywasm"
 license = "MIT OR Apache-2.0"
 keywords = ["interpreter", "no-std", "tinywasm", "wasm", "webassembly"]
@@ -31,9 +31,9 @@ pretty_env_logger = "0.5"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0" }
 wasm-testsuite = { version = "0.7" }
-wasmparser = { version = "0.256", default-features = false }
-wast = "256"
-wat = "1.256"
+wasmparser = { version = "0.257", default-features = false }
+wast = "257"
+wat = "1.257"
 
 criterion = { version = "0.8", default-features = false, features = ["cargo_bench_support", "rayon"] }
 

Cargo.toml

@@ -164,7 +164,7 @@ pub(crate) fn convert_module_code(
     for (local_index, local) in locals_reader.into_iter().enumerate() {
         let local = local?;
         if let Some(validator) = validator.as_mut() {
-            validator.define_locals(locals_position + local_index, local.0, local.1)?;
+            validator.define_locals(locals_position + local_index as u64, local.0, local.1)?;
         }
         extend_local_types(&mut local_types, local.0, local.1)?;
     }

crates/parser/src/conversion.rs

@@ -20,7 +20,7 @@ pub enum ParseError {
         /// The error message
         message: String,
         /// The offset in the module where the error occurred
-        offset: usize,
+        offset: u64,
     },
     /// An invalid encoding was encountered
     InvalidEncoding(Encoding),

crates/parser/src/error.rs

@@ -249,7 +249,7 @@ impl Parser {
                         buffer.truncate(buffer.len() - buffer_offset);
                         buffer_offset = 0;
                     }
-                    let read_bytes = Self::read_more(&mut stream, &mut buffer, hint as usize)?;
+                    let read_bytes = Self::read_more(&mut stream, &mut buffer, hint)?;
                     eof = read_bytes == 0;
                 }
                 wasmparser::Chunk::Parsed { consumed, payload } => {
@@ -258,17 +258,12 @@ impl Parser {
 
                     match payload {
                         wasmparser::Payload::CodeSectionStart { count, range, size } => {
-                            let defer = reader.begin_code_section(
-                                count,
-                                range.clone(),
-                                size,
-                                validator.as_mut(),
-                                &self.options,
-                            )?;
+                            let defer =
+                                reader.begin_code_section(count, range, size, validator.as_mut(), &self.options)?;
 
                             #[cfg(parallel_parser)]
                             if defer {
-                                deferred_code_section = Some((count, range.end - size as usize, size as usize));
+                                deferred_code_section = Some((count, size as usize));
                             }
 
                             #[cfg(not(parallel_parser))]
@@ -284,21 +279,21 @@ impl Parser {
                     buffer_offset += consumed;
 
                     #[cfg(parallel_parser)]
-                    if let Some((count, body_offset, section_size)) = deferred_code_section {
+                    if let Some((count, section_size)) = deferred_code_section {
                         while buffer.len() - buffer_offset < section_size {
                             let remaining = section_size - (buffer.len() - buffer_offset);
                             let read_bytes = Self::read_more(&mut stream, &mut buffer, remaining)?;
                             if read_bytes == 0 {
                                 return Err(ParseError::ParseError {
                                     message: "unexpected end-of-file".into(),
-                                    offset: body_offset + buffer.len() - buffer_offset,
+                                    offset: parser.offset() + (buffer.len() - buffer_offset) as u64,
                                 });
                             }
                         }
 
                         let section_end = buffer_offset + section_size;
                         let section_bytes = alloc::sync::Arc::<[u8]>::from(buffer[buffer_offset..section_end].to_vec());
-                        reader.queue_owned_code_section(count, body_offset, section_bytes, validator.as_mut())?;
+                        reader.queue_owned_code_section(count, parser.offset(), section_bytes, validator.as_mut())?;
                         parser.skip_section();
                         buffer_offset = section_end;
                         continue;

crates/parser/src/lib.rs

@@ -330,7 +330,7 @@ impl<'a> ModuleReader<'a> {
     pub(crate) fn begin_code_section(
         &mut self,
         count: u32,
-        range: Range<usize>,
+        range: Range<u64>,
         size: u32,
         validator: Option<&mut Validator>,
         options: &ParserOptions,
@@ -434,7 +434,7 @@ impl<'a> ModuleReader<'a> {
     pub(crate) fn queue_owned_code_section(
         &mut self,
         count: u32,
-        body_offset: usize,
+        body_offset: u64,
         section_bytes: Arc<[u8]>,
         validator: Option<&mut Validator>,
     ) -> Result<()> {
@@ -446,6 +446,8 @@ impl<'a> ModuleReader<'a> {
         for _ in 0..count {
             let body_reader = reader.read_reader()?;
             let body_range = body_reader.range();
+            let body_start = (body_range.start - body_offset) as usize;
+            let body_end = (body_range.end - body_offset) as usize;
             #[cfg(feature = "validate")]
             let func_to_validate = {
                 let function = wasmparser::FunctionBody::new(body_reader);
@@ -456,7 +458,7 @@ impl<'a> ModuleReader<'a> {
             self.queue_function(
                 crate::parallel::FunctionBodyInput::Owned(crate::parallel::OwnedFunctionBody {
                     section_bytes: section_bytes.clone(),
-                    body_range: (body_range.start - body_offset)..(body_range.end - body_offset),
+                    body_range: body_start..body_end,
                     body_offset: body_range.start,
                 }),
                 func_to_validate,

crates/parser/src/module.rs

@@ -17,7 +17,7 @@ pub(crate) struct OwnedFunctionBody {
     // function jobs from that section.
     pub section_bytes: Arc<[u8]>,
     pub body_range: Range<usize>,
-    pub body_offset: usize,
+    pub body_offset: u64,
 }
 
 pub(crate) struct PendingFunction<'a> {

crates/parser/src/parallel.rs

@@ -221,7 +221,7 @@ impl<'a> FunctionBuilder<'a> {
 struct ValidateThenVisit<'a, 'm> {
     validator: &'a mut FuncValidator<ValidatorResources>,
     builder: &'a mut FunctionBuilder<'m>,
-    position: usize,
+    position: u64,
 }
 
 impl ModuleMetadata {

crates/parser/src/visit.rs

@@ -700,7 +700,7 @@ impl From<&ImportKind> for ExternalKind {
 #[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
 pub struct Data {
     pub data: Box<[u8]>,
-    pub range: Range<usize>,
+    pub range: Range<u64>,
     pub kind: DataKind,
 }
 
@@ -718,7 +718,7 @@ pub enum DataKind {
 pub struct Element {
     pub kind: ElementKind,
     pub items: Box<[ElementItem]>,
-    pub range: Range<usize>,
+    pub range: Range<u64>,
     pub ty: RefType,
 }