Skip to content

Commit f99b3a9

Browse files
feat: decouple validation from parsing
Signed-off-by: Henry <mail@henrygressmann.de>
1 parent dc36616 commit f99b3a9

11 files changed

Lines changed: 1459 additions & 950 deletions

File tree

‎crates/parser/src/conversion.rs‎

Lines changed: 27 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -136,42 +136,44 @@ pub(crate) fn convert_module_export(export: wasmparser::Export<'_>) -> Result<Ex
136136

137137
pub(crate) fn convert_module_code(
138138
func: wasmparser::FunctionBody<'_>,
139-
mut validator: FuncValidator<ValidatorResources>,
139+
mut validator: Option<FuncValidator<ValidatorResources>>,
140140
reader_allocs: OperatorsReaderAllocations,
141-
) -> Result<(FunctionCode, FuncValidatorAllocations, OperatorsReaderAllocations)> {
141+
metadata: &crate::visit::ModuleMetadata,
142+
ty_idx: u32,
143+
) -> Result<(FunctionCode, Option<FuncValidatorAllocations>, OperatorsReaderAllocations)> {
142144
let locals_reader = func.get_locals_reader()?;
143-
let count = locals_reader.get_count();
144145
let pos = locals_reader.original_position();
145-
146-
// maps a local's address to the index in the type's locals array
147-
let mut local_addr_map = Vec::with_capacity(count as usize);
148-
let mut local_counts = ValueCounts::default();
146+
let signature = metadata.signature(ty_idx)?.clone();
147+
let mut local_types = signature.params.clone();
149148

150149
for (i, local) in locals_reader.into_iter().enumerate() {
151150
let local = local?;
152-
validator.define_locals(pos + i, local.0, local.1)?;
151+
if let Some(validator) = validator.as_mut() {
152+
validator.define_locals(pos + i, local.0, local.1)?;
153+
}
154+
let size = crate::visit::OperandSize::from(local.1);
155+
let count = usize::try_from(local.0)
156+
.map_err(|_| crate::ParseError::Other("local declaration count is too large".into()))?;
157+
local_types.reserve(count);
158+
local_types.extend(core::iter::repeat_n(size, count));
153159
}
154160

155-
for i in 0..validator.len_locals() {
156-
match validator.get_local_type(i) {
157-
Some(wasmparser::ValType::I32 | wasmparser::ValType::F32 | wasmparser::ValType::Ref(_)) => {
158-
local_addr_map.push(local_counts.c32);
159-
local_counts.c32 += 1;
160-
}
161-
Some(wasmparser::ValType::I64 | wasmparser::ValType::F64) => {
162-
local_addr_map.push(local_counts.c64);
163-
local_counts.c64 += 1;
164-
}
165-
Some(wasmparser::ValType::V128) => {
166-
local_addr_map.push(local_counts.c128);
167-
local_counts.c128 += 1;
168-
}
169-
None => return Err(crate::ParseError::UnsupportedOperator("Unknown local type".to_string())),
170-
}
161+
// maps a local's address to the index in the type's locals array
162+
let mut local_addr_map = Vec::with_capacity(local_types.len());
163+
let mut local_counts = ValueCounts::default();
164+
165+
for ty in &local_types {
166+
let (count, error) = match ty {
167+
crate::visit::OperandSize::S32 => (&mut local_counts.c32, "too many 32-bit locals"),
168+
crate::visit::OperandSize::S64 => (&mut local_counts.c64, "too many 64-bit locals"),
169+
crate::visit::OperandSize::S128 => (&mut local_counts.c128, "too many 128-bit locals"),
170+
};
171+
local_addr_map.push(*count);
172+
*count = count.checked_add(1).ok_or_else(|| crate::ParseError::Other(error.into()))?;
171173
}
172174

173175
let (body, data, validator_allocs, reader_allocs) =
174-
process_operators_and_validate(validator, func, local_addr_map, reader_allocs)?;
176+
process_operators_and_validate(validator, func, local_types, local_addr_map, metadata, ty_idx, reader_allocs)?;
175177
Ok((
176178
FunctionCode { instructions: body, data, locals: local_counts, uses_local_memory: false },
177179
validator_allocs,

‎crates/parser/src/error.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -60,8 +60,8 @@ impl Display for ParseError {
6060

6161
impl core::error::Error for ParseError {}
6262

63-
impl From<wasmparser::BinaryReaderError> for ParseError {
64-
fn from(value: wasmparser::BinaryReaderError) -> Self {
63+
impl From<wasmparser::Error> for ParseError {
64+
fn from(value: wasmparser::Error) -> Self {
6565
Self::ParseError { message: value.message().to_string(), offset: value.offset() }
6666
}
6767
}

‎crates/parser/src/lib.rs‎

Lines changed: 29 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -49,12 +49,12 @@ pub use tinywasm_types::Module;
4949
#[non_exhaustive]
5050
#[derive(Debug, Clone)]
5151
pub struct ParserOptions {
52+
/// Whether to validate modules while parsing.
53+
pub validation: bool,
5254
/// Whether to optimize local memory allocation by skipping allocation of unused local memories.
5355
pub optimize_local_memory_allocation: bool,
5456
/// Whether to run the peephole rewrite optimizer.
5557
pub optimize_rewrite: bool,
56-
/// Whether to remove `Nop` and `MergeBarrier` instructions after rewriting.
57-
pub optimize_remove_nop: bool,
5858

5959
#[cfg(parallel_parser)]
6060
/// Number of threads to use for parallel parsing.
@@ -70,16 +70,27 @@ pub struct ParserOptions {
7070
impl Default for ParserOptions {
7171
fn default() -> Self {
7272
Self {
73+
validation: true,
7374
optimize_local_memory_allocation: true,
7475
optimize_rewrite: true,
75-
optimize_remove_nop: true,
7676
#[cfg(parallel_parser)]
7777
parser_threads: None,
7878
}
7979
}
8080
}
8181

8282
impl ParserOptions {
83+
/// Enable or disable WebAssembly validation.
84+
pub const fn with_validation(mut self, enabled: bool) -> Self {
85+
self.validation = enabled;
86+
self
87+
}
88+
89+
/// Returns whether WebAssembly validation is enabled.
90+
pub const fn validation(&self) -> bool {
91+
self.validation
92+
}
93+
8394
/// Enable or disable the optimization that skips allocating unused local memories.
8495
pub const fn with_local_memory_allocation_optimization(mut self, enabled: bool) -> Self {
8596
self.optimize_local_memory_allocation = enabled;
@@ -102,17 +113,6 @@ impl ParserOptions {
102113
self.optimize_rewrite
103114
}
104115

105-
/// Enable or disable `Nop`/`MergeBarrier` removal after rewriting.
106-
pub const fn with_nop_removal_optimization(mut self, enabled: bool) -> Self {
107-
self.optimize_remove_nop = enabled;
108-
self
109-
}
110-
111-
/// Returns whether `Nop`/`MergeBarrier` removal is enabled.
112-
pub const fn optimize_remove_nop(&self) -> bool {
113-
self.optimize_remove_nop
114-
}
115-
116116
#[cfg(parallel_parser)]
117117
/// Set the number of threads for parallel parsing.
118118
///
@@ -188,18 +188,18 @@ impl Parser {
188188
/// Parse a [`Module`] from bytes
189189
pub fn parse_module_bytes(&self, wasm: impl AsRef<[u8]>) -> Result<Module> {
190190
let wasm = wasm.as_ref();
191-
let mut validator = Self::create_validator(self.options.clone());
191+
let mut validator = self.options.validation().then(|| Self::create_validator(self.options.clone()));
192192
let mut reader = ModuleReader::default();
193193

194194
for payload in wasmparser::Parser::new(0).parse_all(wasm) {
195195
match payload? {
196196
wasmparser::Payload::CodeSectionStart { count, range, size } => {
197-
reader.begin_code_section(count, range, size, &mut validator, &self.options)?;
197+
reader.begin_code_section(count, range, size, validator.as_mut(), &self.options)?;
198198
}
199199
wasmparser::Payload::CodeSectionEntry(function) => {
200-
reader.process_borrowed_code_section_entry(function, &mut validator, &self.options)?;
200+
reader.process_borrowed_code_section_entry(function, validator.as_mut(), &self.options)?;
201201
}
202-
payload => reader.process_payload(payload, &mut validator)?,
202+
payload => reader.process_payload(payload, validator.as_mut())?,
203203
}
204204
}
205205

@@ -222,7 +222,7 @@ impl Parser {
222222
#[cfg(feature = "std")]
223223
/// Parse a [`Module`] from a stream. Requires `std` feature.
224224
pub fn parse_module_stream(&self, mut stream: impl std::io::Read) -> Result<Module> {
225-
let mut validator = Self::create_validator(self.options.clone());
225+
let mut validator = self.options.validation().then(|| Self::create_validator(self.options.clone()));
226226
let mut reader = ModuleReader::default();
227227
let mut buffer = alloc::vec::Vec::new();
228228
let mut parser = wasmparser::Parser::new(0);
@@ -240,8 +240,13 @@ impl Parser {
240240

241241
match payload {
242242
wasmparser::Payload::CodeSectionStart { count, range, size } => {
243-
let defer =
244-
reader.begin_code_section(count, range.clone(), size, &mut validator, &self.options)?;
243+
let defer = reader.begin_code_section(
244+
count,
245+
range.clone(),
246+
size,
247+
validator.as_mut(),
248+
&self.options,
249+
)?;
245250

246251
#[cfg(parallel_parser)]
247252
if defer {
@@ -252,10 +257,10 @@ impl Parser {
252257
let _ = defer;
253258
}
254259
wasmparser::Payload::CodeSectionEntry(function) => {
255-
reader.process_inline_code_section_entry(function, &mut validator, &self.options)?;
260+
reader.process_inline_code_section_entry(function, validator.as_mut(), &self.options)?;
256261
}
257262
payload => {
258-
reader.process_payload(payload, &mut validator)?;
263+
reader.process_payload(payload, validator.as_mut())?;
259264
}
260265
}
261266
buffer.drain(..consumed);
@@ -274,7 +279,7 @@ impl Parser {
274279
}
275280

276281
let section_bytes = alloc::sync::Arc::<[u8]>::from(buffer[..section_size].to_vec());
277-
reader.queue_owned_code_section(count, body_offset, section_bytes, &mut validator)?;
282+
reader.queue_owned_code_section(count, body_offset, section_bytes, validator.as_mut())?;
278283
parser.skip_section();
279284
buffer.drain(..section_size);
280285
continue;

0 commit comments

Comments
 (0)