[asan, myriad] Simplify main thread handling

[waltl]

Summary

On Myriad RTEMS, we don't need to treat the main thread differently.
The existing thread hooks will do the right thing, so get rid of all
the unneeded special logic.

compiler-rt/trunk/lib/asan/asan_rtems.cc

 
 void EarlyInit() {
   // Provide early initialization of shadow memory so that
   // instrumented code running before full initialzation will not
   // report spurious errors.
   ResetShadowMemory();
 }
 
-// Main thread information.  Initialized in CreateMainThread() and
-// used by ThreadStartHook().
-static uptr MainThreadSelf;
-static AsanThread *MainThread;
-
 // 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
void AsanThread::SetThreadStackAndTls(const AsanThread::InitOptions *options) {
   CHECK_NE(options->stack_bottom, 0);
   CHECK_NE(options->stack_size, 0);
   stack_bottom_ = options->stack_bottom;
   stack_top_ = options->stack_bottom + options->stack_size;
   tls_begin_ = options->tls_bottom;
   tls_end_ = options->tls_bottom + options->tls_size;
 }
 
-// Called by __asan::AsanInitInternal (asan_rtl.c).
+// Called by __asan::AsanInitInternal (asan_rtl.c).  Unlike other ports, the
+// main thread on RTEMS does not require special treatment; its AsanThread is
+// already created by the provided hooks.  This function simply looks up and
+// returns the created thread.
 AsanThread *CreateMainThread() {
-  CHECK_NE(__sanitizer::MainThreadStackBase, 0);
-  CHECK_GT(__sanitizer::MainThreadStackSize, 0);
-  AsanThread *t = CreateAsanThread(
-      nullptr, 0, GetThreadSelf(), true,
-      __sanitizer::MainThreadStackBase, __sanitizer::MainThreadStackSize,
-      __sanitizer::MainThreadTlsBase, __sanitizer::MainThreadTlsSize);
-  SetCurrentThread(t);
-  MainThreadSelf = pthread_self();
-  MainThread = t;
-  return t;
+  return GetThreadContextByTidLocked(0)->thread;
 }
 
 // This is called before each thread creation is attempted.  So, in
 // its first call, the calling thread is the initial and sole thread.
 static void *BeforeThreadCreateHook(uptr user_id, bool detached,
                                     uptr stack_bottom, uptr stack_size,
                                     uptr tls_bottom, uptr tls_size) {
   EnsureMainThreadIDIsCorrect();
static void ThreadCreateHook(void *hook, bool aborted) {
   } else {
     // The thread wasn't created after all.
     // Clean up everything we set up in BeforeThreadCreateHook.
     asanThreadRegistry().FinishThread(thread->tid());
     UnmapOrDie(thread, sizeof(AsanThread));
   }
 }
 
-// This is called (1) in the newly-created thread before it runs
-// anything else, with the pointer returned by BeforeThreadCreateHook
-// (above).  cf. asan_interceptors.cc:asan_thread_start.  (2) before
-// a thread restart.
+// This is called (1) in the newly-created thread before it runs anything else,
+// with the pointer returned by BeforeThreadCreateHook (above).  (2) before a
+// thread restart.
 static void ThreadStartHook(void *hook, uptr os_id) {
-  if (!hook && !MainThreadSelf)
+  if (!hook)
     return;
 
-  DCHECK(hook || os_id == MainThreadSelf);
-  AsanThread *thread = hook ? static_cast<AsanThread *>(hook) : MainThread;
+  AsanThread *thread = static_cast<AsanThread *>(hook);
   SetCurrentThread(thread);
 
   ThreadStatus status =
       asanThreadRegistry().GetThreadLocked(thread->tid())->status;
   DCHECK(status == ThreadStatusCreated || status == ThreadStatusRunning);
   // Determine whether we are starting or restarting the thread.
   if (status == ThreadStatusCreated)
     // In lieu of AsanThread::ThreadStart.

compiler-rt/trunk/lib/sanitizer_common/sanitizer_rtems.h

 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_RTEMS_H
 #define SANITIZER_RTEMS_H
 
 #include "sanitizer_platform.h"
 #if SANITIZER_RTEMS
 #include "sanitizer_common.h"
 
-namespace __sanitizer {
-
-extern uptr MainThreadStackBase, MainThreadStackSize;
-extern uptr MainThreadTlsBase, MainThreadTlsSize;
-
-}  // namespace __sanitizer
-
 #endif  // SANITIZER_RTEMS
 #endif  // SANITIZER_RTEMS_H

compiler-rt/trunk/lib/sanitizer_common/sanitizer_rtems.cc

void ReportFile::Write(const char *buffer, uptr length) {
   }
 }
 
 uptr MainThreadStackBase, MainThreadStackSize;
 uptr MainThreadTlsBase, MainThreadTlsSize;
 
 } // namespace __sanitizer
 
-extern "C" {
-void __sanitizer_startup_hook(void *stack_base, size_t stack_size,
-                              void *tls_base, size_t tls_size) {
-  __sanitizer::MainThreadStackBase = reinterpret_cast<uintptr_t>(stack_base);
-  __sanitizer::MainThreadStackSize = stack_size;
-  __sanitizer::MainThreadTlsBase = reinterpret_cast<uintptr_t>(tls_base);
-  __sanitizer::MainThreadTlsSize = tls_size;
-}
-}  // extern "C"
-
 #endif  // SANITIZER_RTEMS