fix clippy lints

Author: Mic92

src/arch.rs

@@ -141,7 +141,7 @@ cfg_match! {
         pub const ENTRY_TRAMPOLINE: Option<unsafe extern "C" fn() -> !> = Some(entry_trampoline);
 
         #[naked]
-        unsafe extern "C" fn entry_trampoline() -> ! {
+        unsafe extern "C" fn entry_trampoline() -> ! { unsafe {
             core::arch::naked_asm!(
                 "lea r10, [rip + {context}]",
                 "mov r11, [r10 + {size} * 1]", // .env_entry
@@ -154,7 +154,7 @@ cfg_match! {
                 context = sym TRAMPOLINE_CONTEXT,
                 size = const core::mem::size_of::<*const u8>(),
             )
-        }
+        }}
     }
     target_arch = "aarch64" => {
         pub const ENTRY_TRAMPOLINE: Option<unsafe extern "C" fn() -> !> = Some(entry_trampoline);

src/args.rs

@@ -84,16 +84,18 @@ impl CStrExt for CStr {
 
 impl Args {
     pub unsafe fn new(argc: usize, argv: *const *const u8, envp: *const *const u8) -> Self {
-        let (envc, auxv) = count_env(envp);
-
-        Self {
-            env_iterated: false,
-            argc,
-            argv,
-            envp,
-            envc,
-            auxv: AuxVec::from_raw(auxv),
-            extra_env: None,
+        unsafe {
+            let (envc, auxv) = count_env(envp);
+
+            Self {
+                env_iterated: false,
+                argc,
+                argv,
+                envp,
+                envc,
+                auxv: AuxVec::from_raw(auxv),
+                extra_env: None,
+            }
         }
     }
 
@@ -390,11 +392,13 @@ impl<'a> StackShifter<'a> {
 }
 
 unsafe fn count_env(envp: *const *const u8) -> (usize, *const usize) {
-    let mut envc = 0;
-    let mut cur = envp;
-    while !(*cur).is_null() {
-        cur = cur.add(1);
-        envc += 1;
+    unsafe {
+        let mut envc = 0;
+        let mut cur = envp;
+        while !(*cur).is_null() {
+            cur = cur.add(1);
+            envc += 1;
+        }
+        (envc, cur.add(1) as *const usize)
     }
-    (envc, cur.add(1) as *const usize)
 }

src/elf.rs

@@ -1,16 +1,16 @@
 //! ELF wrangling.
 
-use core::ffi::{c_void, CStr};
+use core::ffi::{CStr, c_void};
 use core::fmt;
 use core::mem;
 use core::ptr;
 
 pub use crate::arch::elf_types;
 use crate::arch::elf_types::{
-    header::{Header, ET_DYN},
-    program_header::{ProgramHeader, PF_R, PF_W, PF_X, PT_LOAD},
+    header::{ET_DYN, Header},
+    program_header::{PF_R, PF_W, PF_X, PT_LOAD, ProgramHeader},
 };
-use crate::arch::{elf_jmp, EM_SELF};
+use crate::arch::{EM_SELF, elf_jmp};
 #[rustfmt::skip]
 use crate::sys::{
     self, errno, Error as IoError, File, Read,
@@ -302,7 +302,9 @@ impl ElfMapping {
 
     /// Jumps to the entry point with a stack.
     pub unsafe fn jump_with_sp(self, sp: *const c_void) -> ! {
-        elf_jmp!(sp, self.entry_point);
+        unsafe {
+            elf_jmp!(sp, self.entry_point);
+        }
     }
 }
 

src/fixup.rs

@@ -9,11 +9,10 @@ use core::slice;
 use crate::arch::R_RELATIVE;
 use crate::auxv::AuxVec;
 use crate::elf::{
-    elf_types,
+    ProgramHeaders, elf_types,
     elf_types::dynamic::{DT_NULL, DT_REL, DT_RELA, DT_RELAENT, DT_RELASZ, DT_RELENT, DT_RELSZ},
     elf_types::header::Header,
     elf_types::program_header::PT_DYNAMIC,
-    ProgramHeaders,
 };
 use crate::support::explode;
 
@@ -119,54 +118,61 @@ impl Dynamic {
 }
 
 pub unsafe fn fixup_relocs(envp: *const *const u8) {
-    // Reference: <https://gist.github.com/Amanieu/588e3f9d330019c5d39f3ce60e8e0aae>
-    let auxv = find_auxv(envp);
-    let auxv = AuxVec::from_raw(auxv);
-
-    let at_base = auxv.at_base.as_ref().map_or_else(ptr::null, |v| v.value());
-    let (load_offset, phs) = if at_base.is_null() {
-        // We were executed directly
-        if let (Some(phdr), Some(phent), Some(phnum)) =
-            (&auxv.at_phdr, &auxv.at_phent, &auxv.at_phnum)
-        {
-            if phdr.value().is_null() {
-                explode("AT_PHDR is null");
+    unsafe {
+        // Reference: <https://gist.github.com/Amanieu/588e3f9d330019c5d39f3ce60e8e0aae>
+        let auxv = find_auxv(envp);
+        let auxv = AuxVec::from_raw(auxv);
+
+        let at_base = auxv.at_base.as_ref().map_or_else(ptr::null, |v| v.value());
+        let (load_offset, phs) = if at_base.is_null() {
+            // We were executed directly
+            if let (Some(phdr), Some(phent), Some(phnum)) =
+                (&auxv.at_phdr, &auxv.at_phent, &auxv.at_phnum)
+            {
+                if phdr.value().is_null() {
+                    explode("AT_PHDR is null");
+                }
+                let phs = ProgramHeaders::from_raw(phdr.value(), phent.value(), phnum.value());
+                let load_offset = phdr.value() as usize - mem::size_of::<Header>();
+                (load_offset, phs)
+            } else {
+                explode("AT_PHDR, AT_PHENT, AT_PHNUM must exist");
             }
-            let phs = ProgramHeaders::from_raw(phdr.value(), phent.value(), phnum.value());
-            let load_offset = phdr.value() as usize - mem::size_of::<Header>();
-            (load_offset, phs)
         } else {
-            explode("AT_PHDR, AT_PHENT, AT_PHNUM must exist");
-        }
-    } else {
-        // We are the loader
-        let ehdr: *const Header = at_base.cast();
-        let header: &Header = unsafe { &*ehdr };
+            // We are the loader
+            let ehdr: *const Header = at_base.cast();
+            let header: &Header = &*ehdr;
 
-        if &header.e_ident[..4] != b"\x7fELF".as_slice() {
-            explode("We are not an ELF ourselves");
-        }
+            if &header.e_ident[..4] != b"\x7fELF".as_slice() {
+                explode("We are not an ELF ourselves");
+            }
 
-        let phdr = unsafe { ehdr.add(1).cast() };
+            let phdr = ehdr.add(1).cast();
 
-        let phs =
-            ProgramHeaders::from_raw(phdr, header.e_phentsize as usize, header.e_phnum as usize);
-        (at_base as usize, phs)
-    };
+            let phs = ProgramHeaders::from_raw(
+                phdr,
+                header.e_phentsize as usize,
+                header.e_phnum as usize,
+            );
+            (at_base as usize, phs)
+        };
 
-    let dynamic = if let Some(dynamic) = Dynamic::from_program_headers(&phs, load_offset) {
-        dynamic
-    } else {
-        explode("No dynamic section in own executable");
-    };
+        let dynamic = if let Some(dynamic) = Dynamic::from_program_headers(&phs, load_offset) {
+            dynamic
+        } else {
+            explode("No dynamic section in own executable");
+        };
 
-    dynamic.fixup();
+        dynamic.fixup();
+    }
 }
 
 unsafe fn find_auxv(envp: *const *const u8) -> *const usize {
-    let mut cur = envp;
-    while !(*cur).is_null() {
-        cur = cur.add(1);
+    unsafe {
+        let mut cur = envp;
+        while !(*cur).is_null() {
+            cur = cur.add(1);
+        }
+        cur.add(1) as *const usize
     }
-    cur.add(1) as *const usize
 }

src/main.rs

@@ -13,7 +13,7 @@ mod fixup;
 mod support;
 mod sys;
 
-use core::ffi::{c_void, CStr};
+use core::ffi::{CStr, c_void};
 use core::mem::MaybeUninit;
 use core::ptr;
 
@@ -49,11 +49,13 @@ struct Context {
 
 #[unsafe(no_mangle)]
 unsafe extern "C" fn main(argc: usize, argv: *const *const u8, envp: *const *const u8) -> ! {
-    fixup::fixup_relocs(envp);
+    unsafe {
+        fixup::fixup_relocs(envp);
 
-    ARGS.write(Args::new(argc, argv, envp));
-    let stack = STACK.assume_init_mut().bottom();
-    arch::main_relocate_stack!(stack, real_main);
+        ARGS.write(Args::new(argc, argv, envp));
+        let stack = STACK.assume_init_mut().bottom();
+        arch::main_relocate_stack!(stack, real_main);
+    }
 }
 
 #[unsafe(no_mangle)]

src/sys.rs

@@ -9,7 +9,7 @@
 //! This dependency may be reduced further. For memory operations,
 //! compiler-builtins provides faster implementations.
 
-use core::ffi::{c_char, c_int, c_void, CStr};
+use core::ffi::{CStr, c_char, c_int, c_void};
 use core::fmt;
 use core::ptr;
 use core::slice;
@@ -182,5 +182,4 @@ pub fn new_slice_leak(size: usize) -> Option<&'static mut [u8]> {
 #[cfg(not(test))]
 #[lang = "eh_personality"]
 #[unsafe(no_mangle)]
-pub extern "C" fn rust_eh_personality() {
-}
+pub extern "C" fn rust_eh_personality() {}