2af544de8b
* Update cranelift to 0.58.0 * Update `wasmprinter` dep to require 0.2.1 We already had it in the lock file, but this ensures we won't ever go back down. * Ensure that our error messages match `assert_invalid`'s The bulk of this work was done in https://github.com/bytecodealliance/wasmparser/pull/186 but now we can test it at the `wasmtime` level as well. Fixes #492 * Stop feeling guilty about not matching `assert_malformed` messages Remove the "TODO" and stop printing warning messages. These would just be busy work to implement, and getting all the messages the exact same relies on using the same structure as the spec interpreter's parser, which means that where you have a helper function and they don't, then things go wrong, and vice versa. Not worth it. Fixes #492 * Enable (but ignore) the reference-types proposal tests * Match test suite directly, instead of roundabout starts/endswith * Enable (but ignore) bulk memory operations proposal test suite
131 lines
3.5 KiB
Rust
131 lines
3.5 KiB
Rust
use crate::backend::{CodeGenSession, TranslatedCodeSection};
|
|
use crate::error::Error;
|
|
use crate::function_body;
|
|
use crate::module::SimpleContext;
|
|
use cranelift_codegen::{binemit, ir};
|
|
use wasmparser::{
|
|
CodeSectionReader, DataSectionReader, ElementSectionReader, ExportSectionReader, FuncType,
|
|
FunctionSectionReader, GlobalSectionReader, ImportSectionReader, MemorySectionReader,
|
|
MemoryType, TableSectionReader, TableType, TypeSectionReader,
|
|
};
|
|
|
|
/// Parses the Type section of the wasm module.
|
|
pub fn type_(types_reader: TypeSectionReader) -> Result<Vec<FuncType>, Error> {
|
|
types_reader
|
|
.into_iter()
|
|
.map(|r| r.map_err(Into::into))
|
|
.collect()
|
|
}
|
|
|
|
/// Parses the Import section of the wasm module.
|
|
pub fn import(imports: ImportSectionReader) -> Result<(), Error> {
|
|
for entry in imports {
|
|
entry?; // TODO
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Parses the Function section of the wasm module.
|
|
pub fn function(functions: FunctionSectionReader) -> Result<Vec<u32>, Error> {
|
|
functions
|
|
.into_iter()
|
|
.map(|r| r.map_err(Into::into))
|
|
.collect()
|
|
}
|
|
|
|
/// Parses the Table section of the wasm module.
|
|
pub fn table(tables: TableSectionReader) -> Result<Vec<TableType>, Error> {
|
|
tables.into_iter().map(|r| r.map_err(Into::into)).collect()
|
|
}
|
|
|
|
/// Parses the Memory section of the wasm module.
|
|
pub fn memory(memories: MemorySectionReader) -> Result<Vec<MemoryType>, Error> {
|
|
memories
|
|
.into_iter()
|
|
.map(|r| r.map_err(Into::into))
|
|
.collect()
|
|
}
|
|
|
|
/// Parses the Global section of the wasm module.
|
|
pub fn global(globals: GlobalSectionReader) -> Result<(), Error> {
|
|
for entry in globals {
|
|
entry?; // TODO
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Parses the Export section of the wasm module.
|
|
pub fn export(exports: ExportSectionReader) -> Result<(), Error> {
|
|
for entry in exports {
|
|
entry?; // TODO
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Parses the Start section of the wasm module.
|
|
pub fn start(_index: u32) -> Result<(), Error> {
|
|
// TODO
|
|
Ok(())
|
|
}
|
|
|
|
/// Parses the Element section of the wasm module.
|
|
pub fn element(elements: ElementSectionReader) -> Result<(), Error> {
|
|
for entry in elements {
|
|
entry?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
struct UnimplementedRelocSink;
|
|
|
|
impl binemit::RelocSink for UnimplementedRelocSink {
|
|
fn reloc_block(&mut self, _: binemit::CodeOffset, _: binemit::Reloc, _: binemit::CodeOffset) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn reloc_external(
|
|
&mut self,
|
|
_: binemit::CodeOffset,
|
|
_: binemit::Reloc,
|
|
_: &ir::ExternalName,
|
|
_: binemit::Addend,
|
|
) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn reloc_constant(&mut self, _: binemit::CodeOffset, _: binemit::Reloc, _: ir::ConstantOffset) {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn reloc_jt(&mut self, _: binemit::CodeOffset, _: binemit::Reloc, _: ir::JumpTable) {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
|
|
/// Parses the Code section of the wasm module.
|
|
pub fn code(
|
|
code: CodeSectionReader,
|
|
translation_ctx: &SimpleContext,
|
|
) -> Result<TranslatedCodeSection, Error> {
|
|
let func_count = code.get_count();
|
|
let mut session = CodeGenSession::new(func_count, translation_ctx);
|
|
|
|
for (idx, body) in code.into_iter().enumerate() {
|
|
let body = body?;
|
|
let mut relocs = UnimplementedRelocSink;
|
|
|
|
function_body::translate_wasm(&mut session, &mut relocs, idx as u32, &body)?;
|
|
}
|
|
|
|
Ok(session.into_translated_code_section()?)
|
|
}
|
|
|
|
/// Parses the Data section of the wasm module.
|
|
pub fn data(data: DataSectionReader) -> Result<(), Error> {
|
|
for entry in data {
|
|
entry?; // TODO
|
|
}
|
|
Ok(())
|
|
}
|