Miscellaneous code cleanups. (#92)

Author: sunfishcode

src/arch/arm.rs

@@ -31,7 +31,7 @@ pub(super) unsafe extern "C" fn _start() -> ! {
     // stack pointer. On many architectures, the incoming frame pointer is
     // already null.
     asm!(
-        "mov r0, sp\n", // Pass the incoming `sp` as the arg to `entry`.
+        "mov r0, sp",   // Pass the incoming `sp` as the arg to `entry`.
         "mov lr, #0",   // Set the return address to zero.
         "b {entry}",    // Jump to `entry`.
         entry = sym super::program::entry,

src/arch/x86.rs

@@ -66,7 +66,7 @@ pub(super) unsafe fn relocation_load(ptr: usize) -> usize {
     // happens outside the Rust memory model. As far as Rust knows, this is
     // just an arbitrary side-effecting opaque operation.
     asm!(
-        "mov {}, DWORD PTR [{}]",
+        "mov {}, [{}]",
         out(reg) r0,
         in(reg) ptr,
         options(nostack, preserves_flags),
@@ -92,7 +92,7 @@ pub(super) unsafe fn relocation_load(ptr: usize) -> usize {
 #[inline]
 pub(super) unsafe fn relocation_store(ptr: usize, value: usize) {
     asm!(
-        "mov DWORD PTR [{}], {}",
+        "mov [{}], {}",
         in(reg) ptr,
         in(reg) value,
         options(nostack, preserves_flags),
@@ -180,7 +180,7 @@ pub(super) unsafe fn clone(
         "push ebp",           // Save incoming register value.
 
         // Pass `fn_` to the child in ebp.
-        "mov ebp, DWORD PTR [eax+8]",
+        "mov ebp, [eax+8]",
 
         "mov esi, [eax+0]",   // Pass `newtls` to the `int 0x80`.
         "mov eax, [eax+4]",   // Pass `__NR_clone` to the `int 0x80`.
@@ -250,7 +250,7 @@ pub(super) unsafe fn set_thread_pointer(ptr: *mut c_void) {
 pub(super) fn thread_pointer() -> *mut c_void {
     let ptr;
     unsafe {
-        asm!("mov {}, DWORD PTR gs:0", out(reg) ptr, options(nostack, preserves_flags, readonly));
+        asm!("mov {}, gs:0", out(reg) ptr, options(nostack, preserves_flags, readonly));
     }
     ptr
 }

src/arch/x86_64.rs

@@ -62,7 +62,7 @@ pub(super) unsafe fn relocation_load(ptr: usize) -> usize {
     // happens outside the Rust memory model. As far as Rust knows, this is
     // just an arbitrary side-effecting opaque operation.
     asm!(
-        "mov {}, QWORD PTR [{}]",
+        "mov {}, [{}]",
         out(reg) r0,
         in(reg) ptr,
         options(nostack, preserves_flags),
@@ -88,7 +88,7 @@ pub(super) unsafe fn relocation_load(ptr: usize) -> usize {
 #[inline]
 pub(super) unsafe fn relocation_store(ptr: usize, value: usize) {
     asm!(
-        "mov QWORD PTR [{}], {}",
+        "mov [{}], {}",
         in(reg) ptr,
         in(reg) value,
         options(nostack, preserves_flags),
@@ -194,7 +194,7 @@ pub(super) unsafe fn set_thread_pointer(ptr: *mut c_void) {
 pub(super) fn thread_pointer() -> *mut c_void {
     let ptr;
     unsafe {
-        asm!("mov {}, QWORD PTR fs:0", out(reg) ptr, options(nostack, preserves_flags, readonly));
+        asm!("mov {}, fs:0", out(reg) ptr, options(nostack, preserves_flags, readonly));
     }
     ptr
 }

src/thread/libc.rs

@@ -3,6 +3,7 @@
 use alloc::boxed::Box;
 use core::any::Any;
 use core::ffi::c_void;
+use core::mem::zeroed;
 use core::ptr::{from_exposed_addr_mut, null_mut, NonNull};
 use rustix::io;
 
@@ -73,7 +74,7 @@ pub fn create_thread(
     }
 
     unsafe {
-        let mut attr: libc::pthread_attr_t = core::mem::zeroed();
+        let mut attr: libc::pthread_attr_t = zeroed();
         match libc::pthread_attr_init(&mut attr) {
             0 => (),
             err => return Err(io::Errno::from_raw_os_error(err)),
@@ -86,7 +87,7 @@ pub fn create_thread(
             0 => (),
             err => return Err(io::Errno::from_raw_os_error(err)),
         }
-        let mut new_thread = core::mem::zeroed();
+        let mut new_thread = zeroed();
         let arg = Box::into_raw(Box::new(fn_));
         match libc::pthread_create(&mut new_thread, &attr, start, arg.cast()) {
             0 => (),
@@ -171,7 +172,7 @@ pub fn current_thread_tls_addr(offset: usize) -> *mut c_void {
 pub unsafe fn thread_stack(thread: Thread) -> (*mut c_void, usize, usize) {
     let thread = thread.0;
 
-    let mut attr: libc::pthread_attr_t = core::mem::zeroed();
+    let mut attr: libc::pthread_attr_t = zeroed();
     assert_eq!(libc::pthread_getattr_np(thread, &mut attr), 0);
 
     let mut stack_size = 0;
@@ -221,7 +222,7 @@ pub unsafe fn join_thread(thread: Thread) {
 #[must_use]
 pub fn default_stack_size() -> usize {
     unsafe {
-        let mut attr: libc::pthread_attr_t = core::mem::zeroed();
+        let mut attr: libc::pthread_attr_t = zeroed();
         assert_eq!(libc::pthread_getattr_np(libc::pthread_self(), &mut attr), 0);
 
         let mut stack_size = 0;
@@ -236,7 +237,7 @@ pub fn default_stack_size() -> usize {
 #[must_use]
 pub fn default_guard_size() -> usize {
     unsafe {
-        let mut attr: libc::pthread_attr_t = core::mem::zeroed();
+        let mut attr: libc::pthread_attr_t = zeroed();
         assert_eq!(libc::pthread_getattr_np(libc::pthread_self(), &mut attr), 0);
 
         let mut guard_size = 0;

src/thread/linux_raw.rs

@@ -7,7 +7,7 @@ use core::any::Any;
 use core::cmp::max;
 use core::ffi::c_void;
 use core::mem::{align_of, size_of};
-use core::ptr::{self, drop_in_place, null, null_mut, NonNull};
+use core::ptr::{drop_in_place, null, null_mut, NonNull};
 use core::slice;
 use core::sync::atomic::Ordering::SeqCst;
 use core::sync::atomic::{AtomicI32, AtomicU8};
@@ -328,26 +328,23 @@ pub(super) unsafe fn initialize_main_thread(mem: *mut c_void) {
     let tid = rustix::runtime::set_tid_address(thread_id_ptr.cast());
 
     // Initialize the thread metadata.
-    ptr::write(
-        metadata,
-        Metadata {
-            abi: Abi {
-                #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-                this: newtls,
-                #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
-                dtv: null(),
-                #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
-                pad: [0_usize; 1],
-            },
-            thread: ThreadData::new(
-                Some(tid),
-                stack_least.cast(),
-                stack_size,
-                guard_size,
-                map_size,
-            ),
+    metadata.write(Metadata {
+        abi: Abi {
+            #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+            this: newtls,
+            #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
+            dtv: null(),
+            #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
+            pad: [0_usize; 1],
         },
-    );
+        thread: ThreadData::new(
+            Some(tid),
+            stack_least.cast(),
+            stack_size,
+            guard_size,
+            map_size,
+        ),
+    });
 
     // Initialize the TLS data with explicit initializer data.
     slice::from_raw_parts_mut(tls_data, STARTUP_TLS_INFO.file_size).copy_from_slice(
@@ -456,26 +453,23 @@ pub fn create_thread(
         let newtls: *mut Abi = &mut (*metadata).abi;
 
         // Initialize the thread metadata.
-        ptr::write(
-            metadata,
-            Metadata {
-                abi: Abi {
-                    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-                    this: newtls,
-                    #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
-                    dtv: null(),
-                    #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
-                    pad: [0_usize; 1],
-                },
-                thread: ThreadData::new(
-                    None, // the real tid will be written by `clone`.
-                    stack_least.cast(),
-                    stack_size,
-                    guard_size,
-                    map_size,
-                ),
+        metadata.write(Metadata {
+            abi: Abi {
+                #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+                this: newtls,
+                #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
+                dtv: null(),
+                #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
+                pad: [0_usize; 1],
             },
-        );
+            thread: ThreadData::new(
+                None, // the real tid will be written by `clone`.
+                stack_least.cast(),
+                stack_size,
+                guard_size,
+                map_size,
+            ),
+        });
 
         // Initialize the TLS data with explicit initializer data.
         slice::from_raw_parts_mut(tls_data, STARTUP_TLS_INFO.file_size).copy_from_slice(
@@ -576,17 +570,17 @@ pub(super) unsafe extern "C" fn entry(
         }
 
         // Check that the incoming stack pointer is where we expect it to be.
-        debug_assert_eq!(builtin_return_address(0), core::ptr::null());
-        debug_assert_ne!(builtin_frame_address(0), core::ptr::null());
+        debug_assert_eq!(builtin_return_address(0), null());
+        debug_assert_ne!(builtin_frame_address(0), null());
         #[cfg(not(any(target_arch = "x86", target_arch = "arm")))]
         debug_assert_eq!(builtin_frame_address(0).addr() & 0xf, 0);
         #[cfg(target_arch = "arm")]
         debug_assert_eq!(builtin_frame_address(0).addr() & 0x3, 0);
         #[cfg(target_arch = "x86")]
         debug_assert_eq!(builtin_frame_address(0).addr() & 0xf, 8);
-        debug_assert_eq!(builtin_frame_address(1), core::ptr::null());
+        debug_assert_eq!(builtin_frame_address(1), null());
         #[cfg(target_arch = "aarch64")]
-        debug_assert_ne!(builtin_sponentry(), core::ptr::null());
+        debug_assert_ne!(builtin_sponentry(), null());
         #[cfg(target_arch = "aarch64")]
         debug_assert_eq!(builtin_sponentry().addr() & 0xf, 0);
 
@@ -754,8 +748,8 @@ unsafe fn wait_for_thread_exit(thread: Thread) {
     // Check whether the thread has exited already; we set the
     // `CloneFlags::CHILD_CLEARTID` flag on the clone syscall, so we can test
     // for `NONE` here.
-    let thread = thread.0.as_ref();
-    let thread_id = &thread.thread_id;
+    let thread_data = thread.0.as_ref();
+    let thread_id = &thread_data.thread_id;
     while let Some(id_value) = ThreadId::from_raw(thread_id.load(SeqCst)) {
         // This doesn't use any shared memory, but we can't use
         // `FutexFlags::PRIVATE` because the wake comes from Linux