Adds deny(clippy::ptr_as_ptr).

src/elf.rs

@@ -1219,7 +1219,7 @@ mod test {
 
         let write_header = |header: Elf64Ehdr| unsafe {
             let mut bytes = elf_bytes.clone();
-            std::ptr::write(bytes.as_mut_ptr() as *mut Elf64Ehdr, header);
+            std::ptr::write(bytes.as_mut_ptr().cast::<Elf64Ehdr>(), header);
             bytes
         };
 
@@ -1322,7 +1322,7 @@ mod test {
 
         let write_header = |header: Elf64Ehdr| unsafe {
             let mut bytes = elf_bytes.clone();
-            std::ptr::write(bytes.as_mut_ptr() as *mut Elf64Ehdr, header);
+            std::ptr::write(bytes.as_mut_ptr().cast::<Elf64Ehdr>(), header);
             bytes
         };
 

src/error.rs

@@ -145,7 +145,7 @@ impl<T: std::fmt::Debug, E: std::fmt::Debug> StableResult<T, E> {
         allow(dead_code)
     )]
     pub(crate) fn discriminant(&self) -> u64 {
-        unsafe { *(self as *const _ as *const u64) }
+        unsafe { *std::ptr::addr_of!(*self).cast::<u64>() }
     }
 }
 

src/jit.rs

@@ -47,7 +47,7 @@ impl JitProgram {
             let raw = allocate_pages(pc_loc_table_size + over_allocated_code_size)?;
             Ok(Self {
                 page_size,
-                pc_section: std::slice::from_raw_parts_mut(raw as *mut usize, pc),
+                pc_section: std::slice::from_raw_parts_mut(raw.cast::<usize>(), pc),
                 text_section: std::slice::from_raw_parts_mut(
                     raw.add(pc_loc_table_size),
                     over_allocated_code_size,
@@ -80,7 +80,7 @@ impl JitProgram {
             self.text_section =
                 std::slice::from_raw_parts_mut(raw.add(pc_loc_table_size), text_section_usage);
             protect_pages(
-                self.pc_section.as_mut_ptr() as *mut u8,
+                self.pc_section.as_mut_ptr().cast::<u8>(),
                 pc_loc_table_size,
                 false,
             )?;
@@ -119,7 +119,7 @@ impl JitProgram {
                 "pop rbp",
                 "pop rbx",
                 host_stack_pointer = in(reg) &mut vm.host_stack_pointer,
-                inlateout("rdi") (vm as *mut _ as *mut u64).offset(get_runtime_environment_key() as isize) => _,
+                inlateout("rdi") std::ptr::addr_of_mut!(*vm).cast::<u64>().offset(get_runtime_environment_key() as isize) => _,
                 inlateout("rax") (vm.previous_instruction_meter as i64).wrapping_add(registers[11] as i64) => _,
                 inlateout("r10") self.pc_section[registers[11] as usize] => _,
                 inlateout("r11") &registers => _,
@@ -1269,7 +1269,7 @@ impl<'a, C: ContextObject> JitCompiler<'a, C> {
     }
 
     fn emit_set_exception_kind(&mut self, err: EbpfError) {
-        let err_kind = unsafe { *(&err as *const _ as *const u64) };
+        let err_kind = unsafe { *std::ptr::addr_of!(err).cast::<u64>() };
         let err_discriminant = ProgramResult::Err(err).discriminant();
         self.emit_ins(X86Instruction::lea(OperandSize::S64, REGISTER_PTR_TO_VM, REGISTER_OTHER_SCRATCH, Some(X86IndirectAccess::Offset(self.slot_in_vm(RuntimeEnvironmentSlot::ProgramResult)))));
         self.emit_ins(X86Instruction::store_immediate(OperandSize::S64, REGISTER_OTHER_SCRATCH, X86IndirectAccess::Offset(0), err_discriminant as i64)); // result.discriminant = err_discriminant;
@@ -1615,8 +1615,9 @@ mod tests {
             ($env:expr, $entry:ident, $slot:ident) => {
                 assert_eq!(
                     unsafe {
-                        (&$env.$entry as *const _ as *const u64)
-                            .offset_from(&$env as *const _ as *const u64) as usize
+                        std::ptr::addr_of!($env.$entry)
+                            .cast::<u64>()
+                            .offset_from(std::ptr::addr_of!($env).cast::<u64>()) as usize
                     },
                     RuntimeEnvironmentSlot::$slot as usize,
                 );

src/lib.rs

@@ -16,6 +16,7 @@
     html_favicon_url = "https://raw.githubusercontent.com/qmonnet/rbpf/master/misc/rbpf.ico"
 )]
 #![deny(clippy::arithmetic_side_effects)]
+#![deny(clippy::ptr_as_ptr)]
 
 extern crate byteorder;
 extern crate combine;

src/memory_management.rs

@@ -113,16 +113,16 @@ pub unsafe fn allocate_pages(size_in_bytes: usize) -> Result<*mut u8, EbpfError>
         winnt::MEM_RESERVE | winnt::MEM_COMMIT,
         winnt::PAGE_READWRITE,
     );
-    Ok(raw as *mut u8)
+    Ok(raw.cast::<u8>())
 }
 
 pub unsafe fn free_pages(raw: *mut u8, size_in_bytes: usize) -> Result<(), EbpfError> {
     #[cfg(not(target_os = "windows"))]
-    libc_error_guard!(munmap, raw as *mut _, size_in_bytes);
+    libc_error_guard!(munmap, raw.cast::<c_void>(), size_in_bytes);
     #[cfg(target_os = "windows")]
     winapi_error_guard!(
         VirtualFree,
-        raw as *mut _,
+        raw.cast::<c_void>(),
         size_in_bytes,
         winnt::MEM_RELEASE, // winnt::MEM_DECOMMIT
     );
@@ -138,7 +138,7 @@ pub unsafe fn protect_pages(
     {
         libc_error_guard!(
             mprotect,
-            raw as *mut _,
+            raw.cast::<c_void>(),
             size_in_bytes,
             if executable_flag {
                 libc::PROT_EXEC | libc::PROT_READ
@@ -153,7 +153,7 @@ pub unsafe fn protect_pages(
         let ptr_old: *mut minwindef::DWORD = &mut old;
         winapi_error_guard!(
             VirtualProtect,
-            raw as *mut _,
+            raw.cast::<c_void>(),
             size_in_bytes,
             if executable_flag {
                 winnt::PAGE_EXECUTE_READ

src/memory_region.rs

@@ -389,7 +389,7 @@ impl<'a> UnalignedMemoryMapping<'a> {
         let initial_len = len;
         let initial_vm_addr = vm_addr;
         let mut value = 0u64;
-        let mut ptr = &mut value as *mut _ as *mut u8;
+        let mut ptr = std::ptr::addr_of_mut!(value).cast::<u8>();
 
         while len > 0 {
             let load_len = len.min(region.vm_addr_end.saturating_sub(vm_addr));
@@ -440,7 +440,7 @@ impl<'a> UnalignedMemoryMapping<'a> {
         // guaranteed to be unique.
         let cache = unsafe { &mut *self.cache.get() };
 
-        let mut src = &value as *const _ as *const u8;
+        let mut src = std::ptr::addr_of!(value).cast::<u8>();
 
         let mut region = match self.find_region(cache, vm_addr) {
             Some(region) if ensure_writable_region(region, &self.cow_cb) => {

src/program.rs

@@ -324,7 +324,7 @@ macro_rules! declare_builtin_function {
             ) {
                 use $crate::vm::ContextObject;
                 let vm = unsafe {
-                    &mut *(($vm as *mut u64).offset(-($crate::vm::get_runtime_environment_key() as isize)) as *mut $crate::vm::EbpfVm<$ContextObject>)
+                    &mut *($vm.cast::<u64>().offset(-($crate::vm::get_runtime_environment_key() as isize)).cast::<$crate::vm::EbpfVm<$ContextObject>>())
                 };
                 let config = vm.loader.get_config();
                 if config.enable_instruction_meter {

src/vm.rs

@@ -426,8 +426,10 @@ impl<'a, C: ContextObject> EbpfVm<'a, C> {
     pub fn invoke_function(&mut self, function: BuiltinFunction<C>) {
         function(
             unsafe {
-                (self as *mut _ as *mut u64).offset(get_runtime_environment_key() as isize)
-                    as *mut _
+                std::ptr::addr_of_mut!(*self)
+                    .cast::<u64>()
+                    .offset(get_runtime_environment_key() as isize)
+                    .cast::<Self>()
             },
             self.registers[1],
             self.registers[2],