std: move UNIX to new destructor list implementation

Author: joboet

library/std/src/sys/unix/mod.rs

@@ -38,7 +38,7 @@ pub mod rand;
 pub mod stack_overflow;
 pub mod stdio;
 pub mod thread;
-pub mod thread_local_dtor;
+pub mod thread_local_guard;
 pub mod thread_local_key;
 pub mod thread_parking;
 pub mod time;

library/std/src/sys/unix/thread_local_dtor.rs renamed to library/std/src/sys/unix/thread_local_guard.rs

@@ -1,8 +1,10 @@
+//! Ensures that thread-local destructors are run on thread exit.
+
 #![cfg(target_thread_local)]
 #![unstable(feature = "thread_local_internals", issue = "none")]
 
-//! Provides thread-local destructors without an associated "key", which
-//! can be more efficient.
+use crate::ptr;
+use crate::sys::common::thread_local::run_dtors;
 
 // Since what appears to be glibc 2.18 this symbol has been shipped which
 // GCC and clang both use to invoke destructors in thread_local globals, so
@@ -16,9 +18,10 @@
 // FIXME: The Rust compiler currently omits weakly function definitions (i.e.,
 // __cxa_thread_atexit_impl) and its metadata from LLVM IR.
 #[no_sanitize(cfi, kcfi)]
-pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
+pub fn activate() {
+    use crate::cell::Cell;
     use crate::mem;
-    use crate::sys_common::thread_local_dtor::register_dtor_fallback;
+    use crate::sys_common::thread_local_key::StaticKey;
 
     /// This is necessary because the __cxa_thread_atexit_impl implementation
     /// std links to by default may be a C or C++ implementation that was not
@@ -43,64 +46,47 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
         >;
     }
 
-    if let Some(f) = __cxa_thread_atexit_impl {
-        unsafe {
-            f(
-                mem::transmute::<
-                    unsafe extern "C" fn(*mut u8),
-                    unsafe extern "C" fn(*mut libc::c_void),
-                >(dtor),
-                t.cast(),
-                &__dso_handle as *const _ as *mut _,
-            );
+    unsafe {
+        if let Some(atexit) = __cxa_thread_atexit_impl {
+            #[thread_local]
+            static REGISTERED: Cell<bool> = Cell::new(false);
+            if !REGISTERED.get() {
+                atexit(
+                    mem::transmute::<
+                        unsafe extern "C" fn(*mut u8),
+                        unsafe extern "C" fn(*mut libc::c_void),
+                    >(run_dtors),
+                    ptr::null_mut(),
+                    &__dso_handle as *const _ as *mut _,
+                );
+                REGISTERED.set(true);
+            }
+        } else {
+            static KEY: StaticKey = StaticKey::new(Some(run_dtors));
+
+            KEY.set(ptr::invalid_mut(1));
         }
-        return;
     }
-    register_dtor_fallback(t, dtor);
 }
 
-// This implementation is very similar to register_dtor_fallback in
-// sys_common/thread_local.rs. The main difference is that we want to hook into
-// macOS's analog of the above linux function, _tlv_atexit. OSX will run the
-// registered dtors before any TLS slots get freed, and when the main thread
+// We hook into macOS's analog of the above linux function, _tlv_atexit. OSX
+// will run `run_dtors` before any TLS slots get freed, and when the main thread
 // exits.
-//
-// Unfortunately, calling _tlv_atexit while tls dtors are running is UB. The
-// workaround below is to register, via _tlv_atexit, a custom DTOR list once per
-// thread. thread_local dtors are pushed to the DTOR list without calling
-// _tlv_atexit.
 #[cfg(any(target_os = "macos", target_os = "ios", target_os = "watchos", target_os = "tvos"))]
-pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
-    use crate::cell::{Cell, RefCell};
-    use crate::ptr;
-
-    #[thread_local]
-    static REGISTERED: Cell<bool> = Cell::new(false);
-
-    #[thread_local]
-    static DTORS: RefCell<Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>> = RefCell::new(Vec::new());
-
-    if !REGISTERED.get() {
-        _tlv_atexit(run_dtors, ptr::null_mut());
-        REGISTERED.set(true);
-    }
+pub fn activate() {
+    use crate::cell::Cell;
 
     extern "C" {
         fn _tlv_atexit(dtor: unsafe extern "C" fn(*mut u8), arg: *mut u8);
     }
 
-    match DTORS.try_borrow_mut() {
-        Ok(mut dtors) => dtors.push((t, dtor)),
-        Err(_) => rtabort!("global allocator may not use TLS"),
-    }
+    #[thread_local]
+    static REGISTERED: Cell<bool> = Cell::new(false);
 
-    unsafe extern "C" fn run_dtors(_: *mut u8) {
-        let mut list = DTORS.take();
-        while !list.is_empty() {
-            for (ptr, dtor) in list {
-                dtor(ptr);
-            }
-            list = DTORS.take();
+    if !REGISTERED.get() {
+        unsafe {
+            _tlv_atexit(run_dtors, ptr::null_mut());
+            REGISTERED.set(true);
         }
     }
 }
@@ -112,7 +98,12 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     target_os = "aix"
 ))]
 #[cfg_attr(target_family = "wasm", allow(unused))] // might remain unused depending on target details (e.g. wasm32-unknown-emscripten)
-pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
-    use crate::sys_common::thread_local_dtor::register_dtor_fallback;
-    register_dtor_fallback(t, dtor);
+pub fn activate() {
+    use crate::sys_common::thread_local_key::StaticKey;
+
+    static KEY: StaticKey = StaticKey::new(Some(run_dtors));
+
+    unsafe {
+        KEY.set(ptr::invalid_mut(1));
+    }
 }

library/std/src/sys_common/mod.rs

@@ -29,7 +29,6 @@ pub mod once;
 pub mod process;
 pub mod thread;
 pub mod thread_info;
-pub mod thread_local_dtor;
 pub mod thread_parking;
 pub mod wstr;
 pub mod wtf8;