Minor cleanups. (#144)

Author: sunfishcode

Cargo.toml

@@ -28,7 +28,7 @@ smallvec = { version = "1.11.1", optional = true, features = ["const_new"] }
 # before `origin_main` is called.
 
 # Enable `env_logger`; eg. recognizing `RUST_LOG=trace`. This requires `std`.
-env_logger = { version = "0.11.0", optional = true, default-features = false }
+env_logger = { version = "0.11.0", default-features = false, optional = true }
 
 # Enable `atomic-dbg`'s simple logger. This doesn't require `std`.
 atomic-dbg = { version = "0.1", default-features = false, optional = true }
@@ -168,7 +168,10 @@ panic-handler = ["unwinding?/panic-handler"]
 # if you know your program will never panic and don't want any extra code.
 panic-handler-abort = ["unwinding?/panic-handler-dummy"]
 
-# Enable this to define the `getauxval` function.
+# Enable this to define a C ABI-compatible `getauxval` function. Most Rust code
+# should use functions in [`rustix::param`] instead.
+#
+# [`rustix::param`]: https://docs.rs/rustix/latest/rustix/param/index.html
 getauxval = ["rustix/param"]
 
 # Enable features which depend on Rust's std.

src/mem/fast.rs

@@ -1,3 +1,5 @@
+//! `memcpy` etc. implementations with performance optimizations.
+//!
 //! The following is derived from src/mem/mod.rs in Rust's
 //! [compiler_builtins library] at revision
 //! cb060052ab7e4bad408c85d44be7e60096e93e38.

src/mem/small.rs

@@ -1,3 +1,8 @@
+//! `memcpy` etc. implementations with small code size.
+//!
+//! This code uses `core::arch::asm!("")` to try to discourage optimizers from
+//! vectorizing or pattern-matching these loops.
+
 #[cfg(not(feature = "nightly"))]
 use crate::ptr::Polyfill as _;
 use core::ffi::{c_char, c_int, c_void};

src/program/linux_raw.rs

@@ -119,10 +119,10 @@ pub(super) unsafe extern "C" fn entry(mem: *mut usize) -> ! {
             static __init_array_end: c_void;
         }
 
-        // Call the `.init_array` functions. As GLIBC does, pass argc, argv,
-        // and envp as extra arguments. In addition to GLIBC ABI compatibility,
+        // Call the `.init_array` functions. As glibc does, pass argc, argv,
+        // and envp as extra arguments. In addition to glibc ABI compatibility,
         // c-scape relies on this.
-        type InitFn = extern "C" fn(c_int, *mut *mut u8, *mut *mut u8);
+        type InitFn = unsafe extern "C" fn(c_int, *mut *mut u8, *mut *mut u8);
         let mut init = core::ptr::addr_of!(__init_array_start).cast::<InitFn>();
         let init_end = core::ptr::addr_of!(__init_array_end).cast::<InitFn>();
         // Prevent the optimizer from optimizing the `!=` comparison to true;

src/relocate.rs

@@ -76,7 +76,7 @@ macro_rules! debug_assert_eq {
 /// In practice, things work if we don't make any calls to functions outside
 /// of this crate, not counting functions directly implemented by the compiler.
 /// So we can do eg. `x == null()` but we can't do `x.is_null()`, because
-/// `null` is directly implemented by the compiler, while `is_null` is not.
+/// `null` is directly implemented by the compiler, while `is_null` is not 🙃.
 ///
 /// We do all the relocation memory accesses using `asm`, as they happen
 /// outside the Rust memory model. They read and write and `mprotect` memory

src/thread/libc.rs

@@ -109,6 +109,8 @@ pub unsafe fn create(
     stack_size: usize,
     guard_size: usize,
 ) -> io::Result<Thread> {
+    // This should really be an `unsafe` function, but `libc::pthread_create`
+    // doesn't have `unsafe` in its signature.
     extern "C" fn start(thread_arg_ptr: *mut c_void) -> *mut c_void {
         unsafe {
             // Unpack the thread arguments.
@@ -213,7 +215,7 @@ pub unsafe fn join(thread: Thread) -> Option<NonNull<c_void>> {
 /// Registers a function to call when the current thread exits.
 #[cfg(feature = "thread-at-exit")]
 pub fn at_exit(func: Box<dyn FnOnce()>) {
-    extern "C" fn call(arg: *mut c_void) {
+    unsafe extern "C" fn call(arg: *mut c_void) {
         unsafe {
             let arg = arg.cast::<Box<dyn FnOnce()>>();
             let arg = Box::from_raw(arg);

src/thread/linux_raw.rs

@@ -339,7 +339,7 @@ pub(super) unsafe fn initialize_main(mem: *mut c_void) {
     // the effective stack size. Linux sets up inaccessible memory at the end
     // of the stack.
     let stack_map_size = getrlimit(Resource::Stack).current.unwrap() as usize;
-    let stack_least = stack_base.cast::<u8>().sub(stack_map_size);
+    let stack_least = stack_base.sub(stack_map_size);
     let stack_size = stack_least.offset_from(mem.cast::<u8>()) as usize;
     let guard_size = page_size();
 

test-crates/origin-start/src/bin/canary.rs

@@ -6,8 +6,8 @@
 
 extern crate alloc;
 
-use core::cell::UnsafeCell;
 use core::arch::asm;
+use core::cell::UnsafeCell;
 use origin::{program, thread};
 
 #[global_allocator]

test-crates/origin-start/src/bin/tls.rs

@@ -9,8 +9,8 @@
 extern crate alloc;
 
 use alloc::boxed::Box;
-use core::cell::UnsafeCell;
 use core::arch::asm;
+use core::cell::UnsafeCell;
 use core::ptr::{addr_of_mut, without_provenance_mut};
 use origin::{program, thread};