Use ptr::cast instead of as casts in several places. (#3507)

`ptr::cast` has the advantage of being unable to silently cast
`*const T` to `*mut T`. This turned up several places that were
performing such casts, which this PR also fixes.

crates/jit/src/code_memory.rs

@@ -200,11 +200,7 @@ unsafe fn register_unwind_info(obj: &File, text: &[u8]) -> Result<Option<UnwindR
         return Ok(None);
     }
     Ok(Some(
-        UnwindRegistration::new(
-            text.as_ptr() as *mut _,
-            unwind_info.as_ptr() as *mut _,
-            unwind_info.len(),
-        )
-        .context("failed to create unwind info registration")?,
+        UnwindRegistration::new(text.as_ptr(), unwind_info.as_ptr(), unwind_info.len())
+            .context("failed to create unwind info registration")?,
     ))
 }

crates/jit/src/instantiate.rs

@@ -387,16 +387,13 @@ impl CompiledModule {
     #[inline]
     pub fn finished_functions(
         &self,
-    ) -> impl ExactSizeIterator<Item = (DefinedFuncIndex, *mut [VMFunctionBody])> + '_ {
+    ) -> impl ExactSizeIterator<Item = (DefinedFuncIndex, *const [VMFunctionBody])> + '_ {
         let code = self.code();
         self.funcs.iter().map(move |(i, info)| {
             let func = &code[info.start as usize..][..info.length as usize];
             (
                 i,
-                std::ptr::slice_from_raw_parts_mut(
-                    func.as_ptr() as *mut VMFunctionBody,
-                    func.len(),
-                ),
+                std::ptr::slice_from_raw_parts(func.as_ptr().cast::<VMFunctionBody>(), func.len()),
             )
         })
     }
@@ -423,7 +420,7 @@ impl CompiledModule {
     /// memory with the stack maps associated with those bytes.
     pub fn stack_maps(
         &self,
-    ) -> impl Iterator<Item = (*mut [VMFunctionBody], &[StackMapInformation])> {
+    ) -> impl Iterator<Item = (*const [VMFunctionBody], &[StackMapInformation])> {
         self.finished_functions()
             .map(|(_, f)| f)
             .zip(self.funcs.values().map(|f| f.stack_maps.as_slice()))

crates/jit/src/profiling/jitdump_linux.rs

@@ -292,7 +292,7 @@ impl State {
         let tid = pid; // ThreadId does appear to track underlying thread. Using PID.
 
         for (idx, func) in module.finished_functions() {
-            let (addr, len) = unsafe { ((*func).as_ptr() as *const u8, (*func).len()) };
+            let (addr, len) = unsafe { ((*func).as_ptr().cast::<u8>(), (*func).len()) };
             if let Some(img) = &dbg_image {
                 if let Err(err) = self.dump_from_debug_image(img, "wasm", addr, len, pid, tid) {
                     println!(

crates/jit/src/profiling/vtune_linux.rs

@@ -130,7 +130,7 @@ impl State {
             .unwrap_or_else(|| format!("wasm_module_{}", global_module_id));
 
         for (idx, func) in module.finished_functions() {
-            let (addr, len) = unsafe { ((*func).as_ptr() as *const u8, (*func).len()) };
+            let (addr, len) = unsafe { ((*func).as_ptr().cast::<u8>(), (*func).len()) };
             let method_name = super::debug_name(module.module(), idx);
             let method_id = self.get_method_id();
             log::trace!(

crates/jit/src/unwind/systemv.rs

@@ -21,8 +21,8 @@ impl UnwindRegistration {
     /// describe an in-memory representation of a `.eh_frame` section. This is
     /// typically arranged for by the `wasmtime-obj` crate.
     pub unsafe fn new(
-        _base_address: *mut u8,
-        unwind_info: *mut u8,
+        _base_address: *const u8,
+        unwind_info: *const u8,
         unwind_len: usize,
     ) -> Result<UnwindRegistration> {
         debug_assert_eq!(

crates/jit/src/unwind/winx64.rs

@@ -11,8 +11,8 @@ pub struct UnwindRegistration {
 
 impl UnwindRegistration {
     pub unsafe fn new(
-        base_address: *mut u8,
-        unwind_info: *mut u8,
+        base_address: *const u8,
+        unwind_info: *const u8,
         unwind_len: usize,
     ) -> Result<UnwindRegistration> {
         assert!(unwind_info as usize % 4 == 0);