63d80fc509
* Remove the need to have a `Store` for an `InstancePre` This commit relaxes a requirement of the `InstancePre` API, notably its construction via `Linker::instantiate_pre`. Previously this function required a `Store<T>` to be present to be able to perform type-checking on the contents of the linker, and now this requirement has been removed. Items stored within a linker are either a `HostFunc`, which has type information inside of it, or an `Extern`, which doesn't have type information inside of it. Due to the usage of `Extern` this is why a `Store` was required during the `InstancePre` construction process, it's used to extract the type of an `Extern`. This commit implements a solution where the type information of an `Extern` is stored alongside the `Extern` itself, meaning that the `InstancePre` construction process no longer requires a `Store<T>`. One caveat of this implementation is that some items, such as tables and memories, technically have a "dynamic type" where during type checking their current size is consulted to match against the minimum size required of an import. This no longer works when using `Linker::instantiate_pre` as the current size used is the one when it was inserted into the linker rather than the one available at instantiation time. It's hoped, however, that this is a relatively esoteric use case that doesn't impact many real-world users. Additionally note that this is an API-breaking change. Not only is the `Store` argument removed from `Linker::instantiate_pre`, but some other methods such as `Linker::define` grew a `Store` argument as the type needs to be extracted when an item is inserted into a linker. Closes #5675 * Fix the C API * Fix benchmark compilation * Add C API docs * Update crates/wasmtime/src/linker.rs Co-authored-by: Andrew Brown <andrew.brown@intel.com> --------- Co-authored-by: Andrew Brown <andrew.brown@intel.com>
81 lines
2.9 KiB
Rust
81 lines
2.9 KiB
Rust
use anyhow::Result;
|
|
use wasmtime::*;
|
|
|
|
/// Return an instance implementing the "spectest" interface used in the
|
|
/// spec testsuite.
|
|
pub fn link_spectest<T>(
|
|
linker: &mut Linker<T>,
|
|
store: &mut Store<T>,
|
|
use_shared_memory: bool,
|
|
) -> Result<()> {
|
|
linker.func_wrap("spectest", "print", || {})?;
|
|
linker.func_wrap("spectest", "print_i32", |val: i32| println!("{}: i32", val))?;
|
|
linker.func_wrap("spectest", "print_i64", |val: i64| println!("{}: i64", val))?;
|
|
linker.func_wrap("spectest", "print_f32", |val: f32| println!("{}: f32", val))?;
|
|
linker.func_wrap("spectest", "print_f64", |val: f64| println!("{}: f64", val))?;
|
|
linker.func_wrap("spectest", "print_i32_f32", |i: i32, f: f32| {
|
|
println!("{}: i32", i);
|
|
println!("{}: f32", f);
|
|
})?;
|
|
linker.func_wrap("spectest", "print_f64_f64", |f1: f64, f2: f64| {
|
|
println!("{}: f64", f1);
|
|
println!("{}: f64", f2);
|
|
})?;
|
|
|
|
let ty = GlobalType::new(ValType::I32, Mutability::Const);
|
|
let g = Global::new(&mut *store, ty, Val::I32(666))?;
|
|
linker.define(&mut *store, "spectest", "global_i32", g)?;
|
|
|
|
let ty = GlobalType::new(ValType::I64, Mutability::Const);
|
|
let g = Global::new(&mut *store, ty, Val::I64(666))?;
|
|
linker.define(&mut *store, "spectest", "global_i64", g)?;
|
|
|
|
let ty = GlobalType::new(ValType::F32, Mutability::Const);
|
|
let g = Global::new(&mut *store, ty, Val::F32(0x4426_8000))?;
|
|
linker.define(&mut *store, "spectest", "global_f32", g)?;
|
|
|
|
let ty = GlobalType::new(ValType::F64, Mutability::Const);
|
|
let g = Global::new(&mut *store, ty, Val::F64(0x4084_d000_0000_0000))?;
|
|
linker.define(&mut *store, "spectest", "global_f64", g)?;
|
|
|
|
let ty = TableType::new(ValType::FuncRef, 10, Some(20));
|
|
let table = Table::new(&mut *store, ty, Val::FuncRef(None))?;
|
|
linker.define(&mut *store, "spectest", "table", table)?;
|
|
|
|
let ty = MemoryType::new(1, Some(2));
|
|
let memory = Memory::new(&mut *store, ty)?;
|
|
linker.define(&mut *store, "spectest", "memory", memory)?;
|
|
|
|
if use_shared_memory {
|
|
let ty = MemoryType::shared(1, 1);
|
|
let memory = Memory::new(&mut *store, ty)?;
|
|
linker.define(&mut *store, "spectest", "shared_memory", memory)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(feature = "component-model")]
|
|
pub fn link_component_spectest<T>(linker: &mut component::Linker<T>) -> Result<()> {
|
|
let engine = linker.engine().clone();
|
|
linker
|
|
.root()
|
|
.func_wrap("host-return-two", |_, _: ()| Ok((2u32,)))?;
|
|
let mut i = linker.instance("host")?;
|
|
i.func_wrap("return-three", |_, _: ()| Ok((3u32,)))?;
|
|
i.instance("nested")?
|
|
.func_wrap("return-four", |_, _: ()| Ok((4u32,)))?;
|
|
|
|
let module = Module::new(
|
|
&engine,
|
|
r#"
|
|
(module
|
|
(global (export "g") i32 i32.const 100)
|
|
(func (export "f") (result i32) i32.const 101)
|
|
)
|
|
"#,
|
|
)?;
|
|
i.module("simple-module", &module)?;
|
|
Ok(())
|
|
}
|