Register new threads with libgc

New thread creation is bottlenecked through `Thread::new`, so this is
the ideal place to register its stack as a rootset with the collector.

Author: jacob-hughes

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

@@ -736,7 +736,7 @@ pub mod guard {
         target_os = "netbsd",
         target_os = "l4re"
     ))]
-    unsafe fn get_stack_start() -> Option<*mut libc::c_void> {
+    pub(crate) unsafe fn get_stack_start() -> Option<*mut libc::c_void> {
         let mut ret = None;
         let mut attr: libc::pthread_attr_t = crate::mem::zeroed();
         #[cfg(target_os = "freebsd")]

library/std/src/thread/mod.rs

@@ -158,6 +158,7 @@
 #[cfg(all(test, not(target_os = "emscripten")))]
 mod tests;
 
+use crate::alloc::GcAllocator;
 use crate::any::Any;
 use crate::cell::UnsafeCell;
 use crate::ffi::{CStr, CString};
@@ -517,6 +518,15 @@ impl Builder {
                 imp::Thread::set_name(name);
             }
 
+            // SAFETY: Register the thread with libgc so that its stack can be scanned
+            // for garbage collection.
+            let stack_start = unsafe { imp::guard::get_stack_start().unwrap() };
+            if stack_start != crate::ptr::null_mut() {
+                unsafe {
+                    GcAllocator::register_thread(&stack_start as *const _ as *mut u8);
+                }
+            }
+
             crate::io::set_output_capture(output_capture);
 
             // SAFETY: we constructed `f` initialized.
@@ -528,6 +538,12 @@ impl Builder {
             let try_result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
                 crate::sys_common::backtrace::__rust_begin_short_backtrace(f)
             }));
+
+            // SAFETY: The thread has no more work to do, so can be unregisterd.
+            unsafe {
+                GcAllocator::unregister_thread();
+            }
+
             // SAFETY: `their_packet` as been built just above and moved by the
             // closure (it is an Arc<...>) and `my_packet` will be stored in the
             // same `JoinInner` as this closure meaning the mutation will be

tests/ui/threads-sendsync/thread_registration.rs

@@ -0,0 +1,15 @@
+// run-pass
+// ignore-emscripten no threads support
+#![feature(rustc_private)]
+
+use std::alloc::GcAllocator;
+use std::thread;
+
+pub fn main() {
+    let res = thread::spawn(child).join().unwrap();
+    assert!(res);
+}
+
+fn child() -> bool {
+    GcAllocator::thread_registered()
+}