7d7ddceb17
This commit updates the wasm-tools family of crates, notably pulling in the refactorings and updates from bytecodealliance/wasm-tools#621 for the latest iteration of the component model. This commit additionally updates all support for the component model for these changes, notably: * Many bits and pieces of type information was refactored. Many `FooTypeIndex` namings are now `TypeFooIndex`. Additionally there is now `TypeIndex` as well as `ComponentTypeIndex` for the two type index spaces in a component. * A number of new sections are now processed to handle the core and component variants. * Internal maps were split such as the `funcs` map into `component_funcs` and `funcs` (same for `instances`). * Canonical options are now processed individually instead of one bulk `into` definition. Overall this was not a major update to the internals of handling the component model in Wasmtime. Instead this was mostly a surface-level refactoring to make sure that everything lines up with the new binary format for components. * All text syntax used in tests was updated to the new syntax.
70 lines
2.6 KiB
Rust
70 lines
2.6 KiB
Rust
use crate::{SignatureIndex, WasmError, WasmResult};
|
|
use cranelift_codegen::ir::{types, Type};
|
|
use cranelift_entity::PrimaryMap;
|
|
use std::boxed::Box;
|
|
use std::vec::Vec;
|
|
|
|
/// Map of signatures to a function's parameter and return types.
|
|
pub(crate) type WasmTypes =
|
|
PrimaryMap<SignatureIndex, (Box<[wasmparser::ValType]>, Box<[wasmparser::ValType]>)>;
|
|
|
|
/// Contains information decoded from the Wasm module that must be referenced
|
|
/// during each Wasm function's translation.
|
|
///
|
|
/// This is only for data that is maintained by `cranelift-wasm` itself, as
|
|
/// opposed to being maintained by the embedder. Data that is maintained by the
|
|
/// embedder is represented with `ModuleEnvironment`.
|
|
#[derive(Debug)]
|
|
pub struct ModuleTranslationState {
|
|
/// A map containing a Wasm module's original, raw signatures.
|
|
///
|
|
/// This is used for translating multi-value Wasm blocks inside functions,
|
|
/// which are encoded to refer to their type signature via index.
|
|
pub(crate) wasm_types: WasmTypes,
|
|
}
|
|
|
|
fn cranelift_to_wasmparser_type(ty: Type) -> WasmResult<wasmparser::ValType> {
|
|
Ok(match ty {
|
|
types::I32 => wasmparser::ValType::I32,
|
|
types::I64 => wasmparser::ValType::I64,
|
|
types::F32 => wasmparser::ValType::F32,
|
|
types::F64 => wasmparser::ValType::F64,
|
|
types::R32 | types::R64 => wasmparser::ValType::ExternRef,
|
|
_ => {
|
|
return Err(WasmError::Unsupported(format!(
|
|
"Cannot convert Cranelift type to Wasm signature: {:?}",
|
|
ty
|
|
)));
|
|
}
|
|
})
|
|
}
|
|
|
|
impl ModuleTranslationState {
|
|
/// Creates a new empty ModuleTranslationState.
|
|
pub fn new() -> Self {
|
|
Self {
|
|
wasm_types: PrimaryMap::new(),
|
|
}
|
|
}
|
|
|
|
/// Create a new ModuleTranslationState with the given function signatures,
|
|
/// provided in terms of Cranelift types. The provided slice of signatures
|
|
/// is indexed by signature number, and contains pairs of (args, results)
|
|
/// slices.
|
|
pub fn from_func_sigs(sigs: &[(&[Type], &[Type])]) -> WasmResult<Self> {
|
|
let mut wasm_types = PrimaryMap::with_capacity(sigs.len());
|
|
for &(ref args, ref results) in sigs {
|
|
let args: Vec<wasmparser::ValType> = args
|
|
.iter()
|
|
.map(|&ty| cranelift_to_wasmparser_type(ty))
|
|
.collect::<Result<_, _>>()?;
|
|
let results: Vec<wasmparser::ValType> = results
|
|
.iter()
|
|
.map(|&ty| cranelift_to_wasmparser_type(ty))
|
|
.collect::<Result<_, _>>()?;
|
|
wasm_types.push((args.into_boxed_slice(), results.into_boxed_slice()));
|
|
}
|
|
Ok(Self { wasm_types })
|
|
}
|
|
}
|