Review feedback

crates/api/src/func.rs

@@ -232,14 +232,14 @@ impl Func {
         // Create our actual trampoline function which translates from a bunch
         // of bit patterns on the stack to actual instances of `Val` being
         // passed to the given function.
-        let func = Box::new(move |caller_vmctx, values_vec: *mut i128| {
+        let func = Box::new(move |caller_vmctx, values_vec: *mut u128| {
             // We have a dynamic guarantee that `values_vec` has the right
             // number of arguments and the right types of arguments. As a result
             // we should be able to safely run through them all and read them.
             let mut args = Vec::with_capacity(ty_clone.params().len());
             for (i, ty) in ty_clone.params().iter().enumerate() {
                 unsafe {
-                    args.push(Val::read_value_from(values_vec.offset(i as isize), ty));
+                    args.push(Val::read_value_from(values_vec.add(i), ty));
                 }
             }
             let mut returns = vec![Val::null(); ty_clone.results().len()];
@@ -532,7 +532,7 @@ impl Func {
                 ptr::null_mut(),
                 self.trampoline,
                 self.export.address,
-                values_vec.as_mut_ptr() as *mut u8,
+                values_vec.as_mut_ptr(),
             )
         } {
             return Err(Trap::from_jit(error));

crates/api/src/trampoline/func.rs

@@ -23,15 +23,15 @@ use wasmtime_jit::{native, CodeMemory};
 use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody, VMTrampoline};
 
 struct TrampolineState {
-    func: Box<dyn Fn(*mut VMContext, *mut i128) -> Result<(), Trap>>,
+    func: Box<dyn Fn(*mut VMContext, *mut u128) -> Result<(), Trap>>,
     #[allow(dead_code)]
     code_memory: CodeMemory,
 }
 
 unsafe extern "C" fn stub_fn(
     vmctx: *mut VMContext,
     caller_vmctx: *mut VMContext,
-    values_vec: *mut i128,
+    values_vec: *mut u128,
 ) {
     // Here we are careful to use `catch_unwind` to ensure Rust panics don't
     // unwind past us. The primary reason for this is that Rust considers it UB
@@ -69,7 +69,7 @@ unsafe extern "C" fn stub_fn(
     unsafe fn call_stub(
         vmctx: *mut VMContext,
         caller_vmctx: *mut VMContext,
-        values_vec: *mut i128,
+        values_vec: *mut u128,
     ) -> Result<(), Trap> {
         let instance = InstanceHandle::from_vmctx(vmctx);
         let state = &instance
@@ -201,7 +201,7 @@ fn make_trampoline(
 
 pub fn create_handle_with_function(
     ft: &FuncType,
-    func: Box<dyn Fn(*mut VMContext, *mut i128) -> Result<(), Trap>>,
+    func: Box<dyn Fn(*mut VMContext, *mut u128) -> Result<(), Trap>>,
     store: &Store,
 ) -> Result<(InstanceHandle, VMTrampoline)> {
     let isa = {

crates/api/src/trampoline/mod.rs

@@ -17,7 +17,7 @@ use wasmtime_runtime::{VMContext, VMFunctionBody, VMTrampoline};
 
 pub fn generate_func_export(
     ft: &FuncType,
-    func: Box<dyn Fn(*mut VMContext, *mut i128) -> Result<(), Trap>>,
+    func: Box<dyn Fn(*mut VMContext, *mut u128) -> Result<(), Trap>>,
     store: &Store,
 ) -> Result<(
     wasmtime_runtime::InstanceHandle,

crates/api/src/values.rs

@@ -80,7 +80,7 @@ impl Val {
         }
     }
 
-    pub(crate) unsafe fn write_value_to(&self, p: *mut i128) {
+    pub(crate) unsafe fn write_value_to(&self, p: *mut u128) {
         match self {
             Val::I32(i) => ptr::write(p as *mut i32, *i),
             Val::I64(i) => ptr::write(p as *mut i64, *i),
@@ -91,7 +91,7 @@ impl Val {
         }
     }
 
-    pub(crate) unsafe fn read_value_from(p: *const i128, ty: &ValType) -> Val {
+    pub(crate) unsafe fn read_value_from(p: *const u128, ty: &ValType) -> Val {
         match ty {
             ValType::I32 => Val::I32(ptr::read(p as *const i32)),
             ValType::I64 => Val::I64(ptr::read(p as *const i64)),

crates/runtime/src/traphandlers.rs

@@ -9,7 +9,6 @@ use std::any::Any;
 use std::cell::Cell;
 use std::error::Error;
 use std::fmt;
-use std::mem;
 use std::ptr;
 use wasmtime_environ::ir;
 
@@ -172,13 +171,10 @@ pub unsafe fn wasmtime_call_trampoline(
     caller_vmctx: *mut VMContext,
     trampoline: VMTrampoline,
     callee: *const VMFunctionBody,
-    values_vec: *mut u8,
+    values_vec: *mut u128,
 ) -> Result<(), Trap> {
     catch_traps(vmctx, || {
-        mem::transmute::<
-            _,
-            extern "C" fn(*mut VMContext, *mut VMContext, *const VMFunctionBody, *mut u8),
-        >(trampoline)(vmctx, caller_vmctx, callee, values_vec)
+        trampoline(vmctx, caller_vmctx, callee, values_vec)
     })
 }