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

Remove old Cranelift compiler code

Browse Source
This commit is contained in:
Brandon Fish 2019-05-26 22:32:11 -05:00
parent bf1cfc2578
commit 3f0cafce5c
4 changed files with 5 additions and 1421 deletions

700
lib/clif-backend/src/func_env.rs

@ -1,700 +0,0 @@
use crate::{module::Converter, module_env::ModuleEnv, relocation::call_names};
use cranelift_codegen::{
cursor::FuncCursor,
ir::{self, InstBuilder},
isa,
};
use cranelift_entity::EntityRef;
use cranelift_wasm::{self, FuncEnvironment, ModuleEnvironment};
use std::mem;
use wasmer_runtime_core::{
memory::MemoryType,
structures::TypedIndex,
types::{FuncIndex, GlobalIndex, LocalOrImport, MemoryIndex, TableIndex},
vm,
};
pub struct FuncEnv<'env, 'module, 'isa> {
env: &'env ModuleEnv<'module, 'isa>,
}
impl<'env, 'module, 'isa> FuncEnv<'env, 'module, 'isa> {
pub fn new(env: &'env ModuleEnv<'module, 'isa>) -> Self {
Self { env }
}
/// Creates a signature with VMContext as the last param
pub fn generate_signature(
&self,
clif_sig_index: cranelift_wasm::SignatureIndex,
) -> ir::Signature {
// Get signature
let mut signature = self.env.signatures[Converter(clif_sig_index).into()].clone();
// Add the vmctx parameter type to it
signature.params.insert(
0,
ir::AbiParam::special(self.pointer_type(), ir::ArgumentPurpose::VMContext),
);
// Return signature
signature
}
}
impl<'env, 'module, 'isa> FuncEnvironment for FuncEnv<'env, 'module, 'isa> {
/// Gets configuration information needed for compiling functions
fn target_config(&self) -> isa::TargetFrontendConfig {
self.env.target_config()
}
/// Gets native pointers types.
///
/// `I64` on 64-bit arch; `I32` on 32-bit arch.
fn pointer_type(&self) -> ir::Type {
ir::Type::int(u16::from(self.target_config().pointer_bits())).unwrap()
}
/// Gets the size of a native pointer in bytes.
fn pointer_bytes(&self) -> u8 {
self.target_config().pointer_bytes()
}
/// Sets up the necessary preamble definitions in `func` to access the global identified
/// by `index`.
///
/// The index space covers both imported and locally declared globals.
fn make_global(
&mut self,
func: &mut ir::Function,
clif_global_index: cranelift_wasm::GlobalIndex,
) -> cranelift_wasm::WasmResult<cranelift_wasm::GlobalVariable> {
let global_index: GlobalIndex = Converter(clif_global_index).into();
// Create VMContext value.
let vmctx = func.create_global_value(ir::GlobalValueData::VMContext);
let ptr_type = self.pointer_type();
let local_global_addr = match global_index.local_or_import(&self.env.module.info) {
LocalOrImport::Local(local_global_index) => {
let globals_base_addr = func.create_global_value(ir::GlobalValueData::Load {
base: vmctx,
offset: (vm::Ctx::offset_globals() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let offset = local_global_index.index() * mem::size_of::<*mut vm::LocalGlobal>();
let local_global_ptr_ptr = func.create_global_value(ir::GlobalValueData::IAddImm {
base: globals_base_addr,
offset: (offset as i64).into(),
global_type: ptr_type,
});
func.create_global_value(ir::GlobalValueData::Load {
base: local_global_ptr_ptr,
offset: 0.into(),
global_type: ptr_type,
readonly: true,
})
}
LocalOrImport::Import(import_global_index) => {
let globals_base_addr = func.create_global_value(ir::GlobalValueData::Load {
base: vmctx,
offset: (vm::Ctx::offset_imported_globals() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let offset = import_global_index.index() * mem::size_of::<*mut vm::LocalGlobal>();
let local_global_ptr_ptr = func.create_global_value(ir::GlobalValueData::IAddImm {
base: globals_base_addr,
offset: (offset as i64).into(),
global_type: ptr_type,
});
func.create_global_value(ir::GlobalValueData::Load {
base: local_global_ptr_ptr,
offset: 0.into(),
global_type: ptr_type,
readonly: true,
})
}
};
Ok(cranelift_wasm::GlobalVariable::Memory {
gv: local_global_addr,
offset: (vm::LocalGlobal::offset_data() as i32).into(),
ty: self.env.get_global(clif_global_index).ty,
})
}
/// Sets up the necessary preamble definitions in `func` to access the linear memory identified
/// by `index`.
///
/// The index space covers both imported and locally declared memories.
fn make_heap(
&mut self,
func: &mut ir::Function,
clif_mem_index: cranelift_wasm::MemoryIndex,
) -> cranelift_wasm::WasmResult<ir::Heap> {
let mem_index: MemoryIndex = Converter(clif_mem_index).into();
// Create VMContext value.
let vmctx = func.create_global_value(ir::GlobalValueData::VMContext);
let ptr_type = self.pointer_type();
let (local_memory_ptr_ptr, description) =
match mem_index.local_or_import(&self.env.module.info) {
LocalOrImport::Local(local_mem_index) => {
let memories_base_addr = func.create_global_value(ir::GlobalValueData::Load {
base: vmctx,
offset: (vm::Ctx::offset_memories() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let local_memory_ptr_offset =
local_mem_index.index() * mem::size_of::<*mut vm::LocalMemory>();
(
func.create_global_value(ir::GlobalValueData::IAddImm {
base: memories_base_addr,
offset: (local_memory_ptr_offset as i64).into(),
global_type: ptr_type,
}),
self.env.module.info.memories[local_mem_index],
)
}
LocalOrImport::Import(import_mem_index) => {
let memories_base_addr = func.create_global_value(ir::GlobalValueData::Load {
base: vmctx,
offset: (vm::Ctx::offset_imported_memories() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let local_memory_ptr_offset =
import_mem_index.index() * mem::size_of::<*mut vm::LocalMemory>();
(
func.create_global_value(ir::GlobalValueData::IAddImm {
base: memories_base_addr,
offset: (local_memory_ptr_offset as i64).into(),
global_type: ptr_type,
}),
self.env.module.info.imported_memories[import_mem_index].1,
)
}
};
let (local_memory_ptr, local_memory_base) = {
let local_memory_ptr = func.create_global_value(ir::GlobalValueData::Load {
base: local_memory_ptr_ptr,
offset: 0.into(),
global_type: ptr_type,
readonly: true,
});
(
local_memory_ptr,
func.create_global_value(ir::GlobalValueData::Load {
base: local_memory_ptr,
offset: (vm::LocalMemory::offset_base() as i32).into(),
global_type: ptr_type,
readonly: false,
}),
)
};
match description.memory_type() {
mem_type @ MemoryType::Dynamic => {
let local_memory_bound = func.create_global_value(ir::GlobalValueData::Load {
base: local_memory_ptr,
offset: (vm::LocalMemory::offset_bound() as i32).into(),
global_type: ptr_type,
readonly: false,
});
Ok(func.create_heap(ir::HeapData {
base: local_memory_base,
min_size: (description.minimum.bytes().0 as u64).into(),
offset_guard_size: mem_type.guard_size().into(),
style: ir::HeapStyle::Dynamic {
bound_gv: local_memory_bound,
},
index_type: ir::types::I32,
}))
}
mem_type @ MemoryType::Static | mem_type @ MemoryType::SharedStatic => Ok(func
.create_heap(ir::HeapData {
base: local_memory_base,
min_size: (description.minimum.bytes().0 as u64).into(),
offset_guard_size: mem_type.guard_size().into(),
style: ir::HeapStyle::Static {
bound: mem_type.bounds().unwrap().into(),
},
index_type: ir::types::I32,
})),
}
}
/// Sets up the necessary preamble definitions in `func` to access the table identified
/// by `index`.
///
/// The index space covers both imported and locally declared tables.
fn make_table(
&mut self,
func: &mut ir::Function,
clif_table_index: cranelift_wasm::TableIndex,
) -> cranelift_wasm::WasmResult<ir::Table> {
let table_index: TableIndex = Converter(clif_table_index).into();
// Create VMContext value.
let vmctx = func.create_global_value(ir::GlobalValueData::VMContext);
let ptr_type = self.pointer_type();
let (table_struct_ptr_ptr, description) = match table_index
.local_or_import(&self.env.module.info)
{
LocalOrImport::Local(local_table_index) => {
let tables_base = func.create_global_value(ir::GlobalValueData::Load {
base: vmctx,
offset: (vm::Ctx::offset_tables() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let table_struct_ptr_offset =
local_table_index.index() * vm::LocalTable::size() as usize;
let table_struct_ptr_ptr = func.create_global_value(ir::GlobalValueData::IAddImm {
base: tables_base,
offset: (table_struct_ptr_offset as i64).into(),
global_type: ptr_type,
});
(
table_struct_ptr_ptr,
self.env.module.info.tables[local_table_index],
)
}
LocalOrImport::Import(import_table_index) => {
let tables_base = func.create_global_value(ir::GlobalValueData::Load {
base: vmctx,
offset: (vm::Ctx::offset_imported_tables() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let table_struct_ptr_offset =
import_table_index.index() * vm::LocalTable::size() as usize;
let table_struct_ptr_ptr = func.create_global_value(ir::GlobalValueData::IAddImm {
base: tables_base,
offset: (table_struct_ptr_offset as i64).into(),
global_type: ptr_type,
});
(
table_struct_ptr_ptr,
self.env.module.info.imported_tables[import_table_index].1,
)
}
};
let table_struct_ptr = func.create_global_value(ir::GlobalValueData::Load {
base: table_struct_ptr_ptr,
offset: 0.into(),
global_type: ptr_type,
readonly: true,
});
let table_base = func.create_global_value(ir::GlobalValueData::Load {
base: table_struct_ptr,
offset: (vm::LocalTable::offset_base() as i32).into(),
global_type: ptr_type,
// The table can reallocate, so the ptr can't be readonly.
readonly: false,
});
let table_count = func.create_global_value(ir::GlobalValueData::Load {
base: table_struct_ptr,
offset: (vm::LocalTable::offset_count() as i32).into(),
global_type: ptr_type,
// The table length can change, so it can't be readonly.
readonly: false,
});
Ok(func.create_table(ir::TableData {
base_gv: table_base,
min_size: (description.minimum as u64).into(),
bound_gv: table_count,
element_size: (vm::Anyfunc::size() as u64).into(),
index_type: ir::types::I32,
}))
}
/// Sets up a signature definition in `func`'s preamble.
///
/// Signature may contain additional argument, but arguments marked as ArgumentPurpose::Normal`
/// must correspond to the arguments in the wasm signature
fn make_indirect_sig(
&mut self,
func: &mut ir::Function,
clif_sig_index: cranelift_wasm::SignatureIndex,
) -> cranelift_wasm::WasmResult<ir::SigRef> {
// Create a signature reference out of specified signature (with VMContext param added).
Ok(func.import_signature(self.generate_signature(clif_sig_index)))
}
/// Sets up an external function definition in the preamble of `func` that can be used to
/// directly call the function `index`.
///
/// The index space covers both imported functions and functions defined in the current module.
fn make_direct_func(
&mut self,
func: &mut ir::Function,
func_index: cranelift_wasm::FuncIndex,
) -> cranelift_wasm::WasmResult<ir::FuncRef> {
// Get signature of function.
let signature_index = self.env.get_func_type(func_index);
// Create a signature reference from specified signature (with VMContext param added).
let signature = func.import_signature(self.generate_signature(signature_index));
// Get name of function.
let name = ir::ExternalName::user(0, func_index.as_u32());
// Create function reference from fuction data.
Ok(func.import_function(ir::ExtFuncData {
name,
signature,
// Make this colocated so all calls between local functions are relative.
colocated: true,
}))
}
/// Generates an indirect call IR with `callee` and `call_args`.
///
/// Inserts instructions at `pos` to the function `callee` in the table
/// `table_index` with WebAssembly signature `sig_index`
#[cfg_attr(feature = "cargo-clippy", allow(clippy::too_many_arguments))]
fn translate_call_indirect(
&mut self,
mut pos: FuncCursor,
_table_index: cranelift_wasm::TableIndex,
table: ir::Table,
clif_sig_index: cranelift_wasm::SignatureIndex,
sig_ref: ir::SigRef,
callee: ir::Value,
call_args: &[ir::Value],
) -> cranelift_wasm::WasmResult<ir::Inst> {
// Get the pointer type based on machine's pointer size.
let ptr_type = self.pointer_type();
// The `callee` value is an index into a table of Anyfunc structures.
let entry_addr = pos.ins().table_addr(ptr_type, table, callee, 0);
let mflags = ir::MemFlags::trusted();
let func_ptr = pos.ins().load(
ptr_type,
mflags,
entry_addr,
vm::Anyfunc::offset_func() as i32,
);
let vmctx_ptr = {
let loaded_vmctx_ptr = pos.ins().load(
ptr_type,
mflags,
entry_addr,
vm::Anyfunc::offset_vmctx() as i32,
);
let argument_vmctx_ptr = pos
.func
.special_param(ir::ArgumentPurpose::VMContext)
.expect("missing vmctx parameter");
// If the loaded vmctx ptr is zero, use the caller vmctx, else use the callee (loaded) vmctx.
pos.ins()
.select(loaded_vmctx_ptr, loaded_vmctx_ptr, argument_vmctx_ptr)
};
let found_sig = pos.ins().load(
ir::types::I32,
mflags,
entry_addr,
vm::Anyfunc::offset_sig_id() as i32,
);
pos.ins().trapz(func_ptr, ir::TrapCode::IndirectCallToNull);
let expected_sig = {
let sig_index_global = pos.func.create_global_value(ir::GlobalValueData::Symbol {
// The index of the `ExternalName` is the undeduplicated, signature index.
name: ir::ExternalName::user(
call_names::SIG_NAMESPACE,
clif_sig_index.index() as u32,
),
offset: 0.into(),
colocated: false,
});
pos.ins().symbol_value(ir::types::I64, sig_index_global)
// let dynamic_sigindices_array_ptr = pos.ins().load(
// ptr_type,
// mflags,
// )
// let expected_sig = pos.ins().iconst(ir::types::I32, sig_index.index() as i64);
// self.env.deduplicated[clif_sig_index]
};
let not_equal_flags = pos.ins().ifcmp(found_sig, expected_sig);
pos.ins().trapif(
ir::condcodes::IntCC::NotEqual,
not_equal_flags,
ir::TrapCode::BadSignature,
);
// Build a value list for the indirect call instruction containing the call_args
// and the vmctx parameter.
let mut args = Vec::with_capacity(call_args.len() + 1);
args.push(vmctx_ptr);
args.extend(call_args.iter().cloned());
Ok(pos.ins().call_indirect(sig_ref, func_ptr, &args))
}
/// Generates a call IR with `callee` and `call_args` and inserts it at `pos`
/// TODO: add support for imported functions
fn translate_call(
&mut self,
mut pos: FuncCursor,
clif_callee_index: cranelift_wasm::FuncIndex,
callee: ir::FuncRef,
call_args: &[ir::Value],
) -> cranelift_wasm::WasmResult<ir::Inst> {
let callee_index: FuncIndex = Converter(clif_callee_index).into();
let ptr_type = self.pointer_type();
match callee_index.local_or_import(&self.env.module.info) {
LocalOrImport::Local(local_function_index) => {
// this is an internal function
let vmctx = pos
.func
.special_param(ir::ArgumentPurpose::VMContext)
.expect("missing vmctx parameter");
let mut args = Vec::with_capacity(call_args.len() + 1);
args.push(vmctx);
args.extend(call_args.iter().cloned());
let sig_ref = pos.func.dfg.ext_funcs[callee].signature;
let function_ptr = {
let mflags = ir::MemFlags::trusted();
let function_array_ptr = pos.ins().load(
ptr_type,
mflags,
vmctx,
vm::Ctx::offset_local_functions() as i32,
);
pos.ins().load(
ptr_type,
mflags,
function_array_ptr,
(local_function_index.index() as i32) * 8,
)
};
Ok(pos.ins().call_indirect(sig_ref, function_ptr, &args))
}
LocalOrImport::Import(imported_func_index) => {
// this is an imported function
let vmctx = pos.func.create_global_value(ir::GlobalValueData::VMContext);
let imported_funcs = pos.func.create_global_value(ir::GlobalValueData::Load {
base: vmctx,
offset: (vm::Ctx::offset_imported_funcs() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let imported_func_offset =
imported_func_index.index() * vm::ImportedFunc::size() as usize;
let imported_func_struct_addr =
pos.func.create_global_value(ir::GlobalValueData::IAddImm {
base: imported_funcs,
offset: (imported_func_offset as i64).into(),
global_type: ptr_type,
});
let imported_func_addr = pos.func.create_global_value(ir::GlobalValueData::Load {
base: imported_func_struct_addr,
offset: (vm::ImportedFunc::offset_func() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let imported_vmctx_addr = pos.func.create_global_value(ir::GlobalValueData::Load {
base: imported_func_struct_addr,
offset: (vm::ImportedFunc::offset_vmctx() as i32).into(),
global_type: ptr_type,
readonly: true,
});
let imported_func_addr = pos.ins().global_value(ptr_type, imported_func_addr);
let imported_vmctx_addr = pos.ins().global_value(ptr_type, imported_vmctx_addr);
let sig_ref = pos.func.dfg.ext_funcs[callee].signature;
let mut args = Vec::with_capacity(call_args.len() + 1);
args.push(imported_vmctx_addr);
args.extend(call_args.iter().cloned());
Ok(pos
.ins()
.call_indirect(sig_ref, imported_func_addr, &args[..]))
}
}
}
/// Generates code corresponding to wasm `memory.grow`.
///
/// `index` refers to the linear memory to query.
///
/// `heap` refers to the IR generated by `make_heap`.
///
/// `val` refers the value to grow the memory by.
fn translate_memory_grow(
&mut self,
mut pos: FuncCursor,
clif_mem_index: cranelift_wasm::MemoryIndex,
_heap: ir::Heap,
by_value: ir::Value,
) -> cranelift_wasm::WasmResult<ir::Value> {
let signature = pos.func.import_signature(ir::Signature {
call_conv: self.target_config().default_call_conv,
params: vec![
ir::AbiParam::special(self.pointer_type(), ir::ArgumentPurpose::VMContext),
ir::AbiParam::new(ir::types::I32),
ir::AbiParam::new(ir::types::I32),
],
returns: vec![ir::AbiParam::new(ir::types::I32)],
});
let mem_index: MemoryIndex = Converter(clif_mem_index).into();
let (namespace, mem_index, description) =
match mem_index.local_or_import(&self.env.module.info) {
LocalOrImport::Local(local_mem_index) => (
call_names::LOCAL_NAMESPACE,
local_mem_index.index(),
self.env.module.info.memories[local_mem_index],
),
LocalOrImport::Import(import_mem_index) => (
call_names::IMPORT_NAMESPACE,
import_mem_index.index(),
self.env.module.info.imported_memories[import_mem_index].1,
),
};
let name_index = match description.memory_type() {
MemoryType::Dynamic => call_names::DYNAMIC_MEM_GROW,
MemoryType::Static => call_names::STATIC_MEM_GROW,
MemoryType::SharedStatic => call_names::SHARED_STATIC_MEM_GROW,
};
let name = ir::ExternalName::user(namespace, name_index);
let mem_grow_func = pos.func.import_function(ir::ExtFuncData {
name,
signature,
colocated: false,
});
let const_mem_index = pos.ins().iconst(ir::types::I32, mem_index as i64);
let vmctx = pos
.func
.special_param(ir::ArgumentPurpose::VMContext)
.expect("missing vmctx parameter");
let call_inst = pos
.ins()
.call(mem_grow_func, &[vmctx, const_mem_index, by_value]);
Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
}
/// Generates code corresponding to wasm `memory.size`.
///
/// `index` refers to the linear memory to query.
///
/// `heap` refers to the IR generated by `make_heap`.
fn translate_memory_size(
&mut self,
mut pos: FuncCursor,
clif_mem_index: cranelift_wasm::MemoryIndex,
_heap: ir::Heap,
) -> cranelift_wasm::WasmResult<ir::Value> {
let signature = pos.func.import_signature(ir::Signature {
call_conv: self.target_config().default_call_conv,
params: vec![
ir::AbiParam::special(self.pointer_type(), ir::ArgumentPurpose::VMContext),
ir::AbiParam::new(ir::types::I32),
],
returns: vec![ir::AbiParam::new(ir::types::I32)],
});
let mem_index: MemoryIndex = Converter(clif_mem_index).into();
let (namespace, mem_index, description) =
match mem_index.local_or_import(&self.env.module.info) {
LocalOrImport::Local(local_mem_index) => (
call_names::LOCAL_NAMESPACE,
local_mem_index.index(),
self.env.module.info.memories[local_mem_index],
),
LocalOrImport::Import(import_mem_index) => (
call_names::IMPORT_NAMESPACE,
import_mem_index.index(),
self.env.module.info.imported_memories[import_mem_index].1,
),
};
let name_index = match description.memory_type() {
MemoryType::Dynamic => call_names::DYNAMIC_MEM_SIZE,
MemoryType::Static => call_names::STATIC_MEM_SIZE,
MemoryType::SharedStatic => call_names::SHARED_STATIC_MEM_SIZE,
};
let name = ir::ExternalName::user(namespace, name_index);
let mem_grow_func = pos.func.import_function(ir::ExtFuncData {
name,
signature,
colocated: false,
});
let const_mem_index = pos.ins().iconst(ir::types::I32, mem_index as i64);
let vmctx = pos
.func
.special_param(ir::ArgumentPurpose::VMContext)
.expect("missing vmctx parameter");
let call_inst = pos.ins().call(mem_grow_func, &[vmctx, const_mem_index]);
Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
}
}

91
lib/clif-backend/src/lib.rs

@ -2,10 +2,8 @@
mod cache; mod cache;
mod code; mod code;
mod func_env;
mod libcalls; mod libcalls;
mod module; mod module;
mod module_env;
mod relocation; mod relocation;
mod resolver; mod resolver;
mod signal; mod signal;
@ -17,87 +15,12 @@ use cranelift_codegen::{
}; };
use target_lexicon::Triple; use target_lexicon::Triple;
use wasmer_runtime_core::cache::{Artifact, Error as CacheError};
use wasmer_runtime_core::{
backend::{Compiler, CompilerConfig, Token},
error::{CompileError, CompileResult},
module::ModuleInner,
};
#[macro_use] #[macro_use]
extern crate serde_derive; extern crate serde_derive;
extern crate rayon; extern crate rayon;
extern crate serde; extern crate serde;
use wasmparser::{self, WasmDecoder};
pub struct OldCraneliftCompiler {}
impl OldCraneliftCompiler {
pub fn new() -> Self {
Self {}
}
}
impl Compiler for OldCraneliftCompiler {
/// Compiles wasm binary to a wasmer module.
fn compile(
&self,
wasm: &[u8],
compiler_config: CompilerConfig,
_: Token,
) -> CompileResult<ModuleInner> {
validate(wasm)?;
let isa = get_isa();
let mut module = module::Module::new(&compiler_config);
let module_env = module_env::ModuleEnv::new(&mut module, &*isa);
let func_bodies = module_env.translate(wasm)?;
module.compile(&*isa, func_bodies)
}
/// Create a wasmer Module from an already-compiled cache.
unsafe fn from_cache(&self, cache: Artifact, _: Token) -> Result<ModuleInner, CacheError> {
module::Module::from_cache(cache)
}
//
// fn compile_to_backend_cache_data(
// &self,
// wasm: &[u8],
// _: Token,
// ) -> CompileResult<(Box<ModuleInfo>, Vec<u8>, Memory)> {
// validate(wasm)?;
// let isa = get_isa();
// let mut module = module::Module::new(wasm);
// let module_env = module_env::ModuleEnv::new(&mut module, &*isa);
// let func_bodies = module_env.translate(wasm)?;
// let (info, backend_cache, compiled_code) = module
// .compile_to_backend_cache(&*isa, func_bodies)
// .map_err(|e| CompileError::InternalError {
// msg: format!("{:?}", e),
// })?;
// let buffer =
// backend_cache
// .into_backend_data()
// .map_err(|e| CompileError::InternalError {
// msg: format!("{:?}", e),
// })?;
// Ok((Box::new(info), buffer, compiled_code))
// }
}
fn get_isa() -> Box<isa::TargetIsa> { fn get_isa() -> Box<isa::TargetIsa> {
let flags = { let flags = {
let mut builder = settings::builder(); let mut builder = settings::builder();
@ -114,20 +37,6 @@ fn get_isa() -> Box<isa::TargetIsa> {
isa::lookup(Triple::host()).unwrap().finish(flags) isa::lookup(Triple::host()).unwrap().finish(flags)
} }
fn validate(bytes: &[u8]) -> CompileResult<()> {
let mut parser = wasmparser::ValidatingParser::new(bytes, None);
loop {
let state = parser.read();
match *state {
wasmparser::ParserState::EndWasm => break Ok(()),
wasmparser::ParserState::Error(err) => Err(CompileError::ValidationError {
msg: err.message.to_string(),
})?,
_ => {}
}
}
}
/// The current version of this crate /// The current version of this crate
pub const VERSION: &str = env!("CARGO_PKG_VERSION"); pub const VERSION: &str = env!("CARGO_PKG_VERSION");

78
lib/clif-backend/src/module.rs

@ -1,22 +1,17 @@
use crate::cache::{BackendCache, CacheGenerator}; use crate::cache::{BackendCache, CacheGenerator};
use crate::{resolver::FuncResolverBuilder, signal::Caller, trampoline::Trampolines}; use crate::{resolver::FuncResolverBuilder, signal::Caller};
use cranelift_codegen::{ir, isa}; use cranelift_codegen::ir;
use cranelift_entity::EntityRef; use cranelift_entity::EntityRef;
use cranelift_wasm; use cranelift_wasm;
use hashbrown::HashMap;
use std::sync::Arc; use std::sync::Arc;
use wasmer_runtime_core::cache::{Artifact, Error as CacheError}; use wasmer_runtime_core::cache::{Artifact, Error as CacheError};
use wasmer_runtime_core::{ use wasmer_runtime_core::{
backend::{Backend, CompilerConfig}, module::{ModuleInfo, ModuleInner},
error::CompileResult, structures::TypedIndex,
module::{ModuleInfo, ModuleInner, StringTable}, types::{FuncIndex, FuncSig, GlobalIndex, MemoryIndex, SigIndex, TableIndex, Type},
structures::{Map, TypedIndex},
types::{
FuncIndex, FuncSig, GlobalIndex, LocalFuncIndex, MemoryIndex, SigIndex, TableIndex, Type,
},
}; };
/// This contains all of the items in a `ModuleInner` except the `func_resolver`. /// This contains all of the items in a `ModuleInner` except the `func_resolver`.
@ -25,69 +20,6 @@ pub struct Module {
} }
impl Module { impl Module {
pub fn new(compiler_config: &CompilerConfig) -> Self {
Self {
info: ModuleInfo {
memories: Map::new(),
globals: Map::new(),
tables: Map::new(),
imported_functions: Map::new(),
imported_memories: Map::new(),
imported_tables: Map::new(),
imported_globals: Map::new(),
exports: HashMap::new(),
data_initializers: Vec::new(),
elem_initializers: Vec::new(),
start_func: None,
func_assoc: Map::new(),
signatures: Map::new(),
backend: Backend::Cranelift,
namespace_table: StringTable::new(),
name_table: StringTable::new(),
em_symbol_map: compiler_config.symbol_map.clone(),
custom_sections: HashMap::new(),
},
}
}
pub fn compile(
self,
isa: &isa::TargetIsa,
functions: Map<LocalFuncIndex, ir::Function>,
) -> CompileResult<ModuleInner> {
let (func_resolver_builder, handler_data) =
FuncResolverBuilder::new(isa, functions, &self.info)?;
let trampolines = Arc::new(Trampolines::new(isa, &self.info));
let (func_resolver, backend_cache) = func_resolver_builder.finalize(
&self.info.signatures,
Arc::clone(&trampolines),
handler_data.clone(),
)?;
let cache_gen = Box::new(CacheGenerator::new(
backend_cache,
Arc::clone(&func_resolver.memory),
));
let runnable_module = Caller::new(handler_data, trampolines, func_resolver);
Ok(ModuleInner {
runnable_module: Box::new(runnable_module),
cache_gen,
info: self.info,
})
}
pub fn from_cache(cache: Artifact) -> Result<ModuleInner, CacheError> { pub fn from_cache(cache: Artifact) -> Result<ModuleInner, CacheError> {
let (info, compiled_code, backend_cache) = BackendCache::from_cache(cache)?; let (info, compiled_code, backend_cache) = BackendCache::from_cache(cache)?;

557
lib/clif-backend/src/module_env.rs

@ -1,557 +0,0 @@
use crate::{
func_env::FuncEnv,
module::{Converter, Module},
};
use cranelift_codegen::{ir, isa};
use cranelift_wasm::{self, translate_module, FuncTranslator, ModuleEnvironment};
use wasmer_runtime_core::{
error::{CompileError, CompileResult},
module::{
DataInitializer, ExportIndex, ImportName, NameIndex, NamespaceIndex, StringTableBuilder,
TableInitializer,
},
structures::{Map, TypedIndex},
types::{
ElementType, GlobalDescriptor, GlobalIndex, GlobalInit, Initializer, LocalFuncIndex,
LocalOrImport, MemoryDescriptor, SigIndex, TableDescriptor, Value,
},
units::Pages,
};
pub struct ModuleEnv<'module, 'isa> {
pub module: &'module mut Module,
isa: &'isa isa::TargetIsa,
pub signatures: Map<SigIndex, ir::Signature>,
globals: Map<GlobalIndex, cranelift_wasm::Global>,
func_bodies: Map<LocalFuncIndex, ir::Function>,
namespace_table_builder: StringTableBuilder<NamespaceIndex>,
name_table_builder: StringTableBuilder<NameIndex>,
}
impl<'module, 'isa> ModuleEnv<'module, 'isa> {
pub fn new(module: &'module mut Module, isa: &'isa isa::TargetIsa) -> Self {
Self {
module,
isa,
signatures: Map::new(),
globals: Map::new(),
func_bodies: Map::new(),
namespace_table_builder: StringTableBuilder::new(),
name_table_builder: StringTableBuilder::new(),
}
}
pub fn translate(mut self, wasm: &[u8]) -> CompileResult<Map<LocalFuncIndex, ir::Function>> {
translate_module(wasm, &mut self)
.map_err(|e| CompileError::InternalError { msg: e.to_string() })?;
self.module.info.namespace_table = self.namespace_table_builder.finish();
self.module.info.name_table = self.name_table_builder.finish();
Ok(self.func_bodies)
}
/// Return the global for the given global index.
pub fn get_global(&self, global_index: cranelift_wasm::GlobalIndex) -> &cranelift_wasm::Global {
&self.globals[Converter(global_index).into()]
}
/// Return the signature index for the given function index.
pub fn get_func_type(
&self,
func_index: cranelift_wasm::FuncIndex,
) -> cranelift_wasm::SignatureIndex {
let sig_index: SigIndex = self.module.info.func_assoc[Converter(func_index).into()];
Converter(sig_index).into()
}
}
impl<'module, 'isa, 'data> ModuleEnvironment<'data> for ModuleEnv<'module, 'isa> {
/// Get the information needed to produce Cranelift IR for the current target.
fn target_config(&self) -> isa::TargetFrontendConfig {
self.isa.frontend_config()
}
/// Declares a function signature to the environment.
fn declare_signature(&mut self, sig: ir::Signature) {
self.signatures.push(sig.clone());
self.module.info.signatures.push(Converter(sig).into());
}
/// Declares a function import to the environment.
fn declare_func_import(
&mut self,
clif_sig_index: cranelift_wasm::SignatureIndex,
namespace: &'data str,
name: &'data str,
) {
// We convert the cranelift signature index to
// a wasmer signature index without deduplicating
// because we'll deduplicate later.
let sig_index = Converter(clif_sig_index).into();
self.module.info.func_assoc.push(sig_index);
let namespace_index = self.namespace_table_builder.register(namespace);
let name_index = self.name_table_builder.register(name);
// Add import names to list of imported functions
self.module.info.imported_functions.push(ImportName {
namespace_index,
name_index,
});
}
/// Declares the type (signature) of a local function in the module.
fn declare_func_type(&mut self, clif_sig_index: cranelift_wasm::SignatureIndex) {
// We convert the cranelift signature index to
// a wasmer signature index without deduplicating
// because we'll deduplicate later.
let sig_index = Converter(clif_sig_index).into();
self.module.info.func_assoc.push(sig_index);
}
/// Declares a global to the environment.
fn declare_global(&mut self, global: cranelift_wasm::Global) {
let desc = GlobalDescriptor {
mutable: global.mutability,
ty: Converter(global.ty).into(),
};
let init = match global.initializer {
cranelift_wasm::GlobalInit::I32Const(x) => Initializer::Const(Value::I32(x)),
cranelift_wasm::GlobalInit::I64Const(x) => Initializer::Const(Value::I64(x)),
cranelift_wasm::GlobalInit::F32Const(x) => {
Initializer::Const(Value::F32(f32::from_bits(x)))
}
cranelift_wasm::GlobalInit::F64Const(x) => {
Initializer::Const(Value::F64(f64::from_bits(x)))
}
cranelift_wasm::GlobalInit::GetGlobal(global_index) => {
// assert!(!desc.mutable);
let global_index: GlobalIndex = Converter(global_index).into();
let imported_global_index = global_index
.local_or_import(&self.module.info)
.import()
.expect("invalid global initializer when declaring an imported global");
Initializer::GetGlobal(imported_global_index)
}
_ => panic!("invalid global initializer when declaring a local global"),
};
// Add global ir to the list of globals
self.module.info.globals.push(GlobalInit { desc, init });
self.globals.push(global);
}
/// Declares a global import to the environment.
fn declare_global_import(
&mut self,
global: cranelift_wasm::Global,
namespace: &'data str,
name: &'data str,
) {
assert!(match global.initializer {
cranelift_wasm::GlobalInit::Import => true,
_ => false,
});
let namespace_index = self.namespace_table_builder.register(namespace);
let name_index = self.name_table_builder.register(name);
let import_name = ImportName {
namespace_index,
name_index,
};
let desc = GlobalDescriptor {
mutable: global.mutability,
ty: Converter(global.ty).into(),
};
// Add global ir to the list of globals
self.module.info.imported_globals.push((import_name, desc));
self.globals.push(global);
}
/// Declares a table to the environment.
fn declare_table(&mut self, table: cranelift_wasm::Table) {
use cranelift_wasm::TableElementType;
// Add table ir to the list of tables
self.module.info.tables.push(TableDescriptor {
element: match table.ty {
TableElementType::Func => ElementType::Anyfunc,
_ => unimplemented!(),
},
minimum: table.minimum,
maximum: table.maximum,
});
}
/// Declares a table import to the environment.
fn declare_table_import(
&mut self,
table: cranelift_wasm::Table,
namespace: &'data str,
name: &'data str,
) {
use cranelift_wasm::TableElementType;
let namespace_index = self.namespace_table_builder.register(namespace);
let name_index = self.name_table_builder.register(name);
let import_name = ImportName {
namespace_index,
name_index,
};
let imported_table = TableDescriptor {
element: match table.ty {
TableElementType::Func => ElementType::Anyfunc,
_ => unimplemented!(),
},
minimum: table.minimum,
maximum: table.maximum,
};
// Add import names to list of imported tables
self.module
.info
.imported_tables
.push((import_name, imported_table));
}
/// Fills a declared table with references to functions in the module.
fn declare_table_elements(
&mut self,
table_index: cranelift_wasm::TableIndex,
base: Option<cranelift_wasm::GlobalIndex>,
offset: usize,
elements: Box<[cranelift_wasm::FuncIndex]>,
) {
// Convert Cranelift GlobalIndex to wamser GlobalIndex
// let base = base.map(|index| WasmerGlobalIndex::new(index.index()));
let base = match base {
Some(global_index) => {
let global_index: GlobalIndex = Converter(global_index).into();
Initializer::GetGlobal(match global_index.local_or_import(&self.module.info) {
LocalOrImport::Import(imported_global_index) => imported_global_index,
LocalOrImport::Local(_) => {
panic!("invalid global initializer when declaring an imported global")
}
})
}
None => Initializer::Const((offset as i32).into()),
};
// Add table initializer to list of table initializers
self.module.info.elem_initializers.push(TableInitializer {
table_index: Converter(table_index).into(),
base,
elements: elements
.iter()
.map(|&func_index| Converter(func_index).into())
.collect(),
});
}
/// Declares a memory to the environment
fn declare_memory(&mut self, memory: cranelift_wasm::Memory) {
self.module.info.memories.push(MemoryDescriptor {
minimum: Pages(memory.minimum),
maximum: memory.maximum.map(|max| Pages(max)),
shared: memory.shared,
});
}
/// Declares a memory import to the environment.
fn declare_memory_import(
&mut self,
memory: cranelift_wasm::Memory,
namespace: &'data str,
name: &'data str,
) {
let namespace_index = self.namespace_table_builder.register(namespace);
let name_index = self.name_table_builder.register(name);
let import_name = ImportName {
namespace_index,
name_index,
};
let memory = MemoryDescriptor {
minimum: Pages(memory.minimum),
maximum: memory.maximum.map(|max| Pages(max)),
shared: memory.shared,
};
// Add import names to list of imported memories
self.module
.info
.imported_memories
.push((import_name, memory));
}
/// Fills a declared memory with bytes at module instantiation.
fn declare_data_initialization(
&mut self,
memory_index: cranelift_wasm::MemoryIndex,
base: Option<cranelift_wasm::GlobalIndex>,
offset: usize,
data: &'data [u8],
) {
// Convert Cranelift GlobalIndex to wamser GlobalIndex
let base = match base {
Some(global_index) => {
let global_index: GlobalIndex = Converter(global_index).into();
Initializer::GetGlobal(match global_index.local_or_import(&self.module.info) {
LocalOrImport::Import(imported_global_index) => imported_global_index,
LocalOrImport::Local(_) => {
panic!("invalid global initializer when declaring an imported global")
}
})
}
None => Initializer::Const((offset as i32).into()),
};
// Add data initializer to list of data initializers
self.module.info.data_initializers.push(DataInitializer {
memory_index: Converter(memory_index).into(),
base,
data: data.to_vec(),
});
}
/// Declares a function export to the environment.
fn declare_func_export(&mut self, func_index: cranelift_wasm::FuncIndex, name: &'data str) {
self.module.info.exports.insert(
name.to_string(),
ExportIndex::Func(Converter(func_index).into()),
);
}
/// Declares a table export to the environment.
fn declare_table_export(&mut self, table_index: cranelift_wasm::TableIndex, name: &'data str) {
self.module.info.exports.insert(
name.to_string(),
ExportIndex::Table(Converter(table_index).into()),
);
}
/// Declares a memory export to the environment.
fn declare_memory_export(
&mut self,
memory_index: cranelift_wasm::MemoryIndex,
name: &'data str,
) {
self.module.info.exports.insert(
name.to_string(),
ExportIndex::Memory(Converter(memory_index).into()),
);
}
/// Declares a global export to the environment.
fn declare_global_export(
&mut self,
global_index: cranelift_wasm::GlobalIndex,
name: &'data str,
) {
self.module.info.exports.insert(
name.to_string(),
ExportIndex::Global(Converter(global_index).into()),
);
}
/// Declares a start function.
fn declare_start_func(&mut self, func_index: cranelift_wasm::FuncIndex) {
self.module.info.start_func = Some(Converter(func_index).into());
}
/// Provides the contents of a function body.
fn define_function_body(
&mut self,
body_bytes: &'data [u8],
body_offset: usize,
) -> cranelift_wasm::WasmResult<()> {
let mut func_translator = FuncTranslator::new();
let func_body = {
let mut func_env = FuncEnv::new(self);
let func_index = self.func_bodies.next_index();
let name = ir::ExternalName::user(0, func_index.index() as u32);
let sig = func_env.generate_signature(
self.get_func_type(Converter(func_index.convert_up(&self.module.info)).into()),
);
let mut func = ir::Function::with_name_signature(name, sig);
func_translator.translate(body_bytes, body_offset, &mut func, &mut func_env)?;
#[cfg(feature = "debug")]
{
use cranelift_codegen::cursor::{Cursor, FuncCursor};
use cranelift_codegen::ir::InstBuilder;
let entry_ebb = func.layout.entry_block().unwrap();
let ebb = func.dfg.make_ebb();
func.layout.insert_ebb(ebb, entry_ebb);
let mut pos = FuncCursor::new(&mut func).at_first_insertion_point(ebb);
let params = pos.func.dfg.ebb_params(entry_ebb).to_vec();
let new_ebb_params: Vec<_> = params
.iter()
.map(|&param| {
pos.func
.dfg
.append_ebb_param(ebb, pos.func.dfg.value_type(param))
})
.collect();
let start_debug = {
let signature = pos.func.import_signature(ir::Signature {
call_conv: self.target_config().default_call_conv,
params: vec![
ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
ir::AbiParam::new(ir::types::I32),
],
returns: vec![],
});
let name = ir::ExternalName::testcase("strtdbug");
pos.func.import_function(ir::ExtFuncData {
name,
signature,
colocated: false,
})
};
let end_debug = {
let signature = pos.func.import_signature(ir::Signature {
call_conv: self.target_config().default_call_conv,
params: vec![ir::AbiParam::special(
ir::types::I64,
ir::ArgumentPurpose::VMContext,
)],
returns: vec![],
});
let name = ir::ExternalName::testcase("enddbug");
pos.func.import_function(ir::ExtFuncData {
name,
signature,
colocated: false,
})
};
let i32_print = {
let signature = pos.func.import_signature(ir::Signature {
call_conv: self.target_config().default_call_conv,
params: vec![
ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
ir::AbiParam::new(ir::types::I32),
],
returns: vec![],
});
let name = ir::ExternalName::testcase("i32print");
pos.func.import_function(ir::ExtFuncData {
name,
signature,
colocated: false,
})
};
let i64_print = {
let signature = pos.func.import_signature(ir::Signature {
call_conv: self.target_config().default_call_conv,
params: vec![
ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
ir::AbiParam::new(ir::types::I64),
],
returns: vec![],
});
let name = ir::ExternalName::testcase("i64print");
pos.func.import_function(ir::ExtFuncData {
name,
signature,
colocated: false,
})
};
let f32_print = {
let signature = pos.func.import_signature(ir::Signature {
call_conv: self.target_config().default_call_conv,
params: vec![
ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
ir::AbiParam::new(ir::types::F32),
],
returns: vec![],
});
let name = ir::ExternalName::testcase("f32print");
pos.func.import_function(ir::ExtFuncData {
name,
signature,
colocated: false,
})
};
let f64_print = {
let signature = pos.func.import_signature(ir::Signature {
call_conv: self.target_config().default_call_conv,
params: vec![
ir::AbiParam::special(ir::types::I64, ir::ArgumentPurpose::VMContext),
ir::AbiParam::new(ir::types::F64),
],
returns: vec![],
});
let name = ir::ExternalName::testcase("f64print");
pos.func.import_function(ir::ExtFuncData {
name,
signature,
colocated: false,
})
};
let vmctx = pos
.func
.special_param(ir::ArgumentPurpose::VMContext)
.expect("missing vmctx parameter");
let func_index = pos.ins().iconst(
ir::types::I32,
func_index.index() as i64 + self.module.info.imported_functions.len() as i64,
);
pos.ins().call(start_debug, &[vmctx, func_index]);
for param in new_ebb_params.iter().cloned() {
match pos.func.dfg.value_type(param) {
ir::types::I32 => pos.ins().call(i32_print, &[vmctx, param]),
ir::types::I64 => pos.ins().call(i64_print, &[vmctx, param]),
ir::types::F32 => pos.ins().call(f32_print, &[vmctx, param]),
ir::types::F64 => pos.ins().call(f64_print, &[vmctx, param]),
_ => unimplemented!(),
};
}
pos.ins().call(end_debug, &[vmctx]);
pos.ins().jump(entry_ebb, new_ebb_params.as_slice());
}
func
};
// Add function body to list of function bodies.
self.func_bodies.push(func_body);
Ok(())
}
}