fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2024-12-14 14:45:40 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into patch-1

Browse Source
This commit is contained in:
Mackenzie Clark 2019-04-01 09:11:23 -07:00 committed by GitHub
commit 6a8d48af59
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 31 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/llvm-backend/src/backend.rs
View File

@ -23,10 +23,7 @@ use wasmer_runtime_core::{
export::Context,
module::{ModuleInfo, ModuleInner},
structures::TypedIndex,
types::{
FuncIndex, FuncSig, LocalFuncIndex, LocalOrImport, MemoryIndex, SigIndex, TableIndex, Type,
Value,
},
types::{FuncIndex, FuncSig, LocalFuncIndex, LocalOrImport, SigIndex, Type, Value},
vm::{self, ImportBacking},
vmcalls,
};
@ -57,6 +54,7 @@ enum LLVMResult {
OBJECT_LOAD_FAILURE,
}
#[allow(dead_code)]
#[repr(C)]
enum WasmTrapType {
Unreachable = 0,
@ -220,7 +218,7 @@ pub struct LLVMBackend {
}
impl LLVMBackend {
pub fn new(module: Module, intrinsics: Intrinsics) -> (Self, LLVMProtectedCaller) {
pub fn new(module: Module, _intrinsics: Intrinsics) -> (Self, LLVMProtectedCaller) {
Target::initialize_x86(&InitializationConfig {
asm_parser: true,
asm_printer: true,

16
lib/llvm-backend/src/code.rs
View File

@ -3,14 +3,14 @@ use inkwell::{
context::Context,
module::{Linkage, Module},
passes::PassManager,
types::{BasicType, BasicTypeEnum, FunctionType, IntType, PointerType},
types::{BasicType, BasicTypeEnum, FunctionType, PointerType},
values::{BasicValue, FloatValue, FunctionValue, IntValue, PhiValue, PointerValue},
AddressSpace, FloatPredicate, IntPredicate,
};
use smallvec::SmallVec;
use wasmer_runtime_core::{
memory::MemoryType,
module::{ExportIndex, ModuleInfo},
module::ModuleInfo,
structures::{Map, SliceMap, TypedIndex},
types::{
FuncIndex, FuncSig, GlobalIndex, LocalFuncIndex, LocalOrImport, MemoryIndex, SigIndex,
@ -102,7 +102,6 @@ pub fn parse_function_bodies(
parse_function(
&context,
&module,
&builder,
&intrinsics,
info,
@ -143,7 +142,6 @@ pub fn parse_function_bodies(
fn parse_function(
context: &Context,
module: &Module,
builder: &Builder,
intrinsics: &Intrinsics,
info: &ModuleInfo,
@ -155,7 +153,6 @@ fn parse_function(
) -> Result<(), BinaryReaderError> {
let sig_index = info.func_assoc[func_index.convert_up(info)];
let func_sig = &info.signatures[sig_index];
let llvm_sig = &signatures[sig_index];
let function = functions[func_index];
let mut state = State::new();
@ -193,7 +190,7 @@ fn parse_function(
let param_len = locals.len();
let mut local_idx = 0;
for (index, local) in locals_reader.into_iter().enumerate() {
for local in locals_reader.into_iter() {
let (count, ty) = local?;
let wasmer_ty = type_to_type(ty)?;
let ty = type_to_llvm(intrinsics, wasmer_ty);
@ -490,7 +487,6 @@ fn parse_function(
if let ControlFrame::IfElse {
if_else,
next,
phis,
if_else_state,
..
} = &frame
@ -866,7 +862,7 @@ fn parse_function(
let value = call_site.try_as_basic_value().left().unwrap();
state.push1(value);
}
returns @ _ => unimplemented!("multi-value returns"),
_ => unimplemented!("multi-value returns"),
}
}
@ -2158,7 +2154,7 @@ fn parse_function(
[one_value] => {
builder.build_return(Some(one_value));
}
returns @ _ => {
_ => {
// let struct_ty = llvm_sig.get_return_type().as_struct_type();
// let ret_struct = struct_ty.const_zero();
unimplemented!("multi-value returns not yet implemented")
@ -2211,7 +2207,7 @@ fn trap_if_not_representatable_as_int(
),
};
let masked = builder.build_and(
builder.build_and(
float_bits,
int_ty.const_int(exponent_mask, false),
"masked_bits",

60
lib/llvm-backend/src/intrinsics.rs
View File

@ -4,10 +4,7 @@ use inkwell::{
context::Context,
module::Module,
types::{BasicType, FloatType, FunctionType, IntType, PointerType, StructType, VoidType},
values::{
BasicValue, BasicValueEnum, FloatValue, FunctionValue, InstructionValue, IntValue,
PointerValue,
},
values::{BasicValue, BasicValueEnum, FloatValue, FunctionValue, IntValue, PointerValue},
AddressSpace,
};
use std::marker::PhantomData;
@ -117,7 +114,6 @@ pub struct Intrinsics {
pub throw_trap: FunctionValue,
ctx_ty: StructType,
pub ctx_ptr_ty: PointerType,
}
@ -370,7 +366,6 @@ impl Intrinsics {
void_ty.fn_type(&[i32_ty_basic], false),
None,
),
ctx_ty,
ctx_ptr_ty,
}
}
@ -383,9 +378,6 @@ impl Intrinsics {
cache_builder: Builder,
) -> CtxType<'a> {
CtxType {
ctx_ty: self.ctx_ty,
ctx_ptr_ty: self.ctx_ptr_ty,
ctx_ptr_value: func_value.get_nth_param(0).unwrap().into_pointer_value(),
builder,
@ -435,9 +427,6 @@ struct ImportedFuncCache {
}
pub struct CtxType<'a> {
ctx_ty: StructType,
ctx_ptr_ty: PointerType,
ctx_ptr_value: PointerValue,
builder: &'a Builder,
@ -460,9 +449,8 @@ impl<'a> CtxType<'a> {
}
pub fn memory(&mut self, index: MemoryIndex) -> MemoryCache {
let (cached_memories, builder, info, ctx_ptr_value, intrinsics, cache_builder) = (
let (cached_memories, info, ctx_ptr_value, intrinsics, cache_builder) = (
&mut self.cached_memories,
self.builder,
self.info,
self.ctx_ptr_value,
self.intrinsics,
@ -618,10 +606,8 @@ impl<'a> CtxType<'a> {
}
pub fn dynamic_sigindex(&mut self, index: SigIndex) -> IntValue {
let (cached_sigindices, builder, info, ctx_ptr_value, intrinsics, cache_builder) = (
let (cached_sigindices, ctx_ptr_value, intrinsics, cache_builder) = (
&mut self.cached_sigindices,
self.builder,
self.info,
self.ctx_ptr_value,
self.intrinsics,
&self.cache_builder,
@ -651,9 +637,8 @@ impl<'a> CtxType<'a> {
}
pub fn global_cache(&mut self, index: GlobalIndex) -> GlobalCache {
let (cached_globals, builder, ctx_ptr_value, info, intrinsics, cache_builder) = (
let (cached_globals, ctx_ptr_value, info, intrinsics, cache_builder) = (
&mut self.cached_globals,
self.builder,
self.ctx_ptr_value,
self.info,
self.intrinsics,
@ -728,9 +713,8 @@ impl<'a> CtxType<'a> {
}
pub fn imported_func(&mut self, index: ImportedFuncIndex) -> (PointerValue, PointerValue) {
let (cached_imported_functions, builder, ctx_ptr_value, intrinsics, cache_builder) = (
let (cached_imported_functions, ctx_ptr_value, intrinsics, cache_builder) = (
&mut self.cached_imported_functions,
self.builder,
self.ctx_ptr_value,
self.intrinsics,
&self.cache_builder,
@ -770,38 +754,4 @@ impl<'a> CtxType<'a> {
(imported_func_cache.func_ptr, imported_func_cache.ctx_ptr)
}
pub fn build_trap(&self) {
self.builder.build_call(self.intrinsics.trap, &[], "trap");
}
}
// pub struct Ctx {
// /// A pointer to an array of locally-defined memories, indexed by `MemoryIndex`.
// pub(crate) memories: *mut *mut LocalMemory,
// /// A pointer to an array of locally-defined tables, indexed by `TableIndex`.
// pub(crate) tables: *mut *mut LocalTable,
// /// A pointer to an array of locally-defined globals, indexed by `GlobalIndex`.
// pub(crate) globals: *mut *mut LocalGlobal,
// /// A pointer to an array of imported memories, indexed by `MemoryIndex,
// pub(crate) imported_memories: *mut *mut LocalMemory,
// /// A pointer to an array of imported tables, indexed by `TableIndex`.
// pub(crate) imported_tables: *mut *mut LocalTable,
// /// A pointer to an array of imported globals, indexed by `GlobalIndex`.
// pub(crate) imported_globals: *mut *mut LocalGlobal,
// /// A pointer to an array of imported functions, indexed by `FuncIndex`.
// pub(crate) imported_funcs: *mut ImportedFunc,
// local_backing: *mut LocalBacking,
// import_backing: *mut ImportBacking,
// module: *const ModuleInner,
// pub data: *mut c_void,
// pub data_finalizer: Option<extern "C" fn(data: *mut c_void)>,
// }

16
lib/llvm-backend/src/lib.rs
View File

@ -1,10 +1,5 @@
#![cfg_attr(nightly, feature(unwind_attributes))]
use inkwell::{
execution_engine::JitFunction,
targets::{CodeModel, FileType, InitializationConfig, RelocMode, Target, TargetMachine},
OptimizationLevel,
};
use wasmer_runtime_core::{
backend::{Compiler, CompilerConfig, Token},
cache::{Artifact, Error as CacheError},
@ -47,19 +42,16 @@ impl Compiler for LLVMCompiler {
// Create placeholder values here.
let cache_gen = {
use wasmer_runtime_core::backend::{
sys::Memory, CacheGen, ProtectedCaller, UserTrapper,
};
use wasmer_runtime_core::backend::{sys::Memory, CacheGen};
use wasmer_runtime_core::cache::Error as CacheError;
use wasmer_runtime_core::error::RuntimeResult;
use wasmer_runtime_core::module::ModuleInfo;
use wasmer_runtime_core::types::{FuncIndex, Value};
use wasmer_runtime_core::vm;
struct Placeholder;
impl CacheGen for Placeholder {
fn generate_cache(
&self,
module: &ModuleInner,
_module: &ModuleInner,
) -> Result<(Box<ModuleInfo>, Box<[u8]>, Memory), CacheError> {
unimplemented!()
}

22
lib/llvm-backend/src/platform/unix.rs
View File

@ -1,7 +1,5 @@
use libc::{c_void, siginfo_t};
use nix::sys::signal::{
sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal, SIGBUS, SIGFPE, SIGILL, SIGSEGV,
};
use nix::sys::signal::{sigaction, SaFlags, SigAction, SigHandler, SigSet, SIGBUS, SIGSEGV};
/// `__register_frame` and `__deregister_frame` on macos take a single fde as an
/// argument, so we need to parse the fde table here.
@ -51,24 +49,22 @@ pub unsafe fn install_signal_handler() {
SaFlags::SA_ONSTACK | SaFlags::SA_SIGINFO,
SigSet::empty(),
);
// sigaction(SIGFPE, &sa).unwrap();
// sigaction(SIGILL, &sa).unwrap();
sigaction(SIGSEGV, &sa).unwrap();
sigaction(SIGBUS, &sa).unwrap();
}
#[cfg_attr(nightly, unwind(allowed))]
extern "C" fn signal_trap_handler(
signum: ::nix::libc::c_int,
siginfo: *mut siginfo_t,
ucontext: *mut c_void,
_signum: ::nix::libc::c_int,
_siginfo: *mut siginfo_t,
_ucontext: *mut c_void,
) {
unsafe {
/// Apparently, we can unwind from arbitary instructions, as long
/// as we don't need to catch the exception inside the function that
/// was interrupted.
///
/// This works on macos, not sure about linux.
// Apparently, we can unwind from arbitary instructions, as long
// as we don't need to catch the exception inside the function that
// was interrupted.
//
// This works on macos, not sure about linux.
throw_trap(2);
}
}

17
lib/llvm-backend/src/trampolines.rs
View File

@ -3,10 +3,9 @@ use inkwell::{
builder::Builder,
context::Context,
module::{Linkage, Module},
passes::PassManager,
types::{BasicType, BasicTypeEnum, FunctionType, PointerType},
values::{BasicValue, FunctionValue, PhiValue, PointerValue},
AddressSpace, FloatPredicate, IntPredicate,
types::{BasicType, FunctionType},
values::FunctionValue,
AddressSpace,
};
use wasmer_runtime_core::{
module::ModuleInfo,
@ -43,20 +42,12 @@ pub fn generate_trampolines(
Some(Linkage::External),
);
generate_trampoline(
trampoline_func,
func_type,
sig,
context,
builder,
intrinsics,
);
generate_trampoline(trampoline_func, sig, context, builder, intrinsics);
}
}
fn generate_trampoline(
trampoline_func: FunctionValue,
sig_type: FunctionType,
func_sig: &FuncSig,
context: &Context,
builder: &Builder,