wasmer/src/webassembly/mod.rs

140 lines
4.7 KiB
Rust
Raw Normal View History

pub mod errors;
pub mod import_object;
2018-10-14 11:59:11 +00:00
pub mod instance;
2018-11-22 04:59:23 +00:00
pub mod math_intrinsics;
2018-10-14 21:48:59 +00:00
pub mod memory;
pub mod module;
2018-10-15 00:48:59 +00:00
pub mod relocation;
2018-10-15 01:03:00 +00:00
pub mod utils;
2018-11-27 04:29:26 +00:00
use cranelift_codegen::{
isa,
settings::{self, Configurable},
};
2018-10-13 13:31:56 +00:00
use std::panic;
2018-10-14 21:48:59 +00:00
use std::str::FromStr;
2018-11-06 14:51:01 +00:00
use target_lexicon;
use wasmparser;
2018-11-15 08:50:54 +00:00
use wasmparser::WasmDecoder;
2018-10-13 17:22:57 +00:00
pub use self::errors::{Error, ErrorKind};
pub use self::import_object::{ImportObject, ImportValue};
pub use self::instance::{Instance, InstanceOptions};
pub use self::memory::LinearMemory;
pub use self::module::{Export, Module, ModuleInfo};
pub struct ResultObject {
/// A webassembly::Module object representing the compiled WebAssembly module.
/// This Module can be instantiated again
pub module: Module,
/// A webassembly::Instance object that contains all the Exported WebAssembly
/// functions.
pub instance: Instance,
}
/// The webassembly::instantiate() function allows you to compile and
/// instantiate WebAssembly code
2018-10-14 21:48:59 +00:00
/// Params:
/// * `buffer_source`: A `Vec<u8>` containing the
/// binary code of the .wasm module you want to compile.
/// * `import_object`: An object containing the values to be imported
/// into the newly-created Instance, such as functions or
/// webassembly::Memory objects. There must be one matching property
/// for each declared import of the compiled module or else a
/// webassembly::LinkError is thrown.
/// Errors:
2018-10-14 21:48:59 +00:00
/// If the operation fails, the Result rejects with a
/// webassembly::CompileError, webassembly::LinkError, or
/// webassembly::RuntimeError, depending on the cause of the failure.
2018-10-14 21:48:59 +00:00
pub fn instantiate(
buffer_source: Vec<u8>,
2018-10-17 15:14:35 +00:00
import_object: ImportObject<&str, &str>,
2018-10-14 21:48:59 +00:00
) -> Result<ResultObject, ErrorKind> {
let flags = {
let mut builder = settings::builder();
2018-11-27 04:29:26 +00:00
builder.set("opt_level", "best").unwrap();
let flags = settings::Flags::new(builder);
debug_assert_eq!(flags.opt_level(), settings::OptLevel::Best);
flags
};
2018-11-15 07:10:35 +00:00
let isa = isa::lookup(triple!("x86_64")).unwrap().finish(flags);
let module = compile(buffer_source)?;
2018-10-15 00:48:59 +00:00
debug!("webassembly - creating instance");
2018-11-15 21:31:37 +00:00
let instance = Instance::new(
&module,
import_object,
2018-11-15 21:31:37 +00:00
InstanceOptions {
mock_missing_imports: true,
mock_missing_globals: true,
mock_missing_tables: true,
2018-11-22 04:59:23 +00:00
isa: isa,
2018-11-15 21:31:37 +00:00
},
)?;
2018-10-15 00:48:59 +00:00
debug!("webassembly - instance created");
2018-10-14 21:48:59 +00:00
Ok(ResultObject { module, instance })
}
2018-10-24 10:36:43 +00:00
/// The webassembly::instantiate_streaming() function compiles and instantiates
/// a WebAssembly module directly from a streamed underlying source.
/// This is the most efficient, optimized way to load wasm code.
2018-10-24 10:36:43 +00:00
pub fn instantiate_streaming(
2018-11-06 14:51:01 +00:00
_buffer_source: Vec<u8>,
_import_object: ImportObject<&str, &str>,
) -> Result<ResultObject, ErrorKind> {
unimplemented!();
}
/// The webassembly::compile() function compiles a webassembly::Module
/// from WebAssembly binary code. This function is useful if it
/// is necessary to a compile a module before it can be instantiated
/// (otherwise, the webassembly::instantiate() function should be used).
2018-10-14 21:48:59 +00:00
/// Params:
/// * `buffer_source`: A `Vec<u8>` containing the
/// binary code of the .wasm module you want to compile.
/// Errors:
2018-10-14 21:48:59 +00:00
/// If the operation fails, the Result rejects with a
/// webassembly::CompileError.
pub fn compile(buffer_source: Vec<u8>) -> Result<Module, ErrorKind> {
2018-10-14 19:41:59 +00:00
// TODO: This should be automatically validated when creating the Module
2018-11-15 08:50:54 +00:00
debug!("webassembly - validating module");
validate_or_error(&buffer_source)?;
2018-10-14 21:48:59 +00:00
2018-11-15 07:10:35 +00:00
let flags = settings::Flags::new(settings::builder());
let isa = isa::lookup(triple!("x86_64")).unwrap().finish(flags);
2018-10-14 21:48:59 +00:00
2018-10-15 00:48:59 +00:00
debug!("webassembly - creating module");
2018-11-15 07:10:35 +00:00
let module = Module::from_bytes(buffer_source, isa.frontend_config())?;
2018-10-15 00:48:59 +00:00
debug!("webassembly - module created");
Ok(module)
}
/// The webassembly::validate() function validates a given typed
/// array of WebAssembly binary code, returning whether the bytes
/// form a valid wasm module (true) or not (false).
2018-10-14 21:48:59 +00:00
/// Params:
2018-11-15 08:50:54 +00:00
/// * `buffer_source`: A `&[u8]` containing the
/// binary code of the .wasm module you want to compile.
2018-11-15 08:50:54 +00:00
pub fn validate(buffer_source: &[u8]) -> bool {
validate_or_error(buffer_source).is_ok()
}
pub fn validate_or_error(bytes: &[u8]) -> Result<(), ErrorKind> {
let mut parser = wasmparser::ValidatingParser::new(bytes, None);
loop {
let state = parser.read();
match *state {
wasmparser::ParserState::EndWasm => return Ok(()),
2018-11-15 21:31:37 +00:00
wasmparser::ParserState::Error(err) => {
return Err(ErrorKind::CompileError(format!(
"Validation error: {}",
err.message
)))
}
2018-11-15 08:50:54 +00:00
_ => (),
}
}
}