std: use catch_unwind instead of drop guard in run_dtors

Author: joboet

library/std/src/sys/common/thread_local/fast_local.rs

@@ -1,7 +1,6 @@
 use super::lazy::LazyKeyInner;
 use crate::cell::{Cell, RefCell};
-use crate::fmt;
-use crate::mem::{self, forget};
+use crate::{fmt, mem, panic};
 
 #[doc(hidden)]
 #[allow_internal_unstable(thread_local_internals, cfg_target_thread_local, thread_local)]
@@ -262,37 +261,32 @@ unsafe fn register_dtor(t: *mut u8, dtor: unsafe fn(*mut u8)) {
 /// May only be called on thread exit. In particular, no thread locals may
 /// currently be referenced.
 pub unsafe extern "C" fn run_dtors(_unused: *mut u8) {
-    struct Guard;
-    impl Drop for Guard {
-        fn drop(&mut self) {
-            rtabort!("thread local panicked on drop");
-        }
-    }
+    // This function must not unwind. This is ensured by the `extern "C"` ABI,
+    // but by catching the unwind, we can print a more helpful message.
 
-    // This function must not unwind. This is ensured by the `extern "C"` ABI
-    // regardless, but by using a guard that aborts on drop, we can give a
-    // nicer abort reason.
-    let guard = Guard;
-    let dtors = &DTORS;
+    match panic::catch_unwind(|| {
+        let dtors = &DTORS;
 
-    loop {
-        // Ensure that the `RefMut` guard is not held while the destructor is
-        // executed to allow initializing TLS variables in destructors.
-        let (t, dtor) = {
-            let mut dtors = dtors.borrow_mut();
-            match dtors.pop() {
-                Some(entry) => entry,
-                None => break,
-            }
-        };
+        loop {
+            // Ensure that the `RefMut` guard is not held while the destructor is
+            // executed to allow initializing TLS variables in destructors.
+            let (t, dtor) = {
+                let mut dtors = dtors.borrow_mut();
+                match dtors.pop() {
+                    Some(entry) => entry,
+                    None => break,
+                }
+            };
 
-        unsafe {
-            (dtor)(t);
+            unsafe {
+                (dtor)(t);
+            }
         }
-    }
 
-    // All destructors were run, deallocate the list.
-    drop(dtors.replace(Vec::new()));
-    // Disarm the guard.
-    forget(guard);
+        // All destructors were run, deallocate the list.
+        drop(dtors.replace(Vec::new()));
+    }) {
+        Ok(()) => {}
+        Err(_) => rtabort!("thread local panicked on drop"),
+    }
 }