sanitizers: switch BlockingMutex(LINKER_INITIALIZED) to Mutex

[dvyukov]

Summary

Mutex does not support LINKER_INITIALIZED support.
As preparation to switching BlockingMutex to Mutex,
proactively replace all BlockingMutex(LINKER_INITIALIZED) to Mutex.
All of these are objects with static storage duration and Mutex ctor
is constexpr, so it should be equivalent.

[dvyukov]

compiler-rt/lib/sanitizer_common/sanitizer_coverage_fuchsia.cpp

54

This change is different from the rest.
There is only 1 static instance of this class below.

compiler-rt/lib/asan/asan_globals.cpp

 
 typedef __asan_global Global;
 
 struct ListOfGlobals {
   const Global *g;
   ListOfGlobals *next;
 };
 
-static BlockingMutex mu_for_globals(LINKER_INITIALIZED);
+static Mutex mu_for_globals;
 static LowLevelAllocator allocator_for_globals;
 static ListOfGlobals *list_of_all_globals;
 
 static const int kDynamicInitGlobalsInitialCapacity = 512;
 struct DynInitGlobal {
   Global g;
   bool initialized;
 };
if (g >= grs.g_first && g <= grs.g_last)
       return grs.stack_id;
   }
   return 0;
 }
 
 int GetGlobalsForAddress(uptr addr, Global *globals, u32 *reg_sites,
                          int max_globals) {
   if (!flags()->report_globals) return 0;
-  BlockingMutexLock lock(&mu_for_globals);
+  Lock lock(&mu_for_globals);
   int res = 0;
   for (ListOfGlobals *l = list_of_all_globals; l; l = l->next) {
     const Global &g = *l->g;
     if (flags()->report_globals >= 2)
       ReportGlobal(g, "Search");
     if (IsAddressNearGlobal(addr, g)) {
       internal_memcpy(&globals[res], &g, sizeof(g));
       if (reg_sites)
static void UnregisterGlobal(const Global *g) {
   // Release ODR indicator.
   if (UseODRIndicator(g) && g->odr_indicator != UINTPTR_MAX) {
     u8 *odr_indicator = reinterpret_cast<u8 *>(g->odr_indicator);
     *odr_indicator = UNREGISTERED;
   }
 }
 
 void StopInitOrderChecking() {
-  BlockingMutexLock lock(&mu_for_globals);
+  Lock lock(&mu_for_globals);
   if (!flags()->check_initialization_order || !dynamic_init_globals)
     return;
   flags()->check_initialization_order = false;
   for (uptr i = 0, n = dynamic_init_globals->size(); i < n; ++i) {
     DynInitGlobal &dyn_g = (*dynamic_init_globals)[i];
     const Global *g = &dyn_g.g;
     // Unpoison the whole global.
     PoisonShadowForGlobal(g, 0);
void __asan_unregister_elf_globals(uptr *flag, void *start, void *stop) {
   *flag = 0;
 }
 
 // Register an array of globals.
 void __asan_register_globals(__asan_global *globals, uptr n) {
   if (!flags()->report_globals) return;
   GET_STACK_TRACE_MALLOC;
   u32 stack_id = StackDepotPut(stack);
-  BlockingMutexLock lock(&mu_for_globals);
+  Lock lock(&mu_for_globals);
   if (!global_registration_site_vector) {
     global_registration_site_vector =
         new (allocator_for_globals) GlobalRegistrationSiteVector;
     global_registration_site_vector->reserve(128);
   }
   GlobalRegistrationSite site = {stack_id, &globals[0], &globals[n - 1]};
   global_registration_site_vector->push_back(site);
   if (flags()->report_globals >= 2) {
void __asan_register_globals(__asan_global *globals, uptr n) {
   PoisonShadow(reinterpret_cast<uptr>(globals), n * sizeof(__asan_global),
                kAsanGlobalRedzoneMagic);
 }
 
 // Unregister an array of globals.
 // We must do this when a shared objects gets dlclosed.
 void __asan_unregister_globals(__asan_global *globals, uptr n) {
   if (!flags()->report_globals) return;
-  BlockingMutexLock lock(&mu_for_globals);
+  Lock lock(&mu_for_globals);
   for (uptr i = 0; i < n; i++) {
     if (SANITIZER_WINDOWS && globals[i].beg == 0) {
       // Skip globals that look like padding from the MSVC incremental linker.
       // See comment in __asan_register_globals.
       continue;
     }
     UnregisterGlobal(&globals[i]);
   }

 void __asan_before_dynamic_init(const char *module_name) {
   if (!flags()->check_initialization_order ||
       !CanPoisonMemory() ||
       !dynamic_init_globals)
     return;
   bool strict_init_order = flags()->strict_init_order;
   CHECK(module_name);
   CHECK(asan_inited);
-  BlockingMutexLock lock(&mu_for_globals);
+  Lock lock(&mu_for_globals);
   if (flags()->report_globals >= 3)
     Printf("DynInitPoison module: %s\n", module_name);
   for (uptr i = 0, n = dynamic_init_globals->size(); i < n; ++i) {
     DynInitGlobal &dyn_g = (*dynamic_init_globals)[i];
     const Global *g = &dyn_g.g;
     if (dyn_g.initialized)
       continue;
     if (g->module_name != module_name)
       PoisonShadowForGlobal(g, kAsanInitializationOrderMagic);
     else if (!strict_init_order)
       dyn_g.initialized = true;
   }
 }
 
 // This method runs immediately after dynamic initialization in each TU, when
 // all dynamically initialized globals except for those defined in the current
 // TU are poisoned.  It simply unpoisons all dynamically initialized globals.
 void __asan_after_dynamic_init() {
   if (!flags()->check_initialization_order ||
       !CanPoisonMemory() ||
       !dynamic_init_globals)
     return;
   CHECK(asan_inited);
-  BlockingMutexLock lock(&mu_for_globals);
+  Lock lock(&mu_for_globals);
   // FIXME: Optionally report that we're unpoisoning globals from a module.
   for (uptr i = 0, n = dynamic_init_globals->size(); i < n; ++i) {
     DynInitGlobal &dyn_g = (*dynamic_init_globals)[i];
     const Global *g = &dyn_g.g;
     if (!dyn_g.initialized) {
       // Unpoison the whole global.
       PoisonShadowForGlobal(g, 0);
       // Poison redzones back.
       PoisonRedZones(*g);
     }
   }
 }

compiler-rt/lib/asan/asan_report.cpp

 #include "sanitizer_common/sanitizer_symbolizer.h"
 
 namespace __asan {
 
 // -------------------- User-specified callbacks ----------------- {{{1
 static void (*error_report_callback)(const char*);
 static char *error_message_buffer = nullptr;
 static uptr error_message_buffer_pos = 0;
-static BlockingMutex error_message_buf_mutex(LINKER_INITIALIZED);
+static Mutex error_message_buf_mutex;
 static const unsigned kAsanBuggyPcPoolSize = 25;
 static __sanitizer::atomic_uintptr_t AsanBuggyPcPool[kAsanBuggyPcPoolSize];
 
 void AppendToErrorMessageBuffer(const char *buffer) {
-  BlockingMutexLock l(&error_message_buf_mutex);
+  Lock l(&error_message_buf_mutex);
   if (!error_message_buffer) {
     error_message_buffer =
       (char*)MmapOrDieQuietly(kErrorMessageBufferSize, __func__);
     error_message_buffer_pos = 0;
   }
   uptr length = internal_strlen(buffer);
   RAW_CHECK(kErrorMessageBufferSize >= error_message_buffer_pos);
   uptr remaining = kErrorMessageBufferSize - error_message_buffer_pos;
~ScopedInErrorReport() {
 
     if (common_flags()->print_module_map == 2)
       DumpProcessMap();
 
     // Copy the message buffer so that we could start logging without holding a
     // lock that gets aquired during printing.
     InternalMmapVector<char> buffer_copy(kErrorMessageBufferSize);
     {
-      BlockingMutexLock l(&error_message_buf_mutex);
+      Lock l(&error_message_buf_mutex);
       internal_memcpy(buffer_copy.data(),
                       error_message_buffer, kErrorMessageBufferSize);
       // Clear error_message_buffer so that if we find other errors
       // we don't re-log this error.
       error_message_buffer_pos = 0;
     }
 
     LogFullErrorReport(buffer_copy.data());

 void __asan_report_error(uptr pc, uptr bp, uptr sp, uptr addr, int is_write,
                          uptr access_size, u32 exp) {
   ENABLE_FRAME_POINTER;
   bool fatal = flags()->halt_on_error;
   ReportGenericError(pc, bp, sp, addr, is_write, access_size, exp, fatal);
 }
 
 void NOINLINE __asan_set_error_report_callback(void (*callback)(const char*)) {
-  BlockingMutexLock l(&error_message_buf_mutex);
+  Lock l(&error_message_buf_mutex);
   error_report_callback = callback;
 }
 
 void __asan_describe_address(uptr addr) {
   // Thread registry must be locked while we're describing an address.
   asanThreadRegistry().Lock();
   PrintAddressDescription(addr, 1, "");
   asanThreadRegistry().Unlock();

compiler-rt/lib/asan/asan_stats.cpp

 void AsanStats::MergeFrom(const AsanStats *stats) {
   uptr *dst_ptr = reinterpret_cast<uptr*>(this);
   const uptr *src_ptr = reinterpret_cast<const uptr*>(stats);
   uptr num_fields = sizeof(*this) / sizeof(uptr);
   for (uptr i = 0; i < num_fields; i++)
     dst_ptr[i] += src_ptr[i];
 }
 
-static BlockingMutex print_lock(LINKER_INITIALIZED);
+static Mutex print_lock;
 
 static AsanStats unknown_thread_stats(LINKER_INITIALIZED);
 static AsanStats dead_threads_stats(LINKER_INITIALIZED);
-static BlockingMutex dead_threads_stats_lock(LINKER_INITIALIZED);
+static Mutex dead_threads_stats_lock;
 // Required for malloc_zone_statistics() on OS X. This can't be stored in
 // per-thread AsanStats.
 static uptr max_malloced_memory;
 
 static void MergeThreadStats(ThreadContextBase *tctx_base, void *arg) {
   AsanStats *accumulated_stats = reinterpret_cast<AsanStats*>(arg);
   AsanThreadContext *tctx = static_cast<AsanThreadContext*>(tctx_base);
   if (AsanThread *t = tctx->thread)
     accumulated_stats->MergeFrom(&t->stats());
 }
 
 static void GetAccumulatedStats(AsanStats *stats) {
   stats->Clear();
   {
     ThreadRegistryLock l(&asanThreadRegistry());
     asanThreadRegistry()
         .RunCallbackForEachThreadLocked(MergeThreadStats, stats);
   }
   stats->MergeFrom(&unknown_thread_stats);
   {
-    BlockingMutexLock lock(&dead_threads_stats_lock);
+    Lock lock(&dead_threads_stats_lock);
     stats->MergeFrom(&dead_threads_stats);
   }
   // This is not very accurate: we may miss allocation peaks that happen
   // between two updates of accumulated_stats_. For more accurate bookkeeping
   // the maximum should be updated on every malloc(), which is unacceptable.
   if (max_malloced_memory < stats->malloced) {
     max_malloced_memory = stats->malloced;
   }
 }
 
 void FlushToDeadThreadStats(AsanStats *stats) {
-  BlockingMutexLock lock(&dead_threads_stats_lock);
+  Lock lock(&dead_threads_stats_lock);
   dead_threads_stats.MergeFrom(stats);
   stats->Clear();
 }
 
 void FillMallocStatistics(AsanMallocStats *malloc_stats) {
   AsanStats stats;
   GetAccumulatedStats(&stats);
   malloc_stats->blocks_in_use = stats.mallocs;
   malloc_stats->size_in_use = stats.malloced;
   malloc_stats->max_size_in_use = max_malloced_memory;
   malloc_stats->size_allocated = stats.mmaped;
 }
 
 AsanStats &GetCurrentThreadStats() {
   AsanThread *t = GetCurrentThread();
   return (t) ? t->stats() : unknown_thread_stats;
 }
 
 static void PrintAccumulatedStats() {
   AsanStats stats;
   GetAccumulatedStats(&stats);
   // Use lock to keep reports from mixing up.
-  BlockingMutexLock lock(&print_lock);
+  Lock lock(&print_lock);
   stats.Print();
   StackDepotStats *stack_depot_stats = StackDepotGetStats();
   Printf("Stats: StackDepot: %zd ids; %zdM allocated\n",
          stack_depot_stats->n_uniq_ids, stack_depot_stats->allocated >> 20);
   PrintInternalAllocatorStats();
 }
 
 }  // namespace __asan

compiler-rt/lib/asan/asan_thread.cpp

void AsanThreadContext::OnFinished() {
   // Drop the link to the AsanThread object.
   thread = nullptr;
 }
 
 // MIPS requires aligned address
 static ALIGNED(16) char thread_registry_placeholder[sizeof(ThreadRegistry)];
 static ThreadRegistry *asan_thread_registry;
 
-static BlockingMutex mu_for_thread_context(LINKER_INITIALIZED);
+static Mutex mu_for_thread_context;
 static LowLevelAllocator allocator_for_thread_context;
 
 static ThreadContextBase *GetAsanThreadContext(u32 tid) {
-  BlockingMutexLock lock(&mu_for_thread_context);
+  Lock lock(&mu_for_thread_context);
   return new(allocator_for_thread_context) AsanThreadContext(tid);
 }
 
 ThreadRegistry &asanThreadRegistry() {
   static bool initialized;
   // Don't worry about thread_safety - this should be called when there is
   // a single thread.
   if (!initialized) {

compiler-rt/lib/cfi/cfi.cpp

void InitShadow() {
   // Shadow is 2 -> 2**kShadowGranularity.
   SetShadowSize((vma >> (kShadowGranularity - 1)) + 1);
   VReport(1, "CFI: VMA size %zx, shadow size %zx\n", vma, GetShadowSize());
 
   UpdateShadow();
 }
 
 THREADLOCAL int in_loader;
-BlockingMutex shadow_update_lock(LINKER_INITIALIZED);
+Mutex shadow_update_lock;
 
 void EnterLoader() NO_THREAD_SAFETY_ANALYSIS {
   if (in_loader == 0) {
     shadow_update_lock.Lock();
   }
   ++in_loader;
 }
 

 INTERCEPTOR(int, dlclose, void *handle) {
   EnsureInterceptorsInitialized();
   EnterLoader();
   int res = REAL(dlclose)(handle);
   ExitLoader();
   return res;
 }
 
-static BlockingMutex interceptor_init_lock(LINKER_INITIALIZED);
+static Mutex interceptor_init_lock;
 static bool interceptors_inited = false;
 
 static void EnsureInterceptorsInitialized() {
-  BlockingMutexLock lock(&interceptor_init_lock);
+  Lock lock(&interceptor_init_lock);
   if (interceptors_inited)
     return;
 
   INTERCEPT_FUNCTION(dlopen);
   INTERCEPT_FUNCTION(dlclose);
 
   interceptors_inited = true;
 }

compiler-rt/lib/lsan/lsan_common.cpp

 #include "sanitizer_common/sanitizer_thread_registry.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 
 #if CAN_SANITIZE_LEAKS
 namespace __lsan {
 
 // This mutex is used to prevent races between DoLeakCheck and IgnoreObject, and
 // also to protect the global list of root regions.
-BlockingMutex global_mutex(LINKER_INITIALIZED);
+Mutex global_mutex;
 
 Flags lsan_flags;
 
 
 void DisableCounterUnderflow() {
   if (common_flags()->detect_leaks) {
     Report("Unmatched call to __lsan_enable().\n");
     Die();
VReport(1, "Rerun with %zu suppressed stacks.",
             GetSuppressionContext()->GetSortedSuppressedStacks().size());
   }
 }
 
 static bool has_reported_leaks = false;
 bool HasReportedLeaks() { return has_reported_leaks; }
 
 void DoLeakCheck() {
-  BlockingMutexLock l(&global_mutex);
+  Lock l(&global_mutex);
   static bool already_done;
   if (already_done) return;
   already_done = true;
   has_reported_leaks = CheckForLeaks();
   if (has_reported_leaks) HandleLeaks();
 }
 
 static int DoRecoverableLeakCheck() {
-  BlockingMutexLock l(&global_mutex);
+  Lock l(&global_mutex);
   bool have_leaks = CheckForLeaks();
   return have_leaks ? 1 : 0;
 }
 
 void DoRecoverableLeakCheckVoid() { DoRecoverableLeakCheck(); }
 
 Suppression *LeakSuppressionContext::GetSuppressionForAddr(uptr addr) {
   Suppression *s = nullptr;

 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __lsan_ignore_object(const void *p) {
 #if CAN_SANITIZE_LEAKS
   if (!common_flags()->detect_leaks)
     return;
   // Cannot use PointsIntoChunk or LsanMetadata here, since the allocator is not
   // locked.
-  BlockingMutexLock l(&global_mutex);
+  Lock l(&global_mutex);
   IgnoreObjectResult res = IgnoreObjectLocked(p);
   if (res == kIgnoreObjectInvalid)
     VReport(1, "__lsan_ignore_object(): no heap object found at %p", p);
   if (res == kIgnoreObjectAlreadyIgnored)
     VReport(1, "__lsan_ignore_object(): "
            "heap object at %p is already being ignored\n", p);
   if (res == kIgnoreObjectSuccess)
     VReport(1, "__lsan_ignore_object(): ignoring heap object at %p\n", p);
 #endif // CAN_SANITIZE_LEAKS
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __lsan_register_root_region(const void *begin, uptr size) {
 #if CAN_SANITIZE_LEAKS
-  BlockingMutexLock l(&global_mutex);
+  Lock l(&global_mutex);
   CHECK(root_regions);
   RootRegion region = {reinterpret_cast<uptr>(begin), size};
   root_regions->push_back(region);
   VReport(1, "Registered root region at %p of size %llu\n", begin, size);
 #endif // CAN_SANITIZE_LEAKS
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __lsan_unregister_root_region(const void *begin, uptr size) {
 #if CAN_SANITIZE_LEAKS
-  BlockingMutexLock l(&global_mutex);
+  Lock l(&global_mutex);
   CHECK(root_regions);
   bool removed = false;
   for (uptr i = 0; i < root_regions->size(); i++) {
     RootRegion region = (*root_regions)[i];
     if (region.begin == reinterpret_cast<uptr>(begin) && region.size == size) {
       removed = true;
       uptr last_index = root_regions->size() - 1;
       (*root_regions)[i] = (*root_regions)[last_index];

compiler-rt/lib/memprof/memprof_stats.cpp

 void MemprofStats::MergeFrom(const MemprofStats *stats) {
   uptr *dst_ptr = reinterpret_cast<uptr *>(this);
   const uptr *src_ptr = reinterpret_cast<const uptr *>(stats);
   uptr num_fields = sizeof(*this) / sizeof(uptr);
   for (uptr i = 0; i < num_fields; i++)
     dst_ptr[i] += src_ptr[i];
 }
 
-static BlockingMutex print_lock(LINKER_INITIALIZED);
+static Mutex print_lock;
 
 static MemprofStats unknown_thread_stats(LINKER_INITIALIZED);
 static MemprofStats dead_threads_stats(LINKER_INITIALIZED);
-static BlockingMutex dead_threads_stats_lock(LINKER_INITIALIZED);
+static Mutex dead_threads_stats_lock;
 // Required for malloc_zone_statistics() on OS X. This can't be stored in
 // per-thread MemprofStats.
 static uptr max_malloced_memory;
 
 static void MergeThreadStats(ThreadContextBase *tctx_base, void *arg) {
   MemprofStats *accumulated_stats = reinterpret_cast<MemprofStats *>(arg);
   MemprofThreadContext *tctx = static_cast<MemprofThreadContext *>(tctx_base);
   if (MemprofThread *t = tctx->thread)
     accumulated_stats->MergeFrom(&t->stats());
 }
 
 static void GetAccumulatedStats(MemprofStats *stats) {
   stats->Clear();
   {
     ThreadRegistryLock l(&memprofThreadRegistry());
     memprofThreadRegistry().RunCallbackForEachThreadLocked(MergeThreadStats,
                                                            stats);
   }
   stats->MergeFrom(&unknown_thread_stats);
   {
-    BlockingMutexLock lock(&dead_threads_stats_lock);
+    Lock lock(&dead_threads_stats_lock);
     stats->MergeFrom(&dead_threads_stats);
   }
   // This is not very accurate: we may miss allocation peaks that happen
   // between two updates of accumulated_stats_. For more accurate bookkeeping
   // the maximum should be updated on every malloc(), which is unacceptable.
   if (max_malloced_memory < stats->malloced) {
     max_malloced_memory = stats->malloced;
   }
 }
 
 void FlushToDeadThreadStats(MemprofStats *stats) {
-  BlockingMutexLock lock(&dead_threads_stats_lock);
+  Lock lock(&dead_threads_stats_lock);
   dead_threads_stats.MergeFrom(stats);
   stats->Clear();
 }
 
 MemprofStats &GetCurrentThreadStats() {
   MemprofThread *t = GetCurrentThread();
   return (t) ? t->stats() : unknown_thread_stats;
 }
 
 static void PrintAccumulatedStats() {
   MemprofStats stats;
   GetAccumulatedStats(&stats);
   // Use lock to keep reports from mixing up.
-  BlockingMutexLock lock(&print_lock);
+  Lock lock(&print_lock);
   stats.Print();
   StackDepotStats *stack_depot_stats = StackDepotGetStats();
   Printf("Stats: StackDepot: %zd ids; %zdM allocated\n",
          stack_depot_stats->n_uniq_ids, stack_depot_stats->allocated >> 20);
   PrintInternalAllocatorStats();
 }
 
 } // namespace __memprof

compiler-rt/lib/memprof/memprof_thread.cpp

 void MemprofThreadContext::OnFinished() {
   // Drop the link to the MemprofThread object.
   thread = nullptr;
 }
 
 static ALIGNED(16) char thread_registry_placeholder[sizeof(ThreadRegistry)];
 static ThreadRegistry *memprof_thread_registry;
 
-static BlockingMutex mu_for_thread_context(LINKER_INITIALIZED);
+static Mutex mu_for_thread_context;
 static LowLevelAllocator allocator_for_thread_context;
 
 static ThreadContextBase *GetMemprofThreadContext(u32 tid) {
-  BlockingMutexLock lock(&mu_for_thread_context);
+  Lock lock(&mu_for_thread_context);
   return new (allocator_for_thread_context) MemprofThreadContext(tid);
 }
 
 ThreadRegistry &memprofThreadRegistry() {
   static bool initialized;
   // Don't worry about thread_safety - this should be called when there is
   // a single thread.
   if (!initialized) {

compiler-rt/lib/sanitizer_common/sanitizer_coverage_fuchsia.cpp

 static_assert(SANITIZER_WORDSIZE == 64, "Fuchsia is always LP64");
 
 constexpr const char kSancovSinkName[] = "sancov";
 
 // Collects trace-pc guard coverage.
 // This class relies on zero-initialization.
 class TracePcGuardController final {
  public:
+  constexpr TracePcGuardController() {}
+
   // For each PC location being tracked, there is a u32 reserved in global
   // data called the "guard".  At startup, we assign each guard slot a
   // unique index into the big results array.  Later during runtime, the
   // first call to TracePcGuard (below) will store the corresponding PC at
   // that index in the array.  (Each later call with the same guard slot is
   // presumed to be from the same PC.)  Then it clears the guard slot back
   // to zero, which tells the compiler not to bother calling in again.  At
   // the end of the run, we have a big array where each element is either

 
  private:
   // We map in the largest possible view into the VMO: one word
   // for every possible 32-bit index value.  This avoids the need
   // to change the mapping when increasing the size of the VMO.
   // We can always spare the 32G of address space.
   static constexpr size_t MappingSize = sizeof(uptr) << 32;
 
-  BlockingMutex setup_lock_ = BlockingMutex(LINKER_INITIALIZED);
+  Mutex setup_lock_;
   uptr *array_ = nullptr;
   u32 next_index_ = 0;
   zx_handle_t vmo_ = {};
   char vmo_name_[ZX_MAX_NAME_LEN] = {};
 
   size_t DataSize() const { return next_index_ * sizeof(uintptr_t); }
 
   u32 Setup(u32 num_guards) {

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

void *internal_start_thread(void *(*func)(void *arg), void *arg) {
   pthread_create(&th, 0, func, arg);
   internal_sigprocmask(SIG_SETMASK, &old, 0);
   return th;
 }
 
 void internal_join_thread(void *th) { pthread_join((pthread_t)th, 0); }
 
 #if !SANITIZER_GO
-static BlockingMutex syslog_lock(LINKER_INITIALIZED);
-#endif
+static Mutex syslog_lock;
+#  endif
 
 void WriteOneLineToSyslog(const char *s) {
 #if !SANITIZER_GO
   syslog_lock.CheckLocked();
   if (GetMacosAlignedVersion() >= MacosVersion(10, 12)) {
     os_log_error(OS_LOG_DEFAULT, "%{public}s", s);
   } else {
     asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", s);
   }
 #endif
 }
 
 // buffer to store crash report application information
 static char crashreporter_info_buff[__sanitizer::kErrorMessageBufferSize] = {};
-static BlockingMutex crashreporter_info_mutex(LINKER_INITIALIZED);
+static Mutex crashreporter_info_mutex;
 
 extern "C" {
 // Integrate with crash reporter libraries.
 #if HAVE_CRASHREPORTERCLIENT_H
 CRASH_REPORTER_CLIENT_HIDDEN
 struct crashreporter_annotations_t gCRAnnotations
     __attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION))) = {
         CRASHREPORTER_ANNOTATIONS_VERSION,

 static const char *__crashreporter_info__ __attribute__((__used__)) =
     &crashreporter_info_buff[0];
 asm(".desc ___crashreporter_info__, 0x10");
 #endif
 
 }  // extern "C"
 
 static void CRAppendCrashLogMessage(const char *msg) {
-  BlockingMutexLock l(&crashreporter_info_mutex);
+  Lock l(&crashreporter_info_mutex);
   internal_strlcat(crashreporter_info_buff, msg,
                    sizeof(crashreporter_info_buff));
 #if HAVE_CRASHREPORTERCLIENT_H
   (void)CRSetCrashLogMessage(crashreporter_info_buff);
 #endif
 }
 
 void LogMessageOnPrintf(const char *str) {
#endif
 
   // Log to syslog.
   // The logging on OS X may call pthread_create so we need the threading
   // environment to be fully initialized. Also, this should never be called when
   // holding the thread registry lock since that may result in a deadlock. If
   // the reporting thread holds the thread registry mutex, and asl_log waits
   // for GCD to dispatch a new thread, the process will deadlock, because the
   // pthread_create wrapper needs to acquire the lock as well.
-  BlockingMutexLock l(&syslog_lock);
+  Lock l(&syslog_lock);
   if (common_flags()->log_to_syslog)
     WriteToSyslog(buffer);
 
   // The report is added to CrashLog as part of logging all of Printf output.
 #endif
 }
 
 SignalContext::WriteFlag SignalContext::GetWriteFlag() const {

compiler-rt/lib/sanitizer_common/tests/sanitizer_thread_registry_test.cpp

 #include "sanitizer_pthread_wrappers.h"
 
 #include "gtest/gtest.h"
 
 #include <vector>
 
 namespace __sanitizer {
 
-static BlockingMutex tctx_allocator_lock(LINKER_INITIALIZED);
+static Mutex tctx_allocator_lock;
 static LowLevelAllocator tctx_allocator;
 
 template<typename TCTX>
 static ThreadContextBase *GetThreadContext(u32 tid) {
-  BlockingMutexLock l(&tctx_allocator_lock);
+  Lock l(&tctx_allocator_lock);
   return new(tctx_allocator) TCTX(tid);
 }
 
 static const u32 kMaxRegistryThreads = 1000;
 static const u32 kRegistryQuarantine = 2;
 
 static void CheckThreadQuantity(ThreadRegistry *registry, uptr exp_total,
                                 uptr exp_running, uptr exp_alive) {