Miscellaneous documentation cleanups. (#89)

Author: sunfishcode

README.md

@@ -24,8 +24,8 @@ its own implementations of this functionality, written in Rust.
 
 For a C-ABI-compatible interface to this functionality, see [c-scape].
 
-This is used by [Mustang] and [Eyra] in their libc implementations, and in
-the [Origin Studio] project in its std implementation, which are three different
+This is used by [Mustang] and [Eyra] in their libc implementations, and in the
+[Origin Studio] project in its std implementation, which are three different
 ways to support building Rust programs written entirely in Rust.
 
 ## Example crates
@@ -51,9 +51,9 @@ Origin can also be used on its own, in several different configurations:
 
  - The [origin-start-no-alloc example] is like origin-start, but disables the
    "alloc" and "thread" features, since Origin's "thread" feature currently
-   depends on "alloc". Without "alloc", functions that return owned strings
-   or `Vec`s are not available. In this mode, Origin avoids using a
-   global allocator entirely.
+   depends on "alloc". Without "alloc", functions that return owned strings or
+   `Vec`s are not available. In this mode, Origin avoids using a global
+   allocator entirely.
 
  - The [origin-start-lto example] is like origin-start, but builds with LTO.
 
@@ -69,14 +69,15 @@ default they do still depend on a dynamic linker.
 
 For fully static linking, there are two options:
 
- - Build with `RUSTFLAGS=-C target-feature=+crt-static -C relocation-model=static`.
-   This disables PIE mode, which is safer in terms of Origin's code, but loses
-   the security benefits of Address-Space Layout Randomization (ASLR).
+ - Build with
+   `RUSTFLAGS=-C target-feature=+crt-static -C relocation-model=static`. This
+   disables PIE mode, which is safer in terms of Origin's code, but loses the
+   security benefits of Address-Space Layout Randomization (ASLR).
 
- - Build with `RUSTFLAGS=-C target-feature=+crt-static` and enable
-   Origin's `experimental-relocate` feature. This allows PIE mode to work,
-   however it does so by enabling some highly experimental code in origin for
-   performing relocations.
+ - Build with `RUSTFLAGS=-C target-feature=+crt-static` and enable Origin's
+   `experimental-relocate` feature. This allows PIE mode to work, however it
+   does so by enabling some experimental code in origin for performing
+   relocations.
 
 [basic example]: https://github.com/sunfishcode/origin/blob/main/example-crates/basic/README.md
 [no-std example]: https://github.com/sunfishcode/origin/blob/main/example-crates/no-std/README.md

example-crates/tiny/README.md

@@ -197,7 +197,7 @@ instructions are `origin::program::entry` and everything, including the user
 
 ## Optimizations not done
 
-In theory this code code be made even smaller.
+In theory this code be made even smaller.
 
 That first `mov $rsp,%rdi` is moving the incoming stack pointer we got from the
 OS into the first argument register to pass to `origin::program::entry` so that

src/arch/aarch64.rs

@@ -94,15 +94,15 @@ pub(super) unsafe fn relocation_store(ptr: usize, value: usize) {
     );
 }
 
-/// Mark "relro" memory as readonly.
+/// Mark “relro” memory as readonly.
 ///
-/// "relro" is a relocation feature in which memory can be readonly after
+/// “relro” is a relocation feature in which memory can be readonly after
 /// relocations are applied.
 ///
 /// This function conceptually casts `ptr` to a `*mut c_void` and does a
 /// `rustix::mm::mprotect(ptr, len, MprotectFlags::READ)`. However, it does
 /// this using `asm` and `usize` types which don't carry provenance, as it's
-/// used by `relocate` to implement the "relro" feature which cannot be
+/// used by `relocate` to implement the “relro” feature which cannot be
 /// expressed in the Rust memory model.
 ///
 /// # Safety

src/arch/arm.rs

@@ -94,15 +94,15 @@ pub(super) unsafe fn relocation_store(ptr: usize, value: usize) {
     );
 }
 
-/// Mark "relro" memory as readonly.
+/// Mark “relro” memory as readonly.
 ///
-/// "relro" is a relocation feature in which memory can be readonly after
+/// “relro” is a relocation feature in which memory can be readonly after
 /// relocations are applied.
 ///
 /// This function conceptually casts `ptr` to a `*mut c_void` and does a
 /// `rustix::mm::mprotect(ptr, len, MprotectFlags::READ)`. However, it does
 /// this using `asm` and `usize` types which don't carry provenance, as it's
-/// used by `relocate` to implement the "relro" feature which cannot be
+/// used by `relocate` to implement the “relro” feature which cannot be
 /// expressed in the Rust memory model.
 ///
 /// # Safety

src/arch/riscv64.rs

@@ -94,15 +94,15 @@ pub(super) unsafe fn relocation_store(ptr: usize, value: usize) {
     );
 }
 
-/// Mark "relro" memory as readonly.
+/// Mark “relro” memory as readonly.
 ///
-/// "relro" is a relocation feature in which memory can be readonly after
+/// “relro” is a relocation feature in which memory can be readonly after
 /// relocations are applied.
 ///
 /// This function conceptually casts `ptr` to a `*mut c_void` and does a
 /// `rustix::mm::mprotect(ptr, len, MprotectFlags::READ)`. However, it does
 /// this using `asm` and `usize` types which don't carry provenance, as it's
-/// used by `relocate` to implement the "relro" feature which cannot be
+/// used by `relocate` to implement the “relro” feature which cannot be
 /// expressed in the Rust memory model.
 ///
 /// # Safety

src/arch/x86.rs

@@ -99,15 +99,15 @@ pub(super) unsafe fn relocation_store(ptr: usize, value: usize) {
     );
 }
 
-/// Mark "relro" memory as readonly.
+/// Mark “relro” memory as readonly.
 ///
-/// "relro" is a relocation feature in which memory can be readonly after
+/// “relro” is a relocation feature in which memory can be readonly after
 /// relocations are applied.
 ///
 /// This function conceptually casts `ptr` to a `*mut c_void` and does a
 /// `rustix::mm::mprotect(ptr, len, MprotectFlags::READ)`. However, it does
 /// this using `asm` and `usize` types which don't carry provenance, as it's
-/// used by `relocate` to implement the "relro" feature which cannot be
+/// used by `relocate` to implement the “relro” feature which cannot be
 /// expressed in the Rust memory model.
 ///
 /// # Safety

src/arch/x86_64.rs

@@ -95,15 +95,15 @@ pub(super) unsafe fn relocation_store(ptr: usize, value: usize) {
     );
 }
 
-/// Mark "relro" memory as readonly.
+/// Mark “relro” memory as readonly.
 ///
-/// "relro" is a relocation feature in which memory can be readonly after
+/// “relro” is a relocation feature in which memory can be readonly after
 /// relocations are applied.
 ///
 /// This function conceptually casts `ptr` to a `*mut c_void` and does a
 /// `rustix::mm::mprotect(ptr, len, MprotectFlags::READ)`. However, it does
 /// this using `asm` and `usize` types which don't carry provenance, as it's
-/// used by `relocate` to implement the "relro" feature which cannot be
+/// used by `relocate` to implement the “relro” feature which cannot be
 /// expressed in the Rust memory model.
 ///
 /// # Safety

src/program.rs

@@ -242,7 +242,7 @@ pub fn at_exit(func: Box<dyn FnOnce() + Send>) {
         use core::ffi::c_void;
 
         extern "C" {
-            // <https://refspecs.linuxbase.org/LSB_3.1.0/LSB-generic/LSB-generic/baselib---cxa-atexit.html>
+            // <https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/baselib---cxa-atexit.html>
             fn __cxa_atexit(
                 func: unsafe extern "C" fn(*mut c_void),
                 arg: *mut c_void,

src/signal/libc.rs

@@ -39,7 +39,7 @@ pub unsafe fn sigaction(sig: Signal, action: Option<Sigaction>) -> io::Result<Si
     }
 }
 
-/// Return a special "ignore" signal handler for ignoring signals.
+/// Return a special “ignore” signal handler for ignoring signals.
 ///
 /// If you're looking for `sig_dfl`; use [`SigDfl`].
 #[doc(alias = "SIG_IGN")]
@@ -48,8 +48,8 @@ pub const fn sig_ign() -> Sighandler {
     libc::SIG_IGN
 }
 
-/// A special "default" signal handler representing the default behavior for
-/// handling a signal.
+/// A special “default” signal handler representing the default behavior
+/// for handling a signal.
 ///
 /// If you're looking for `SigIgn`; use [`sig_ign`].
 #[doc(alias = "SIG_DFL")]

src/signal/linux_raw.rs

@@ -43,7 +43,7 @@ pub unsafe fn sigaction(sig: Signal, action: Option<Sigaction>) -> io::Result<Si
     rustix::runtime::sigaction(sig, action)
 }
 
-/// Return a special "ignore" signal handler for ignoring signals.
+/// Return a special “ignore” signal handler for ignoring signals.
 ///
 /// If you're looking for `sig_dlf`; use [`SigDfl`].
 #[doc(alias = "SIG_IGN")]
@@ -52,8 +52,8 @@ pub const fn sig_ign() -> Sighandler {
     linux_raw_sys::signal_macros::sig_ign()
 }
 
-/// A special "default" signal handler representing the default behavior for
-/// handling a signal.
+/// A special “default” signal handler representing the default behavior
+/// for handling a signal.
 ///
 /// If you're looking for `SigIgn`; use [`sig_ign`].
 #[doc(alias = "SIG_DFL")]