diff --git a/libcxxabi/src/cxa_guard_impl.h b/libcxxabi/src/cxa_guard_impl.h
--- a/libcxxabi/src/cxa_guard_impl.h
+++ b/libcxxabi/src/cxa_guard_impl.h
@@ -144,6 +144,12 @@
   IntType* b_;
 };
 
+#ifdef _LIBCXXABI_HAS_NO_THREADS
+static inline bool IsThreaded() { return false; }
+#else
+static inline bool IsThreaded() { return std::__libcpp_might_have_multiple_threads(); }
+#endif
+
 //===----------------------------------------------------------------------===//
 //                       PlatformGetThreadID
 //===----------------------------------------------------------------------===//
@@ -529,6 +535,57 @@
   static_assert(Wait != nullptr && Wake != nullptr, "");
 };
 
+//===----------------------------------------------------------------------===//
+//                         Hybrid Implementation
+//===----------------------------------------------------------------------===//
+
+/// InitByteHybrid - At runtime determines whether we're in a single-threaded
+/// or multi-threaded environment. Then manages reads and writes to the init
+/// byte by delegating to either InitByteNoThreads or InitByteGlobalMutex.
+template <class Mutex, class CondVar, Mutex& global_mutex, CondVar& global_cond,
+          uint32_t (*GetThreadID)() = PlatformThreadID, bool (*ImpSelector)() = IsThreaded>
+struct InitByteHybrid {
+  using InitByteGlobalMutexT = InitByteGlobalMutex<Mutex, CondVar, global_mutex, global_cond, GetThreadID>;
+
+private:
+  InitByteNoThreads init_byte_no_threads;
+  InitByteGlobalMutexT init_byte_global_mutex;
+
+public:
+  InitByteHybrid() = delete;
+  InitByteHybrid(InitByteHybrid const&) = delete;
+  InitByteHybrid& operator=(InitByteHybrid const&) = delete;
+
+  explicit InitByteHybrid(uint8_t* _init_byte_address, uint32_t* _thread_id_address)
+      : init_byte_no_threads(_init_byte_address, _thread_id_address),
+        init_byte_global_mutex(_init_byte_address, _thread_id_address) {}
+
+  /// The init_byte portion of cxa_guard_acquire. Returns true if
+  /// initialization has already been completed.
+  bool acquire() {
+    if (ImpSelector())
+      return init_byte_global_mutex.acquire();
+    else
+      return init_byte_no_threads.acquire();
+  }
+
+  /// The init_byte portion of cxa_guard_release.
+  void release() {
+    if (ImpSelector())
+      return init_byte_global_mutex.release();
+    else
+      return init_byte_no_threads.release();
+  }
+
+  /// The init_byte portion of cxa_guard_abort.
+  void abort() {
+    if (ImpSelector())
+      return init_byte_global_mutex.abort();
+    else
+      return init_byte_no_threads.abort();
+  }
+};
+
 //===----------------------------------------------------------------------===//
 //                          GuardObject
 //===----------------------------------------------------------------------===//
@@ -609,6 +666,12 @@
           uint32_t (*GetThreadIDArg)() = PlatformThreadID>
 using FutexGuard = GuardObject<InitByteFutex<Wait, Wake, GetThreadIDArg>>;
 
+/// HybridGuard - Manages initialization using a hybrid of InitByteNoThreads
+/// and InitByteGlobalMutex
+template <class Mutex, class CondVar, Mutex& global_mutex, CondVar& global_cond,
+          uint32_t (*GetThreadID)() = PlatformThreadID, bool (*ImpSelector)() = IsThreaded>
+using HybridGuard = GuardObject<InitByteHybrid<Mutex, CondVar, global_mutex, global_cond, GetThreadID, ImpSelector>>;
+
 //===----------------------------------------------------------------------===//
 //
 //===----------------------------------------------------------------------===//
@@ -620,7 +683,7 @@
 template <class T>
 _LIBCPP_SAFE_STATIC T GlobalStatic<T>::instance = {};
 
-enum class Implementation { NoThreads, GlobalMutex, Futex };
+enum class Implementation { NoThreads, GlobalMutex, Futex, Hybrid };
 
 template <Implementation Impl>
 struct SelectImplementation;
@@ -641,11 +704,19 @@
   using type = FutexGuard<PlatformFutexWait, PlatformFutexWake, PlatformThreadID>;
 };
 
+template <>
+struct SelectImplementation<Implementation::Hybrid> {
+  using type = HybridGuard<LibcppMutex, LibcppCondVar, GlobalStatic<LibcppMutex>::instance,
+                           GlobalStatic<LibcppCondVar>::instance, PlatformThreadID>;
+};
+
 // TODO(EricWF): We should prefer the futex implementation when available. But
 // it should be done in a separate step from adding the implementation.
 constexpr Implementation CurrentImplementation =
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
     Implementation::NoThreads;
+#elif defined(__MVS__)
+    Implementation::Hybrid;
 #elif defined(_LIBCXXABI_USE_FUTEX)
     Implementation::Futex;
 #else
diff --git a/libcxxabi/test/guard_test_basic.pass.cpp b/libcxxabi/test/guard_test_basic.pass.cpp
--- a/libcxxabi/test/guard_test_basic.pass.cpp
+++ b/libcxxabi/test/guard_test_basic.pass.cpp
@@ -115,11 +115,20 @@
 void NopFutexWake(int*) { assert(false); }
 uint32_t MockGetThreadID() { return 0; }
 
+bool ImpSelectorFalse() { return false; }
+bool ImpSelectorTrue() { return true; }
+
 int main(int, char**) {
   {
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
     static_assert(CurrentImplementation == Implementation::NoThreads, "");
     static_assert(std::is_same<SelectedImplementation, NoThreadsGuard>::value, "");
+#elif defined(__MVS__)
+    static_assert(CurrentImplementation == Implementation::Hybrid, "");
+    static_assert(std::is_same<SelectedImplementation,
+                               HybridGuard<LibcppMutex, LibcppCondVar, GlobalStatic<LibcppMutex>::instance,
+                                           GlobalStatic<LibcppCondVar>::instance>>::value,
+                  "");
 #else
     static_assert(CurrentImplementation == Implementation::GlobalMutex, "");
     static_assert(std::is_same<SelectedImplementation,
@@ -151,6 +160,16 @@
     Tests<uint32_t, FutexImpl>::test();
     Tests<uint64_t, FutexImpl>::test();
   }
+  {
+    using HybridImplNothreads =
+        HybridGuard<NopMutex, NopCondVar, global_nop_mutex, global_nop_cond, MockGetThreadID, ImpSelectorFalse>;
+    using HybridImplThreaded =
+        HybridGuard<NopMutex, NopCondVar, global_nop_mutex, global_nop_cond, MockGetThreadID, ImpSelectorTrue>;
+    Tests<uint32_t, HybridImplNothreads>::test();
+    Tests<uint64_t, HybridImplNothreads>::test();
+    Tests<uint32_t, HybridImplThreaded>::test();
+    Tests<uint64_t, HybridImplThreaded>::test();
+  }
 
   return 0;
 }
diff --git a/libcxxabi/test/guard_threaded_test.pass.cpp b/libcxxabi/test/guard_threaded_test.pass.cpp
--- a/libcxxabi/test/guard_threaded_test.pass.cpp
+++ b/libcxxabi/test/guard_threaded_test.pass.cpp
@@ -327,6 +327,7 @@
 
 void test_all_impls() {
   using MutexImpl = SelectImplementation<Implementation::GlobalMutex>::type;
+  using HybridImpl = SelectImplementation<Implementation::Hybrid>::type;
 
   // Attempt to test the Futex based implementation if it's supported on the
   // target platform.
@@ -338,6 +339,7 @@
   >::type;
 
   test_impl<MutexImpl>();
+  test_impl<HybridImpl>();
   if (PlatformSupportsFutex())
     test_impl<FutexImpl>();
 }