From 5c15ff9673c2459dc31623cf997b527ea1108a28 Mon Sep 17 00:00:00 2001 From: losfair Date: Thu, 9 Jan 2020 01:42:21 +0800 Subject: [PATCH 1/6] `ExceptionCode` and `ExceptionTable`. --- lib/runtime-core/src/backend.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/lib/runtime-core/src/backend.rs b/lib/runtime-core/src/backend.rs index 19995f3a7a8..96e6eb30a9c 100644 --- a/lib/runtime-core/src/backend.rs +++ b/lib/runtime-core/src/backend.rs @@ -183,6 +183,26 @@ pub struct CompilerConfig { pub backend_specific_config: Option, } +/// An exception table for a `RunnableModule`. +#[derive(Clone, Debug, Default)] +pub struct ExceptionTable { + /// Mappings from offsets in generated machine code to the corresponding exception code. + pub offset_to_code: HashMap, +} + +/// The code of an exception. +#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)] +pub enum ExceptionCode { + /// An `unreachable` opcode was executed. + Unreachable, + + /// An arithmetic exception, e.g. divided by zero. + Arithmetic, + + /// Memory access exception, e.g. misaligned/out-of-bound read/write. + Memory, +} + pub trait Compiler { /// Compiles a `Module` from WebAssembly binary format. /// The `CompileToken` parameter ensures that this can only @@ -214,6 +234,10 @@ pub trait RunnableModule: Send + Sync { None } + fn get_exception_table(&self) -> Option<&ExceptionTable> { + None + } + unsafe fn patch_local_function(&self, _idx: usize, _target_address: usize) -> bool { false } From f44517b9fb5bb123a91f0801c9eca4272860feda Mon Sep 17 00:00:00 2001 From: losfair Date: Thu, 9 Jan 2020 01:42:50 +0800 Subject: [PATCH 2/6] Look up exception tables in trap handler. --- lib/runtime-core/src/fault.rs | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/lib/runtime-core/src/fault.rs b/lib/runtime-core/src/fault.rs index 2628e5df5c4..d30578624f6 100644 --- a/lib/runtime-core/src/fault.rs +++ b/lib/runtime-core/src/fault.rs @@ -375,15 +375,23 @@ extern "C" fn signal_trap_handler( _ => {} } + // Now we have looked up all possible handler tables but failed to find a handler + // for this exception that allows a normal return. + // + // So here we check whether this exception is caused by a suspend signal, return the + // state image if so, or throw the exception out otherwise. + let ctx: &mut vm::Ctx = &mut **CURRENT_CTX.with(|x| x.get()); let es_image = fault .read_stack(None) .expect("fault.read_stack() failed. Broken invariants?"); if is_suspend_signal { + // If this is a suspend signal, we parse the runtime state and return the resulting image. let image = build_instance_image(ctx, es_image); unwind_result = Box::new(image); } else { + // Otherwise, this is a real exception and we just throw it to the caller. if es_image.frames.len() > 0 { eprintln!( "\n{}", @@ -391,7 +399,26 @@ extern "C" fn signal_trap_handler( ); es_image.print_backtrace_if_needed(); } - // Just let the error propagate otherwise + + // Look up the exception tables and try to find an exception code. + let exc_code = CURRENT_CODE_VERSIONS.with(|versions| { + let versions = versions.borrow(); + for v in versions.iter() { + if let Some(table) = v.runnable_module.get_exception_table() { + let ip = fault.ip.get(); + let end = v.base + v.msm.total_size; + if ip >= v.base && ip < end { + if let Some(exc_code) = table.offset_to_code.get(&(ip - v.base)) { + return Some(*exc_code); + } + } + } + } + None + }); + if let Some(code) = exc_code { + unwind_result = Box::new(code); + } } true From 4b5b8976e9616084dbd088123236253ebd452055 Mon Sep 17 00:00:00 2001 From: losfair Date: Fri, 10 Jan 2020 02:53:08 +0800 Subject: [PATCH 3/6] Serialize/deserialize exception codes. --- lib/runtime-core/src/backend.rs | 10 ++++++++-- lib/runtime-core/src/error.rs | 3 +++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/lib/runtime-core/src/backend.rs b/lib/runtime-core/src/backend.rs index 96e6eb30a9c..aceb752a755 100644 --- a/lib/runtime-core/src/backend.rs +++ b/lib/runtime-core/src/backend.rs @@ -184,14 +184,20 @@ pub struct CompilerConfig { } /// An exception table for a `RunnableModule`. -#[derive(Clone, Debug, Default)] +#[derive(Clone, Debug, Default, Serialize, Deserialize)] pub struct ExceptionTable { /// Mappings from offsets in generated machine code to the corresponding exception code. pub offset_to_code: HashMap, } +impl ExceptionTable { + pub fn new() -> Self { + Self::default() + } +} + /// The code of an exception. -#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)] pub enum ExceptionCode { /// An `unreachable` opcode was executed. Unreachable, diff --git a/lib/runtime-core/src/error.rs b/lib/runtime-core/src/error.rs index 391386e3b4f..fad87600549 100644 --- a/lib/runtime-core/src/error.rs +++ b/lib/runtime-core/src/error.rs @@ -1,6 +1,7 @@ //! The error module contains the data structures and helper functions used to implement errors that //! are produced and returned from the wasmer runtime core. use crate::types::{FuncSig, GlobalDescriptor, MemoryDescriptor, TableDescriptor, Type}; +use crate::backend::ExceptionCode; use core::borrow::Borrow; use std::any::Any; @@ -208,6 +209,8 @@ impl std::fmt::Display for RuntimeError { write!(f, "\"{}\"", s) } else if let Some(s) = data.downcast_ref::<&str>() { write!(f, "\"{}\"", s) + } else if let Some(exc_code) = data.downcast_ref::() { + write!(f, "\"{:?}\"", exc_code) } else { write!(f, "unknown error") } From 8bf0c1966cf6dc698d6554db03b0ca5b47320df0 Mon Sep 17 00:00:00 2001 From: losfair Date: Fri, 10 Jan 2020 02:53:31 +0800 Subject: [PATCH 4/6] Push code version for non-WASI entrypoints. --- src/bin/wasmer.rs | 32 ++++++++++++++++++++++++++------ 1 file changed, 26 insertions(+), 6 deletions(-) diff --git a/src/bin/wasmer.rs b/src/bin/wasmer.rs index 04ef6d3a2f3..cf33d2e5bab 100644 --- a/src/bin/wasmer.rs +++ b/src/bin/wasmer.rs @@ -41,6 +41,11 @@ use wasmer_runtime_core::{ loader::{Instance as LoadedInstance, LocalLoader}, Module, }; +#[cfg(unix)] +use wasmer_runtime_core::{ + fault::{pop_code_version, push_code_version}, + state::CodeVersion, +}; #[cfg(feature = "wasi")] use wasmer_wasi; @@ -472,12 +477,6 @@ fn execute_wasi( #[cfg(not(feature = "managed"))] { use wasmer_runtime::error::RuntimeError; - #[cfg(unix)] - use wasmer_runtime_core::{ - fault::{pop_code_version, push_code_version}, - state::CodeVersion, - }; - let result; #[cfg(unix)] @@ -849,11 +848,32 @@ fn execute_wasm(options: &Run) -> Result<(), String> { }; let args = options.parse_args(&module, invoke_fn)?; + #[cfg(unix)] + let cv_pushed = if let Some(msm) = instance.module.runnable_module.get_module_state_map() { + push_code_version(CodeVersion { + baseline: true, + msm: msm, + base: instance.module.runnable_module.get_code().unwrap().as_ptr() as usize, + backend: options.backend, + runnable_module: instance.module.runnable_module.clone(), + }); + true + } else { + false + }; + let result = instance .dyn_func(&invoke_fn) .map_err(|e| format!("{:?}", e))? .call(&args) .map_err(|e| format!("{:?}", e))?; + + #[cfg(unix)] + { + if cv_pushed { + pop_code_version().unwrap(); + } + } println!("{}({:?}) returned {:?}", invoke_fn, args, result); } } From 0a23327401801873c9c135ad92db814fec044d5c Mon Sep 17 00:00:00 2001 From: losfair Date: Fri, 10 Jan 2020 02:54:23 +0800 Subject: [PATCH 5/6] Emit exception table in singlepass. --- lib/singlepass-backend/src/codegen_x64.rs | 162 ++++++++++++++++++++-- 1 file changed, 154 insertions(+), 8 deletions(-) diff --git a/lib/singlepass-backend/src/codegen_x64.rs b/lib/singlepass-backend/src/codegen_x64.rs index ccc1089931b..c39fab5a5ea 100644 --- a/lib/singlepass-backend/src/codegen_x64.rs +++ b/lib/singlepass-backend/src/codegen_x64.rs @@ -25,6 +25,7 @@ use wasmer_runtime_core::{ sys::{Memory, Protect}, Architecture, Backend, CacheGen, CompilerConfig, InlineBreakpoint, InlineBreakpointType, MemoryBoundCheckMode, RunnableModule, Token, + ExceptionTable, ExceptionCode, }, cache::{Artifact, Error as CacheError}, codegen::*, @@ -224,6 +225,8 @@ pub struct X64FunctionCode { unreachable_depth: usize, config: Arc, + + exception_table: Option, } enum FuncPtrInner {} @@ -242,6 +245,7 @@ pub struct X64ExecutionContext { breakpoints: BreakpointMap, func_import_count: usize, msm: ModuleStateMap, + exception_table: ExceptionTable, } /// On-disk cache format. @@ -264,6 +268,9 @@ pub struct CacheImage { /// Module state map. msm: ModuleStateMap, + + /// An exception table that maps instruction offsets to exception codes. + exception_table: ExceptionTable, } #[derive(Debug)] @@ -322,6 +329,10 @@ impl RunnableModule for X64ExecutionContext { Some(self.breakpoints.clone()) } + fn get_exception_table(&self) -> Option<&ExceptionTable> { + Some(&self.exception_table) + } + unsafe fn patch_local_function(&self, idx: usize, target_address: usize) -> bool { /* 0: 48 b8 42 42 42 42 42 42 42 42 movabsq $4774451407313060418, %rax @@ -662,16 +673,18 @@ impl ModuleCodeGenerator &mut self, _module_info: Arc>, ) -> Result<&mut X64FunctionCode, CodegenError> { - let (mut assembler, mut function_labels, breakpoints) = match self.functions.last_mut() { + let (mut assembler, mut function_labels, breakpoints, exception_table) = match self.functions.last_mut() { Some(x) => ( x.assembler.take().unwrap(), x.function_labels.take().unwrap(), x.breakpoints.take().unwrap(), + x.exception_table.take().unwrap(), ), None => ( self.assembler.take().unwrap(), self.function_labels.take().unwrap(), HashMap::new(), + ExceptionTable::new(), ), }; @@ -707,6 +720,7 @@ impl ModuleCodeGenerator machine, unreachable_depth: 0, config: self.config.as_ref().unwrap().clone(), + exception_table: Some(exception_table), }; self.functions.push(code); Ok(self.functions.last_mut().unwrap()) @@ -716,16 +730,18 @@ impl ModuleCodeGenerator mut self, _: &ModuleInfo, ) -> Result<(X64ExecutionContext, Box), CodegenError> { - let (assembler, function_labels, breakpoints) = match self.functions.last_mut() { + let (assembler, function_labels, breakpoints, exception_table) = match self.functions.last_mut() { Some(x) => ( x.assembler.take().unwrap(), x.function_labels.take().unwrap(), x.breakpoints.take().unwrap(), + x.exception_table.take().unwrap(), ), None => ( self.assembler.take().unwrap(), self.function_labels.take().unwrap(), HashMap::new(), + ExceptionTable::new(), ), }; @@ -797,6 +813,7 @@ impl ModuleCodeGenerator function_offsets: out_offsets.iter().map(|x| x.0 as usize).collect(), func_import_count: self.func_import_count, msm: msm.clone(), + exception_table: exception_table.clone(), }; let cache = SinglepassCache { @@ -812,6 +829,7 @@ impl ModuleCodeGenerator function_pointers: out_labels, function_offsets: out_offsets, msm: msm, + exception_table, }, Box::new(cache), )) @@ -915,6 +933,7 @@ impl ModuleCodeGenerator breakpoints: Arc::new(HashMap::new()), func_import_count: cache_image.func_import_count, msm: cache_image.msm, + exception_table: cache_image.exception_table, }; Ok(ModuleInner { runnable_module: Arc::new(Box::new(ec)), @@ -947,10 +966,22 @@ impl X64FunctionCode { .insert(m.state.wasm_inst_offset, SuspendOffset::Trappable(offset)); } + /// Marks each address in the code range emitted by `f` with the exception code `code`. + fn mark_range_with_exception_code R, R>(a: &mut Assembler, etable: &mut ExceptionTable, code: ExceptionCode, f: F) -> R { + let begin = a.get_offset().0; + let ret = f(a); + let end = a.get_offset().0; + for i in begin..end { + etable.offset_to_code.insert(i, code); + } + ret + } + /// Moves `loc` to a valid location for `div`/`idiv`. fn emit_relaxed_xdiv( a: &mut Assembler, m: &mut Machine, + etable: &mut ExceptionTable, op: fn(&mut Assembler, Size, Location), sz: Size, loc: Location, @@ -962,10 +993,12 @@ impl X64FunctionCode { Location::Imm64(_) | Location::Imm32(_) => { a.emit_mov(sz, loc, Location::GPR(GPR::RCX)); // must not be used during div (rax, rdx) Self::mark_trappable(a, m, fsm, control_stack); + etable.offset_to_code.insert(a.get_offset().0, ExceptionCode::Arithmetic); op(a, sz, Location::GPR(GPR::RCX)); } _ => { Self::mark_trappable(a, m, fsm, control_stack); + etable.offset_to_code.insert(a.get_offset().0, ExceptionCode::Arithmetic); op(a, sz, loc); } } @@ -1876,6 +1909,7 @@ impl X64FunctionCode { config: &CodegenConfig, a: &mut Assembler, m: &mut Machine, + etable: &mut ExceptionTable, addr: Location, memarg: &MemoryImmediate, check_alignment: bool, @@ -1949,7 +1983,8 @@ impl X64FunctionCode { // Trap if the end address of the requested area is above that of the linear memory. a.emit_add(Size::S64, Location::GPR(tmp_base), Location::GPR(tmp_addr)); a.emit_cmp(Size::S64, Location::GPR(tmp_bound), Location::GPR(tmp_addr)); - a.emit_conditional_trap(Condition::Above); + + Self::mark_range_with_exception_code(a, etable, ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::Above)); m.release_temp_gpr(tmp_bound); } @@ -1989,11 +2024,13 @@ impl X64FunctionCode { Location::Imm32(align - 1), Location::GPR(tmp_aligncheck), ); - a.emit_conditional_trap(Condition::NotEqual); + Self::mark_range_with_exception_code(a, etable, ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::NotEqual)); m.release_temp_gpr(tmp_aligncheck); } - cb(a, m, tmp_addr)?; + Self::mark_range_with_exception_code(a, etable, ExceptionCode::Memory, |a| { + cb(a, m, tmp_addr) + })?; m.release_temp_gpr(tmp_addr); Ok(()) @@ -2005,6 +2042,7 @@ impl X64FunctionCode { config: &CodegenConfig, a: &mut Assembler, m: &mut Machine, + etable: &mut ExceptionTable, loc: Location, target: Location, ret: Location, @@ -2038,6 +2076,7 @@ impl X64FunctionCode { config, a, m, + etable, target, memarg, true, @@ -2108,6 +2147,7 @@ impl X64FunctionCode { fn emit_f32_int_conv_check_trap( a: &mut Assembler, m: &mut Machine, + etable: &mut ExceptionTable, reg: XMM, lower_bound: f32, upper_bound: f32, @@ -2117,6 +2157,7 @@ impl X64FunctionCode { Self::emit_f32_int_conv_check(a, m, reg, lower_bound, upper_bound, trap, trap, trap, end); a.emit_label(trap); + etable.offset_to_code.insert(a.get_offset().0, ExceptionCode::Arithmetic); a.emit_ud2(); a.emit_label(end); } @@ -2232,6 +2273,7 @@ impl X64FunctionCode { fn emit_f64_int_conv_check_trap( a: &mut Assembler, m: &mut Machine, + etable: &mut ExceptionTable, reg: XMM, lower_bound: f64, upper_bound: f64, @@ -2241,6 +2283,7 @@ impl X64FunctionCode { Self::emit_f64_int_conv_check(a, m, reg, lower_bound, upper_bound, trap, trap, trap, end); a.emit_label(trap); + etable.offset_to_code.insert(a.get_offset().0, ExceptionCode::Arithmetic); a.emit_ud2(); a.emit_label(end); } @@ -2365,7 +2408,7 @@ impl FunctionCodeGenerator for X64FunctionCode { ), Location::GPR(GPR::RSP), ); - a.emit_conditional_trap(Condition::Below); + Self::mark_range_with_exception_code(a, self.exception_table.as_mut().unwrap(), ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::Below)); } self.locals = self @@ -2788,6 +2831,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_relaxed_xdiv( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), Assembler::emit_div, Size::S32, loc_b, @@ -2813,6 +2857,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_relaxed_xdiv( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), Assembler::emit_idiv, Size::S32, loc_b, @@ -2838,6 +2883,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_relaxed_xdiv( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), Assembler::emit_div, Size::S32, loc_b, @@ -2889,6 +2935,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_relaxed_xdiv( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), Assembler::emit_idiv, Size::S32, loc_b, @@ -3187,6 +3234,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_relaxed_xdiv( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), Assembler::emit_div, Size::S64, loc_b, @@ -3212,6 +3260,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_relaxed_xdiv( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), Assembler::emit_idiv, Size::S64, loc_b, @@ -3237,6 +3286,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_relaxed_xdiv( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), Assembler::emit_div, Size::S64, loc_b, @@ -3296,6 +3346,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_relaxed_xdiv( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), Assembler::emit_idiv, Size::S64, loc_b, @@ -4748,6 +4799,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_f32_int_conv_check_trap( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), tmp_in, GEF32_LT_U32_MIN, LEF32_GT_U32_MAX, @@ -4859,6 +4911,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_f32_int_conv_check_trap( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), tmp_in, GEF32_LT_I32_MIN, LEF32_GT_I32_MAX, @@ -4976,6 +5029,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_f32_int_conv_check_trap( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), tmp_in, GEF32_LT_I64_MIN, LEF32_GT_I64_MAX, @@ -5093,6 +5147,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_f32_int_conv_check_trap( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), tmp_in, GEF32_LT_U64_MIN, LEF32_GT_U64_MAX, @@ -5253,6 +5308,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_f64_int_conv_check_trap( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), tmp_in, GEF64_LT_U32_MIN, LEF64_GT_U32_MAX, @@ -5370,6 +5426,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_f64_int_conv_check_trap( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), real_in, GEF64_LT_I32_MIN, LEF64_GT_I32_MAX, @@ -5493,6 +5550,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_f64_int_conv_check_trap( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), tmp_in, GEF64_LT_I64_MIN, LEF64_GT_I64_MAX, @@ -5611,6 +5669,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Self::emit_f64_int_conv_check_trap( a, &mut self.machine, + self.exception_table.as_mut().unwrap(), tmp_in, GEF64_LT_U64_MIN, LEF64_GT_U64_MAX, @@ -6210,7 +6269,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Location::GPR(table_base), ); a.emit_cmp(Size::S32, func_index, Location::GPR(table_count)); - a.emit_conditional_trap(Condition::BelowEqual); + Self::mark_range_with_exception_code(a, self.exception_table.as_mut().unwrap(), ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::BelowEqual)); a.emit_mov(Size::S64, func_index, Location::GPR(table_count)); a.emit_imul_imm32_gpr64(vm::Anyfunc::size() as u32, table_count); a.emit_add( @@ -6236,7 +6295,7 @@ impl FunctionCodeGenerator for X64FunctionCode { Location::GPR(sigidx), Location::Memory(table_count, (vm::Anyfunc::offset_sig_id() as usize) as i32), ); - a.emit_conditional_trap(Condition::NotEqual); + Self::mark_range_with_exception_code(a, self.exception_table.as_mut().unwrap(), ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::NotEqual)); self.machine.release_temp_gpr(sigidx); self.machine.release_temp_gpr(table_count); @@ -6587,6 +6646,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6619,6 +6679,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6651,6 +6712,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6684,6 +6746,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6717,6 +6780,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6750,6 +6814,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6779,6 +6844,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -6807,6 +6873,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -6835,6 +6902,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -6863,6 +6931,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -6895,6 +6964,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6927,6 +6997,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6959,6 +7030,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -6992,6 +7064,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -7025,6 +7098,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -7058,6 +7132,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -7091,6 +7166,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -7138,6 +7214,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, false, @@ -7167,6 +7244,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -7195,6 +7273,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -7223,6 +7302,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -7251,6 +7331,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -7279,6 +7360,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, false, @@ -7298,6 +7380,7 @@ impl FunctionCodeGenerator for X64FunctionCode { } Operator::Unreachable => { Self::mark_trappable(a, &self.machine, &mut self.fsm, &mut self.control_stack); + self.exception_table.as_mut().unwrap().offset_to_code.insert(a.get_offset().0, ExceptionCode::Unreachable); a.emit_ud2(); self.unreachable_depth = 1; } @@ -7526,6 +7609,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -7558,6 +7642,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -7591,6 +7676,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -7620,6 +7706,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, true, @@ -7648,6 +7735,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, true, @@ -7676,6 +7764,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, true, @@ -7708,6 +7797,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -7740,6 +7830,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -7773,6 +7864,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -7806,6 +7898,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -7849,6 +7942,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, true, @@ -7877,6 +7971,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, true, @@ -7905,6 +8000,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, true, @@ -7933,6 +8029,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target_addr, memarg, true, @@ -7969,6 +8066,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8004,6 +8102,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8039,6 +8138,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8070,6 +8170,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8105,6 +8206,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8136,6 +8238,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8171,6 +8274,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8207,6 +8311,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8243,6 +8348,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8279,6 +8385,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8311,6 +8418,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8347,6 +8455,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8379,6 +8488,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8415,6 +8525,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -8448,6 +8559,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8477,6 +8589,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8506,6 +8619,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8535,6 +8649,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8564,6 +8679,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8593,6 +8709,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8622,6 +8739,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8651,6 +8769,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8680,6 +8799,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8709,6 +8829,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8738,6 +8859,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8767,6 +8889,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8796,6 +8919,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8825,6 +8949,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8854,6 +8979,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8883,6 +9009,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8912,6 +9039,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8941,6 +9069,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8970,6 +9099,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -8999,6 +9129,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -9028,6 +9159,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), loc, target, ret, @@ -9059,6 +9191,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9090,6 +9223,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9121,6 +9255,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9152,6 +9287,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9183,6 +9319,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9214,6 +9351,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9245,6 +9383,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9290,6 +9429,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9340,6 +9480,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9390,6 +9531,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9440,6 +9582,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9490,6 +9633,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9540,6 +9684,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, @@ -9590,6 +9735,7 @@ impl FunctionCodeGenerator for X64FunctionCode { &self.config, a, &mut self.machine, + self.exception_table.as_mut().unwrap(), target, memarg, true, From 9e2080def1328f3b08e770a0d13fd8fa2a2f03c0 Mon Sep 17 00:00:00 2001 From: losfair Date: Fri, 10 Jan 2020 02:54:50 +0800 Subject: [PATCH 6/6] Run cargo fmt. --- lib/runtime-core/src/error.rs | 2 +- lib/singlepass-backend/src/codegen_x64.rs | 121 ++++++++++++++-------- src/bin/wasmer.rs | 25 ++--- 3 files changed, 93 insertions(+), 55 deletions(-) diff --git a/lib/runtime-core/src/error.rs b/lib/runtime-core/src/error.rs index fad87600549..94abce06d5a 100644 --- a/lib/runtime-core/src/error.rs +++ b/lib/runtime-core/src/error.rs @@ -1,7 +1,7 @@ //! The error module contains the data structures and helper functions used to implement errors that //! are produced and returned from the wasmer runtime core. -use crate::types::{FuncSig, GlobalDescriptor, MemoryDescriptor, TableDescriptor, Type}; use crate::backend::ExceptionCode; +use crate::types::{FuncSig, GlobalDescriptor, MemoryDescriptor, TableDescriptor, Type}; use core::borrow::Borrow; use std::any::Any; diff --git a/lib/singlepass-backend/src/codegen_x64.rs b/lib/singlepass-backend/src/codegen_x64.rs index c39fab5a5ea..bcf2acb25cd 100644 --- a/lib/singlepass-backend/src/codegen_x64.rs +++ b/lib/singlepass-backend/src/codegen_x64.rs @@ -23,9 +23,8 @@ use std::{ use wasmer_runtime_core::{ backend::{ sys::{Memory, Protect}, - Architecture, Backend, CacheGen, CompilerConfig, InlineBreakpoint, InlineBreakpointType, - MemoryBoundCheckMode, RunnableModule, Token, - ExceptionTable, ExceptionCode, + Architecture, Backend, CacheGen, CompilerConfig, ExceptionCode, ExceptionTable, + InlineBreakpoint, InlineBreakpointType, MemoryBoundCheckMode, RunnableModule, Token, }, cache::{Artifact, Error as CacheError}, codegen::*, @@ -673,20 +672,21 @@ impl ModuleCodeGenerator &mut self, _module_info: Arc>, ) -> Result<&mut X64FunctionCode, CodegenError> { - let (mut assembler, mut function_labels, breakpoints, exception_table) = match self.functions.last_mut() { - Some(x) => ( - x.assembler.take().unwrap(), - x.function_labels.take().unwrap(), - x.breakpoints.take().unwrap(), - x.exception_table.take().unwrap(), - ), - None => ( - self.assembler.take().unwrap(), - self.function_labels.take().unwrap(), - HashMap::new(), - ExceptionTable::new(), - ), - }; + let (mut assembler, mut function_labels, breakpoints, exception_table) = + match self.functions.last_mut() { + Some(x) => ( + x.assembler.take().unwrap(), + x.function_labels.take().unwrap(), + x.breakpoints.take().unwrap(), + x.exception_table.take().unwrap(), + ), + None => ( + self.assembler.take().unwrap(), + self.function_labels.take().unwrap(), + HashMap::new(), + ExceptionTable::new(), + ), + }; let begin_offset = assembler.offset(); let begin_label_info = function_labels @@ -730,20 +730,21 @@ impl ModuleCodeGenerator mut self, _: &ModuleInfo, ) -> Result<(X64ExecutionContext, Box), CodegenError> { - let (assembler, function_labels, breakpoints, exception_table) = match self.functions.last_mut() { - Some(x) => ( - x.assembler.take().unwrap(), - x.function_labels.take().unwrap(), - x.breakpoints.take().unwrap(), - x.exception_table.take().unwrap(), - ), - None => ( - self.assembler.take().unwrap(), - self.function_labels.take().unwrap(), - HashMap::new(), - ExceptionTable::new(), - ), - }; + let (assembler, function_labels, breakpoints, exception_table) = + match self.functions.last_mut() { + Some(x) => ( + x.assembler.take().unwrap(), + x.function_labels.take().unwrap(), + x.breakpoints.take().unwrap(), + x.exception_table.take().unwrap(), + ), + None => ( + self.assembler.take().unwrap(), + self.function_labels.take().unwrap(), + HashMap::new(), + ExceptionTable::new(), + ), + }; let total_size = assembler.get_offset().0; let _output = assembler.finalize().unwrap(); @@ -967,7 +968,12 @@ impl X64FunctionCode { } /// Marks each address in the code range emitted by `f` with the exception code `code`. - fn mark_range_with_exception_code R, R>(a: &mut Assembler, etable: &mut ExceptionTable, code: ExceptionCode, f: F) -> R { + fn mark_range_with_exception_code R, R>( + a: &mut Assembler, + etable: &mut ExceptionTable, + code: ExceptionCode, + f: F, + ) -> R { let begin = a.get_offset().0; let ret = f(a); let end = a.get_offset().0; @@ -993,12 +999,16 @@ impl X64FunctionCode { Location::Imm64(_) | Location::Imm32(_) => { a.emit_mov(sz, loc, Location::GPR(GPR::RCX)); // must not be used during div (rax, rdx) Self::mark_trappable(a, m, fsm, control_stack); - etable.offset_to_code.insert(a.get_offset().0, ExceptionCode::Arithmetic); + etable + .offset_to_code + .insert(a.get_offset().0, ExceptionCode::Arithmetic); op(a, sz, Location::GPR(GPR::RCX)); } _ => { Self::mark_trappable(a, m, fsm, control_stack); - etable.offset_to_code.insert(a.get_offset().0, ExceptionCode::Arithmetic); + etable + .offset_to_code + .insert(a.get_offset().0, ExceptionCode::Arithmetic); op(a, sz, loc); } } @@ -1984,7 +1994,9 @@ impl X64FunctionCode { a.emit_add(Size::S64, Location::GPR(tmp_base), Location::GPR(tmp_addr)); a.emit_cmp(Size::S64, Location::GPR(tmp_bound), Location::GPR(tmp_addr)); - Self::mark_range_with_exception_code(a, etable, ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::Above)); + Self::mark_range_with_exception_code(a, etable, ExceptionCode::Memory, |a| { + a.emit_conditional_trap(Condition::Above) + }); m.release_temp_gpr(tmp_bound); } @@ -2024,7 +2036,9 @@ impl X64FunctionCode { Location::Imm32(align - 1), Location::GPR(tmp_aligncheck), ); - Self::mark_range_with_exception_code(a, etable, ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::NotEqual)); + Self::mark_range_with_exception_code(a, etable, ExceptionCode::Memory, |a| { + a.emit_conditional_trap(Condition::NotEqual) + }); m.release_temp_gpr(tmp_aligncheck); } @@ -2157,7 +2171,9 @@ impl X64FunctionCode { Self::emit_f32_int_conv_check(a, m, reg, lower_bound, upper_bound, trap, trap, trap, end); a.emit_label(trap); - etable.offset_to_code.insert(a.get_offset().0, ExceptionCode::Arithmetic); + etable + .offset_to_code + .insert(a.get_offset().0, ExceptionCode::Arithmetic); a.emit_ud2(); a.emit_label(end); } @@ -2283,7 +2299,9 @@ impl X64FunctionCode { Self::emit_f64_int_conv_check(a, m, reg, lower_bound, upper_bound, trap, trap, trap, end); a.emit_label(trap); - etable.offset_to_code.insert(a.get_offset().0, ExceptionCode::Arithmetic); + etable + .offset_to_code + .insert(a.get_offset().0, ExceptionCode::Arithmetic); a.emit_ud2(); a.emit_label(end); } @@ -2408,7 +2426,12 @@ impl FunctionCodeGenerator for X64FunctionCode { ), Location::GPR(GPR::RSP), ); - Self::mark_range_with_exception_code(a, self.exception_table.as_mut().unwrap(), ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::Below)); + Self::mark_range_with_exception_code( + a, + self.exception_table.as_mut().unwrap(), + ExceptionCode::Memory, + |a| a.emit_conditional_trap(Condition::Below), + ); } self.locals = self @@ -6269,7 +6292,12 @@ impl FunctionCodeGenerator for X64FunctionCode { Location::GPR(table_base), ); a.emit_cmp(Size::S32, func_index, Location::GPR(table_count)); - Self::mark_range_with_exception_code(a, self.exception_table.as_mut().unwrap(), ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::BelowEqual)); + Self::mark_range_with_exception_code( + a, + self.exception_table.as_mut().unwrap(), + ExceptionCode::Memory, + |a| a.emit_conditional_trap(Condition::BelowEqual), + ); a.emit_mov(Size::S64, func_index, Location::GPR(table_count)); a.emit_imul_imm32_gpr64(vm::Anyfunc::size() as u32, table_count); a.emit_add( @@ -6295,7 +6323,12 @@ impl FunctionCodeGenerator for X64FunctionCode { Location::GPR(sigidx), Location::Memory(table_count, (vm::Anyfunc::offset_sig_id() as usize) as i32), ); - Self::mark_range_with_exception_code(a, self.exception_table.as_mut().unwrap(), ExceptionCode::Memory, |a| a.emit_conditional_trap(Condition::NotEqual)); + Self::mark_range_with_exception_code( + a, + self.exception_table.as_mut().unwrap(), + ExceptionCode::Memory, + |a| a.emit_conditional_trap(Condition::NotEqual), + ); self.machine.release_temp_gpr(sigidx); self.machine.release_temp_gpr(table_count); @@ -7380,7 +7413,11 @@ impl FunctionCodeGenerator for X64FunctionCode { } Operator::Unreachable => { Self::mark_trappable(a, &self.machine, &mut self.fsm, &mut self.control_stack); - self.exception_table.as_mut().unwrap().offset_to_code.insert(a.get_offset().0, ExceptionCode::Unreachable); + self.exception_table + .as_mut() + .unwrap() + .offset_to_code + .insert(a.get_offset().0, ExceptionCode::Unreachable); a.emit_ud2(); self.unreachable_depth = 1; } diff --git a/src/bin/wasmer.rs b/src/bin/wasmer.rs index cf33d2e5bab..1f62182adaf 100644 --- a/src/bin/wasmer.rs +++ b/src/bin/wasmer.rs @@ -849,18 +849,19 @@ fn execute_wasm(options: &Run) -> Result<(), String> { let args = options.parse_args(&module, invoke_fn)?; #[cfg(unix)] - let cv_pushed = if let Some(msm) = instance.module.runnable_module.get_module_state_map() { - push_code_version(CodeVersion { - baseline: true, - msm: msm, - base: instance.module.runnable_module.get_code().unwrap().as_ptr() as usize, - backend: options.backend, - runnable_module: instance.module.runnable_module.clone(), - }); - true - } else { - false - }; + let cv_pushed = + if let Some(msm) = instance.module.runnable_module.get_module_state_map() { + push_code_version(CodeVersion { + baseline: true, + msm: msm, + base: instance.module.runnable_module.get_code().unwrap().as_ptr() as usize, + backend: options.backend, + runnable_module: instance.module.runnable_module.clone(), + }); + true + } else { + false + }; let result = instance .dyn_func(&invoke_fn)