2018-10-11 19:29:36 +00:00
|
|
|
pub mod errors;
|
2018-10-17 14:08:31 +00:00
|
|
|
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-10-11 19:29:36 +00:00
|
|
|
|
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;
|
2018-10-14 20:23:48 +00:00
|
|
|
use wasmparser;
|
2018-11-15 08:50:54 +00:00
|
|
|
use wasmparser::WasmDecoder;
|
2018-10-13 17:22:57 +00:00
|
|
|
|
2018-10-11 19:29:36 +00:00
|
|
|
pub use self::errors::{Error, ErrorKind};
|
2018-11-16 15:55:49 +00:00
|
|
|
pub use self::import_object::{ImportObject, ImportValue};
|
2018-11-14 03:44:24 +00:00
|
|
|
pub use self::instance::{Instance, InstanceOptions};
|
2018-10-14 20:23:48 +00:00
|
|
|
pub use self::memory::LinearMemory;
|
2018-10-15 11:45:44 +00:00
|
|
|
pub use self::module::{Export, Module, ModuleInfo};
|
2018-10-14 20:23:48 +00:00
|
|
|
|
|
|
|
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,
|
|
|
|
}
|
2018-10-11 19:29:36 +00:00
|
|
|
|
2018-10-14 20:10:53 +00:00
|
|
|
/// The webassembly::instantiate() function allows you to compile and
|
2018-10-11 19:29:36 +00:00
|
|
|
/// instantiate WebAssembly code
|
2018-10-14 21:48:59 +00:00
|
|
|
/// Params:
|
2018-10-11 19:29:36 +00:00
|
|
|
/// * `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
|
2018-10-14 20:10:53 +00:00
|
|
|
/// webassembly::Memory objects. There must be one matching property
|
2018-10-11 19:29:36 +00:00
|
|
|
/// for each declared import of the compiled module or else a
|
2018-10-14 20:10:53 +00:00
|
|
|
/// webassembly::LinkError is thrown.
|
2018-10-11 19:29:36 +00:00
|
|
|
/// Errors:
|
2018-10-14 21:48:59 +00:00
|
|
|
/// If the operation fails, the Result rejects with a
|
2018-10-14 20:10:53 +00:00
|
|
|
/// 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> {
|
2018-11-25 18:51:21 +00:00
|
|
|
let flags = {
|
|
|
|
let mut builder = settings::builder();
|
2018-11-27 04:29:26 +00:00
|
|
|
builder.set("opt_level", "best").unwrap();
|
2018-11-25 18:51:21 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2018-10-14 20:23:48 +00:00
|
|
|
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,
|
2018-11-17 08:58:35 +00:00
|
|
|
import_object,
|
2018-11-15 21:31:37 +00:00
|
|
|
InstanceOptions {
|
|
|
|
mock_missing_imports: true,
|
2018-11-19 21:09:16 +00:00
|
|
|
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-14 20:23:48 +00:00
|
|
|
}
|
|
|
|
|
2018-10-24 10:36:43 +00:00
|
|
|
/// The webassembly::instantiate_streaming() function compiles and instantiates
|
2018-10-24 09:56:42 +00:00
|
|
|
/// 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>,
|
2018-10-24 09:56:42 +00:00
|
|
|
) -> Result<ResultObject, ErrorKind> {
|
|
|
|
unimplemented!();
|
|
|
|
}
|
|
|
|
|
2018-10-14 20:23:48 +00:00
|
|
|
/// 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:
|
2018-10-14 20:23:48 +00:00
|
|
|
/// * `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
|
2018-10-14 20:23:48 +00:00
|
|
|
/// 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");
|
2018-10-14 19:13:19 +00:00
|
|
|
|
|
|
|
Ok(module)
|
2018-10-11 19:29:36 +00:00
|
|
|
}
|
|
|
|
|
2018-10-14 20:10:53 +00:00
|
|
|
/// The webassembly::validate() function validates a given typed
|
2018-10-11 19:29:36 +00:00
|
|
|
/// 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
|
2018-10-11 19:29:36 +00:00
|
|
|
/// 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
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
}
|
2018-10-11 19:29:36 +00:00
|
|
|
}
|