[HWASAN] Set os_id in Thread::Init to make sure that the thread can be found by GetThreadByOsIDLocked.

compiler-rt/lib/hwasan/hwasan_interceptors.cpp

static void *HwasanThreadStartFunc(void *arg) {
   __hwasan_thread_enter();
   ThreadStartArg A = *reinterpret_cast<ThreadStartArg*>(arg);
   UnmapOrDie(arg, GetPageSizeCached());
   return A.callback(A.param);
 }
 
 INTERCEPTOR(int, pthread_create, void *th, void *attr, void *(*callback)(void*),
             void * param) {
+  EnsureMainThreadIDIsCorrect();
   ScopedTaggingDisabler disabler;
   ThreadStartArg *A = reinterpret_cast<ThreadStartArg *> (MmapOrDie(
       GetPageSizeCached(), "pthread_create"));
   *A = {callback, param};
   int res = REAL(pthread_create)(th, attr, &HwasanThreadStartFunc, A);
   return res;
 }
 

compiler-rt/lib/hwasan/hwasan_thread.h

private:
   bool random_state_inited_;  // Whether InitRandomState() has been called.
 
   friend struct ThreadListHead;
 };
 
 Thread *GetCurrentThread();
 uptr *GetCurrentThreadLongPtr();
 
+// Used to handle fork().
+void EnsureMainThreadIDIsCorrect();
+
 struct ScopedTaggingDisabler {
   ScopedTaggingDisabler() { GetCurrentThread()->DisableTagging(); }
   ~ScopedTaggingDisabler() { GetCurrentThread()->EnableTagging(); }
 };
 
 } // namespace __hwasan
 
 #endif // HWASAN_THREAD_H

compiler-rt/lib/hwasan/hwasan_thread.cpp

 void Thread::Init(uptr stack_buffer_start, uptr stack_buffer_size,
                   const InitState *state) {
   CHECK_EQ(0, unique_id_);  // try to catch bad stack reuse
   CHECK_EQ(0, stack_top_);
   CHECK_EQ(0, stack_bottom_);
 
   static atomic_uint64_t unique_id;
   unique_id_ = atomic_fetch_add(&unique_id, 1, memory_order_relaxed);
+  if (!IsMainThread())
+    os_id_ = GetTid();
 
   if (auto sz = flags()->heap_history_size)
     heap_allocations_ = HeapAllocationsRingBuffer::New(sz);
 
 #if !SANITIZER_FUCHSIA
   // Do not initialize the stack ring buffer just yet on Fuchsia. Threads will
   // be initialized before we enter the thread itself, so we will instead call
   // this later.
if (flags()->random_tags) {
       EnsureRandomStateInited();
       random_state_ += 1;
       tag = random_state_ & tag_mask;
     }
   } while (!tag);
   return tag;
 }
 
+void EnsureMainThreadIDIsCorrect() {
+  auto *t = __hwasan::GetCurrentThread();
+  if (t && (t->IsMainThread()))
+    t->set_os_id(GetTid());
+}
+
 } // namespace __hwasan
 
 // --- Implementation of LSan-specific functions --- {{{1
 namespace __lsan {
 
 static __hwasan::HwasanThreadList *GetHwasanThreadListLocked() {
   auto &tl = __hwasan::hwasanThreadList();
   tl.CheckLocked();
   return &tl;
 }
 
 static __hwasan::Thread *GetThreadByOsIDLocked(tid_t os_id) {
   return GetHwasanThreadListLocked()->FindThreadLocked(
       [os_id](__hwasan::Thread *t) { return t->os_id() == os_id; });
 }
 
 void LockThreadRegistry() { __hwasan::hwasanThreadList().Lock(); }
 
 void UnlockThreadRegistry() { __hwasan::hwasanThreadList().Unlock(); }
 
-void EnsureMainThreadIDIsCorrect() {
-  auto *t = __hwasan::GetCurrentThread();
-  if (t && (t->IsMainThread()))
-    t->set_os_id(GetTid());
-}
+void EnsureMainThreadIDIsCorrect() { __hwasan::EnsureMainThreadIDIsCorrect(); }
 
 bool GetThreadRangesLocked(tid_t os_id, uptr *stack_begin, uptr *stack_end,
                            uptr *tls_begin, uptr *tls_end, uptr *cache_begin,
                            uptr *cache_end, DTLS **dtls) {
   auto *t = GetThreadByOsIDLocked(os_id);
   if (!t)
     return false;
   *stack_begin = t->stack_bottom();

compiler-rt/test/lsan/TestCases/Linux/cleanup_in_tsd_destructor.c

 // Regression test for thread lifetime tracking. Thread data should be
 // considered live during the thread's termination, at least until the
 // user-installed TSD destructors have finished running (since they may contain
 // additional cleanup tasks). LSan doesn't actually meet that goal 100%, but it
 // makes its best effort.
 // RUN: %clang_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0:use_tls=1" %run %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 // Investigate why it does not fail with use_stack=0
 // UNSUPPORTED: arm-linux || armhf-linux
 
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 

compiler-rt/test/lsan/TestCases/Linux/fork_threaded.cpp

 // Test that thread local data is handled correctly after forking without
 // exec(). In this test leak checking is initiated from a non-main thread.
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %run %t 2>&1
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 __thread void *thread_local_var;

compiler-rt/test/lsan/TestCases/Linux/guard-page.c

 // Check that if LSan finds that SP doesn't point into thread stack (e.g.
 // if swapcontext is used), LSan will not hit the guard page.
 // RUN: %clang_lsan %s -o %t && %run %t
-
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
 // Missing 'getcontext' and 'makecontext' on Android.
 // UNSUPPORTED: android
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <pthread.h>

compiler-rt/test/lsan/TestCases/Linux/libdl_deadlock.cpp

 // Regression test for a deadlock in leak detection,
 // where lsan would call dl_iterate_phdr while holding the allocator lock.
 // RUN: %clangxx_lsan %s -o %t && %run %t
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 #include <link.h>
 #include <mutex>
 #include <stdlib.h>
 #include <thread>
 #include <unistd.h>
 
 std::mutex in, out;
 

compiler-rt/test/lsan/TestCases/many_tls_keys_pthread.cpp

 // Test that lsan handles tls correctly for many threads
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 // On glibc, this requires the range returned by GetTLS to include
 // specific_1stblock and specific in `struct pthread`.
 // UNSUPPORTED: arm-linux, armhf-linux
 
 // TSD on NetBSD does not use TLS
 // UNSUPPORTED: target={{.*netbsd.*}}
 
 #include <assert.h>
int main() {
   }
   // spin until all threads have finished
   while (finished < NUM_THREADS)
     sleep(1);
   exit(0);
 }
 
 // CHECK: LeakSanitizer: detected memory leaks
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK: SUMMARY: {{.*}}Sanitizer:

compiler-rt/test/lsan/TestCases/many_tls_keys_thread.cpp

 // Test that lsan handles tls correctly for many threads
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0:use_tls=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 // Patch r303906 did not fix all the problems.
 // UNSUPPORTED: arm-linux,armhf-linux
 
 #include <assert.h>
 #include <limits.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <unistd.h>
int main() {
   }
   // spin until all threads have finished
   while (finished < NUM_THREADS)
     sleep(1);
   exit(0);
 }
 
 // CHECK: LeakSanitizer: detected memory leaks
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK: SUMMARY: {{.*}}Sanitizer:

compiler-rt/test/lsan/TestCases/use_registers.cpp

 // Test that registers of running threads are included in the root set.
 // RUN: %clangxx_lsan -pthread %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 #include "sanitizer_common/print_address.h"
 #include <assert.h>
 #include <pthread.h>
 #include <sched.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 extern "C" void *registers_thread_func(void *arg) {
int main() {
   assert(res == 0);
   while (!__sync_fetch_and_xor(&sync, 0))
     sched_yield();
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK: SUMMARY: {{.*}}Sanitizer:

compiler-rt/test/lsan/TestCases/use_registers_extra.cpp

 // Test that registers of running threads are included in the root set.
 // RUN: %clangxx_lsan -pthread %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_stacks=0:use_registers=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 // FIXME: Support more platforms.
 // REQUIRES: x86-target-arch && linux
 
 #include "sanitizer_common/print_address.h"
 #include <assert.h>
 #include <pthread.h>
 #include <sched.h>
 #include <stdio.h>
int main() {
   assert(res == 0);
   while (!__sync_fetch_and_xor(&sync, 0))
     sched_yield();
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK: SUMMARY: {{.*}}Sanitizer:

compiler-rt/test/lsan/TestCases/use_stacks_threaded.cpp

 // Test that stacks of non-main threads are included in the root set.
 // RUN: %clangxx_lsan -pthread %s -o %t
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts="report_objects=1:use_registers=0:use_stacks=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
-// Fixme: remove once test passes with hwasan
-// UNSUPPORTED: hwasan
-
 #include <assert.h>
 #include <pthread.h>
 #include <sched.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "sanitizer_common/print_address.h"
 
 extern "C"
int main() {
   assert(res == 0);
   while (!__sync_fetch_and_xor(&sync, 0))
     sched_yield();
   return 0;
 }
 // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: [[ADDR]] (1337 bytes)
-// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:
+// CHECK: SUMMARY: {{.*}}Sanitizer: