runtime error: global allocator may not use TLS on arm64 macos

[MarinPostma]

When using TLS from the global allocator on arm64 macos, I get the following fatal runtime error:

fatal runtime error: global allocator may not use TLS

This doesn't happen on x86 linux, and I can't find any mention of it anywhere. Grepping the rust repo returns nothing for that error either, so I'm not sure where it's coming from

I tried this code:

use std::alloc::{GlobalAlloc, System};

#[global_allocator]
static GLOBAL: Allocator = Allocator;

struct Allocator;

thread_local! {
    static FOO: usize = 0;
}

unsafe impl GlobalAlloc for Allocator {
    unsafe fn alloc(&self, layout: std::alloc::Layout) -> *mut u8 {
        FOO.with(|foo| {
            println!("{foo}");
        });
        System.alloc(layout)
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: std::alloc::Layout) {
        System.dealloc(ptr, layout)
    }
}

fn main() {
    let hello = String::from("hello");
    println!("{hello}");
}

Meta

rustc --version --verbose:

rustc 1.79.0 (129f3b996 2024-06-10)
binary: rustc
commit-hash: 129f3b9964af4d4a709d1383930ade12dfe7c081
commit-date: 2024-06-10
host: aarch64-apple-darwin
release: 1.79.0
LLVM version: 18.1.7

Backtrace

<backtrace>

[joboet]

The message describes the problem: the global allocator must not use thread_local!, as the implementation of the macro needs to allocate on most platforms.

We may in the future decide to allow this by using the system allocator here, but this is fundamentally just the tip of the iceberg: nearly every API in std may allocate – I'd argue that you should not use std at all when implementing your own global allocator.

[workingjubilee]

Grepping the rust repo returns nothing for that error either,

@MarinPostma You are searching overly specifically. The first part, "fatal runtime error", is an error from rtabort!:

rust/library/std/src/rt.rs

Lines 39 to 42 in a299aa5

	macro_rules! rtabort {
	($($t:tt)*) => {
	{
	rtprintpanic!("fatal runtime error: {}\n", format_args!($($t)*));

The second part is inside the TLS dtor registration, currently:

rust/library/std/src/sys/thread_local/destructors/list.rs

Lines 4 to 13 in a299aa5

	#[thread_local]
	static DTORS: RefCell<Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>> = RefCell::new(Vec::new());
	pub unsafe fn register(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
	let Ok(mut dtors) = DTORS.try_borrow_mut() else {
	// This point can only be reached if the global allocator calls this
	// function again.
	// FIXME: maybe use the system allocator instead?
	rtabort!("the global allocator may not use TLS with destructors");
	};

[MarinPostma]

@workingjubilee that's not the one, notice the absence of "in destructor"

[ChrisDenton]

Yes, the error message has been tweaked since then but it's still the same error condition. Here's where it is on the 1.79 branch

rust/library/std/src/sys/pal/unix/thread_local_dtor.rs

Lines 105 to 109 in 129f3b9

	match DTORS.try_borrow_mut() {
	Ok(mut dtors) => dtors.push((t, dtor)),
	Err(_) => rtabort!("global allocator may not use TLS"),
	}

[workingjubilee]

there are actually 5 copies of it on the 1.79 branch.

which is why the refactoring that made there be only one.

[workingjubilee]

doesn't seem to be anything to fix here, currently?