[LIBC] Cleanup code in `thread_exit`

[goldstein.w.n]

Summary

1. Avoid proper function calls and referencing local variables after

the stack has been deallocated. A proper function call/return or local
variable reference that may have spilled will cause invalid memory
reads after the stack has been deallocated.

2. Mark the function as [[noreturn]] and place

__builtin_unreachable() after the SYS_exit syscalls.

[goldstein.w.n]

Rebase

libc/src/__support/threads/linux/thread.cpp

if (guardsize) {
 
     if (result != 0)
       return Error{int(-result)};
   }
   mmap_result += guardsize;
   return reinterpret_cast<void *>(mmap_result);
 }
 
-LIBC_INLINE void free_stack(void *stack, size_t stacksize, size_t guardsize) {
+// This must always be inlined as we may be freeing the calling threads stack in
+// which case a normal return from the top the stack would cause an invalid
+// memory read.
+static __attribute__((always_inline)) inline void
+free_stack(void *stack, size_t stacksize, size_t guardsize) {
   uintptr_t stackaddr = reinterpret_cast<uintptr_t>(stack);
   stackaddr -= guardsize;
   stack = reinterpret_cast<void *>(stackaddr);
   __llvm_libc::syscall_impl(SYS_munmap, stack, stacksize + guardsize);
 }
 
 struct Thread;
 
 // We align the start args to 16-byte boundary as we adjust the allocated
 // stack memory with its size. We want the adjusted address to be at a
 // 16-byte boundary to satisfy the x86_64 and aarch64 ABI requirements.
 // If different architecture in future requires higher alignment, then we
 // can add a platform specific alignment spec.
 struct alignas(STACK_ALIGNMENT) StartArgs {
   ThreadAttributes *thread_attrib;
   ThreadRunner runner;
   void *arg;
 };
 
-static void cleanup_thread_resources(ThreadAttributes *attrib) {
+// This must always be inlined as we may be freeing the calling threads stack in
+// which case a normal return from the top the stack would cause an invalid
+// memory read.
+static __attribute__((always_inline)) inline void
+cleanup_thread_resources(ThreadAttributes *attrib) {
   // Cleanup the TLS before the stack as the TLS information is stored on
   // the stack.
   cleanup_tls(attrib->tls, attrib->tls_size);
   if (attrib->owned_stack)
     free_stack(attrib->stack, attrib->stacksize, attrib->guardsize);
 }
 
 __attribute__((always_inline)) inline uintptr_t get_start_args_addr() {
void thread_exit(ThreadReturnValue retval, ThreadStyle style) {
   if (!attrib->detach_state.compare_exchange_strong(
           joinable_state, uint32_t(DetachState::EXITING))) {
     // Thread is detached so cleanup the resources.
     cleanup_thread_resources(attrib);
 
     // Set the CLEAR_TID address to nullptr to prevent the kernel
     // from signalling at a non-existent futex location.
     __llvm_libc::syscall_impl(SYS_set_tid_address, 0);
+    // Return value for detached thread should be unused. We need to avoid
+    // referencing `style` or `retval.*` because they may be stored on the stack
+    // and we have deallocated our stack!
+    __llvm_libc::syscall_impl(SYS_exit, 0);
+    __builtin_unreachable();
   }
 
-  // TODO: We may have deallocated the stack. Can we reference local variables
-  // that may have spilled?
   if (style == ThreadStyle::POSIX)
     __llvm_libc::syscall_impl(SYS_exit, retval.posix_retval);
   else
     __llvm_libc::syscall_impl(SYS_exit, retval.stdc_retval);
+  __builtin_unreachable();
 }
 
 } // namespace __llvm_libc

libc/src/__support/threads/thread.h

struct Thread {
 
   // Return the name of the thread in |name|. Return the error number of error.
   int get_name(cpp::StringStream &name) const;
 };
 
 extern thread_local Thread self;
 
 // Platforms should implement this function.
-void thread_exit(ThreadReturnValue retval, ThreadStyle style);
+[[noreturn]] void thread_exit(ThreadReturnValue retval, ThreadStyle style);
 
 namespace internal {
 // Internal namespace containing utilities which are to be used by platform
 // implementations of threads.
 
 // Return the current thread's atexit callback manager. After thread startup
 // but before running the thread function, platform implementations should
 // set the "atexit_callback_mgr" field of the thread's attributes to the value