sanitizer_common: rename Mutex to MutexState

[dvyukov]

Summary

We have 3 different mutexes (RWMutex, BlockingMutex __tsan::Mutex),
each with own set of downsides. I want to unify them under a name Mutex.
But it will conflict with Mutex in the deadlock detector,
which is a way too generic name. Rename it to MutexState.

[dvyukov]

fix Go build

compiler-rt/lib/sanitizer_common/sanitizer_deadlock_detector2.cpp

 };
 
 struct DDLogicalThread {
   u64         ctx;
   ThreadMutex locked[kMaxNesting];
   int         nlocked;
 };
 
-struct Mutex {
+struct MutexState {
   StaticSpinMutex mtx;
   u32 seq;
   int nlink;
   Link link[kMaxLink];
 };
 
 struct DD final : public DDetector {
   explicit DD(const DDFlags *flags);
struct DD final : public DDetector {
   void MutexBeforeUnlock(DDCallback *cb, DDMutex *m, bool wlock);
   void MutexDestroy(DDCallback *cb, DDMutex *m);
 
   DDReport *GetReport(DDCallback *cb);
 
   void CycleCheck(DDPhysicalThread *pt, DDLogicalThread *lt, DDMutex *mtx);
   void Report(DDPhysicalThread *pt, DDLogicalThread *lt, int npath);
   u32 allocateId(DDCallback *cb);
-  Mutex *getMutex(u32 id);
-  u32 getMutexId(Mutex *m);
+  MutexState *getMutex(u32 id);
+  u32 getMutexId(MutexState *m);
 
   DDFlags flags;
 
-  Mutex* mutex[kL1Size];
+  MutexState *mutex[kL1Size];
 
   SpinMutex mtx;
   InternalMmapVector<u32> free_id;
   int id_gen = 0;
 };
 
 DDetector *DDetector::Create(const DDFlags *flags) {
   (void)flags;

 
 void DD::MutexInit(DDCallback *cb, DDMutex *m) {
   VPrintf(2, "#%llu: DD::MutexInit(%p)\n", cb->lt->ctx, m);
   m->id = kNoId;
   m->recursion = 0;
   atomic_store(&m->owner, 0, memory_order_relaxed);
 }
 
-Mutex *DD::getMutex(u32 id) {
-  return &mutex[id / kL2Size][id % kL2Size];
-}
+MutexState *DD::getMutex(u32 id) { return &mutex[id / kL2Size][id % kL2Size]; }
 
-u32 DD::getMutexId(Mutex *m) {
+u32 DD::getMutexId(MutexState *m) {
   for (int i = 0; i < kL1Size; i++) {
-    Mutex *tab = mutex[i];
+    MutexState *tab = mutex[i];
     if (tab == 0)
       break;
     if (m >= tab && m < tab + kL2Size)
       return i * kL2Size + (m - tab);
   }
   return -1;
 }
 
 u32 DD::allocateId(DDCallback *cb) {
   u32 id = -1;
   SpinMutexLock l(&mtx);
   if (free_id.size() > 0) {
     id = free_id.back();
     free_id.pop_back();
   } else {
     CHECK_LT(id_gen, kMaxMutex);
     if ((id_gen % kL2Size) == 0) {
-      mutex[id_gen / kL2Size] = (Mutex*)MmapOrDie(kL2Size * sizeof(Mutex),
-          "deadlock detector (mutex table)");
+      mutex[id_gen / kL2Size] = (MutexState *)MmapOrDie(
+          kL2Size * sizeof(MutexState), "deadlock detector (mutex table)");
     }
     id = id_gen++;
   }
   CHECK_LE(id, kMaxMutex);
   VPrintf(3, "#%llu: DD::allocateId assign id %d\n", cb->lt->ctx, id);
   return id;
 }
 
if (flags.second_deadlock_stack)
     tm->stk = cb->Unwind();
   if (lt->nlocked == 1) {
     VPrintf(3, "#%llu: DD::MutexBeforeLock first mutex\n",
         cb->lt->ctx);
     return;
   }
 
   bool added = false;
-  Mutex *mtx = getMutex(m->id);
+  MutexState *mtx = getMutex(m->id);
   for (int i = 0; i < lt->nlocked - 1; i++) {
     u32 id1 = lt->locked[i].id;
     u32 stk1 = lt->locked[i].stk;
-    Mutex *mtx1 = getMutex(id1);
+    MutexState *mtx1 = getMutex(id1);
     SpinMutexLock l(&mtx1->mtx);
     if (mtx1->nlink == kMaxLink) {
       // FIXME(dvyukov): check stale links
       continue;
     }
     int li = 0;
     for (; li < mtx1->nlink; li++) {
       Link *link = &mtx1->link[li];
if (lt->locked[i].id == m->id) {
       lt->locked[i] = lt->locked[last];
       lt->nlocked--;
       break;
     }
   }
 
   // Clear and invalidate the mutex descriptor.
   {
-    Mutex *mtx = getMutex(m->id);
+    MutexState *mtx = getMutex(m->id);
     SpinMutexLock l(&mtx->mtx);
     mtx->seq++;
     mtx->nlink = 0;
   }
 
   // Return id to cache.
   {
     SpinMutexLock l(&mtx);
     free_id.push_back(m->id);
   }
 }
 
 void DD::CycleCheck(DDPhysicalThread *pt, DDLogicalThread *lt,
     DDMutex *m) {
   internal_memset(pt->visited, 0, sizeof(pt->visited));
   int npath = 0;
   int npending = 0;
   {
-    Mutex *mtx = getMutex(m->id);
+    MutexState *mtx = getMutex(m->id);
     SpinMutexLock l(&mtx->mtx);
     for (int li = 0; li < mtx->nlink; li++)
       pt->pending[npending++] = mtx->link[li];
   }
   while (npending > 0) {
     Link link = pt->pending[--npending];
     if (link.id == kEndId) {
       npath--;
       continue;
     }
     if (pt->visited[link.id])
       continue;
-    Mutex *mtx1 = getMutex(link.id);
+    MutexState *mtx1 = getMutex(link.id);
     SpinMutexLock l(&mtx1->mtx);
     if (mtx1->seq != link.seq)
       continue;
     pt->visited[link.id] = true;
     if (mtx1->nlink == 0)
       continue;
     pt->path[npath++] = link;
     pt->pending[npending++] = Link(kEndId);
     if (link.id == m->id)
       return Report(pt, lt, npath);  // Bingo!
     for (int li = 0; li < mtx1->nlink; li++) {
       Link *link1 = &mtx1->link[li];
-      // Mutex *mtx2 = getMutex(link->id);
+      // MutexState *mtx2 = getMutex(link->id);
       // FIXME(dvyukov): fast seq check
       // FIXME(dvyukov): fast nlink != 0 check
       // FIXME(dvyukov): fast pending check?
       // FIXME(dvyukov): npending can be larger than kMaxMutex
       pt->pending[npending++] = *link1;
     }
   }
 }

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 
 char **GetEnviron() {
   char **argv, **envp;
   GetArgsAndEnv(&argv, &envp);
   return envp;
 }
 
 #if !SANITIZER_SOLARIS
-enum MutexState {
-  MtxUnlocked = 0,
-  MtxLocked = 1,
-  MtxSleeping = 2
-};
+enum { MtxUnlocked = 0, MtxLocked = 1, MtxSleeping = 2 };
 
 BlockingMutex::BlockingMutex() {
   internal_memset(this, 0, sizeof(*this));
 }
 
 void BlockingMutex::Lock() {
   CHECK_EQ(owner_, 0);
   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);