[Threading] Move stack bounds fetching into the threading library.

Fetching the current stack bounds is done using threading functions, so
should be in the threading library.

rdar://90776105

Author: al45tair

include/swift/Threading/Impl.h

@@ -20,6 +20,18 @@
 
 #include "TLSKeys.h"
 
+namespace swift {
+namespace threading_impl {
+
+struct stack_bounds {
+  void *low;
+  void *high;
+};
+
+} // namespace swift
+} // namespace threading_impl
+
+
 // Try to autodetect if we aren't told what to do
 #if !SWIFT_THREADING_NONE && !SWIFT_THREADING_DARWIN &&                        \
     !SWIFT_THREADING_LINUX && !SWIFT_THREADING_PTHREADS &&                     \

include/swift/Threading/Impl/C11.h

@@ -55,6 +55,10 @@ bool thread_is_main();
 inline bool threads_same(thread_id a, thread_id b) {
   return ::thrd_equal(a, b);
 }
+inline stack_bounds thread_get_current_stack_bounds() {
+  stack_bounds zero = { nullptr, nullptr };
+  return zero;
+}
 
 // .. Mutex support ..........................................................
 

include/swift/Threading/Impl/Darwin.h

@@ -38,6 +38,19 @@ inline bool threads_same(thread_id a, thread_id b) {
   return ::pthread_equal(a, b);
 }
 
+inline stack_bounds thread_get_current_stack_bounds() {
+  stack_bounds result;
+  pthread_t thread = pthread_self();
+
+  // On Apple platforms, pthread_get_stackaddr_np() gets the address of the
+  // *end* of the stack (i.e. the highest address in stack space), *NOT* the
+  // address of the *base* of the stack (the lowest address).
+  result.high = pthread_get_stackaddr_np(thread);
+  result.low = (char *)result.high - pthread_get_stacksize_np(thread);
+
+  return result;
+}
+
 // .. Mutex support ..........................................................
 
 using mutex_handle = ::os_unfair_lock;

include/swift/Threading/Impl/Linux.h

@@ -61,6 +61,8 @@ inline bool threads_same(thread_id a, thread_id b) {
   return ::pthread_equal(a, b);
 }
 
+stack_bounds thread_get_current_stack_bounds();
+
 // .. Mutex support ..........................................................
 
 using mutex_handle = ::pthread_mutex_t;

include/swift/Threading/Impl/Nothreads.h

@@ -27,6 +27,10 @@ using thread_id = unsigned;
 inline thread_id thread_get_current() { return 0; }
 inline bool thread_is_main() { return true; }
 inline bool threads_same(thread_id a, thread_id b) { return a == b; }
+inline stack_bounds thread_get_current_stack_bounds() {
+  stack_bounds zero = { nullptr, nullptr };
+  return zero;
+}
 
 // .. Mutex support ..........................................................
 

include/swift/Threading/Impl/Pthreads.h

@@ -60,6 +60,8 @@ inline bool threads_same(thread_id a, thread_id b) {
   return ::pthread_equal(a, b);
 }
 
+stack_bounds thread_get_current_stack_bounds();
+
 // .. Mutex support ..........................................................
 
 using mutex_handle = ::pthread_mutex_t;

include/swift/Threading/Impl/Win32.h

@@ -31,6 +31,7 @@ using thread_id = ::DWORD;
 inline thread_id thread_get_current() { return ::GetCurrentThreadId(); }
 bool thread_is_main();
 inline bool threads_same(thread_id a, thread_id b) { return a == b; }
+stack_bounds thread_get_current_stack_bounds();
 
 // .. Mutex support ..........................................................
 

include/swift/Threading/Thread.h

@@ -27,6 +27,7 @@ namespace swift {
 class Thread {
 public:
   using Id = threading_impl::thread_id;
+  using StackBounds = threading_impl::stack_bounds;
 
 private:
   Id id_;
@@ -65,6 +66,11 @@ class Thread {
   bool operator!=(const Thread &other) const {
     return !threading_impl::threads_same(id_, other.id_);
   }
+
+  // Retrieve the bounds of the current thread's stack
+  static StackBounds stackBounds() {
+    return threading_impl::thread_get_current_stack_bounds();
+  }
 };
 
 } // namespace swift

lib/Threading/Linux.cpp

@@ -57,4 +57,23 @@ void swift::threading_impl::once_slow(once_t &predicate, void (*fn)(void *),
   linux::ulock_unlock(&predicate.lock);
 }
 
+swift::threading_impl::stack_bounds
+swift::threading_impl::thread_get_current_stack_bounds() {
+  stack_bounds result = { nullptr, nullptr };
+  pthread_attr_t attr;
+  size_t size = 0;
+  void *begin = nullptr;
+
+  if (!pthread_getattr_np(pthread_self(), &attr)) {
+    if (!pthread_attr_getstack(&attr, &begin, &size)) {
+      result.low = begin;
+      result.high = (char *)begin + size;
+    }
+
+    pthread_attr_destroy(&attr);
+  }
+
+  return result;
+}
+
 #endif // SWIFT_THREADING_LINUX

lib/Threading/Pthreads.cpp

@@ -16,6 +16,10 @@
 
 #if SWIFT_THREADING_PTHREADS
 
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+#include <pthread_np.h>
+#endif
+
 #include "swift/Threading/Impl/Pthreads.h"
 #include "swift/Threading/Errors.h"
 
@@ -72,4 +76,43 @@ void swift::threading_impl::once_slow(once_t &predicate, void (*fn)(void *),
   pthread_mutex_unlock(&onceMutex);
 }
 
+#if defined(__OpenBSD__)
+swift::threading_impl::stack_bounds
+swift::threading_impl::thread_get_current_stack_bounds() {
+  stack_bounds result = { nullptr, nullptr };
+  stack_t sinfo;
+
+  if (!pthread_stackseg_np(pthread_self(), &sinfo)) {
+    result.low = (char *)sinfo.ss_sp - sinfo.ss_size;
+    result.high = sinfo.ss_sp;
+  }
+
+  return result;
+}
+#else
+swift::threading_impl::stack_bounds
+swift::threading_impl::thread_get_current_stack_bounds() {
+  stack_bounds result = { nullptr, nullptr };
+  pthread_attr_t attr;
+  size_t size = 0;
+  void *begin = nullptr;
+
+#if defined(__FreeBSD__)
+  if (pthread_attr_init(&attr))
+    return result;
+#endif
+
+  if (!pthread_getattr_np(pthread_self(), &attr)) {
+    if (!pthread_attr_getstack(&attr, &begin, &size)) {
+      result.low = begin;
+      result.high = (char *)begin + size;
+    }
+
+    pthread_attr_destroy(&attr);
+  }
+
+  return result;
+}
+#endif
+
 #endif // SWIFT_THREADING_PTHREADS