sanitizer_common: prohibit Mutex(LINKER_INITIALIZED)

[dvyukov]

Summary

Mutex does not support LINKER_INITIALIZED ctor.
But we used to support it with BlockingMutex.
To prevent potential bugs delete LINKER_INITIALIZED Mutex ctor.
Also mark existing ctor as explicit.

Depends on D106944.

compiler-rt/lib/sanitizer_common/sanitizer_mutex.h

struct MutexMeta {
   // then Bar mutex can be locked while under Foo mutex.
   // Can also contain the special MutexLeaf/MutexMulti marks.
   MutexType can_lock[10];
 };
 #endif
 
 class CheckedMutex {
  public:
-  constexpr CheckedMutex(MutexType type)
+  explicit constexpr CheckedMutex(MutexType type)
 #if SANITIZER_CHECK_DEADLOCKS
       : type_(type)
 #endif
   {
   }
 
   ALWAYS_INLINE void Lock() {
 #if SANITIZER_CHECK_DEADLOCKS

 };
 
 // Reader-writer mutex.
 // Derive from CheckedMutex for the purposes of EBO.
 // We could make it a field marked with [[no_unique_address]],
 // but this attribute is not supported by some older compilers.
 class MUTEX Mutex : CheckedMutex {
  public:
-  constexpr Mutex(MutexType type = MutexUnchecked) : CheckedMutex(type) {}
+  explicit constexpr Mutex(MutexType type = MutexUnchecked)
+      : CheckedMutex(type) {}
 
   void Lock() ACQUIRE() {
     CheckedMutex::Lock();
     u64 reset_mask = ~0ull;
     u64 state = atomic_load_relaxed(&state_);
     const uptr kMaxSpinIters = 1500;
     for (uptr spin_iters = 0;; spin_iters++) {
       u64 new_state;
static constexpr u64 kWaitingReaderMask = ((1ull << kCounterWidth) - 1)
                                             << kWaitingReaderShift;
   static constexpr u64 kWaitingWriterShift = 2 * kCounterWidth;
   static constexpr u64 kWaitingWriterInc = 1ull << kWaitingWriterShift;
   static constexpr u64 kWaitingWriterMask = ((1ull << kCounterWidth) - 1)
                                             << kWaitingWriterShift;
   static constexpr u64 kWriterLock = 1ull << (3 * kCounterWidth);
   static constexpr u64 kWriterSpinWait = 1ull << (3 * kCounterWidth + 1);
 
+  Mutex(LinkerInitialized) = delete;
   Mutex(const Mutex &) = delete;
   void operator=(const Mutex &) = delete;
 };
 
 void FutexWait(atomic_uint32_t *p, u32 cmp);
 void FutexWake(atomic_uint32_t *p, u32 count);
 
 class MUTEX BlockingMutex {