T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Implement RFC 11: Redesigning Wasmtime's APIs (#2897)

Browse Source 
Implement Wasmtime's new API as designed by RFC 11. This is quite a large commit which has had lots of discussion externally, so for more information it's best to read the RFC thread and the PR thread.
This commit is contained in:
Alex Crichton
2021-06-03 09:10:53 -05:00
committed by GitHub
parent a5a28b1c5b
commit 7a1b7cdf92
233 changed files with 13349 additions and 11997 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
crates/wast/src/spectest.rs
View File

@@ -3,43 +3,43 @@ use wasmtime::*;
/// Return an instance implementing the "spectest" interface used in the
/// spec testsuite.
pub fn link_spectest(linker: &mut Linker) -> Result<()> {
linker.func("spectest", "print", || {})?;
linker.func("spectest", "print_i32", |val: i32| println!("{}: i32", val))?;
linker.func("spectest", "print_i64", |val: i64| println!("{}: i64", val))?;
linker.func("spectest", "print_f32", |val: f32| println!("{}: f32", val))?;
linker.func("spectest", "print_f64", |val: f64| println!("{}: f64", val))?;
linker.func("spectest", "print_i32_f32", |i: i32, f: f32| {
pub fn link_spectest(linker: &mut Linker<()>, store: &mut Store<()>) -> 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("spectest", "print_f64_f64", |f1: f64, f2: f64| {
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(linker.store(), ty, Val::I32(666))?;
let g = Global::new(&mut *store, ty, Val::I32(666))?;
linker.define("spectest", "global_i32", g)?;
let ty = GlobalType::new(ValType::I64, Mutability::Const);
let g = Global::new(linker.store(), ty, Val::I64(666))?;
let g = Global::new(&mut *store, ty, Val::I64(666))?;
linker.define("spectest", "global_i64", g)?;
let ty = GlobalType::new(ValType::F32, Mutability::Const);
let g = Global::new(linker.store(), ty, Val::F32(0x4426_8000))?;
let g = Global::new(&mut *store, ty, Val::F32(0x4426_8000))?;
linker.define("spectest", "global_f32", g)?;
let ty = GlobalType::new(ValType::F64, Mutability::Const);
let g = Global::new(linker.store(), ty, Val::F64(0x4084_d000_0000_0000))?;
let g = Global::new(&mut *store, ty, Val::F64(0x4084_d000_0000_0000))?;
linker.define("spectest", "global_f64", g)?;
let ty = TableType::new(ValType::FuncRef, Limits::new(10, Some(20)));
let table = Table::new(linker.store(), ty, Val::FuncRef(None))?;
let table = Table::new(&mut *store, ty, Val::FuncRef(None))?;
linker.define("spectest", "table", table)?;
let ty = MemoryType::new(Limits::new(1, Some(2)));
let memory = Memory::new(linker.store(), ty)?;
let memory = Memory::new(&mut *store, ty)?;
linker.define("spectest", "memory", memory)?;
Ok(())

38
crates/wast/src/wast.rs
View File

@@ -36,11 +36,8 @@ pub struct WastContext {
/// Wast files have a concept of a "current" module, which is the most
/// recently defined.
current: Option<Instance>,
// FIXME(#1479) this is only needed to retain correct trap information after
// we've dropped previous `Instance` values.
modules: Vec<Module>,
linker: Linker,
store: Store,
linker: Linker<()>,
store: Store<()>,
}
enum Outcome<T = Vec<Val>> {
@@ -59,36 +56,37 @@ impl<T> Outcome<T> {
impl WastContext {
/// Construct a new instance of `WastContext`.
pub fn new(store: Store) -> Self {
pub fn new(store: Store<()>) -> Self {
// Spec tests will redefine the same module/name sometimes, so we need
// to allow shadowing in the linker which picks the most recent
// definition as what to link when linking.
let mut linker = Linker::new(&store);
let mut linker = Linker::new(store.engine());
linker.allow_shadowing(true);
Self {
current: None,
linker,
store,
modules: Vec::new(),
}
}
fn get_export(&self, module: Option<&str>, name: &str) -> Result<Extern> {
fn get_export(&mut self, module: Option<&str>, name: &str) -> Result<Extern> {
match module {
Some(module) => self.linker.get_one_by_name(module, Some(name)),
Some(module) => self
.linker
.get(&mut self.store, module, Some(name))
.ok_or_else(|| anyhow!("no item named `{}::{}` found", module, name)),
None => self
.current
.as_ref()
.ok_or_else(|| anyhow!("no previous instance found"))?
.get_export(name)
.get_export(&mut self.store, name)
.ok_or_else(|| anyhow!("no item named `{}` found", name)),
}
}
fn instantiate(&mut self, module: &[u8]) -> Result<Outcome<Instance>> {
let module = Module::new(self.store.engine(), module)?;
self.modules.push(module.clone());
let instance = match self.linker.instantiate(&module) {
let instance = match self.linker.instantiate(&mut self.store, &module) {
Ok(i) => i,
Err(e) => return e.downcast::<Trap>().map(Outcome::Trap),
};
@@ -97,7 +95,7 @@ impl WastContext {
/// Register "spectest" which is used by the spec testsuite.
pub fn register_spectest(&mut self) -> Result<()> {
link_spectest(&mut self.linker)?;
link_spectest(&mut self.linker, &mut self.store)?;
Ok(())
}
@@ -133,7 +131,7 @@ impl WastContext {
Outcome::Trap(e) => return Err(e).context("instantiation failed"),
};
if let Some(name) = instance_name {
self.linker.instance(name, &instance)?;
self.linker.instance(&mut self.store, name, instance)?;
}
self.current = Some(instance);
Ok(())
@@ -142,13 +140,13 @@ impl WastContext {
/// Register an instance to make it available for performing actions.
fn register(&mut self, name: Option<&str>, as_name: &str) -> Result<()> {
match name {
Some(name) => self.linker.alias(name, as_name),
Some(name) => self.linker.alias_module(name, as_name),
None => {
let current = self
let current = *self
.current
.as_ref()
.ok_or(anyhow!("no previous instance"))?;
self.linker.instance(as_name, current)?;
self.linker.instance(&mut self.store, as_name, current)?;
Ok(())
}
}
@@ -165,7 +163,7 @@ impl WastContext {
.get_export(instance_name, field)?
.into_func()
.ok_or_else(|| anyhow!("no function named `{}`", field))?;
Ok(match func.call(args) {
Ok(match func.call(&mut self.store, args) {
Ok(result) => Outcome::Ok(result.into()),
Err(e) => Outcome::Trap(e.downcast()?),
})
@@ -177,7 +175,7 @@ impl WastContext {
.get_export(instance_name, field)?
.into_global()
.ok_or_else(|| anyhow!("no global named `{}`", field))?;
Ok(Outcome::Ok(vec![global.get()]))
Ok(Outcome::Ok(vec![global.get(&mut self.store)]))
}
fn assert_return(&self, result: Outcome, results: &[wast::AssertExpression]) -> Result<()> {