Update to the latest nightly Rust. (#131)

Update to nightly-2024-10-06, fix new warnings about static mut
references, and a few other minor cleanups.

Author: sunfishcode

.github/workflows/main.yml

@@ -58,7 +58,7 @@ jobs:
         rustup target add ${{ matrix.target }}
       if: matrix.target != ''
 
-    - uses: actions/cache@v3
+    - uses: actions/cache@v4
       with:
         path: ${{ runner.tool_cache }}/qemu
         key: qemu-${{ matrix.target }}-${{ env.QEMU_BUILD_VERSION }}-patched

example-crates/external-start/src/main.rs

@@ -89,5 +89,6 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
 // linker, however origin gains control before libc can call this `main`.
 #[no_mangle]
 unsafe fn main(_argc: i32, _argv: *mut *mut u8, _envp: *mut *mut u8) -> i32 {
+    eprintln!("Main was not supposed to be called!");
     core::intrinsics::abort();
 }

example-crates/tiny/README.md

@@ -10,7 +10,7 @@ and `.comment` sections:
 objcopy -R .eh_frame -R .comment target/release/tiny even-smaller
 ```
 
-On x86-64, this produces a executable with size 408 bytes.
+On x86-64, this produces an executable with size 408 bytes.
 
 How is this achieved?
 
@@ -29,7 +29,7 @@ needed for our minimal test program:
 origin = { path = "../..", default-features = false, features = ["origin-start"] }
 ```
 
-Then, we add a `#[profile.release]` section to our Cargo.toml, to enable
+Then, we add a `[profile.release]` section to our Cargo.toml, to enable
 several optimizations:
 
 ```toml

rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2024-08-19"
+channel = "nightly-2024-10-06"
 components = ["rustc", "cargo", "rust-std", "rust-src", "rustfmt"]

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

@@ -11,6 +11,7 @@ extern crate alloc;
 extern crate compiler_builtins;
 
 use atomic_dbg::dbg;
+use core::cell::UnsafeCell;
 use core::arch::asm;
 use origin::{program, thread};
 
@@ -27,7 +28,7 @@ extern "C" fn eh_personality() {}
 static GLOBAL_ALLOCATOR: rustix_dlmalloc::GlobalDlmalloc = rustix_dlmalloc::GlobalDlmalloc;
 
 extern "C" {
-    static mut __stack_chk_guard: usize;
+    static __stack_chk_guard: UnsafeCell<usize>;
 }
 
 /// Read the canary field from its well-known location in TLS, if there is one,
@@ -47,21 +48,21 @@ fn tls_guard() -> usize {
 
     #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
     unsafe {
-        ret = __stack_chk_guard;
+        ret = *__stack_chk_guard.get();
     }
 
     ret
 }
 
 #[no_mangle]
 unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) -> i32 {
-    assert_ne!(__stack_chk_guard, 0);
-    assert_eq!(__stack_chk_guard, tls_guard());
+    assert_ne!(*__stack_chk_guard.get(), 0);
+    assert_eq!(*__stack_chk_guard.get(), tls_guard());
 
     let thread = thread::create(
         |_args| {
-            assert_ne!(__stack_chk_guard, 0);
-            assert_eq!(__stack_chk_guard, tls_guard());
+            assert_ne!(*__stack_chk_guard.get(), 0);
+            assert_eq!(*__stack_chk_guard.get(), tls_guard());
             None
         },
         &[],
@@ -72,8 +73,8 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
 
     thread::join(thread);
 
-    assert_ne!(__stack_chk_guard, 0);
-    assert_eq!(__stack_chk_guard, tls_guard());
+    assert_ne!(*__stack_chk_guard.get(), 0);
+    assert_eq!(*__stack_chk_guard.get(), tls_guard());
 
     program::exit(203);
 }

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

@@ -8,13 +8,13 @@
 #![feature(core_intrinsics)]
 #![feature(thread_local)]
 #![feature(strict_provenance)]
-#![feature(const_mut_refs)]
 
 extern crate alloc;
 extern crate compiler_builtins;
 
 use alloc::boxed::Box;
 use atomic_dbg::dbg;
+use core::cell::UnsafeCell;
 use core::arch::asm;
 use core::ptr::{addr_of_mut, without_provenance_mut};
 use origin::{program, thread};
@@ -37,7 +37,7 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
     check_eq(TEST_DATA.0);
 
     // Mutate one of the TLS fields.
-    THREAD_LOCAL[1] = without_provenance_mut(77);
+    (*THREAD_LOCAL.get())[1] = without_provenance_mut(77);
 
     // Assert that the mutation happened properly.
     check_eq([TEST_DATA.0[0], without_provenance_mut(77), TEST_DATA.0[2]]);
@@ -48,14 +48,14 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
         check_eq([TEST_DATA.0[0], without_provenance_mut(79), TEST_DATA.0[2]]);
 
         // Mutate one of the TLS fields.
-        THREAD_LOCAL[1] = without_provenance_mut(80);
+        (*THREAD_LOCAL.get())[1] = without_provenance_mut(80);
     }));
     thread::at_exit(Box::new(|| {
         // Assert that we see the value stored at the end of `main`.
         check_eq([TEST_DATA.0[0], without_provenance_mut(78), TEST_DATA.0[2]]);
 
         // Mutate one of the TLS fields.
-        THREAD_LOCAL[1] = without_provenance_mut(79);
+        (*THREAD_LOCAL.get())[1] = without_provenance_mut(79);
     }));
 
     let thread = thread::create(
@@ -64,7 +64,7 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
             check_eq(TEST_DATA.0);
 
             // Mutate one of the TLS fields.
-            THREAD_LOCAL[1] = without_provenance_mut(175);
+            (*THREAD_LOCAL.get())[1] = without_provenance_mut(175);
 
             // Assert that the mutation happened properly.
             check_eq([TEST_DATA.0[0], without_provenance_mut(175), TEST_DATA.0[2]]);
@@ -88,7 +88,7 @@ unsafe fn origin_main(_argc: usize, _argv: *mut *mut u8, _envp: *mut *mut u8) ->
     check_eq([TEST_DATA.0[0], without_provenance_mut(77), TEST_DATA.0[2]]);
 
     // Mutate one of the TLS fields.
-    THREAD_LOCAL[1] = without_provenance_mut(78);
+    (*THREAD_LOCAL.get())[1] = without_provenance_mut(78);
 
     // Assert that the mutation happened properly.
     check_eq([TEST_DATA.0[0], without_provenance_mut(78), TEST_DATA.0[2]]);
@@ -107,7 +107,7 @@ static TEST_DATA: SyncTestData = {
 };
 
 #[thread_local]
-static mut THREAD_LOCAL: [*const u32; 3] = TEST_DATA.0;
+static THREAD_LOCAL: UnsafeCell<[*const u32; 3]> = UnsafeCell::new(TEST_DATA.0);
 
 // Some variables to point to.
 static mut SOME_REGULAR_DATA: u32 = 909;
@@ -116,11 +116,11 @@ static mut SOME_ZERO_DATA: u32 = 0;
 fn check_eq(data: [*const u32; 3]) {
     unsafe {
         // Check `THREAD_LOCAL` using a static address.
-        asm!("# {}", in(reg) THREAD_LOCAL.as_mut_ptr(), options(nostack, preserves_flags));
-        assert_eq!(THREAD_LOCAL, data);
+        asm!("# {}", in(reg) (*THREAD_LOCAL.get()).as_mut_ptr(), options(nostack, preserves_flags));
+        assert_eq!(*THREAD_LOCAL.get(), data);
 
         // Check `THREAD_LOCAL` using a dynamic address.
-        let mut thread_local_addr: *mut [*const u32; 3] = addr_of_mut!(THREAD_LOCAL);
+        let mut thread_local_addr: *mut [*const u32; 3] = THREAD_LOCAL.get();
         asm!("# {}", inout(reg) thread_local_addr, options(pure, nomem, nostack, preserves_flags));
         assert_eq!(*thread_local_addr, data);
     }