wasmer/lib/runtime-core/src/backend.rs

174 lines
4.4 KiB
Rust
Raw Normal View History

2019-01-18 20:13:01 +00:00
use crate::{
error::CompileResult,
module::ModuleInner,
2019-06-12 14:02:15 +00:00
state::ModuleStateMap,
typed_func::Wasm,
types::{LocalFuncIndex, SigIndex},
2019-01-18 20:13:01 +00:00
vm,
};
2019-02-19 23:36:22 +00:00
use crate::{
cache::{Artifact, Error as CacheError},
2019-07-03 17:45:06 +00:00
codegen::BreakpointMap,
module::ModuleInfo,
sys::Memory,
};
use std::{any::Any, ptr::NonNull};
2019-01-08 17:09:47 +00:00
2019-03-27 21:01:27 +00:00
use hashbrown::HashMap;
pub mod sys {
pub use crate::sys::*;
}
2019-01-11 03:59:57 +00:00
pub use crate::sig_registry::SigRegistry;
2019-02-21 00:41:41 +00:00
#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
pub enum Backend {
Cranelift,
2019-04-11 19:44:03 +00:00
Singlepass,
LLVM,
}
impl Backend {
pub fn variants() -> &'static [&'static str] {
&[
"cranelift",
#[cfg(feature = "backend:singlepass")]
"singlepass",
#[cfg(feature = "backend:llvm")]
"llvm",
]
}
/// stable string representation of the backend
/// can be used as part of a cache key, for example
pub fn to_string(&self) -> &'static str {
match self {
Backend::Cranelift => "cranelift",
Backend::Singlepass => "singlepass",
Backend::LLVM => "llvm",
}
}
}
impl Default for Backend {
fn default() -> Self {
Backend::Cranelift
}
}
impl std::str::FromStr for Backend {
type Err = String;
fn from_str(s: &str) -> Result<Backend, String> {
match s.to_lowercase().as_str() {
"singlepass" => Ok(Backend::Singlepass),
"cranelift" => Ok(Backend::Cranelift),
"llvm" => Ok(Backend::LLVM),
_ => Err(format!("The backend {} doesn't exist", s)),
}
}
}
#[cfg(test)]
mod backend_test {
use super::*;
use std::str::FromStr;
#[test]
fn str_repr_matches() {
// if this test breaks, think hard about why it's breaking
// can we avoid having these be different?
for &backend in &[Backend::Cranelift, Backend::LLVM, Backend::Singlepass] {
assert_eq!(backend, Backend::from_str(backend.to_string()).unwrap());
}
}
}
2019-01-18 20:13:01 +00:00
/// This type cannot be constructed from
/// outside the runtime crate.
pub struct Token {
_private: (),
}
impl Token {
pub(crate) fn generate() -> Self {
Self { _private: () }
}
}
#[derive(Copy, Clone, Debug)]
pub enum MemoryBoundCheckMode {
Default,
Enable,
Disable,
}
impl Default for MemoryBoundCheckMode {
fn default() -> MemoryBoundCheckMode {
MemoryBoundCheckMode::Default
}
}
2019-03-27 21:01:27 +00:00
/// Configuration data for the compiler
#[derive(Default)]
2019-03-27 21:01:27 +00:00
pub struct CompilerConfig {
/// Symbol information generated from emscripten; used for more detailed debug messages
pub symbol_map: Option<HashMap<u32, String>>,
pub memory_bound_check_mode: MemoryBoundCheckMode,
pub enforce_stack_check: bool,
2019-03-27 21:01:27 +00:00
}
2019-01-08 17:09:47 +00:00
pub trait Compiler {
2019-01-18 20:13:01 +00:00
/// Compiles a `Module` from WebAssembly binary format.
/// The `CompileToken` parameter ensures that this can only
/// be called from inside the runtime.
2019-03-27 21:01:27 +00:00
fn compile(
&self,
wasm: &[u8],
comp_conf: CompilerConfig,
_: Token,
) -> CompileResult<ModuleInner>;
unsafe fn from_cache(&self, cache: Artifact, _: Token) -> Result<ModuleInner, CacheError>;
2019-01-18 20:13:01 +00:00
}
pub trait RunnableModule: Send + Sync {
2019-01-18 20:13:01 +00:00
/// This returns a pointer to the function designated by the `local_func_index`
/// parameter.
fn get_func(
2019-01-16 18:26:10 +00:00
&self,
info: &ModuleInfo,
2019-01-16 18:26:10 +00:00
local_func_index: LocalFuncIndex,
) -> Option<NonNull<vm::Func>>;
2019-06-12 14:02:15 +00:00
fn get_module_state_map(&self) -> Option<ModuleStateMap> {
None
}
2019-06-09 13:21:18 +00:00
2019-07-03 17:45:06 +00:00
fn get_breakpoints(&self) -> Option<BreakpointMap> {
2019-06-27 07:49:43 +00:00
None
}
/// A wasm trampoline contains the necessary data to dynamically call an exported wasm function.
/// Given a particular signature index, we are returned a trampoline that is matched with that
/// signature and an invoke function that can call the trampoline.
fn get_trampoline(&self, info: &ModuleInfo, sig_index: SigIndex) -> Option<Wasm>;
2019-04-18 17:00:15 +00:00
unsafe fn do_early_trap(&self, data: Box<dyn Any>) -> !;
2019-05-02 16:23:41 +00:00
2019-05-14 08:13:42 +00:00
/// Returns the machine code associated with this module.
2019-05-14 08:04:08 +00:00
fn get_code(&self) -> Option<&[u8]> {
None
}
2019-05-14 08:13:42 +00:00
/// Returns the beginning offsets of all functions, including import trampolines.
2019-05-14 08:04:08 +00:00
fn get_offsets(&self) -> Option<Vec<usize>> {
None
}
2019-01-08 17:09:47 +00:00
}
pub trait CacheGen: Send + Sync {
2019-04-19 20:54:48 +00:00
fn generate_cache(&self) -> Result<(Box<[u8]>, Memory), CacheError>;
2019-02-21 00:41:41 +00:00
}