fix

lib/clif-backend/src/call/recovery.rs

@@ -36,24 +36,24 @@ unsafe impl Sync for HandlerData {}
 
 pub struct HandlerData {
     pub trap_data: TrapSink,
-    buffer_ptr: *const c_void,
+    exec_buffer_ptr: *const c_void,
-    buffer_size: usize,
+    exec_buffer_size: usize,
 }
 
 impl HandlerData {
-    pub fn new(trap_data: TrapSink, buffer_ptr: *const c_void, buffer_size: usize) -> Self {
+    pub fn new(trap_data: TrapSink, exec_buffer_ptr: *const c_void, exec_buffer_size: usize) -> Self {
         Self {
             trap_data,
-            buffer_ptr,
+            exec_buffer_ptr,
-            buffer_size,
+            exec_buffer_size,
         }
     }
 
     pub fn lookup(&self, ip: *const c_void) -> Option<TrapData> {
         let ip = ip as usize;
-        let buffer_ptr = self.buffer_ptr as usize;
+        let buffer_ptr = self.exec_buffer_ptr as usize;
 
-        if buffer_ptr <= ip && ip < buffer_ptr + self.buffer_size {
+        if buffer_ptr <= ip && ip < buffer_ptr + self.exec_buffer_size {
             let offset = ip - buffer_ptr;
             self.trap_data.lookup(offset)
         } else {
@@ -90,18 +90,9 @@ pub fn call_protected<T>(handler_data: &HandlerData, f: impl FnOnce() -> T) -> R
                             table: TableIndex::new(0),
                         },
                         TrapCode::HeapOutOfBounds => {
-                            let addr =
+                            RuntimeError::OutOfBoundsAccess {
-                                (faulting_addr as usize) - (handler_data.buffer_ptr as usize);
+                                memory: MemoryIndex::new(0),
-                            if addr <= handler_data.buffer_size {
+                                addr: 0,
-                                // in the memory
-                                RuntimeError::OutOfBoundsAccess {
-                                    memory: MemoryIndex::new(0),
-                                    addr: addr as u32,
-                                }
-                            } else {
-                                // if there's an invalid access outside of the memory, including guard pages
-                                // just kill the process.
-                                panic!("invalid memory access, way out of bounds")
                             }
                         }
                         TrapCode::TableOutOfBounds => RuntimeError::TableOutOfBounds {
@@ -112,17 +103,9 @@ pub fn call_protected<T>(handler_data: &HandlerData, f: impl FnOnce() -> T) -> R
                         },
                     },
                     Ok(SIGSEGV) | Ok(SIGBUS) => {
-                        let addr = (faulting_addr as usize) - (handler_data.buffer_ptr as usize);
+                        RuntimeError::OutOfBoundsAccess {
-                        if addr <= handler_data.buffer_size {
+                            memory: MemoryIndex::new(0),
-                            // in the memory
+                            addr: 0,
-                            RuntimeError::OutOfBoundsAccess {
-                                memory: MemoryIndex::new(0),
-                                addr: addr as u32,
-                            }
-                        } else {
-                            // if there's an invalid access outside of the memory, including guard pages
-                            // just kill the process.
-                            panic!("invalid memory access, way out of bounds")
                         }
                     }
                     Ok(SIGFPE) => RuntimeError::IllegalArithmeticOperation,

lib/emscripten/src/lib.rs

@@ -95,7 +95,7 @@ pub struct EmscriptenData<'a> {
     pub memset: Func<'a, (u32, u32, u32), u32>,
     pub stack_alloc: Func<'a, u32, u32>,
 
-    pub jumps: Vec<UnsafeCell<[u8; 27]>>,
+    pub jumps: Vec<UnsafeCell<[u32; 27]>>,
 }
 
 impl<'a> EmscriptenData<'a> {
@@ -144,6 +144,8 @@ pub fn run_emscripten_instance(
         instance.call("___emscripten_environ_constructor", &[])?;
     }
 
+    println!("running emscripten instance");
+
     let main_func = instance.dyn_func("_main")?;
     let num_params = main_func.signature().params().len();
     let _result = match num_params {

lib/emscripten/tests/emtests/_common.rs

@@ -30,14 +30,14 @@ macro_rules! assert_emscripten_output {
             $args,
         ).expect("run_emscripten_instance finishes");
 
-         let output = capturer.end().unwrap().0;
+        let output = capturer.end().unwrap().0;
-         let expected_output = include_str!($expected);
+        let expected_output = include_str!($expected);
 
-         assert!(
+        assert!(
-             output.contains(expected_output),
+            output.contains(expected_output),
-             "Output: `{}` does not contain expected output: `{}`",
+            "Output: `{}` does not contain expected output: `{}`",
-             output,
+            output,
-             expected_output
+            expected_output
-         );
+        );
     }};
 }

lib/runtime-core/src/instance.rs

@@ -113,7 +113,7 @@ impl Instance {
                 .func_assoc
                 .get(*func_index)
                 .expect("broken invariant, incorrect func index");
-            let signature = SigRegistry.lookup_signature(sig_index);
+            let signature = &self.module.info.signatures[sig_index];
 
             if signature.params() != Args::types() || signature.returns() != Rets::types() {
                 Err(ResolveError::Signature {