Remove return value from wmemcheck libcalls (#9676)

This isn't used in the compiled code so don't bake it in.

Author: alexcrichton

crates/environ/src/builtin.rs

@@ -43,16 +43,16 @@ macro_rules! foreach_builtin_function {
             new_epoch(vmctx: vmctx) -> i64;
             // Invoked before malloc returns.
             #[cfg(feature = "wmemcheck")]
-            check_malloc(vmctx: vmctx, addr: i32, len: i32) -> i32;
+            check_malloc(vmctx: vmctx, addr: i32, len: i32);
             // Invoked before the free returns.
             #[cfg(feature = "wmemcheck")]
-            check_free(vmctx: vmctx, addr: i32) -> i32;
+            check_free(vmctx: vmctx, addr: i32);
             // Invoked before a load is executed.
             #[cfg(feature = "wmemcheck")]
-            check_load(vmctx: vmctx, num_bytes: i32, addr: i32, offset: i32) -> i32;
+            check_load(vmctx: vmctx, num_bytes: i32, addr: i32, offset: i32);
             // Invoked before a store is executed.
             #[cfg(feature = "wmemcheck")]
-            check_store(vmctx: vmctx, num_bytes: i32, addr: i32, offset: i32) -> i32;
+            check_store(vmctx: vmctx, num_bytes: i32, addr: i32, offset: i32);
             // Invoked after malloc is called.
             #[cfg(feature = "wmemcheck")]
             malloc_start(vmctx: vmctx);

crates/wasmtime/src/runtime/vm/libcalls.rs

@@ -1110,14 +1110,12 @@ unsafe fn check_malloc(
     instance: &mut Instance,
     addr: u32,
     len: u32,
-) -> Result<u32> {
+) -> Result<()> {
     if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
         let result = wmemcheck_state.malloc(addr as usize, len as usize);
         wmemcheck_state.memcheck_on();
         match result {
-            Ok(()) => {
-                return Ok(0);
-            }
+            Ok(()) => {}
             Err(DoubleMalloc { addr, len }) => {
                 bail!("Double malloc at addr {:#x} of size {}", addr, len)
             }
@@ -1129,19 +1127,17 @@ unsafe fn check_malloc(
             }
         }
     }
-    Ok(0)
+    Ok(())
 }
 
 // Hook for validating free using wmemcheck_state.
 #[cfg(feature = "wmemcheck")]
-unsafe fn check_free(_store: &mut dyn VMStore, instance: &mut Instance, addr: u32) -> Result<u32> {
+unsafe fn check_free(_store: &mut dyn VMStore, instance: &mut Instance, addr: u32) -> Result<()> {
     if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
         let result = wmemcheck_state.free(addr as usize);
         wmemcheck_state.memcheck_on();
         match result {
-            Ok(()) => {
-                return Ok(0);
-            }
+            Ok(()) => {}
             Err(InvalidFree { addr }) => {
                 bail!("Invalid free at addr {:#x}", addr)
             }
@@ -1150,7 +1146,7 @@ unsafe fn check_free(_store: &mut dyn VMStore, instance: &mut Instance, addr: u3
             }
         }
     }
-    Ok(0)
+    Ok(())
 }
 
 // Hook for validating load using wmemcheck_state.
@@ -1161,13 +1157,11 @@ fn check_load(
     num_bytes: u32,
     addr: u32,
     offset: u32,
-) -> Result<u32> {
+) -> Result<()> {
     if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
         let result = wmemcheck_state.read(addr as usize + offset as usize, num_bytes as usize);
         match result {
-            Ok(()) => {
-                return Ok(0);
-            }
+            Ok(()) => {}
             Err(InvalidRead { addr, len }) => {
                 bail!("Invalid load at addr {:#x} of size {}", addr, len);
             }
@@ -1179,7 +1173,7 @@ fn check_load(
             }
         }
     }
-    Ok(0)
+    Ok(())
 }
 
 // Hook for validating store using wmemcheck_state.
@@ -1190,13 +1184,11 @@ fn check_store(
     num_bytes: u32,
     addr: u32,
     offset: u32,
-) -> Result<u32> {
+) -> Result<()> {
     if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
         let result = wmemcheck_state.write(addr as usize + offset as usize, num_bytes as usize);
         match result {
-            Ok(()) => {
-                return Ok(0);
-            }
+            Ok(()) => {}
             Err(InvalidWrite { addr, len }) => {
                 bail!("Invalid store at addr {:#x} of size {}", addr, len)
             }
@@ -1208,7 +1200,7 @@ fn check_store(
             }
         }
     }
-    Ok(0)
+    Ok(())
 }
 
 // Hook for turning wmemcheck load/store validation off when entering a malloc function.