[libc++abi] Simplify __cxa_get_globals_fast callsites

[smeenai]

Summary

Now that __cxa_get_globals is unconditionally using TLS (if we support
threads), it's equivalent to __cxa_get_globals_fast, and we don't need
to check if the return value of the latter is null. Update the test to
check this property as well.

[MaskRay]

libcxxabi/test/test_exception_storage.pass.cpp

31

The adjustment should be merged into D138460

[smeenai]

libcxxabi/test/test_exception_storage.pass.cpp

31

D138460 was originally stacked under D138461, and D138461 is what guaranteed that __cxa_get_globals_fast would be non-null even if you called it on a thread before __cxa_get_globals, so it wasn't correct to make the change then. It could be folded into D138460 now (since D138461 landed before it), but I felt it made more sense to keep it here. This change is the follow-up to D138461 that tweaks the rest of the code to rely on __cxa_get_globals_fast never returning non-null, and so I wanted the test for that specific functionality to also live here.

[MaskRay]

I checked every calls site of __cxa_get_globals_fast and confirm that this is comprehenstive.

libcxxabi/test/test_exception_storage.pass.cpp

31

Ah, right. Thanks for the description.

[smeenai]

Rebase

[smeenai]

Update test comment

[smeenai]

Rebase

[thakis]

libcxxabi/test/test_exception_storage.pass.cpp

31

D138461 seems to break things, so maybe it'll have to be reverted again (see comments over there).

[smeenai]

Pausing this while D138461 is sorted out.

libcxxabi/src/cxa_default_handlers.cpp

 }
 
 __attribute__((noreturn))
 static void demangling_terminate_handler()
 {
     using namespace __cxxabiv1;
     __cxa_eh_globals* globals = __cxa_get_globals_fast();
 
-    // If there is no uncaught exception, just note that we're terminating
-    if (!globals)
-        abort_message("terminating");
-
     __cxa_exception* exception_header = globals->caughtExceptions;
     if (!exception_header)
         abort_message("terminating");
 
     _Unwind_Exception* unwind_exception =
         reinterpret_cast<_Unwind_Exception*>(exception_header + 1) - 1;
 
     // If we're terminating due to a foreign exception

libcxxabi/src/cxa_exception.cpp

static_assert(__builtin_offsetof(__cxa_exception, referenceCount) ==
                     __builtin_offsetof(__cxa_dependent_exception,
                                        primaryException),
                 "the layout of __cxa_exception must match the layout of "
                 "__cxa_dependent_exception");
   static_assert(__builtin_offsetof(__cxa_exception, handlerCount) ==
                     __builtin_offsetof(__cxa_dependent_exception, handlerCount),
                 "the layout of __cxa_exception must match the layout of "
                 "__cxa_dependent_exception");
-    __cxa_eh_globals* globals = __cxa_get_globals_fast(); // __cxa_get_globals called in __cxa_begin_catch
+    __cxa_eh_globals* globals = __cxa_get_globals_fast();
     __cxa_exception* exception_header = globals->caughtExceptions;
     // If we've rethrown a foreign exception, then globals->caughtExceptions
     //    will have been made an empty stack by __cxa_rethrow() and there is
     //    nothing more to be done.  Do nothing!
     if (NULL != exception_header)
     {
         bool native_exception = __isOurExceptionClass(&exception_header->unwindHeader);
         if (native_exception)

 }
 
 // Note:  exception_header may be masquerading as a __cxa_dependent_exception
 //        and that's ok.  exceptionType is there too.
 //        However watch out for foreign exceptions.  Return null for them.
 std::type_info *__cxa_current_exception_type() {
 //  get the current exception
     __cxa_eh_globals *globals = __cxa_get_globals_fast();
-    if (NULL == globals)
-        return NULL;     //  If there have never been any exceptions, there are none now.
     __cxa_exception *exception_header = globals->caughtExceptions;
     if (NULL == exception_header)
         return NULL;        //  No current exception
     if (!__isOurExceptionClass(&exception_header->unwindHeader))
         return NULL;
     return exception_header->exceptionType;
 }
 
void __cxa_decrement_exception_refcount(void *thrown_object) throw() {
     }
 }
 
 /*
     Returns a pointer to the thrown object (if any) at the top of the
     caughtExceptions stack.  Atomically increment the exception's referenceCount.
     If there is no such thrown object or if the thrown object is foreign,
     returns null.
-
-    We can use __cxa_get_globals_fast here to get the globals because if there have
-    been no exceptions thrown, ever, on this thread, we can return NULL without
-    the need to allocate the exception-handling globals.
 */
 void *__cxa_current_primary_exception() throw() {
 //  get the current exception
     __cxa_eh_globals* globals = __cxa_get_globals_fast();
-    if (NULL == globals)
-        return NULL;        //  If there are no globals, there is no exception
     __cxa_exception* exception_header = globals->caughtExceptions;
     if (NULL == exception_header)
         return NULL;        //  No current exception
     if (!__isOurExceptionClass(&exception_header->unwindHeader))
         return NULL;        // Can't capture a foreign exception (no way to refcount it)
     if (isDependentException(&exception_header->unwindHeader)) {
         __cxa_dependent_exception* dep_exception_header =
             reinterpret_cast<__cxa_dependent_exception*>(exception_header);

 bool
 __cxa_uncaught_exception() throw() { return __cxa_uncaught_exceptions() != 0; }
 
 unsigned int
 __cxa_uncaught_exceptions() throw()
 {
     // This does not report foreign exceptions in flight
     __cxa_eh_globals* globals = __cxa_get_globals_fast();
-    if (globals == 0)
-        return 0;
     return globals->uncaughtExceptions;
 }
 
 }  // extern "C"
 
 }  // abi

libcxxabi/src/cxa_handlers.cpp

 __attribute__((noreturn))
 void
 terminate() noexcept
 {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     // If there might be an uncaught exception
     using namespace __cxxabiv1;
     __cxa_eh_globals* globals = __cxa_get_globals_fast();
-    if (globals)
-    {
-        __cxa_exception* exception_header = globals->caughtExceptions;
-        if (exception_header)
-        {
-            _Unwind_Exception* unwind_exception =
-                reinterpret_cast<_Unwind_Exception*>(exception_header + 1) - 1;
-            if (__isOurExceptionClass(unwind_exception))
-                __terminate(exception_header->terminateHandler);
-        }
-    }
 #endif
     __terminate(get_terminate());
 }
 
 new_handler
 get_new_handler() noexcept
 {
     return __libcpp_atomic_load(&__cxa_new_handler, _AO_Acquire);
 }
 
 }  // std

libcxxabi/test/test_exception_storage.pass.cpp

 
 static void thread_code(void*& globals) {
 #ifndef TEST_HAS_NO_THREADS
   std::thread::id thread_id = std::this_thread::get_id();
 #else
   int thread_id = 0;
 #endif
 
-  globals = __cxxabiv1::__cxa_get_globals();
-  if (!globals)
-    std::cerr << "Got null result from __cxa_get_globals on thread " << thread_id << "\n";
-
   void* fast_globals = __cxxabiv1::__cxa_get_globals_fast();
+  if (!fast_globals)
+    std::cerr << "Got null result from __cxa_get_globals_fast on thread " << thread_id << "\n";
+
+  globals = __cxxabiv1::__cxa_get_globals();
   if (globals != fast_globals) {
     std::cerr << "__cxa_get_globals returned " << globals << " but __cxa_get_globals_fast returned " << fast_globals
               << " on thread " << thread_id << "\n";
     globals = nullptr;
   }
 }
 
 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::thread> threads;
 
   //  Make the threads, let them run, and wait for them to finish
   for (int i = 0; i < num_threads; ++i)
     threads.emplace_back(thread_code, std::ref(thread_globals[i]));
   for (std::thread& thread : threads)
     thread.join();
 
   for (int i = 0; i < num_threads; ++i) {
-    // Either __cxa_get_globals was nullptr or __cxa_get_globals_fast returned a
+    // Either __cxa_get_globals_fast was nullptr or __cxa_get_globals returned a
     // different value. We already diagnosed both in the thread.
     if (!thread_globals[i])
       return 1;
   }
 
   int retval = 0;
   std::sort(thread_globals.begin(), thread_globals.end());
   for (int i = 1; i < num_threads; ++i) {