[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

lib/Threading/Win32.cpp

@@ -97,4 +97,26 @@ void swift::threading_impl::once_slow(once_t &predicate, void (*fn)(void *),
 #endif
 }
 
+swift::threading_impl::stack_bounds
+swift::threading_impl::thread_get_current_stack_bounds() {
+#if _WIN32_WINNT >= 0x0602
+  ULONG_PTR lowLimit = 0;
+  ULONG_PTR highLimit = 0;
+
+  GetCurrentThreadStackLimits(&lowLimit, &highLimit);
+
+  stack_bounds result = { (void *)lowLimit, (void *)highLimit };
+#else
+  MEMORY_BASIC_INFORMATION mbi;
+  VirtualQuery(&mbi, &mbi, sizeof(mbi));
+
+  stack_bounds result = {
+    mbi.AllocationBase,
+    (char *)mbi.BaseAddress + mbi.RegionSize
+  };
+#endif
+
+  return result;
+}
+
 #endif // SWIFT_THREADING_WIN32

stdlib/public/stubs/Stubs.cpp

@@ -64,14 +64,12 @@
 #include <android/api-level.h>
 #endif
 
-#if defined(__FreeBSD__) || defined(__OpenBSD__)
-#include <pthread_np.h>
-#endif
-
 #include "swift/Runtime/Debug.h"
 #include "swift/Runtime/SwiftDtoa.h"
 #include "swift/Basic/Lazy.h"
 
+#include "swift/Threading/Thread.h"
+
 #include "SwiftShims/LibcShims.h"
 #include "SwiftShims/RuntimeShims.h"
 #include "SwiftShims/RuntimeStubs.h"
@@ -537,84 +535,10 @@ __swift_bool swift_stdlib_isStackAllocationSafe(__swift_size_t byteCount,
 
 __swift_bool _swift_stdlib_getCurrentStackBounds(__swift_uintptr_t *outBegin,
                                                  __swift_uintptr_t *outEnd) {
-#if SWIFT_THREADING_NONE
-  // This platform does not support threads, so the API we'd call to get stack
-  // bounds (i.e. libpthread) is not going to be usable.
-  return false;
-
-#elif SWIFT_THREADING_DARWIN
-  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).
-  void *end = pthread_get_stackaddr_np(thread);
-  if (!end) {
-    return false;
-  }
-  *outEnd = (uintptr_t)end;
-  *outBegin = *outEnd - pthread_get_stacksize_np(thread);
-  return true;
-
-#elif SWIFT_THREADING_C11
-  // We don't know any way to do this for C11 threads
-  return false;
-
-#elif SWIFT_THREADING_WIN32
-
-#if _WIN32_WINNT >= 0x0602
-  ULONG_PTR lowLimit = 0;
-  ULONG_PTR highLimit = 0;
-  GetCurrentThreadStackLimits(&lowLimit, &highLimit);
-  *outBegin = lowLimit;
-  *outEnd = highLimit;
-  return true;
-#else
-  // Need _WIN32_WINNT to be 0x0602 or higher to use
-  // GetCurrentThreadStackLimits().  We could use VirtualQuery() instead,
-  // and give it the address of a page we know is on the stack?
-  return false;
-#endif
-
-#elif SWIFT_THREADING_PTHREADS || SWIFT_THREADING_LINUX
-
-#if defined(__OpenBSD__)
-  stack_t sinfo;
-  if (pthread_stackseg_np(pthread_self(), &sinfo) != 0) {
+  swift::Thread::StackBounds bounds = swift::Thread::stackBounds();
+  if (!bounds.low)
     return false;
-  }
-
-  *outBegin = (uintptr_t)sinfo.ss_sp - sinfo.ss_size;
-  *outEnd = (uintptr_t)sinfo.ss_sp;
+  *outBegin = (uintptr_t)bounds.low;
+  *outEnd = (uintptr_t)bounds.high;
   return true;
-#elif defined(__FreeBSD__) || defined(__ANDROID__) || defined(__linux__)
-  pthread_attr_t attr;
-
-#if defined(__FreeBSD__)
-  if (0 != pthread_attr_init(&attr) || 0 != pthread_attr_get_np(pthread_self(), &attr)) {
-    return false;
-  }
-#else
-  if (0 != pthread_getattr_np(pthread_self(), &attr)) {
-    return false;
-  }
-#endif
-
-  void *begin = nullptr;
-  size_t size = 0;
-  bool success = (0 == pthread_attr_getstack(&attr, &begin, &size));
-
-  *outBegin = (uintptr_t)begin;
-  *outEnd = *outBegin + size;
-
-  pthread_attr_destroy(&attr);
-  return success;
-#else
-#warning Please teach _swift_stdlib_getCurrentStackBounds() about your platform
-  return false;
-#endif
-
-#else
-# error Unknown threading package selected; please teach _swift_stdlib_getCurrentStackBounds() what to do.
-#endif
 }