[NFC][lsan] Move SetCurrentThread call

[vitalybuka]

Summary

Future patch will set the current context as well.
Existing callsite requires additional lock to find context.

[vitalybuka]

another callsite

compiler-rt/lib/lsan/lsan_fuchsia.cpp

void ThreadContext::OnCreated(void *arg) {
   stack_end_ = args->stack_end;
 }
 
 struct OnStartedArgs {
   uptr cache_begin, cache_end;
 };
 
 void ThreadContext::OnStarted(void *arg) {
+  ThreadContextLsanBase::OnStarted(arg);
   auto args = reinterpret_cast<const OnStartedArgs *>(arg);
   cache_begin_ = args->cache_begin;
   cache_end_ = args->cache_end;
 }
 
 void ThreadStart(u32 tid) {
   OnStartedArgs args;
   GetAllocatorCacheRange(&args.cache_begin, &args.cache_end);

compiler-rt/lib/lsan/lsan_mac.cpp

typedef struct {
   u32 parent_tid;
 } lsan_block_context_t;
 
 ALWAYS_INLINE
 void lsan_register_worker_thread(int parent_tid) {
   if (GetCurrentThread() == kInvalidTid) {
     u32 tid = ThreadCreate(parent_tid, true);
     ThreadStart(tid, GetTid());
-    SetCurrentThread(tid);
   }
 }
 
 // For use by only those functions that allocated the context via
 // alloc_lsan_context().
 extern "C" void lsan_dispatch_call_block_and_release(void *block) {
   lsan_block_context_t *context = (lsan_block_context_t *)block;
   VReport(2,

compiler-rt/lib/lsan/lsan_posix.cpp

struct OnStartedArgs {
   uptr cache_begin;
   uptr cache_end;
   uptr tls_begin;
   uptr tls_end;
   DTLS *dtls;
 };
 
 void ThreadContext::OnStarted(void *arg) {
+  ThreadContextLsanBase::OnStarted(arg);
   auto args = reinterpret_cast<const OnStartedArgs *>(arg);
   stack_begin_ = args->stack_begin;
   stack_end_ = args->stack_end;
   tls_begin_ = args->tls_begin;
   tls_end_ = args->tls_end;
   cache_begin_ = args->cache_begin;
   cache_end_ = args->cache_end;
   dtls_ = args->dtls;

compiler-rt/lib/lsan/lsan_thread.h

 
 #include "sanitizer_common/sanitizer_thread_registry.h"
 
 namespace __lsan {
 
 class ThreadContextLsanBase : public ThreadContextBase {
  public:
   explicit ThreadContextLsanBase(int tid);
+  void OnStarted(void *arg) override;
   void OnFinished() override;
   uptr stack_begin() { return stack_begin_; }
   uptr stack_end() { return stack_end_; }
   uptr cache_begin() { return cache_begin_; }
   uptr cache_end() { return cache_end_; }
 
   // The argument is passed on to the subclass's OnStarted member function.
   static void ThreadStart(u32 tid, tid_t os_id, ThreadType thread_type,

compiler-rt/lib/lsan/lsan_thread.cpp

void InitializeThreadRegistry() {
   static ALIGNED(64) char thread_registry_placeholder[sizeof(ThreadRegistry)];
   thread_registry =
       new (thread_registry_placeholder) ThreadRegistry(CreateThreadContext);
 }
 
 ThreadContextLsanBase::ThreadContextLsanBase(int tid)
     : ThreadContextBase(tid) {}
 
+void ThreadContextLsanBase::OnStarted(void *arg) { SetCurrentThread(tid); }
+
 void ThreadContextLsanBase::OnFinished() {
   AllocatorThreadFinish();
   DTLS_Destroy();
+  SetCurrentThread(kInvalidTid);
 }
 
 u32 ThreadCreate(u32 parent_tid, bool detached, void *arg) {
   return thread_registry->CreateThread(0, detached, parent_tid, arg);
 }
 
 void ThreadContextLsanBase::ThreadStart(u32 tid, tid_t os_id,
                                         ThreadType thread_type, void *arg) {
   thread_registry->StartThread(tid, os_id, thread_type, arg);
-  SetCurrentThread(tid);
 }
 
-void ThreadFinish() {
-  thread_registry->FinishThread(GetCurrentThread());
-  SetCurrentThread(kInvalidTid);
-}
+void ThreadFinish() { thread_registry->FinishThread(GetCurrentThread()); }
 
 ThreadContext *CurrentThreadContext() {
   if (!thread_registry)
     return nullptr;
   if (GetCurrentThread() == kInvalidTid)
     return nullptr;
   // No lock needed when getting current thread.
   return (ThreadContext *)thread_registry->GetThreadLocked(GetCurrentThread());