fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-04-03 08:21:04 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into fix/emscripten-translate

Browse Source 
# Conflicts:
#	Cargo.lock
This commit is contained in:
Syrus 2019-01-24 14:05:44 -08:00
commit 762405f6e9
8 changed files with 168 additions and 12 deletions

14
Cargo.lock generated

@ -491,8 +491,8 @@ dependencies = [
"wabt 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
"wasmer-clif-backend 0.1.1",
"wasmer-emscripten 0.1.0",
"wasmer-runtime 0.1.1",
"wasmer-runtime-core 0.1.1",
"wasmer-runtime 0.1.3",
"wasmer-runtime-core 0.1.2",
]
[[package]]
@ -507,7 +507,7 @@ dependencies = [
"hashbrown 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"nix 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
"target-lexicon 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"wasmer-runtime-core 0.1.1",
"wasmer-runtime-core 0.1.2",
"wasmparser 0.23.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
@ -522,20 +522,20 @@ dependencies = [
"time 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)",
"wabt 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
"wasmer-clif-backend 0.1.1",
"wasmer-runtime-core 0.1.1",
"wasmer-runtime-core 0.1.2",
]
[[package]]
name = "wasmer-runtime"
version = "0.1.1"
version = "0.1.3"
dependencies = [
"wasmer-clif-backend 0.1.1",
"wasmer-runtime-core 0.1.1",
"wasmer-runtime-core 0.1.2",
]
[[package]]
name = "wasmer-runtime-core"
version = "0.1.1"
version = "0.1.2"
dependencies = [
"errno 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
"field-offset 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

2
lib/runtime-core/Cargo.toml

@ -1,6 +1,6 @@
[package]
name = "wasmer-runtime-core"
version = "0.1.1"
version = "0.1.2"
description = "Wasmer runtime core library"
license = "MIT"
authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]

1
lib/runtime-core/src/backing.rs

@ -60,7 +60,6 @@ impl LocalBacking {
for (_, mem) in &module.memories {
// If we use emscripten, we set a fixed initial and maximum
debug!("Instance - init memory ({}, {:?})", mem.min, mem.max);
// let memory = if options.abi == InstanceABI::Emscripten {
// // We use MAX_PAGES, so at the end the result is:
// // (initial * LinearMemory::PAGE_SIZE) == LinearMemory::DEFAULT_HEAP_SIZE

7
lib/runtime-core/src/error.rs

@ -140,6 +140,7 @@ pub enum Error {
CompileError(CompileError),
LinkError(Vec<LinkError>),
RuntimeError(RuntimeError),
ResolveError(ResolveError),
CallError(CallError),
}
@ -167,6 +168,12 @@ impl From<Box<RuntimeError>> for Box<Error> {
}
}
impl From<Box<ResolveError>> for Box<Error> {
fn from(resolve_err: Box<ResolveError>) -> Self {
Box::new(Error::ResolveError(*resolve_err))
}
}
impl From<Box<CallError>> for Box<Error> {
fn from(call_err: Box<CallError>) -> Self {
Box::new(Error::CallError(*call_err))

1
lib/runtime-core/src/memory.rs

@ -47,7 +47,6 @@ impl LinearMemory {
pub fn new(mem: &Memory) -> Self {
assert!(mem.min <= Self::MAX_PAGES);
assert!(mem.max.is_none() || mem.max.unwrap() <= Self::MAX_PAGES);
debug!("Instantiate LinearMemory(mem: {:?})", mem);
let (mmap_size, initial_pages, offset_guard_size, requires_signal_catch) = if
/*mem.is_static_heap()*/

5
lib/runtime/Cargo.toml

@ -1,14 +1,15 @@
[package]
name = "wasmer-runtime"
version = "0.1.1"
version = "0.1.3"
description = "Wasmer runtime library"
license = "MIT"
authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]
repository = "https://github.com/wasmerio/wasmer"
edition = "2018"
readme = "README.md"
[dependencies]
wasmer-runtime-core = { path = "../runtime-core", version = "0.1.1" }
wasmer-runtime-core = { path = "../runtime-core", version = "0.1.2" }
wasmer-clif-backend = { path = "../clif-backend", version = "0.1.1", optional = true }
[features]

75
lib/runtime/README.md Normal file

@ -0,0 +1,75 @@
# Wasmer-Runtime
Wasmer-runtime is a library that makes embedding WebAssembly
in your application easy, efficient, and safe.
# How to use Wasmer-Runtime
The easiest way is to use the [`instantiate`] function to create an [`Instance`].
Then you can use [`call`] or [`func`] and then [`call`][func.call] to call an exported function safely.
[`instantiate`]: https://docs.rs/wasmer-runtime/*/wasmer_runtime/fn.instantiate.html
[`Instance`]: https://docs.rs/wasmer-runtime/*/wasmer_runtime/struct.Instance.html
[`call`]: https://docs.rs/wasmer-runtime/*/wasmer_runtime/struct.Instance.html#method.call
[`func`]: https://docs.rs/wasmer-runtime/*/wasmer_runtime/struct.Instance.html#method.func
[func.call]: https://docs.rs/wasmer-runtime/*/wasmer_runtime/struct.Function.html#method.call
## Here's an example:
Given this WebAssembly:
```wat
(module
(type $t0 (func (param i32) (result i32)))
(func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
get_local $p0
i32.const 1
i32.add))
```
compiled into wasm bytecode, we can call the exported "add_one" function:
```rust
static WASM: &'static [u8] = &[
// The module above compiled to bytecode goes here.
0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60,
0x01, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0b, 0x01, 0x07,
0x61, 0x64, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x00, 0x00, 0x0a, 0x09, 0x01,
0x07, 0x00, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x0b, 0x00, 0x1a, 0x04, 0x6e,
0x61, 0x6d, 0x65, 0x01, 0x0a, 0x01, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f,
0x6f, 0x6e, 0x65, 0x02, 0x07, 0x01, 0x00, 0x01, 0x00, 0x02, 0x70, 0x30,
];
use wasmer_runtime::{
instantiate,
Value,
imports,
error,
};
fn main() -> error::Result<()> {
// We're not importing anything, so make an empty import object.
let import_object = imports! {};
let mut instance = instantiate(WASM, import_object)?;
let values = instance
.func("add_one")?
.call(&[Value::I32(42)])?;
assert_eq!(values[0], Value::I32(43));
Ok(())
}
```
# Additional Notes:
The `wasmer-runtime` is build to support compiler multiple backends.
Currently, we support the [Cranelift] compiler with the [`wasmer-clif-backend`] crate.
You can specify the compiler you wish to use with the [`compile_with`] function.
[Cranelift]: https://github.com/CraneStation/cranelift
[`wasmer-clif-backend`]: https://crates.io/crates/wasmer-clif-backend
[`compile_with`]: https://docs.rs/wasmer-runtime/*/wasmer_runtime/fn.compile_with.html

75
lib/runtime/src/lib.rs

@ -1,3 +1,78 @@
//! Wasmer-runtime is a library that makes embedding WebAssembly
//! in your application easy, efficient, and safe.
//!
//! # How to use Wasmer-Runtime
//!
//! The easiest way is to use the [`instantiate`] function to create an [`Instance`].
//! Then you can use [`call`] or [`func`] and then [`call`][func.call] to call an exported function safely.
//!
//! [`instantiate`]: fn.instantiate.html
//! [`Instance`]: struct.Instance.html
//! [`call`]: struct.Instance.html#method.call
//! [`func`]: struct.Instance.html#method.func
//! [func.call]: struct.Function.html#method.call
//!
//! ## Here's an example:
//!
//! Given this WebAssembly:
//!
//! ```wat
//! (module
//! (type $t0 (func (param i32) (result i32)))
//! (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
//! get_local $p0
//! i32.const 1
//! i32.add))
//! ```
//!
//! compiled into wasm bytecode, we can call the exported "add_one" function:
//!
//! ```
//! static WASM: &'static [u8] = &[
//! // The module above compiled to bytecode goes here.
//! // ...
//! # 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60,
//! # 0x01, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0b, 0x01, 0x07,
//! # 0x61, 0x64, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x00, 0x00, 0x0a, 0x09, 0x01,
//! # 0x07, 0x00, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x0b, 0x00, 0x1a, 0x04, 0x6e,
//! # 0x61, 0x6d, 0x65, 0x01, 0x0a, 0x01, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f,
//! # 0x6f, 0x6e, 0x65, 0x02, 0x07, 0x01, 0x00, 0x01, 0x00, 0x02, 0x70, 0x30,
//! ];
//!
//! use wasmer_runtime::{
//! instantiate,
//! Value,
//! imports,
//! error,
//! };
//!
//! fn main() -> error::Result<()> {
//! // We're not importing anything, so make an empty import object.
//! let import_object = imports! {};
//!
//! let mut instance = instantiate(WASM, import_object)?;
//!
//! let values = instance
//! .func("add_one")?
//! .call(&[Value::I32(42)])?;
//!
//! assert_eq!(values[0], Value::I32(43));
//!
//! Ok(())
//! }
//! ```
//!
//! # Additional Notes:
//!
//! The `wasmer-runtime` is build to support compiler multiple backends.
//! Currently, we support the [Cranelift] compiler with the [`wasmer-clif-backend`] crate.
//!
//! You can specify the compiler you wish to use with the [`compile_with`] function.
//!
//! [Cranelift]: https://github.com/CraneStation/cranelift
//! [`wasmer-clif-backend`]: https://crates.io/crates/wasmer-clif-backend
//! [`compile_with`]: fn.compile_with.html
pub use wasmer_runtime_core::import::ImportObject;
pub use wasmer_runtime_core::instance::{Function, Instance};
pub use wasmer_runtime_core::module::Module;