[libcxx][SystemZ][z/OS] Update libcxx/src/memory.cpp to accommodate POSIX(OFF)

[DanielMcIntosh-IBM]

Summary

Add an early return from __sp_mut::lock() and unlock when we're in a
single-threaded environment to prevent the shared_ptr std::atomic_... overloads
from calling mutex functions when the threading API is disabled.

Depends on D110349

[jroelofs]

libcxx/src/memory.cpp

152

I'd leave the 4-space indentation alone, since that seems to be the local style in the rest of libcxx.

195

micro-optimization: when threading is disabled, always return muts[0].

[DanielMcIntosh-IBM]

Update function names as a result of changes to D110349

libcxx/src/memory.cpp

152

arc actually won't let me not change the indentation

[DanielMcIntosh-IBM]

Rebase and update indentation to match the rest of the file

[DanielMcIntosh-IBM]

libcxx/src/memory.cpp

152

Never mind, just discovered arc's --nolint option

libcxx/src/memory.cpp

 _LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) noexcept
    : __lx(p)
 {
 }
 
 void
 __sp_mut::lock() noexcept
 {
+    // The __sp_mut class should only be used for the shared_ptr overloads of
+    // std::atomic_... functions. Ownership of __sp_mut is always released
+    // before the end of any of these overloads, and none of them spawn new
+    // threads. Thus, there is no danger of one thread calling __sp_mut::lock
+    // and skipping acquisition of __lx followed by another thread calling it
+    // (and acquiring __lx) before the first thread calls __sp_mut::unlock.
+    //
+    // We can't acquire the mutex when the threading API is disabled. Since we
+    // don't need to acquire it when single-threaded anyways, we just don't
+    // bother aquiring the mutex unless we're multi-threaded (and thus the
+    // threading API is enabled).
+    if (!__libcpp_might_have_multiple_threads())
+        return;
     auto m = static_cast<__libcpp_mutex_t*>(__lx);
     unsigned count = 0;
-    while (!__libcpp_mutex_trylock(m))
-    {
-        if (++count > 16)
-        {
+    while (!__libcpp_mutex_trylock(m)) {
+        if (++count > 16) {
             __libcpp_mutex_lock(m);
             break;
         }
         this_thread::yield();
     }
 }
 
 void
 __sp_mut::unlock() noexcept
 {
+    // See comment in __sp_mut::lock() for discussion of why this is safe.
+    if (!__libcpp_might_have_multiple_threads())
+        return;
     __libcpp_mutex_unlock(static_cast<__libcpp_mutex_t*>(__lx));
 }
 
 __sp_mut&
 __get_sp_mut(const void* p)
 {
     static __sp_mut muts[__sp_mut_count]
     {
         &mut_back[ 0], &mut_back[ 1], &mut_back[ 2], &mut_back[ 3],
         &mut_back[ 4], &mut_back[ 5], &mut_back[ 6], &mut_back[ 7],
         &mut_back[ 8], &mut_back[ 9], &mut_back[10], &mut_back[11],
         &mut_back[12], &mut_back[13], &mut_back[14], &mut_back[15]
     };
     return muts[hash<const void*>()(p) & (__sp_mut_count-1)];
 }
 
 #endif // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 
 void
 declare_reachable(void*)
 {
 }