Fix stack walking builds on macOS and Windows

Summary: Guard POSIX-only stack-walking code from Windows builds. On macOS, use <sys/ucontext.h>, Darwin-specific register accessors, and unqualified signalset macros to support modern Xcode SDKs and arm64e pointer authentication. Update the associated tests accordingly.

Reviewed By: DinoV

Differential Revision: D116973275

fbshipit-source-id: 8d713698d41d4a7dab0a67cbb52ff4dfc28f3566

Author: yoney

CMakeLists.txt

@@ -505,6 +505,12 @@ if (BUILD_RUNTIME_TESTS)
     list(REMOVE_ITEM RUNTIME_TESTS_SOURCES ${PROJECT_SOURCE_DIR}/RuntimeTests/util_test.cpp)
   endif()
 
+  # Stack walking is stubbed out on Windows and compile-only on macOS, where
+  # sem_init() fails with ENOSYS.
+  if (WINDOWS OR MACOS)
+    list(REMOVE_ITEM RUNTIME_TESTS_SOURCES ${PROJECT_SOURCE_DIR}/RuntimeTests/stack_walk_test.cpp)
+  endif()
+
   add_executable(RuntimeTests ${RUNTIME_TESTS_SOURCES})
 
   target_link_libraries(

cinderx/Jit/stack_walk.cpp

@@ -2,10 +2,16 @@
 
 #include "cinderx/Jit/stack_walk.h"
 
+#if defined(__APPLE__) || defined(__linux__)
+
 #include <fmt/format.h>
 #include <sys/syscall.h>
 #include <sys/uio.h>
+#ifdef __APPLE__
+#include <sys/ucontext.h>
+#else
 #include <ucontext.h>
+#endif
 #include <unistd.h>
 
 #include <atomic>
@@ -17,10 +23,11 @@
 #include <cstring>
 #include <ctime>
 #include <mutex>
+#include <stdexcept>
+#include <system_error>
 
 namespace cinderx {
 
-#if defined(__APPLE__) || defined(__linux__)
 namespace {
 
 // How far above the previous record a caller's record may sit when the stack's
@@ -393,7 +400,9 @@ static std::atomic<StackWalk*> s_active;
 bool StackWalk::installHandler(int signum, struct sigaction* prev) {
   struct sigaction action = {};
   action.sa_sigaction = handleSignal;
-  ::sigemptyset(&action.sa_mask);
+  // Darwin exposes the signal-set helpers as macros, so they cannot be
+  // namespace-qualified.
+  sigemptyset(&action.sa_mask);
   action.sa_flags = SA_SIGINFO | SA_RESTART;
   return ::sigaction(signum, &action, prev) == 0;
 }
@@ -420,7 +429,7 @@ bool StackWalk::handlerIsOurs(int signum) {
 // terminates the process.
 int StackWalk::claimSignum() {
   sigset_t blocked;
-  ::sigemptyset(&blocked);
+  sigemptyset(&blocked);
   ::pthread_sigmask(SIG_BLOCK, nullptr, &blocked);
 
   auto claim = [&blocked](int signum) {
@@ -429,7 +438,7 @@ int StackWalk::claimSignum() {
     // it reads as unclaimed below and taking it would be undetectable - but a
     // thread that waits on a signal has to block it first, and the convention
     // is to block it in every thread before any of them start.
-    if (::sigismember(&blocked, signum) == 1) {
+    if (sigismember(&blocked, signum) == 1) {
       return false;
     }
     // Already carrying this class's handler, which means an earlier scan
@@ -516,7 +525,7 @@ void StackWalk::resetSignumCache() {
   if (signum > 0 && handlerIsOurs(signum)) {
     struct sigaction action = {};
     action.sa_handler = SIG_DFL;
-    ::sigemptyset(&action.sa_mask);
+    sigemptyset(&action.sa_mask);
     ::sigaction(signum, &action, nullptr);
   }
 }
@@ -837,12 +846,22 @@ StackWalk::Publish StackWalk::publishBatch(size_t count) {
 void StackWalk::captureFrames(const void* ucontext) {
   auto uc = static_cast<const ucontext_t*>(ucontext);
 
-#if defined(__x86_64__)
+#if defined(__APPLE__) && defined(__aarch64__)
+  // StackWalk is compile-only on macOS because sem_init() is unsupported and
+  // its constructor always throws. The context extraction still has to build
+  // as part of the JIT library.
+  const auto& state = uc->uc_mcontext->__ss;
+  auto frame = reinterpret_cast<const StackFrame*>(
+      __darwin_arm_thread_state64_get_fp(state));
+  auto pc =
+      reinterpret_cast<const void*>(__darwin_arm_thread_state64_get_pc(state));
+  auto sp = static_cast<uintptr_t>(__darwin_arm_thread_state64_get_sp(state));
+#elif defined(__linux__) && defined(__x86_64__)
   auto frame =
       reinterpret_cast<const StackFrame*>(uc->uc_mcontext.gregs[REG_RBP]);
   auto pc = reinterpret_cast<const void*>(uc->uc_mcontext.gregs[REG_RIP]);
   auto sp = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_RSP]);
-#elif defined(__aarch64__)
+#elif defined(__linux__) && defined(__aarch64__)
   auto frame = reinterpret_cast<const StackFrame*>(uc->uc_mcontext.regs[29]);
   auto pc = reinterpret_cast<const void*>(uc->uc_mcontext.pc);
   auto sp = static_cast<uintptr_t>(uc->uc_mcontext.sp);
@@ -907,5 +926,6 @@ void StackWalk::captureFrames(const void* ucontext) {
     ::sem_post(&handler_exited_);
   }
 }
-#endif
 } // namespace cinderx
+
+#endif

cinderx/RuntimeTests/stack_walk_test.cpp

@@ -7,7 +7,11 @@
 #include <pthread.h>
 #include <semaphore.h>
 #include <sys/mman.h>
+#ifdef __APPLE__
+#include <sys/ucontext.h>
+#else
 #include <ucontext.h>
+#endif
 #include <unistd.h>
 
 #include <algorithm>
@@ -148,17 +152,17 @@ class SpinningThread {
     // which signals as soon as the thread is up cannot beat it.
     if (deaf_to != 0) {
       sigset_t deaf;
-      ::sigemptyset(&deaf);
-      ::sigaddset(&deaf, deaf_to);
+      sigemptyset(&deaf);
+      sigaddset(&deaf, deaf_to);
       ::pthread_sigmask(SIG_BLOCK, &deaf, nullptr);
     }
     ready_.store(true, std::memory_order_release);
     while (!stop_.load(std::memory_order_acquire)) {
       if (deaf_to != 0 && !listening_.load(std::memory_order_relaxed) &&
           listen_.load(std::memory_order_acquire)) {
         sigset_t deaf;
-        ::sigemptyset(&deaf);
-        ::sigaddset(&deaf, deaf_to);
+        sigemptyset(&deaf);
+        sigaddset(&deaf, deaf_to);
         ::pthread_sigmask(SIG_UNBLOCK, &deaf, nullptr);
         listening_.store(true, std::memory_order_release);
       }
@@ -866,7 +870,7 @@ class OccupiedSignals {
   OccupiedSignals(const std::vector<int>& signums, void (*handler)(int)) {
     struct sigaction action = {};
     action.sa_handler = handler;
-    ::sigemptyset(&action.sa_mask);
+    sigemptyset(&action.sa_mask);
     for (int signum : signums) {
       struct sigaction prev = {};
       if (::sigaction(signum, &action, &prev) == 0) {
@@ -1081,7 +1085,7 @@ TEST(StackWalkSignalDiscoveryTest, AWalkerRescansAfterItsSignalIsTakenOver) {
 
     struct sigaction action = {};
     action.sa_handler = &occupyingHandler;
-    ::sigemptyset(&action.sa_mask);
+    sigemptyset(&action.sa_mask);
     ASSERT_EQ(::sigaction(taken, &action, nullptr), 0);
 
     size_t frames = 0;