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

Make more code work with no_std. (#407)

Browse Source 
* Make more code work with no_std.

no_std support is still incomplete, but this patch takes care of the
bulk of the straightforward parts.
This commit is contained in:
Dan Gohman
2019-10-08 16:53:32 -07:00
committed by GitHub
parent c0b37bb713
commit 8e1b44b29c
100 changed files with 380 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
wasmtime-api/src/callable.rs
View File

@@ -3,7 +3,8 @@ use crate::runtime::Store;
use crate::trap::Trap;
use crate::types::FuncType;
use crate::values::Val;
use std::rc::Rc;
use alloc::rc::Rc;
use alloc::vec::Vec;
use crate::trampoline::generate_func_export;
use cranelift_codegen::ir;

6
wasmtime-api/src/context.rs
View File

@@ -1,6 +1,6 @@
use std::cell::{RefCell, RefMut};
use std::hash::{Hash, Hasher};
use std::rc::Rc;
use alloc::rc::Rc;
use core::cell::{RefCell, RefMut};
use core::hash::{Hash, Hasher};
use wasmtime_jit::{CompilationStrategy, Compiler, Features};

11
wasmtime-api/src/externals.rs
View File

@@ -5,9 +5,10 @@ use crate::trampoline::{generate_global_export, generate_memory_export, generate
use crate::trap::Trap;
use crate::types::{ExternType, FuncType, GlobalType, MemoryType, TableType, ValType};
use crate::values::{from_checked_anyfunc, into_checked_anyfunc, Val};
use std::rc::Rc;
use std::result::Result;
use std::slice;
use alloc::boxed::Box;
use alloc::rc::Rc;
use core::result::Result;
use core::slice;
use wasmtime_runtime::InstanceHandle;
// Externals
@@ -171,8 +172,8 @@ impl Func {
}
}
impl std::fmt::Debug for Func {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
impl core::fmt::Debug for Func {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "Func")
}
}

10
wasmtime-api/src/instance.rs
View File

@@ -3,10 +3,14 @@ use crate::externals::Extern;
use crate::module::Module;
use crate::r#ref::HostRef;
use crate::runtime::Store;
use crate::{HashMap, HashSet};
use alloc::borrow::ToOwned;
use alloc::boxed::Box;
use alloc::rc::Rc;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use core::cell::RefCell;
use failure::Error;
use std::cell::RefCell;
use std::collections::{HashMap, HashSet};
use std::rc::Rc;
use wasmtime_jit::{instantiate, Resolver};
use wasmtime_runtime::{Export, InstanceHandle};

9
wasmtime-api/src/lib.rs
View File

@@ -1,5 +1,7 @@
//! Wasmtime embed API. Based on wasm-c-api.
#![cfg_attr(not(feature = "std"), no_std)]
mod callable;
mod context;
mod externals;
@@ -17,6 +19,8 @@ pub mod wasm;
#[macro_use]
extern crate failure_derive;
#[macro_use]
extern crate alloc;
pub use crate::callable::Callable;
pub use crate::externals::*;
@@ -27,3 +31,8 @@ pub use crate::runtime::{Config, Engine, Store};
pub use crate::trap::Trap;
pub use crate::types::*;
pub use crate::values::*;
#[cfg(not(feature = "std"))]
use hashbrown::{hash_map, HashMap, HashSet};
#[cfg(feature = "std")]
use std::collections::{hash_map, HashMap, HashSet};

7
wasmtime-api/src/module.rs
View File

@@ -4,6 +4,9 @@ use crate::types::{
ExportType, ExternType, FuncType, GlobalType, ImportType, Limits, MemoryType, Mutability,
TableType, ValType,
};
use alloc::boxed::Box;
use alloc::string::String;
use alloc::vec::Vec;
use failure::Error;
use wasmparser::{validate, ExternalKind, ImportSectionEntryType, ModuleReader, SectionCode};
@@ -12,7 +15,7 @@ fn into_memory_type(mt: wasmparser::MemoryType) -> MemoryType {
assert!(!mt.shared);
MemoryType::new(Limits::new(
mt.limits.initial,
mt.limits.maximum.unwrap_or(::std::u32::MAX),
mt.limits.maximum.unwrap_or(::core::u32::MAX),
))
}
@@ -53,7 +56,7 @@ fn into_table_type(tt: wasmparser::TableType) -> TableType {
let ty = into_valtype(&tt.element_type);
let limits = Limits::new(
tt.limits.initial,
tt.limits.maximum.unwrap_or(::std::u32::MAX),
tt.limits.maximum.unwrap_or(::core::u32::MAX),
);
TableType::new(ty, limits)
}

9
wasmtime-api/src/ref.rs
View File

@@ -1,7 +1,8 @@
use std::any::Any;
use std::cell::{self, RefCell};
use std::fmt;
use std::rc::{Rc, Weak};
use alloc::boxed::Box;
use alloc::rc::{Rc, Weak};
use core::any::Any;
use core::cell::{self, RefCell};
use core::fmt;
pub trait HostInfo {
fn finalize(&mut self) {}

10
wasmtime-api/src/runtime.rs
View File

@@ -1,6 +1,8 @@
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use crate::HashMap;
use alloc::boxed::Box;
use alloc::rc::Rc;
use alloc::string::String;
use core::cell::RefCell;
use crate::context::{create_compiler, Context};
use crate::r#ref::HostRef;
@@ -132,7 +134,7 @@ impl Store {
&mut self,
signature: &ir::Signature,
) -> wasmtime_runtime::VMSharedSignatureIndex {
use std::collections::hash_map::Entry;
use crate::hash_map::Entry;
let index = self.context().compiler().signatures().register(signature);
match self.signature_cache.entry(index) {
Entry::Vacant(v) => {

4
wasmtime-api/src/trampoline/code_memory.rs
View File

@@ -1,10 +1,10 @@
//! Memory management for executable code.
// Copy of wasmtime's wasmtime-jit/src/code_memory.rs
use alloc::string::String;
use alloc::vec::Vec;
use core::{cmp, mem};
use region;
use std::string::String;
use std::vec::Vec;
use wasmtime_runtime::{Mmap, VMFunctionBody};
/// Memory manager for executable code.

11
wasmtime-api/src/trampoline/create_handle.rs
View File

@@ -7,10 +7,13 @@ use failure::Error;
use wasmtime_environ::Module;
use wasmtime_runtime::{Imports, InstanceHandle, VMFunctionBody};
use std::any::Any;
use std::cell::{RefCell, RefMut};
use std::collections::{HashMap, HashSet};
use std::rc::Rc;
use crate::{HashMap, HashSet};
use alloc::boxed::Box;
use alloc::rc::Rc;
use alloc::string::String;
use alloc::vec::Vec;
use core::any::Any;
use core::cell::{RefCell, RefMut};
use crate::runtime::Store;

5
wasmtime-api/src/trampoline/func.rs
View File

@@ -14,8 +14,11 @@ use failure::Error;
use wasmtime_environ::{Export, Module};
use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody};
use alloc::boxed::Box;
use alloc::rc::Rc;
use alloc::string::ToString;
use alloc::vec::Vec;
use core::cmp;
use std::rc::Rc;
use crate::{Callable, FuncType, Store, Trap, Val};

1
wasmtime-api/src/trampoline/global.rs
View File

@@ -1,3 +1,4 @@
use alloc::boxed::Box;
use cranelift_entity::PrimaryMap;
use failure::Error;
use wasmtime_environ::Module;

4
wasmtime-api/src/trampoline/memory.rs
View File

@@ -1,3 +1,5 @@
use alloc::boxed::Box;
use alloc::string::ToString;
use cranelift_entity::PrimaryMap;
use failure::Error;
use wasmtime_environ::Module;
@@ -13,7 +15,7 @@ pub fn create_handle_with_memory(memory: &MemoryType) -> Result<InstanceHandle,
let memory = cranelift_wasm::Memory {
minimum: memory.limits().min(),
maximum: if memory.limits().max() == std::u32::MAX {
maximum: if memory.limits().max() == core::u32::MAX {
None
} else {
Some(memory.limits().max())

2
wasmtime-api/src/trampoline/mod.rs
View File

@@ -8,8 +8,8 @@ mod memory;
mod table;
use crate::r#ref::HostRef;
use alloc::rc::Rc;
use failure::Error;
use std::rc::Rc;
use self::func::create_handle_with_function;
use self::global::create_global;

4
wasmtime-api/src/trampoline/table.rs
View File

@@ -1,3 +1,5 @@
use alloc::boxed::Box;
use alloc::string::ToString;
use cranelift_entity::PrimaryMap;
use cranelift_wasm::TableElementType;
use failure::Error;
@@ -12,7 +14,7 @@ pub fn create_handle_with_table(table: &TableType) -> Result<InstanceHandle, Err
let table = cranelift_wasm::Table {
minimum: table.limits().min(),
maximum: if table.limits().max() == std::u32::MAX {
maximum: if table.limits().max() == core::u32::MAX {
None
} else {
Some(table.limits().max())

2
wasmtime-api/src/trap.rs
View File

@@ -1,3 +1,5 @@
use alloc::string::{String, ToString};
#[derive(Fail, Debug)]
#[fail(display = "Wasm trap")]
pub struct Trap {

12
wasmtime-api/src/types.rs
View File

@@ -1,3 +1,7 @@
use alloc::borrow::ToOwned;
use alloc::boxed::Box;
use alloc::string::String;
use alloc::vec::Vec;
use cranelift_codegen::ir;
// Type Representations
@@ -24,7 +28,7 @@ impl Limits {
pub fn at_least(min: u32) -> Limits {
Limits {
min,
max: ::std::u32::MAX,
max: ::core::u32::MAX,
}
}
@@ -257,7 +261,7 @@ impl TableType {
false
});
let ty = ValType::FuncRef;
let limits = Limits::new(table.minimum, table.maximum.unwrap_or(::std::u32::MAX));
let limits = Limits::new(table.minimum, table.maximum.unwrap_or(::core::u32::MAX));
TableType::new(ty, limits)
}
}
@@ -280,7 +284,7 @@ impl MemoryType {
pub(crate) fn from_cranelift_memory(memory: cranelift_wasm::Memory) -> MemoryType {
MemoryType::new(Limits::new(
memory.minimum,
memory.maximum.unwrap_or(::std::u32::MAX),
memory.maximum.unwrap_or(::core::u32::MAX),
))
}
}
@@ -296,7 +300,7 @@ impl From<String> for Name {
}
}
impl ::std::string::ToString for Name {
impl ::alloc::string::ToString for Name {
fn to_string(&self) -> String {
self.0.to_owned()
}

2
wasmtime-api/src/values.rs
View File

@@ -2,7 +2,7 @@ use crate::externals::Func;
use crate::r#ref::{AnyRef, HostRef};
use crate::runtime::Store;
use crate::types::ValType;
use std::ptr;
use core::ptr;
use cranelift_codegen::ir;
use wasmtime_jit::RuntimeValue;

32
wasmtime-api/src/wasm.rs
View File

@@ -10,11 +10,11 @@ use super::{
HostInfo, HostRef, ImportType, Instance, Limits, Memory, MemoryType, Module, Name, Store,
Table, TableType, Trap, Val, ValType,
};
use std::boxed::Box;
use std::mem;
use std::ptr;
use std::rc::Rc;
use std::slice;
use alloc::boxed::Box;
use alloc::rc::Rc;
use core::mem;
use core::ptr;
use core::slice;
macro_rules! declare_vec {
($name:ident, $elem_ty:path) => {
@@ -345,12 +345,12 @@ pub struct wasm_func_t {
func: HostRef<Func>,
ext: Option<Box<wasm_extern_t>>,
}
pub type wasm_func_callback_t = ::std::option::Option<
pub type wasm_func_callback_t = ::core::option::Option<
unsafe extern "C" fn(args: *const wasm_val_t, results: *mut wasm_val_t) -> *mut wasm_trap_t,
>;
pub type wasm_func_callback_with_env_t = ::std::option::Option<
pub type wasm_func_callback_with_env_t = ::core::option::Option<
unsafe extern "C" fn(
env: *mut ::std::os::raw::c_void,
env: *mut ::core::ffi::c_void,
args: *const wasm_val_t,
results: *mut wasm_val_t,
) -> *mut wasm_trap_t,
@@ -569,8 +569,8 @@ impl Into<HostRef<Trap>> for wasm_trap_t {
struct CallbackWithEnv {
callback: wasm_func_callback_with_env_t,
env: *mut ::std::os::raw::c_void,
finalizer: ::std::option::Option<unsafe extern "C" fn(env: *mut ::std::os::raw::c_void)>,
env: *mut ::core::ffi::c_void,
finalizer: ::core::option::Option<unsafe extern "C" fn(env: *mut ::core::ffi::c_void)>,
}
impl Callable for CallbackWithEnv {
@@ -801,8 +801,8 @@ pub unsafe extern "C" fn wasm_func_new_with_env(
store: *mut wasm_store_t,
ty: *const wasm_functype_t,
callback: wasm_func_callback_with_env_t,
env: *mut ::std::os::raw::c_void,
finalizer: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
env: *mut ::core::ffi::c_void,
finalizer: ::core::option::Option<unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void)>,
) -> *mut wasm_func_t {
let store = (*store).store.clone();
let ty = (*ty).functype.clone();
@@ -1618,8 +1618,8 @@ pub unsafe extern "C" fn wasm_tabletype_new(
}
struct HostInfoState {
info: *mut ::std::os::raw::c_void,
finalizer: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
info: *mut ::core::ffi::c_void,
finalizer: ::core::option::Option<unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void)>,
}
impl HostInfo for HostInfoState {
@@ -1635,8 +1635,8 @@ impl HostInfo for HostInfoState {
#[no_mangle]
pub unsafe extern "C" fn wasm_instance_set_host_info_with_finalizer(
instance: *mut wasm_instance_t,
info: *mut ::std::os::raw::c_void,
finalizer: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
info: *mut ::core::ffi::c_void,
finalizer: ::core::option::Option<unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void)>,
) {
let info = if info.is_null() && finalizer.is_none() {
None