[libcxxabi] Overhaul test_exception_storage.pass.cpp

[ldionne]

Summary

I'm making a change in this area (https://reviews.llvm.org/D138461), so update the test:

• Add proper synchronization instead of a sleep.
• Avoid some unnecessary size_t casts.
• Spawn the number of hardware threads instead of 10.
• Check that __cxa_get_globals and __cxa_get_globals_fast return the same values.
• Split the test in with-threads and without-threads tests to simplify the code.

[smeenai]

I need to look into the CI failures.

[smeenai]

Rebase

[smeenai]

Print to stderr and add more details to error

[MaskRay]

libcxxabi/test/test_exception_storage.pass.cpp

19–22

static

42

Since #include <thread> is included, is there a reason to use std::__libcpp_thread_t instead of std::thread?

[smeenai]

Address comments

[smeenai]

Mark test as unsupported for C++03

[smeenai]

Rebase and synchronize threads to avoid duplicates

[smeenai]

Hopefully make CI happy this time

[smeenai]

CI is happy now. Could someone from the libc++abi group please take a look?

[smeenai]

Pinging the libc++abi reviewer group.

[ldionne]

[Github PR transition cleanup]

Commandeering to update. There's a few changes I want to make (for example it's not OK to disable this test when localization isn't supported).

[ldionne]

Rebase and make a few changes to avoid requiring localization support.

[ldionne]

Will ship once CI is green.

[ldionne]

Fix C++03 and C++11 tests.

libcxxabi/test/test_exception_storage.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <cstdio>
-#include <cstdlib>
+#include <thread>
+#include <vector>
 #include <__threading_support>
-#include <unistd.h>
 
 #include "../src/cxa_exception.h"
 
 #include "test_macros.h"
 
-typedef __cxxabiv1::__cxa_eh_globals globals_t ;
-
-void *thread_code (void *parm) {
-    size_t *result = (size_t *) parm;
-    globals_t *glob1, *glob2;
-
-    glob1 = __cxxabiv1::__cxa_get_globals ();
-    if ( NULL == glob1 )
-        std::printf("Got null result from __cxa_get_globals\n");
+void* thread_code(void* parm) {
+  void* globals = __cxxabiv1::__cxa_get_globals();
+  if (!globals)
 
-    glob2 = __cxxabiv1::__cxa_get_globals_fast ();
-    if ( glob1 != glob2 )
-        std::printf("Got different globals!\n");
+  void* fast_globals = __cxxabiv1::__cxa_get_globals_fast();
+  if (globals != fast_globals) {
+    std::printf("Got different result from __cxa_get_globals (%p) and __cxa_get_globals_fast (%p) \n", globals,
+                fast_globals);
+    globals = nullptr;
+  }
 
-    *result = (size_t) glob1;
-#ifndef TEST_HAS_NO_THREADS
-    sleep ( 1 );
-#endif
-    return parm;
+  *static_cast<void**>(parm) = globals;
 }
 
-#ifndef TEST_HAS_NO_THREADS
-#define NUMTHREADS  10
-size_t                 thread_globals [ NUMTHREADS ] = { 0 };
-std::__libcpp_thread_t   threads        [ NUMTHREADS ];
-#endif
-
 int main() {
 #ifndef TEST_HAS_NO_THREADS
+  int num_threads = std::thread::hardware_concurrency();
+  if (num_threads == 0)
+    num_threads = 4; // arbitrary fallback value
+
+  std::vector<void*> thread_globals(num_threads);
+  std::vector<std::__libcpp_thread_t> threads(num_threads);
+
   //  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 ] );
+  for (int i = 0; i < num_threads; ++i)
+    std::__libcpp_thread_create(&threads[i], thread_code, &thread_globals[i]);
+  for (int i = 0; i < num_threads; ++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;
-        }
-    }
+  for (int i = 0; i < num_threads; ++i) {
+    // Either __cxa_get_globals was nullptr or __cxa_get_globals_fast returned a
+    // different value. We already diagnosed both in the thread.
+    if (!thread_globals[i])
+      return 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 // TEST_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;
+  int retval = 0;
+  std::sort(thread_globals.begin(), thread_globals.end());
+  for (int i = 1; i < num_threads; ++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  // TEST_HAS_NO_THREADS
+  void* thread_globals;
 #endif // !TEST_HAS_NO_THREADS
 }