[NFC][libcxxabi] In cxa_guard, add a dedicated base class for the Guard classes.

[DanielMcIntosh-IBM]

Summary

This moves all of the common work such as splitting up the raw guard
object out of the individual Guard classes. In the process we also
update the signature of the InitByteNoThreads constructor to match the
others.

While the Guard classes already all inherited from the GuardObject
class, we want that to focus on managing reads/writes to the guard byte
(and thus we renamed GuardObject to GuardByte).

This is the 4th of 6 changes to overhaul cxa_guard.
See D108343 for what the final result will be and more details on why
cxa_guard is getting overhauled.

Depends on D110093

[DanielMcIntosh-IBM]

Ping

[DanielMcIntosh-IBM]

Ping.

[DanielMcIntosh-IBM]

Ping

[DanielMcIntosh-IBM]

Abandoning, since I no longer think this is the best way of grouping the changes. See D115367, D115368 and D115369 for a newer version that groups things a little better.

libcxxabi/src/cxa_guard_impl.h

uint32_t PlatformThreadID() {
   static_assert(sizeof(pid_t) == sizeof(uint32_t), "");
   return static_cast<uint32_t>(syscall(SYS_gettid));
 }
 #else
 constexpr uint32_t (*PlatformThreadID)() = nullptr;
 #endif
 
 //===----------------------------------------------------------------------===//
-//                          GuardBase
+//                          GuardByte
 //===----------------------------------------------------------------------===//
 
 enum class AcquireResult {
   INIT_IS_DONE,
   INIT_IS_PENDING,
 };
 constexpr AcquireResult INIT_IS_DONE = AcquireResult::INIT_IS_DONE;
 constexpr AcquireResult INIT_IS_PENDING = AcquireResult::INIT_IS_PENDING;
 
 static constexpr uint8_t UNSET = 0;
 static constexpr uint8_t COMPLETE_BIT = (1 << 0);
 static constexpr uint8_t PENDING_BIT = (1 << 1);
 static constexpr uint8_t WAITING_BIT = (1 << 2);
 
+/// Manages reads and writes to the guard byte. Until cxa_guard_release is
+/// called this is basically a wrapper around the Derived class
 template <class Derived>
-struct GuardObject {
-  GuardObject() = delete;
-  GuardObject(GuardObject const&) = delete;
-  GuardObject& operator=(GuardObject const&) = delete;
+struct GuardByte {
+  GuardByte() = delete;
+  GuardByte(GuardByte const&) = delete;
+  GuardByte& operator=(GuardByte const&) = delete;
 
-  explicit GuardObject(uint8_t* const guard_byte_address) : guard_byte(guard_byte_address) {}
+  explicit GuardByte(uint8_t* const guard_byte_address) : guard_byte(guard_byte_address) {}
 
 public:
   /// Implements __cxa_guard_acquire
   AcquireResult cxa_guard_acquire() {
     if (guard_byte.load(std::_AO_Acquire) != UNSET)
       return INIT_IS_DONE;
     return derived()->acquire_init_byte();
   }

 
 /// InitByteNoThreads - Doesn't use any inter-thread synchronization when
 /// managing reads and writes to the init byte.
 struct InitByteNoThreads {
   InitByteNoThreads() = delete;
   InitByteNoThreads(InitByteNoThreads const&) = delete;
   InitByteNoThreads& operator=(InitByteNoThreads const&) = delete;
 
-  explicit InitByteNoThreads(uint8_t* _init_byte_address) : init_byte_address(_init_byte_address) {}
+  explicit InitByteNoThreads(uint8_t* _init_byte_address, uint32_t*) : init_byte_address(_init_byte_address) {}
 
   /// The init_byte portion of cxa_guard_acquire.
   /// Note: On completion, we haven't 'acquired' ownership of anything mutex
   /// related. The name is simply referring to __cxa_guard_acquire.
   AcquireResult acquire_init_byte() {
     if (*init_byte_address == COMPLETE_BIT)
       return INIT_IS_DONE;
     if (*init_byte_address & PENDING_BIT)
private:
 
   static_assert(Wait != nullptr && Wake != nullptr, "");
 };
 
 //===----------------------------------------------------------------------===//
 //                                   Guards
 //===----------------------------------------------------------------------===//
 
+template <class InitByteT>
+struct GuardBase : GuardByte<GuardBase<InitByteT>>, InitByteT {
+  using GuardByteT = typename GuardBase::GuardByte;
+
+  GuardBase() = delete;
+  GuardBase(GuardBase const&) = delete;
+  GuardBase& operator=(GuardBase const&) = delete;
+
+  /// ARM Constructor
+  explicit GuardBase(uint32_t* raw_guard_object)
+      : GuardByteT(reinterpret_cast<uint8_t*>(raw_guard_object)),
+        InitByteT(reinterpret_cast<uint8_t*>(raw_guard_object) + 1, nullptr) {}
+
+  /// Itanium Constructor
+  explicit GuardBase(uint64_t* raw_guard_object)
+      : GuardByteT(reinterpret_cast<uint8_t*>(raw_guard_object)),
+        InitByteT(reinterpret_cast<uint8_t*>(raw_guard_object) + 1, reinterpret_cast<uint32_t*>(raw_guard_object) + 1) {
+  }
+};
+
 /// NoThreadsGuard - Manages initialization without performing any inter-thread
 /// synchronization.
-struct NoThreadsGuard : GuardObject<NoThreadsGuard>, InitByteNoThreads {
-  using BaseT = typename NoThreadsGuard::GuardObject;
-  using InitByteT = typename NoThreadsGuard::InitByteNoThreads;
-
-  explicit NoThreadsGuard(uint32_t* raw_guard_object)
-      : BaseT(reinterpret_cast<uint8_t*>(raw_guard_object)),
-        InitByteT(reinterpret_cast<uint8_t*>(raw_guard_object) + 1) {}
-
-  explicit NoThreadsGuard(uint64_t* raw_guard_object)
-      : BaseT(reinterpret_cast<uint8_t*>(raw_guard_object)),
-        InitByteT(reinterpret_cast<uint8_t*>(raw_guard_object) + 1) {}
+struct NoThreadsGuard : GuardBase<InitByteNoThreads> {
+  using BaseT = typename NoThreadsGuard::GuardBase;
+  using BaseT::BaseT;
 };
 
 /// GlobalMutexGuard - Manages initialization using a global mutex and
 /// condition variable.
 template <class Mutex, class CondVar, Mutex& global_mutex, CondVar& global_cond,
           uint32_t (*GetThreadID)() = PlatformThreadID>
-struct GlobalMutexGuard : GuardObject<GlobalMutexGuard<Mutex, CondVar, global_mutex, global_cond, GetThreadID>>,
-                          InitByteGlobalMutex<Mutex, CondVar, global_mutex, global_cond, GetThreadID> {
-
-  using BaseT = typename GlobalMutexGuard::GuardObject;
-  using InitByteT = typename GlobalMutexGuard::InitByteGlobalMutex;
-
-  explicit GlobalMutexGuard(uint32_t* raw_guard_object)
-      : BaseT(reinterpret_cast<uint8_t*>(raw_guard_object)),
-        InitByteT(reinterpret_cast<uint8_t*>(raw_guard_object) + 1, nullptr) {}
-  explicit GlobalMutexGuard(uint64_t* raw_guard_object)
-      : BaseT(reinterpret_cast<uint8_t*>(raw_guard_object)),
-        InitByteT(reinterpret_cast<uint8_t*>(raw_guard_object) + 1, reinterpret_cast<uint32_t*>(raw_guard_object) + 1) {
-  }
+struct GlobalMutexGuard : GuardBase<InitByteGlobalMutex<Mutex, CondVar, global_mutex, global_cond, GetThreadID>> {
+  using BaseT = typename GlobalMutexGuard::GuardBase;
+  using BaseT::BaseT;
 };
 
 /// FutexGuard - Manages initialization using atomics and the futex syscall for
 /// waiting and waking.
 template <void (*Wait)(int*, int) = PlatformFutexWait, void (*Wake)(int*) = PlatformFutexWake,
           uint32_t (*GetThreadIDArg)() = PlatformThreadID>
-struct FutexGuard : GuardObject<FutexGuard<Wait, Wake, GetThreadIDArg>>, InitByteFutex<Wait, Wake, GetThreadIDArg> {
-  using BaseT = typename FutexGuard::GuardObject;
-  using InitByteT = typename FutexGuard::InitByteFutex;
-
-  /// ARM Constructor
-  explicit FutexGuard(uint32_t* raw_guard_object)
-      : BaseT(reinterpret_cast<uint8_t*>(raw_guard_object)),
-        InitByteT(reinterpret_cast<uint8_t*>(raw_guard_object) + 1, nullptr) {}
-
-  /// Itanium Constructor
-  explicit FutexGuard(uint64_t* raw_guard_object)
-      : BaseT(reinterpret_cast<uint8_t*>(raw_guard_object)),
-        InitByteT(reinterpret_cast<uint8_t*>(raw_guard_object) + 1, reinterpret_cast<uint32_t*>(raw_guard_object) + 1) {
-  }
+struct FutexGuard : GuardBase<InitByteFutex<Wait, Wake, GetThreadIDArg>> {
+  using BaseT = typename FutexGuard::GuardBase;
+  using BaseT::BaseT;
 };
 
 //===----------------------------------------------------------------------===//
 //
 //===----------------------------------------------------------------------===//
 
 template <class T>
 struct GlobalStatic {