[asan] Refactor stack unpoisoning.

[robot]

Summary

This adds a customization point to support unpoisoning of signal alternate stacks on POSIX.

[robot]

Not sure if I got the parent/child relation right in Phabricator. This change is supposed to come first, before D81577.

[vitalybuka]

Thank you!
LGTM

compiler-rt/lib/asan/asan_rtl.cpp

553–554

static void UnpoisonStack()

595

static

[vitalybuka]

compiler-rt/lib/asan/asan_rtl.cpp

591–592

Can you please also extract "if (top - bottom > kMaxExpectedCleanupSize) {" block into a function
and use it from PlatformUnpoisonStacks
I missed that PlatformUnpoisonStacks still needs to unpoison main stack. I assumed that return false is going to be enough.

[robot]

Restrict linkage, factor out UnpoisonStack with warning.

[vitalybuka]

LGTM

compiler-rt/lib/asan/asan_fuchsia.cpp

 
 void *AsanDoesNotSupportStaticLinkage() { return nullptr; }
 
 void InitializePlatformExceptionHandlers() {}
 void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
   UNIMPLEMENTED();
 }
 
+bool PlatformUnpoisonStacks() { return false; }
+
 // We can use a plain thread_local variable for TSD.
 static thread_local void *per_thread;
 
 void *AsanTSDGet() { return per_thread; }
 
 void AsanTSDSet(void *tsd) { per_thread = tsd; }
 
 // There's no initialization needed, and the passed-in destructor

compiler-rt/lib/asan/asan_internal.h

 void ReplaceSystemMalloc();
 
 // asan_linux.cpp / asan_mac.cpp / asan_rtems.cpp / asan_win.cpp
 uptr FindDynamicShadowStart();
 void *AsanDoesNotSupportStaticLinkage();
 void AsanCheckDynamicRTPrereqs();
 void AsanCheckIncompatibleRT();
 
+// Unpoisons platform-specific stacks.
+// Returns true if all stacks have been unpoisoned.
+bool PlatformUnpoisonStacks();
+
+// asan_rtl.cpp
+// Unpoison a region containing a stack.
+// Performs a sanity check and warns if the bounds don't look right.
+// The warning contains the type string to identify the stack type.
+void UnpoisonStack(uptr bottom, uptr top, const char *type);
+
 // asan_thread.cpp
 AsanThread *CreateMainThread();
 
 // Support function for __asan_(un)register_image_globals. Searches for the
 // loaded image containing `needle' and then enumerates all global metadata
 // structures declared in that image, applying `op' (e.g.,
 // __asan_(un)register_globals) to them.
 typedef void (*globals_op_fptr)(__asan_global *, uptr);

compiler-rt/lib/asan/asan_posix.cpp

 namespace __asan {
 
 void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
   StartReportDeadlySignal();
   SignalContext sig(siginfo, context);
   ReportDeadlySignal(sig);
 }
 
+bool PlatformUnpoisonStacks() { return false; }
+
 // ---------------------- TSD ---------------- {{{1
 
 #if SANITIZER_NETBSD && !ASAN_DYNAMIC
 // Thread Static Data cannot be used in early static ASan init on NetBSD.
 // Reuse the Asan TSD API for compatibility with existing code
 // with an alternative implementation.
 
 static void (*tsd_destructor)(void *tsd) = nullptr;

compiler-rt/lib/asan/asan_rtems.cpp

 // RTEMS only support static linking; it sufficies to return with no
 // error.
 void *AsanDoesNotSupportStaticLinkage() { return nullptr; }
 
 void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
   UNIMPLEMENTED();
 }
 
+bool PlatformUnpoisonStacks() { return false; }
+
 void EarlyInit() {
   // Provide early initialization of shadow memory so that
   // instrumented code running before full initialzation will not
   // report spurious errors.
   ResetShadowMemory();
 }
 
 // We can use a plain thread_local variable for TSD.

compiler-rt/lib/asan/asan_rtl.cpp

  public:
   AsanInitializer() {
     AsanInitFromRtl();
   }
 };
 
 static AsanInitializer asan_initializer;
 #endif  // ASAN_DYNAMIC
 
-} // namespace __asan
-
-// ---------------------- Interface ---------------- {{{1
-using namespace __asan;
-
-void NOINLINE __asan_handle_no_return() {
-  if (asan_init_is_running)
+void UnpoisonStack(uptr bottom, uptr top, const char *type) {
+  static const uptr kMaxExpectedCleanupSize = 64 << 20;  // 64M
+  if (top - bottom > kMaxExpectedCleanupSize) {
+    static bool reported_warning = false;
+    if (reported_warning)
+      return;
+    reported_warning = true;
+    Report(
+        "WARNING: ASan is ignoring requested __asan_handle_no_return: "
+        "stack type: %s top: %p; bottom %p; size: %p (%zd)\n"
+        "False positive error reports may follow\n"
+        "For details see "
+        "https://github.com/google/sanitizers/issues/189\n",
+        type, top, bottom, top - bottom, top - bottom);
     return;
+  }
+  PoisonShadow(bottom, top - bottom, 0);
+}
+
+static void UnpoisonDefaultStack() {
+  uptr bottom, top;
 
+  if (AsanThread *curr_thread = GetCurrentThread()) {
     int local_stack;
-  AsanThread *curr_thread = GetCurrentThread();
-  uptr PageSize = GetPageSizeCached();
-  uptr top, bottom;
-  if (curr_thread) {
+    const uptr page_size = GetPageSizeCached();
     top = curr_thread->stack_top();
-    bottom = ((uptr)&local_stack - PageSize) & ~(PageSize - 1);
+    bottom = ((uptr)&local_stack - page_size) & ~(page_size - 1);
   } else if (SANITIZER_RTEMS) {
     // Give up On RTEMS.
     return;
   } else {
     CHECK(!SANITIZER_FUCHSIA);
     // If we haven't seen this thread, try asking the OS for stack bounds.
     uptr tls_addr, tls_size, stack_size;
     GetThreadStackAndTls(/*main=*/false, &bottom, &stack_size, &tls_addr,
                          &tls_size);
     top = bottom + stack_size;
   }
-  static const uptr kMaxExpectedCleanupSize = 64 << 20;  // 64M
-  if (top - bottom > kMaxExpectedCleanupSize) {
-    static bool reported_warning = false;
-    if (reported_warning)
-      return;
-    reported_warning = true;
-    Report("WARNING: ASan is ignoring requested __asan_handle_no_return: "
-           "stack top: %p; bottom %p; size: %p (%zd)\n"
-           "False positive error reports may follow\n"
-           "For details see "
-           "https://github.com/google/sanitizers/issues/189\n",
-           top, bottom, top - bottom, top - bottom);
-    return;
-  }
-  PoisonShadow(bottom, top - bottom, 0);
+
+  UnpoisonStack(bottom, top, "default");
+
+static void UnpoisonFakeStack() {
+  AsanThread *curr_thread = GetCurrentThread();
   if (curr_thread && curr_thread->has_fake_stack())
     curr_thread->fake_stack()->HandleNoReturn();
 }
 
+}  // namespace __asan
+
+// ---------------------- Interface ---------------- {{{1
+using namespace __asan;
+
+void NOINLINE __asan_handle_no_return() {
+  if (asan_init_is_running)
+    return;
+
+  if (!PlatformUnpoisonStacks())
+    UnpoisonDefaultStack();
+
+  UnpoisonFakeStack();
+}
+
 extern "C" void *__asan_extra_spill_area() {
   AsanThread *t = GetCurrentThread();
   CHECK(t);
   return t->extra_spill_area();
 }
 
 void __asan_handle_vfork(void *sp) {
   AsanThread *t = GetCurrentThread();

compiler-rt/lib/asan/asan_win.cpp

 void AsanCheckIncompatibleRT() {}
 
 void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
   UNIMPLEMENTED();
 }
 
 void AsanOnDeadlySignal(int, void *siginfo, void *context) { UNIMPLEMENTED(); }
 
+bool PlatformUnpoisonStacks() { return false; }
+
 #if SANITIZER_WINDOWS64
 // Exception handler for dealing with shadow memory.
 static LONG CALLBACK
 ShadowExceptionHandler(PEXCEPTION_POINTERS exception_pointers) {
   uptr page_size = GetPageSizeCached();
   // Only handle access violations.
   if (exception_pointers->ExceptionRecord->ExceptionCode !=
           EXCEPTION_ACCESS_VIOLATION ||