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

[DanielMcIntosh-IBM]

Summary

Stop std::__call_once from performing synchronization when we're in a
single-threaded application in order to prevent calls to mutex functions
when the threading API is disabled.

Depends on D110349, D112319

[DanielMcIntosh-IBM]

Move new test inside #if TEST_STD_VER >= 11 to fix failure in C++03 CI

[DanielMcIntosh-IBM]

Update function names as a result of changes to D110349

[DanielMcIntosh-IBM]

Rebase and update intentation to match the rest of the file

libcxx/src/mutex.cpp

 /// Returns true if it's already been called, and false otherwise
 static inline bool call_once_prep(volatile once_flag::_State_type& flag) {
 #ifdef _LIBCPP_HAS_NO_THREADS
   if (flag != once_flag::_Unset)
     return true;
   flag = once_flag::_Pending;
   return false;
 #else // !_LIBCPP_HAS_NO_THREADS
+  // Instead of checking if threads are enabled using __libcpp_are_threads_enabled,
+  // we can check whether other threads have been spawned, getting a little extra
+  // performance in single-threaded applications.
+  //
+  // This is safe because a) switching from multi- to single-threaded without us
+  // noticing only means we might perform superfluous synchronization. b) we can't
+  // go from single- to multi-threaded unless THIS thread spawns a thread (which
+  // might happen in the user provided function) c) if the user's function DOES
+  // spawn a thread while single-threaded, no thread is currently inside any of
+  // call_once_prep, _finish or _abort.
+  if (!__libcpp_has_spawned_other_threads()) {
+    // Revert to single-threaded implementation
+    if (flag != once_flag::_Unset)
+      return true;
+    flag = once_flag::_Pending;
+    return false;
+  }
+
   __libcpp_mutex_lock(&mut);
   while (flag == once_flag::_Pending)
     __libcpp_condvar_wait(&cv, &mut);
 
   if (flag != once_flag::_Unset) {
     __libcpp_mutex_unlock(&mut);
     return true;
   }
 
   __libcpp_relaxed_store(&flag, once_flag::_Pending);
   __libcpp_mutex_unlock(&mut);
   return false;
 #endif // !_LIBCPP_HAS_NO_THREADS
 }
 
 static inline void call_once_finish(volatile once_flag::_State_type& flag) {
 #ifdef _LIBCPP_HAS_NO_THREADS
   flag = once_flag::_Complete;
 #else // !_LIBCPP_HAS_NO_THREADS
+  // As in call_once_prep, instead of checking if threads are enabled, check
+  // whether other threads have been spawned. See that comment for more details
+  if (!__libcpp_has_spawned_other_threads()) {
+    // Revert to single-threaded implementation
+    flag = once_flag::_Complete;
+    return;
+  }
+
   __libcpp_mutex_lock(&mut);
   __libcpp_atomic_store(&flag, once_flag::_Complete, _AO_Release);
   __libcpp_mutex_unlock(&mut);
   __libcpp_condvar_broadcast(&cv);
 #endif // !_LIBCPP_HAS_NO_THREADS
 }
 
 static inline void call_once_abort(volatile once_flag::_State_type& flag) {
 #ifdef _LIBCPP_HAS_NO_THREADS
   flag = once_flag::_Unset;
 #else // !_LIBCPP_HAS_NO_THREADS
+  // As in call_once_prep, instead of checking if threads are enabled, check
+  // whether other threads have been spawned. See that comment for more details
+  if (!__libcpp_has_spawned_other_threads()) {
+    // Revert to single-threaded implementation
+    flag = once_flag::_Unset;
+    return;
+  }
+
   __libcpp_mutex_lock(&mut);
   __libcpp_relaxed_store(&flag, once_flag::_Unset);
   __libcpp_mutex_unlock(&mut);
   __libcpp_condvar_broadcast(&cv);
 #endif // !_LIBCPP_HAS_NO_THREADS
 }
 
 void __call_once(volatile once_flag::_State_type& flag, void* arg, void (*func)(void*)) {

libcxx/test/std/thread/thread.mutex/thread.once/thread.once.callonce/call_once.pass.cpp

 std::once_flag flg2;
 
 void f2()
 {
     std::call_once(flg2, init2(), 2, 3);
     std::call_once(flg2, init2(), 4, 5);
 }
 
+std::once_flag flg5;
+
+int init5_called = 0;
+
+void f5();
+
+void init5(std::thread* t0) {
+  if (t0 != nullptr) {
+    *t0 = support::make_test_thread(f5);
+    std::this_thread::sleep_for(ms(250));
+  }
+  ++init5_called;
+}
+
+void f5() { std::call_once(flg5, init5, nullptr); }
+
 #endif // TEST_STD_VER >= 11
 
 std::once_flag flg41;
 std::once_flag flg42;
 
 int init41_called = 0;
 int init42_called = 0;
 
struct RefQual
     void operator()() & { ++lv_called; }
     void operator()() && { ++rv_called; }
 };
 
 #endif // TEST_STD_VER >= 11
 
 int main(int, char**)
 {
-    // check basic functionality
-    {
-        std::thread t0 = support::make_test_thread(f0);
-        std::thread t1 = support::make_test_thread(f0);
-        t0.join();
-        t1.join();
-        assert(init0_called == 1);
-    }
+#if TEST_STD_VER >= 11
+  // check 2nd thread spawned from inside init
+  //
+  // This test is most useful if it is done before the other checks, that way
+  // when we first enter init5, no other threads have ever been created
+  {
+    std::thread t0; // don't start a second thread yet
+    std::call_once(flg5, init5, &t0);
+    t0.join();
+    assert(init5_called == 1);
+  }
+#endif // TEST_STD_VER >= 11
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    // check basic exception safety
-    {
-        std::thread t0 = support::make_test_thread(f3);
-        std::thread t1 = support::make_test_thread(f3);
-        t0.join();
-        t1.join();
-        assert(init3_called == 2);
-        assert(init3_completed == 1);
-    }
 #endif
-    // check deadlock avoidance
-    {
-        std::thread t0 = support::make_test_thread(f41);
-        std::thread t1 = support::make_test_thread(f42);
-        t0.join();
-        t1.join();
-        assert(init41_called == 1);
-        assert(init42_called == 1);
-    }
 #if TEST_STD_VER >= 11
-    // check functors with 1 arg
-    {
-        std::thread t0 = support::make_test_thread(f1);
-        std::thread t1 = support::make_test_thread(f1);
-        t0.join();
-        t1.join();
-        assert(init1::called == 1);
-    }
-    // check functors with 2 args
-    {
-        std::thread t0 = support::make_test_thread(f2);
-        std::thread t1 = support::make_test_thread(f2);
-        t0.join();
-        t1.join();
-        assert(init2::called == 5);
-    }
-    {
-        std::once_flag f;
-        std::call_once(f, MoveOnly(), MoveOnly());
-    }
-    // check LWG2442: call_once() shouldn't DECAY_COPY()
-    {
-        std::once_flag f;
-        int i = 0;
-        std::call_once(f, NonCopyable(), i);
-    }
   // reference qualifiers on functions are a C++11 extension
-    {
-        std::once_flag f1, f2;
-        RefQual rq;
-        std::call_once(f1, rq);
-        assert(rq.lv_called == 1);
-        std::call_once(f2, std::move(rq));
-        assert(rq.rv_called == 1);
-    }
 #endif // TEST_STD_VER >= 11
 
   return 0;
 }