diff --git a/lib/runtime-core/src/backend.rs b/lib/runtime-core/src/backend.rs
index 19995f3a7a8..aceb752a755 100644
--- a/lib/runtime-core/src/backend.rs
+++ b/lib/runtime-core/src/backend.rs
@@ -183,6 +183,32 @@ pub struct CompilerConfig {
     pub backend_specific_config: Option<BackendCompilerConfig>,
 }
 
+/// An exception table for a `RunnableModule`.
+#[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<usize, ExceptionCode>,
+}
+
+impl ExceptionTable {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+/// The code of an exception.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
+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 +240,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
     }
diff --git a/lib/runtime-core/src/error.rs b/lib/runtime-core/src/error.rs
index 391386e3b4f..94abce06d5a 100644
--- a/lib/runtime-core/src/error.rs
+++ b/lib/runtime-core/src/error.rs
@@ -1,5 +1,6 @@
 //! 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::backend::ExceptionCode;
 use crate::types::{FuncSig, GlobalDescriptor, MemoryDescriptor, TableDescriptor, Type};
 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::<ExceptionCode>() {
+                    write!(f, "\"{:?}\"", exc_code)
                 } else {
                     write!(f, "unknown error")
                 }
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
diff --git a/lib/singlepass-backend/src/codegen_x64.rs b/lib/singlepass-backend/src/codegen_x64.rs
index ccc1089931b..bcf2acb25cd 100644
--- a/lib/singlepass-backend/src/codegen_x64.rs
+++ b/lib/singlepass-backend/src/codegen_x64.rs
@@ -23,8 +23,8 @@ use std::{
 use wasmer_runtime_core::{
     backend::{
         sys::{Memory, Protect},
-        Architecture, Backend, CacheGen, CompilerConfig, InlineBreakpoint, InlineBreakpointType,
-        MemoryBoundCheckMode, RunnableModule, Token,
+        Architecture, Backend, CacheGen, CompilerConfig, ExceptionCode, ExceptionTable,
+        InlineBreakpoint, InlineBreakpointType, MemoryBoundCheckMode, RunnableModule, Token,
     },
     cache::{Artifact, Error as CacheError},
     codegen::*,
@@ -224,6 +224,8 @@ pub struct X64FunctionCode {
     unreachable_depth: usize,
 
     config: Arc<CodegenConfig>,
+
+    exception_table: Option<ExceptionTable>,
 }
 
 enum FuncPtrInner {}
@@ -242,6 +244,7 @@ pub struct X64ExecutionContext {
     breakpoints: BreakpointMap,
     func_import_count: usize,
     msm: ModuleStateMap,
+    exception_table: ExceptionTable,
 }
 
 /// On-disk cache format.
@@ -264,6 +267,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 +328,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,18 +672,21 @@ impl ModuleCodeGenerator<X64FunctionCode, X64ExecutionContext, CodegenError>
         &mut self,
         _module_info: Arc<RwLock<ModuleInfo>>,
     ) -> Result<&mut X64FunctionCode, CodegenError> {
-        let (mut assembler, mut function_labels, breakpoints) = match self.functions.last_mut() {
-            Some(x) => (
-                x.assembler.take().unwrap(),
-                x.function_labels.take().unwrap(),
-                x.breakpoints.take().unwrap(),
-            ),
-            None => (
-                self.assembler.take().unwrap(),
-                self.function_labels.take().unwrap(),
-                HashMap::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
@@ -707,6 +720,7 @@ impl ModuleCodeGenerator<X64FunctionCode, X64ExecutionContext, CodegenError>
             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,18 +730,21 @@ impl ModuleCodeGenerator<X64FunctionCode, X64ExecutionContext, CodegenError>
         mut self,
         _: &ModuleInfo,
     ) -> Result<(X64ExecutionContext, Box<dyn CacheGen>), CodegenError> {
-        let (assembler, function_labels, breakpoints) = match self.functions.last_mut() {
-            Some(x) => (
-                x.assembler.take().unwrap(),
-                x.function_labels.take().unwrap(),
-                x.breakpoints.take().unwrap(),
-            ),
-            None => (
-                self.assembler.take().unwrap(),
-                self.function_labels.take().unwrap(),
-                HashMap::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();
@@ -797,6 +814,7 @@ impl ModuleCodeGenerator<X64FunctionCode, X64ExecutionContext, CodegenError>
             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 +830,7 @@ impl ModuleCodeGenerator<X64FunctionCode, X64ExecutionContext, CodegenError>
                 function_pointers: out_labels,
                 function_offsets: out_offsets,
                 msm: msm,
+                exception_table,
             },
             Box::new(cache),
         ))
@@ -915,6 +934,7 @@ impl ModuleCodeGenerator<X64FunctionCode, X64ExecutionContext, CodegenError>
             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 +967,27 @@ 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<F: FnOnce(&mut Assembler) -> 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 +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);
                 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 +1919,7 @@ impl X64FunctionCode {
         config: &CodegenConfig,
         a: &mut Assembler,
         m: &mut Machine,
+        etable: &mut ExceptionTable,
         addr: Location,
         memarg: &MemoryImmediate,
         check_alignment: bool,
@@ -1949,7 +1993,10 @@ 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 +2036,15 @@ 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 +2056,7 @@ impl X64FunctionCode {
         config: &CodegenConfig,
         a: &mut Assembler,
         m: &mut Machine,
+        etable: &mut ExceptionTable,
         loc: Location,
         target: Location,
         ret: Location,
@@ -2038,6 +2090,7 @@ impl X64FunctionCode {
             config,
             a,
             m,
+            etable,
             target,
             memarg,
             true,
@@ -2108,6 +2161,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 +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);
         a.emit_ud2();
         a.emit_label(end);
     }
@@ -2232,6 +2289,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 +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);
         a.emit_ud2();
         a.emit_label(end);
     }
@@ -2365,7 +2426,12 @@ impl FunctionCodeGenerator<CodegenError> 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 +2854,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +2880,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +2906,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +2958,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +3257,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +3283,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +3309,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +3369,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +4822,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +4934,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +5052,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +5170,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +5331,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +5449,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +5573,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +5692,7 @@ impl FunctionCodeGenerator<CodegenError> 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 +6292,12 @@ impl FunctionCodeGenerator<CodegenError> 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 +6323,12 @@ impl FunctionCodeGenerator<CodegenError> 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 +6679,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6619,6 +6712,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6651,6 +6745,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6684,6 +6779,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6717,6 +6813,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6750,6 +6847,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6779,6 +6877,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -6807,6 +6906,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -6835,6 +6935,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -6863,6 +6964,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -6895,6 +6997,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6927,6 +7030,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6959,6 +7063,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -6992,6 +7097,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -7025,6 +7131,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -7058,6 +7165,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -7091,6 +7199,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -7138,6 +7247,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     false,
@@ -7167,6 +7277,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -7195,6 +7306,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -7223,6 +7335,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -7251,6 +7364,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -7279,6 +7393,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     false,
@@ -7298,6 +7413,11 @@ impl FunctionCodeGenerator<CodegenError> 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 +7646,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -7558,6 +7679,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -7591,6 +7713,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -7620,6 +7743,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     true,
@@ -7648,6 +7772,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     true,
@@ -7676,6 +7801,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     true,
@@ -7708,6 +7834,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -7740,6 +7867,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -7773,6 +7901,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -7806,6 +7935,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -7849,6 +7979,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     true,
@@ -7877,6 +8008,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     true,
@@ -7905,6 +8037,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     true,
@@ -7933,6 +8066,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target_addr,
                     memarg,
                     true,
@@ -7969,6 +8103,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8004,6 +8139,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8039,6 +8175,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8070,6 +8207,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8105,6 +8243,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8136,6 +8275,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8171,6 +8311,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8207,6 +8348,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8243,6 +8385,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8279,6 +8422,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8311,6 +8455,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8347,6 +8492,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8379,6 +8525,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8415,6 +8562,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -8448,6 +8596,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8477,6 +8626,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8506,6 +8656,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8535,6 +8686,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8564,6 +8716,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8593,6 +8746,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8622,6 +8776,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8651,6 +8806,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8680,6 +8836,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8709,6 +8866,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8738,6 +8896,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8767,6 +8926,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8796,6 +8956,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8825,6 +8986,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8854,6 +9016,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8883,6 +9046,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8912,6 +9076,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8941,6 +9106,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8970,6 +9136,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -8999,6 +9166,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -9028,6 +9196,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     loc,
                     target,
                     ret,
@@ -9059,6 +9228,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9090,6 +9260,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9121,6 +9292,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9152,6 +9324,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9183,6 +9356,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9214,6 +9388,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9245,6 +9420,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9290,6 +9466,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9340,6 +9517,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9390,6 +9568,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9440,6 +9619,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9490,6 +9670,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9540,6 +9721,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
@@ -9590,6 +9772,7 @@ impl FunctionCodeGenerator<CodegenError> for X64FunctionCode {
                     &self.config,
                     a,
                     &mut self.machine,
+                    self.exception_table.as_mut().unwrap(),
                     target,
                     memarg,
                     true,
diff --git a/src/bin/wasmer.rs b/src/bin/wasmer.rs
index 04ef6d3a2f3..1f62182adaf 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,33 @@ 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);
         }
     }