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

[DanielMcIntosh-IBM]

Summary

Stop __cxa_get_globals and __cxa_get_globals_fast from using thread-local storage
when the threading API is disabled.

Also stop test_exception_storage.pass.cpp from spawning threads when the
threading API is disabled.

Depends on D110349, D113048

[jroelofs]

libcxxabi/src/cxa_exception_storage.cpp

103

I think this design requires that a platform never have the ability to transition a process from disabled threads to enabled threads. Even if x/OS cannot do that (can it?), I think it's important to capture that in the documentation of __libcpp_are_threads_enabled in the other patch. Perhaps this static variable ought to be hoisted into that function's implementation too.

[DanielMcIntosh-IBM]

Address review comments

[jroelofs]

LGTM, but of course, please get a Group Reviewer's approval too.

[DanielMcIntosh-IBM]

Rebase and update intentation to match the rest of the file

libcxxabi/src/cxa_exception_storage.cpp

__cxa_eh_globals *__cxa_get_globals() {
         return retVal;
     }
 
     // Note that this implementation will reliably return NULL if not
     // preceded by a call to __cxa_get_globals().  This is an extension
     // to the Itanium ABI and is taken advantage of in several places in
     // libc++abi.
     __cxa_eh_globals *__cxa_get_globals_fast() {
+        // If threads are disabled at runtime, revert to single-threaded implementation.
+        if (!std::__libcpp_is_threading_api_enabled()) {
+            static __cxa_eh_globals eh_globals;
+            return &eh_globals;
+        }
         // First time through, create the key.
         if (0 != std::__libcpp_execute_once(&flag_, construct_))
             abort_message("execute once failure in __cxa_get_globals_fast()");
         return static_cast<__cxa_eh_globals*>(std::__libcpp_tls_get(key_));
     }
 } // extern "C"
 } // namespace __cxxabiv1
 
 #endif

libcxxabi/test/test_exception_storage.pass.cpp

 
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 #define NUMTHREADS  10
 size_t                 thread_globals [ NUMTHREADS ] = { 0 };
 std::__libcpp_thread_t   threads        [ NUMTHREADS ];
 #endif
 
 int main() {
-#ifndef _LIBCXXABI_HAS_NO_THREADS
+#ifdef _LIBCXXABI_HAS_NO_THREADS
+    size_t thread_globals;
+    thread_code(&thread_globals);
+    // Check that __cxa_get_globals() is not NULL.
+    return (thread_globals == 0) ? 1 : 0;
+#else  // !_LIBCXXABI_HAS_NO_THREADS
+    // If threads are disabled at runtime, revert to single-threaded test.
+    if (!std::__libcpp_is_threading_api_enabled()) {
+        thread_code((void*)thread_globals);
+        // Check that __cxa_get_globals() is not NULL.
+        return (thread_globals[0] == 0) ? 1 : 0;
+    }
+
 //  Make the threads, let them run, and wait for them to finish
     for ( int i = 0; i < NUMTHREADS; ++i )
         std::__libcpp_thread_create ( threads + i, thread_code, (void *) (thread_globals + i));
     for ( int i = 0; i < NUMTHREADS; ++i )
         std::__libcpp_thread_join ( &threads [ i ] );
 
     int retVal = 0;
     for ( int i = 0; i < NUMTHREADS; ++i ) {
         if ( 0 == thread_globals [ i ] ) {
             std::printf("Thread #%d had a zero global\n", i);
             retVal = 1;
         }
     }
 
     std::sort ( thread_globals, thread_globals + NUMTHREADS );
     for ( int i = 1; i < NUMTHREADS; ++i ) {
         if ( thread_globals [ i - 1 ] == thread_globals [ i ] ) {
             std::printf("Duplicate thread globals (%d and %d)\n", i-1, i);
             retVal = 2;
         }
     }
     return retVal;
-#else // _LIBCXXABI_HAS_NO_THREADS
-    size_t thread_globals;
-    thread_code(&thread_globals);
-    // Check that __cxa_get_globals() is not NULL.
-    return (thread_globals == 0) ? 1 : 0;
 #endif // !_LIBCXXABI_HAS_NO_THREADS
 }