[NFC][sanitizer] Rename *ThreadRegistry functions

compiler-rt/lib/asan/asan_thread.cpp

__asan::AsanThread *GetAsanThreadByOsIDLocked(tid_t os_id) {
   if (!context)
     return nullptr;
   return context->thread;
 }
 }  // namespace __asan
 
 // --- Implementation of LSan-specific functions --- {{{1
 namespace __lsan {
-void LockThreadRegistry() {
+void LockThreads() {
   __asan::asanThreadRegistry().Lock();
   __asan::asanThreadArgRetval().Lock();
 }
 
-void UnlockThreadRegistry() {
+void UnlockThreads() {
   __asan::asanThreadArgRetval().Unlock();
   __asan::asanThreadRegistry().Unlock();
 }
 
 static ThreadRegistry *GetAsanThreadRegistryLocked() {
   __asan::asanThreadRegistry().CheckLocked();
   return &__asan::asanThreadRegistry();
 }

compiler-rt/lib/hwasan/hwasan_thread.cpp

static __hwasan::HwasanThreadList *GetHwasanThreadListLocked() {
   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() {
+void LockThreads() {
   __hwasan::hwasanThreadList().Lock();
   __hwasan::hwasanThreadArgRetval().Lock();
 }
 
-void UnlockThreadRegistry() {
+void UnlockThreads() {
   __hwasan::hwasanThreadArgRetval().Unlock();
   __hwasan::hwasanThreadList().Unlock();
 }
 
 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,

compiler-rt/lib/lsan/lsan.cpp

extern "C" void __lsan_init() {
   CacheBinaryName();
   AvoidCVE_2016_2143();
   InitializeFlags();
   InitCommonLsan();
   InitializeAllocator();
   ReplaceSystemMalloc();
   InitTlsSize();
   InitializeInterceptors();
-  InitializeThreadRegistry();
+  InitializeThreads();
   InstallDeadlySignalHandlers(LsanOnDeadlySignal);
   InitializeMainThread();
   InstallAtExitCheckLeaks();
 
   InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
 
   lsan_inited = true;
   lsan_init_is_running = false;
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_print_stack_trace() {
   GET_STACK_TRACE_FATAL;
   stack.Print();
 }

compiler-rt/lib/lsan/lsan_common.h

 // Returns true if [addr, addr + sizeof(void *)) is poisoned.
 bool WordIsPoisoned(uptr addr);
 
 //// --------------------------------------------------------------------------
 //// Thread prototypes.
 //// --------------------------------------------------------------------------
 
 // Wrappers for ThreadRegistry access.
-void LockThreadRegistry() SANITIZER_NO_THREAD_SAFETY_ANALYSIS;
-void UnlockThreadRegistry() SANITIZER_NO_THREAD_SAFETY_ANALYSIS;
+void LockThreads() SANITIZER_NO_THREAD_SAFETY_ANALYSIS;
+void UnlockThreads() SANITIZER_NO_THREAD_SAFETY_ANALYSIS;
 // If called from the main thread, updates the main thread's TID in the thread
 // registry. We need this to handle processes that fork() without a subsequent
 // exec(), which invalidates the recorded TID. To update it, we must call
 // gettid() from the main thread. Our solution is to call this function before
 // leak checking and also before every call to pthread_create() (to handle cases
 // where leak checking is initiated from a non-main thread).
 void EnsureMainThreadIDIsCorrect();
 

 
 // Helper for __lsan_ignore_object().
 IgnoreObjectResult IgnoreObject(const void *p);
 
 // The rest of the LSan interface which is implemented by library.
 
 struct ScopedStopTheWorldLock {
   ScopedStopTheWorldLock() {
-    LockThreadRegistry();
+    LockThreads();
     LockAllocator();
   }
 
   ~ScopedStopTheWorldLock() {
     UnlockAllocator();
-    UnlockThreadRegistry();
+    UnlockThreads();
   }
 
   ScopedStopTheWorldLock &operator=(const ScopedStopTheWorldLock &) = delete;
   ScopedStopTheWorldLock(const ScopedStopTheWorldLock &) = delete;
 };
 
 struct Flags {
 #define LSAN_FLAG(Type, Name, DefaultValue, Description) Type Name;

compiler-rt/lib/lsan/lsan_thread.h

protected:
   uptr stack_end_ = 0;
   uptr cache_begin_ = 0;
   uptr cache_end_ = 0;
 };
 
 // This subclass of ThreadContextLsanBase is declared in an OS-specific header.
 class ThreadContext;
 
-void InitializeThreadRegistry();
+void InitializeThreads();
 void InitializeMainThread();
 
 ThreadRegistry *GetLsanThreadRegistryLocked();
 ThreadArgRetval &GetThreadArgRetval();
 
 u32 ThreadCreate(u32 tid, bool detached, void *arg = nullptr);
 void ThreadFinish();
 

compiler-rt/lib/lsan/lsan_thread.cpp

 static Mutex mu_for_thread_context;
 static LowLevelAllocator allocator_for_thread_context;
 
 static ThreadContextBase *CreateThreadContext(u32 tid) {
   Lock lock(&mu_for_thread_context);
   return new (allocator_for_thread_context) ThreadContext(tid);
 }
 
-void InitializeThreadRegistry() {
+void InitializeThreads() {
   static ALIGNED(alignof(
       ThreadRegistry)) char thread_registry_placeholder[sizeof(ThreadRegistry)];
   thread_registry =
       new (thread_registry_placeholder) ThreadRegistry(CreateThreadContext);
 
   static ALIGNED(alignof(ThreadArgRetval)) char
       thread_arg_retval_placeholder[sizeof(ThreadArgRetval)];
   thread_arg_retval = new (thread_arg_retval_placeholder) ThreadArgRetval();

 }
 
 ///// Interface to the common LSan module. /////
 
 void GetThreadExtraStackRangesLocked(tid_t os_id,
                                      InternalMmapVector<Range> *ranges) {}
 void GetThreadExtraStackRangesLocked(InternalMmapVector<Range> *ranges) {}
 
-void LockThreadRegistry() {
+void LockThreads() {
   thread_registry->Lock();
   thread_arg_retval->Lock();
 }
 
-void UnlockThreadRegistry() {
+void UnlockThreads() {
   thread_arg_retval->Unlock();
   thread_registry->Unlock();
 }
 
 ThreadRegistry *GetLsanThreadRegistryLocked() {
   thread_registry->CheckLocked();
   return thread_registry;
 }