[hwasan] Properly restore SP tag on exceptions

[vitalybuka]

compiler-rt/test/hwasan/TestCases/try-catch.cpp

71

Filecheck and printf are unnecessary
exit code is enough

81

just
assert(pthread_attr_init(&attr) == 0)

[fmayer]

compiler-rt/test/hwasan/TestCases/try-catch.cpp

71

I don't think we should change the existing test in this CL. We can do that in a follow up.

81

Why? This makes debugging easier because it tells you what's wrong.

[fmayer]

compiler-rt/test/hwasan/TestCases/try-catch.cpp

81

Oh. Or do you mean this one in particular? I guess, that one shouldn't fail anyway.

[fmayer]

assert

[fmayer]

more assert

[kda]

This looks to be breaking HWASAN sanitizer buildbot:
https://lab.llvm.org/buildbot/#/builders/236/builds/4452

seems to be try-catch.cpp

[fmayer]

In D152036#4394711, @kda wrote:

This looks to be breaking HWASAN sanitizer buildbot:
https://lab.llvm.org/buildbot/#/builders/236/builds/4452

seems to be try-catch.cpp

thinks. looking, i cannot reproduce on my own phone :(

[fmayer]

In D152036#4396207, @fmayer wrote:

In D152036#4394711, @kda wrote:

This looks to be breaking HWASAN sanitizer buildbot:
https://lab.llvm.org/buildbot/#/builders/236/builds/4452

seems to be try-catch.cpp

thinks. looking, i cannot reproduce on my own phone :(

reverted for now until i figure out why it fails on the (old) buildbot phone.

[fmayer]

fix bug around tls

[fmayer]

iwyu

[vitalybuka]

compiler-rt/test/hwasan/TestCases/try-catch.cpp

81

all : less lines, and easier to read

but it's OK either way

compiler-rt/lib/hwasan/hwasan_exceptions.cpp

 #elif defined(__aarch64__)
     uptr fp = get_gr(context, 29); // x29
 #elif SANITIZER_RISCV64
     uptr fp = get_gr(context, 8);  // x8
 #else
 #error Unsupported architecture
 #endif
     uptr sp = get_cfa(context);
-    TagMemory(sp, fp - sp, 0);
+    TagMemory(UntagAddr(sp), UntagAddr(fp) - UntagAddr(sp),
+              GetTagFromPointer(sp));
   }
 
   return rc;
 }

compiler-rt/lib/hwasan/hwasan_thread.cpp

if (IsMainThread()) {
              stack_allocations_->size() * sizeof(uptr));
     }
     Print("Creating  : ");
   }
 }
 
 void Thread::ClearShadowForThreadStackAndTLS() {
   if (stack_top_ != stack_bottom_)
-    TagMemory(stack_bottom_, stack_top_ - stack_bottom_, 0);
+    TagMemory(UntagAddr(stack_bottom_),
+              UntagAddr(stack_top_) - UntagAddr(stack_bottom_),
+              GetTagFromPointer(stack_top_));
   if (tls_begin_ != tls_end_)
-    TagMemory(tls_begin_, tls_end_ - tls_begin_, 0);
+    TagMemory(UntagAddr(tls_begin_),
+              UntagAddr(tls_end_) - UntagAddr(tls_begin_),
+              GetTagFromPointer(tls_begin_));
 }
 
 void Thread::Destroy() {
   if (flags()->verbose_threads)
     Print("Destroying: ");
   AllocatorThreadFinish(allocator_cache());
   ClearShadowForThreadStackAndTLS();
   if (heap_allocations_)

compiler-rt/test/hwasan/TestCases/try-catch.cpp

 // This test is broken with shared libstdc++ / libc++ on Android.
 // RUN: %clangxx_hwasan -static-libstdc++ %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=GOOD
+// RUN: %clangxx_hwasan -static-libstdc++ -DMALLOCEDSTACK %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=GOOD
 // RUN: %clangxx_hwasan -static-libstdc++ -DNO_SANITIZE_F %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=GOOD
 // RUN: %clangxx_hwasan_oldrt -static-libstdc++ %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=GOOD
 // RUN: %clangxx_hwasan_oldrt -static-libstdc++ %s -mllvm -hwasan-instrument-landing-pads=0 -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=BAD
 
 // C++ tests on x86_64 require instrumented libc++/libstdc++.
 // RISC-V target doesn't support oldrt
 // REQUIRES: aarch64-target-arch
 
-#include <stdexcept>
+#include <cassert>
 #include <cstdio>
+#include <errno.h>
+#include <limits.h>
+#include <pthread.h>
+#include <sanitizer/hwasan_interface.h>
+#include <stdexcept>
+#include <string.h>
 
 static void optimization_barrier(void* arg) {
   asm volatile("" : : "r"(arg) : "memory");
 }
 
 __attribute__((noinline))
 void h() {
   char x[1000];
for (int i = 0; i < size; ++i)
     sink = p[i];
 }
 
 __attribute__((noinline, no_sanitize("hwaddress"))) void after_catch() {
   char x[10000];
   hwasan_read(&x[0], sizeof(x));
 }
 
-
 __attribute__((noinline))
 #ifdef NO_SANITIZE_F
 __attribute__((no_sanitize("hwaddress")))
 #endif
-void f() {
+void *
+f(void *) {
   char x[1000];
   try {
     // Put two tagged frames on the stack, throw an exception from the deepest one.
     g();
   } catch (const std::runtime_error &e) {
     // Put an untagged frame on stack, check that it is indeed untagged.
     // This relies on exception support zeroing out stack tags.
     // BAD: tag-mismatch
     after_catch();
     // Check that an in-scope stack allocation is still tagged.
     // This relies on exception support not zeroing too much.
     hwasan_read(&x[0], sizeof(x));
     // GOOD: hello
     printf("%s\n", e.what());
   }
+  return nullptr;
 }
 
 int main() {
-  f();
+  __hwasan_enable_allocator_tagging();
+#ifdef MALLOCEDSTACK
+  pthread_attr_t attr;
+  void *stack = malloc(PTHREAD_STACK_MIN);
+  assert(pthread_attr_init(&attr) == 0);
+  if (pthread_attr_setstack(&attr, stack, PTHREAD_STACK_MIN) != 0) {
+    fprintf(stderr, "pthread_attr_setstack: %s", strerror(errno));
+    abort();
+  }
+  pthread_t thid;
+  if (pthread_create(&thid, &attr, f, nullptr) != 0) {
+    fprintf(stderr, "pthread_create: %s", strerror(errno));
+    abort();
+  }
+  void *ret;
+  if (pthread_join(thid, &ret) != 0) {
+    fprintf(stderr, "pthread_join: %s", strerror(errno));
+    abort();
+  }
+  assert(pthread_attr_destroy(&attr) == 0);
+  free(stack);
+#else
+  f(nullptr);
+#endif
 }