[NFC][lsan] Add GetCurrentThreadId wrapper for GetCurrentThread

[vitalybuka]

Summary

D148281 will change return type of GetCurrentThread(), so it will
return ThreadContext instead of id.

[vitalybuka]

rebase

[MaskRay]

I am going to change return type of GetCurrentThreadId() in the next patch.

Add more context what the inline u32 GetCurrentThreadId() { return GetCurrentThread(); } forwarder does?

[vitalybuka]

In D148394#4270273, @MaskRay wrote:

I am going to change return type of GetCurrentThreadId() in the next patch.

Add more context what the inline u32 GetCurrentThreadId() { return GetCurrentThread(); } forwarder does?

Done

compiler-rt/lib/lsan/lsan_fuchsia.cpp

 void *__sanitizer_before_thread_create_hook(thrd_t thread, bool detached,
                                             const char *name, void *stack_base,
                                             size_t stack_size) {
   ENSURE_LSAN_INITED;
   EnsureMainThreadIDIsCorrect();
   OnCreatedArgs args;
   args.stack_begin = reinterpret_cast<uptr>(stack_base);
   args.stack_end = args.stack_begin + stack_size;
-  u32 parent_tid = GetCurrentThread();
+  u32 parent_tid = GetCurrentThreadId();
   u32 tid = ThreadCreate(parent_tid, detached, &args);
   return reinterpret_cast<void *>(static_cast<uptr>(tid));
 }
 
 // This is called after creating a new thread (in the creating thread),
 // with the pointer returned by __sanitizer_before_thread_create_hook (above).
 void __sanitizer_thread_create_hook(void *hook, thrd_t thread, int error) {
   u32 tid = static_cast<u32>(reinterpret_cast<uptr>(hook));

compiler-rt/lib/lsan/lsan_interceptors.cpp

int res;
     // Ignore all allocations made by pthread_create: thread stack/TLS may be
     // stored by pthread for future reuse even after thread destruction, and
     // the linked list it's stored in doesn't even hold valid pointers to the
     // objects, the latter are calculated by obscure pointer arithmetic.
     ScopedInterceptorDisabler disabler;
     res = REAL(pthread_create)(th, attr, __lsan_thread_start_func, &p);
   }
   if (res == 0) {
-    int tid = ThreadCreate(GetCurrentThread(), IsStateDetached(detached));
+    int tid = ThreadCreate(GetCurrentThreadId(), IsStateDetached(detached));
     CHECK_NE(tid, kMainTid);
     atomic_store(&p.tid, tid, memory_order_release);
     while (atomic_load(&p.tid, memory_order_acquire) != 0)
       internal_sched_yield();
   }
   if (attr == &myattr)
     pthread_attr_destroy(&myattr);
   return res;

compiler-rt/lib/lsan/lsan_mac.cpp

 typedef struct {
   void *block;
   dispatch_function_t func;
   u32 parent_tid;
 } lsan_block_context_t;
 
 ALWAYS_INLINE
 void lsan_register_worker_thread(int parent_tid) {
-  if (GetCurrentThread() == kInvalidTid) {
+  if (GetCurrentThreadId() == kInvalidTid) {
     u32 tid = ThreadCreate(parent_tid, true);
     ThreadStart(tid, GetTid());
   }
 }
 
 // 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) {

 // The caller retains control of the allocated context.
 extern "C" lsan_block_context_t *alloc_lsan_context(void *ctxt,
                                                     dispatch_function_t func) {
   GET_STACK_TRACE_THREAD;
   lsan_block_context_t *lsan_ctxt =
       (lsan_block_context_t *)lsan_malloc(sizeof(lsan_block_context_t), stack);
   lsan_ctxt->block = ctxt;
   lsan_ctxt->func = func;
-  lsan_ctxt->parent_tid = GetCurrentThread();
+  lsan_ctxt->parent_tid = GetCurrentThreadId();
   return lsan_ctxt;
 }
 
 // Define interceptor for dispatch_*_f function with the three most common
 // parameters: dispatch_queue_t, context, dispatch_function_t.
 #define INTERCEPT_DISPATCH_X_F_3(dispatch_x_f)                        \
   INTERCEPTOR(void, dispatch_x_f, dispatch_queue_t dq, void *ctxt,    \
               dispatch_function_t func) {                             \

 void dispatch_after(dispatch_time_t when, dispatch_queue_t queue,
                     void (^work)(void));
 void dispatch_source_set_cancel_handler(dispatch_source_t ds,
                                         void (^work)(void));
 void dispatch_source_set_event_handler(dispatch_source_t ds,
                                        void (^work)(void));
 }
 
-#define GET_LSAN_BLOCK(work)                 \
+#    define GET_LSAN_BLOCK(work)                 \
       void (^lsan_block)(void);                  \
-  int parent_tid = GetCurrentThread();       \
+      int parent_tid = GetCurrentThreadId();     \
       lsan_block = ^(void) {                     \
         lsan_register_worker_thread(parent_tid); \
         work();                                  \
       }
 
 INTERCEPTOR(void, dispatch_async, dispatch_queue_t dq, void (^work)(void)) {
   GET_LSAN_BLOCK(work);
   REAL(dispatch_async)(dq, lsan_block);
 }
 
 INTERCEPTOR(void, dispatch_group_async, dispatch_group_t dg,
             dispatch_queue_t dq, void (^work)(void)) {

compiler-rt/lib/lsan/lsan_posix.cpp

 
 static void OnStackUnwind(const SignalContext &sig, const void *,
                           BufferedStackTrace *stack) {
   stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context,
                 common_flags()->fast_unwind_on_fatal);
 }
 
 void LsanOnDeadlySignal(int signo, void *siginfo, void *context) {
-  HandleDeadlySignal(siginfo, context, GetCurrentThread(), &OnStackUnwind,
+  HandleDeadlySignal(siginfo, context, GetCurrentThreadId(), &OnStackUnwind,
                      nullptr);
 }
 
 void InstallAtExitCheckLeaks() {
   if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit)
     Atexit(DoLeakCheck);
 }
 
 }  // namespace __lsan
 
 #endif  // SANITIZER_POSIX

compiler-rt/lib/lsan/lsan_thread.h

 void InitializeMainThread();
 
 ThreadRegistry *GetLsanThreadRegistryLocked();
 
 u32 ThreadCreate(u32 tid, bool detached, void *arg = nullptr);
 void ThreadFinish();
 
 u32 GetCurrentThread();
+inline u32 GetCurrentThreadId() { return GetCurrentThread(); }
 void SetCurrentThread(u32 tid);
 ThreadContext *CurrentThreadContext();
 void EnsureMainThreadIDIsCorrect();
 
 }  // namespace __lsan
 
 #endif  // LSAN_THREAD_H

compiler-rt/lib/lsan/lsan_thread.cpp

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);
 }
 
-void ThreadFinish() { thread_registry->FinishThread(GetCurrentThread()); }
+void ThreadFinish() { thread_registry->FinishThread(GetCurrentThreadId()); }
 
 ThreadContext *CurrentThreadContext() {
   if (!thread_registry)
     return nullptr;
-  if (GetCurrentThread() == kInvalidTid)
+  if (GetCurrentThreadId() == kInvalidTid)
     return nullptr;
   // No lock needed when getting current thread.
-  return (ThreadContext *)thread_registry->GetThreadLocked(GetCurrentThread());
+  return (ThreadContext *)thread_registry->GetThreadLocked(
+      GetCurrentThreadId());
 }
 
 void EnsureMainThreadIDIsCorrect() {
-  if (GetCurrentThread() == kMainTid)
+  if (GetCurrentThreadId() == kMainTid)
     CurrentThreadContext()->os_id = GetTid();
 }
 
 ///// Interface to the common LSan module. /////
 
 void GetThreadExtraStackRangesLocked(tid_t os_id,
                                      InternalMmapVector<Range> *ranges) {}
 void GetThreadExtraStackRangesLocked(InternalMmapVector<Range> *ranges) {}