build: update unsafe blocks to new 2024 requirements

Author: m4b

src/elf/dynamic.rs

@@ -540,30 +540,30 @@ macro_rules! elf_dyn_std_impl {
             }
 
             /// Given a bias and a memory address (typically for a _correctly_ mmap'd binary in memory), returns the `_DYNAMIC` array as a slice of that memory
-            pub unsafe fn from_raw<'a>(bias: usize, vaddr: usize) -> &'a [Dyn] {
+            pub unsafe fn from_raw<'a>(bias: usize, vaddr: usize) -> &'a [Dyn] { unsafe {
                 let dynp = vaddr.wrapping_add(bias) as *const Dyn;
                 let mut idx = 0;
                 while u64::from((*dynp.offset(idx)).d_tag) != DT_NULL {
                     idx += 1;
                 }
                 slice::from_raw_parts(dynp, idx as usize)
-            }
+            }}
 
             // TODO: these bare functions have always seemed awkward, but not sure where they should go...
             /// Maybe gets and returns the dynamic array with the same lifetime as the `phdrs`, using the provided bias with wrapping addition.
             /// If the bias is wrong, it will either segfault or give you incorrect values, beware
-            pub unsafe fn from_phdrs(bias: usize, phdrs: &[$phdr]) -> Option<&[Dyn]> {
+            pub unsafe fn from_phdrs(bias: usize, phdrs: &[$phdr]) -> Option<&[Dyn]> { unsafe {
                 for phdr in phdrs {
                     // FIXME: change to casting to u64 similar to DT_*?
                     if phdr.p_type as u32 == PT_DYNAMIC {
                         return Some(from_raw(bias, phdr.p_vaddr as usize));
                     }
                 }
                 None
-            }
+            }}
 
             /// Gets the needed libraries from the `_DYNAMIC` array, with the str slices lifetime tied to the dynamic array/strtab's lifetime(s)
-            pub unsafe fn get_needed<'a>(dyns: &[Dyn], strtab: *const Strtab<'a>, count: usize) -> Vec<&'a str> {
+            pub unsafe fn get_needed<'a>(dyns: &[Dyn], strtab: *const Strtab<'a>, count: usize) -> Vec<&'a str> { unsafe {
                 let mut needed = Vec::with_capacity(count.min(dyns.len()));
                 for dynamic in dyns {
                     if u64::from(dynamic.d_tag) == DT_NEEDED {
@@ -572,7 +572,7 @@ macro_rules! elf_dyn_std_impl {
                     }
                 }
                 needed
-            }
+            }}
         }
     };
 }

src/elf/gnu_hash.rs

@@ -97,7 +97,7 @@ macro_rules! elf_gnu_hash_impl {
             pub unsafe fn from_raw_table(
                 hashtab: &'a [u8],
                 dynsyms: &'a [Sym],
-            ) -> Result<Self, &'static str> {
+            ) -> Result<Self, &'static str> { unsafe {
                 if hashtab.as_ptr() as usize % INT_SIZE != 0 {
                     return Err("hashtab is not aligned with 64-bit");
                 }
@@ -151,7 +151,7 @@ macro_rules! elf_gnu_hash_impl {
                     chains,
                     dynsyms,
                 })
-            }
+            }}
 
             /// Locate the hash chain, and corresponding hash value element.
             #[cold]

src/elf/program_header.rs

@@ -341,9 +341,9 @@ macro_rules! elf_program_header_std_impl {
             pub unsafe fn from_raw_parts<'a>(
                 phdrp: *const ProgramHeader,
                 phnum: usize,
-            ) -> &'a [ProgramHeader] {
+            ) -> &'a [ProgramHeader] { unsafe {
                 slice::from_raw_parts(phdrp, phnum)
-            }
+            }}
 
             #[cfg(feature = "std")]
             pub fn from_fd(fd: &mut File, offset: u64, count: usize) -> Result<Vec<ProgramHeader>> {

src/elf/reloc.rs

@@ -188,19 +188,19 @@ macro_rules! elf_rela_std_impl {
             /// 1. `ptr` points to memory received from the kernel (i.e., it loaded the executable), _or_
             /// 2. The binary has already been mmapped (i.e., it's a `SharedObject`), and hence it's safe to return a slice of that memory.
             /// 3. Or if you obtained the pointer in some other lawful manner
-            pub unsafe fn from_raw_rela<'a>(ptr: *const Rela, size: usize) -> &'a [Rela] {
+            pub unsafe fn from_raw_rela<'a>(ptr: *const Rela, size: usize) -> &'a [Rela] { unsafe {
                 slice::from_raw_parts(ptr, size / SIZEOF_RELA)
-            }
+            }}
 
             /// Gets the rel entries given a rel pointer and the _size_ of the rel section in the binary,
             /// in bytes.
             /// Assumes the pointer is valid and can safely return a slice of memory pointing to the rels because:
             /// 1. `ptr` points to memory received from the kernel (i.e., it loaded the executable), _or_
             /// 2. The binary has already been mmapped (i.e., it's a `SharedObject`), and hence it's safe to return a slice of that memory.
             /// 3. Or if you obtained the pointer in some other lawful manner
-            pub unsafe fn from_raw_rel<'a>(ptr: *const Rel, size: usize) -> &'a [Rel] {
+            pub unsafe fn from_raw_rel<'a>(ptr: *const Rel, size: usize) -> &'a [Rel] { unsafe {
                 slice::from_raw_parts(ptr, size / SIZEOF_REL)
-            }
+            }}
 
             #[cfg(feature = "std")]
             pub fn from_fd(fd: &mut File, offset: usize, size: usize) -> Result<Vec<Rela>> {

src/elf/sym.rs

@@ -239,9 +239,9 @@ macro_rules! elf_sym_std_impl {
         ///
         /// This function creates a `Sym` slice directly from a raw pointer
         #[inline]
-        pub unsafe fn from_raw<'a>(symp: *const Sym, count: usize) -> &'a [Sym] {
+        pub unsafe fn from_raw<'a>(symp: *const Sym, count: usize) -> &'a [Sym] { unsafe {
             slice::from_raw_parts(symp, count)
-        }
+        }}
 
         if_std! {
             use crate::error::Result;

src/strtab.rs

@@ -154,9 +154,9 @@ impl<'a> Strtab<'a> {
     ///
     /// # Safety
     /// This function creates a `Strtab` directly from a raw pointer and size
-    pub unsafe fn from_raw(ptr: *const u8, len: usize, delim: u8) -> Strtab<'a> {
+    pub unsafe fn from_raw(ptr: *const u8, len: usize, delim: u8) -> Strtab<'a> { unsafe {
         Self::from_slice_unparsed(core::slice::from_raw_parts(ptr, len), 0, len, delim)
-    }
+    }}
     #[deprecated(since = "0.4.2", note = "Bad performance, use get_at() instead")]
     #[cfg(feature = "alloc")]
     /// Parses a str reference from the parsed table starting at byte `offset`.