[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

554

static void UnpoisonStack()

592

static

[vitalybuka]

compiler-rt/lib/asan/asan_rtl.cpp

579

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

 //===-- asan_fuchsia.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 //

 
 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

 //===-- asan_internal.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 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_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

 //===-- asan_posix.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 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

 //===-- asan_rtems.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 // 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

 //===-- asan_rtl.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
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)
-    return;
+void UnpoisonStack() {
+  uptr top;
+  uptr bottom;
 
+  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);
+}
+
+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())
+    UnpoisonStack();
+
+  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

 //===-- asan_win.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 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 ||