sanitizer_common: don't use [[no_unique_address]]

[dvyukov]

Summary

https://lab.llvm.org/buildbot#builders/112/builds/7881
https://lab.llvm.org/buildbot#builders/121/builds/9907
https://lab.llvm.org/buildbot#builders/105/builds/12770
../../sanitizer_common/sanitizer_mutex.h:288:38: error:
'no_unique_address' attribute directive ignored [-Werror=attributes]

[[no_unique_address]] CheckedMutex checked_;

[melver]

Right, this is only guaranteed to exist with C++20 or later. I guess we're not there yet.

compiler-rt/lib/sanitizer_common/sanitizer_mutex.h

#if SANITIZER_CHECK_DEADLOCKS
 
   void LockImpl(uptr pc);
   void UnlockImpl();
   static void CheckNoLocksImpl();
 #endif
 };
 
 // Reader-writer mutex.
-class MUTEX 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) : checked_(type) {}
+  constexpr Mutex(MutexType type = MutexUnchecked) : CheckedMutex(type) {}
 
   void Lock() ACQUIRE() {
-    checked_.Lock();
+    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;
       bool locked = (state & (kWriterLock | kReaderLockMask)) != 0;
       if (LIKELY(!locked)) {
         // The mutex is not read-/write-locked, try to lock.
for (uptr spin_iters = 0;; spin_iters++) {
       // or we just spun but set kWriterSpinWait.
       // Either way we need to reset kWriterSpinWait
       // next time we take the lock or block again.
       reset_mask = ~kWriterSpinWait;
     }
   }
 
   void Unlock() RELEASE() {
-    checked_.Unlock();
+    CheckedMutex::Unlock();
     bool wake_writer;
     u64 wake_readers;
     u64 new_state;
     u64 state = atomic_load_relaxed(&state_);
     do {
       DCHECK_NE(state & kWriterLock, 0);
       DCHECK_EQ(state & kReaderLockMask, 0);
       new_state = state & ~kWriterLock;
do {
                                                     memory_order_release)));
     if (UNLIKELY(wake_writer))
       writers_.Post();
     else if (UNLIKELY(wake_readers))
       readers_.Post(wake_readers);
   }
 
   void ReadLock() ACQUIRE_SHARED() {
-    checked_.Lock();
+    CheckedMutex::Lock();
     bool locked;
     u64 new_state;
     u64 state = atomic_load_relaxed(&state_);
     do {
       locked =
           (state & kReaderLockMask) == 0 &&
           (state & (kWriterLock | kWriterSpinWait | kWaitingWriterMask)) != 0;
       if (LIKELY(!locked))
         new_state = state + kReaderLockInc;
       else
         new_state = state + kWaitingReaderInc;
     } while (UNLIKELY(!atomic_compare_exchange_weak(&state_, &state, new_state,
                                                     memory_order_acquire)));
     if (UNLIKELY(locked))
       readers_.Wait();
     DCHECK_EQ(atomic_load_relaxed(&state_) & kWriterLock, 0);
     DCHECK_NE(atomic_load_relaxed(&state_) & kReaderLockMask, 0);
   }
 
   void ReadUnlock() RELEASE_SHARED() {
-    checked_.Unlock();
+    CheckedMutex::Unlock();
     bool wake;
     u64 new_state;
     u64 state = atomic_load_relaxed(&state_);
     do {
       DCHECK_NE(state & kReaderLockMask, 0);
       DCHECK_EQ(state & (kWaitingReaderMask | kWriterLock), 0);
       new_state = state - kReaderLockInc;
       wake = (new_state & (kReaderLockMask | kWriterSpinWait)) == 0 &&
public:
 
   void CheckLocked() const CHECK_LOCKED() { CheckWriteLocked(); }
 
   void CheckReadLocked() const CHECK_LOCKED() {
     CHECK(atomic_load(&state_, memory_order_relaxed) & kReaderLockMask);
   }
 
  private:
-  [[no_unique_address]] CheckedMutex checked_;
   atomic_uint64_t state_ = {0};
   Semaphore writers_;
   Semaphore readers_;
 
   // The state has 3 counters:
   //  - number of readers holding the lock,
   //    if non zero, the mutex is read-locked
   //  - number of waiting readers,