[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_is_threading_api_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, between call_once_prep
+    // and finish/abort) c) if that does happen, nobody is inside call_once_prep/
+    // finish/abort, so everybody will check __libcpp_might_have_multiple_threads
+    // again, and aquire the mutex before reading/writing to flag.
+    if (!__libcpp_might_have_multiple_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_might_have_multiple_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_might_have_multiple_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**)
 {
+#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
     // 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);
     }