Make libc++abi work with gcc's ARM unwind library

[mclow.lists]

Summary

See https://bugs.llvm.org/show_bug.cgi?id=35945, which reports that libc++ doesn't build for the Raspberry PI.

The problem is that the exception class is defined as a char[8] in that library, rather than uint64_t, as in other libraries.
Same size, same values, different type.

Solution: Pull the code to check the exception class into a routine, and memcpy the field into a uint64_t and call the routine everywhere we were previously checking directly.

[bebuch]

Thanks for the amazing patch!

I get another error:

/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_default_handlers.cpp: In function ‘void demangling_terminate_handler()’:
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_default_handlers.cpp:41:58: error: ISO C++ forbids comparison between pointer and integer [-fpermissive]
                     unwind_exception->exception_class == kOurDependentExceptionClass ?
                                                          ^

The comparison is still between uint8_t[8] and uint64_t. Please add a fix for this, then I will test again. :-)

BTW: Is the memcpy a better choice than a reinterpret_cast?

[mclow.lists]

Find *all* the places that we are using exception_class and wrap them in helper routines.

[bebuch]

I get some new errors:

/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp: In function ‘void __cxxabiv1::scan_eh_tab(__cxxabiv1::{anonymous}::scan_results&, _Unwind_Action, bool, _Unwind_Control_Block*, _Unwind_Context*)’:
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:564:22: error: ‘_URC_FATAL_PHASE1_ERROR’ was not declared in this scope
     results.reason = _URC_FATAL_PHASE1_ERROR;
                      ^
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:584:30: error: ‘_URC_FATAL_PHASE2_ERROR’ was not declared in this scope
             results.reason = _URC_FATAL_PHASE2_ERROR;
                              ^
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp: In function ‘_Unwind_Reason_Code __cxxabiv1::__gxx_personality_v0(_Unwind_State, _Unwind_Control_Block*, _Unwind_Context*)’:
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:1074:16: error: ‘_URC_FATAL_PHASE1_ERROR’ was not declared in this scope
         return _URC_FATAL_PHASE1_ERROR;
                ^
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:1087:11: error: invalid conversion from ‘int’ to ‘_Unwind_State’ [-fpermissive]
     state &= ~_US_FORCE_UNWIND;
           ^
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:1090:12: warning: enumeration value ‘_US_ACTION_MASK’ not handled in switch [-Wswitch]
     switch (state) {
            ^
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:1090:12: warning: enumeration value ‘_US_FORCE_UNWIND’ not handled in switch [-Wswitch]
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:1090:12: warning: enumeration value ‘_US_END_OF_STACK’ not handled in switch [-Wswitch]
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:1167:12: error: ‘_URC_FATAL_PHASE1_ERROR’ was not declared in this scope
     return _URC_FATAL_PHASE1_ERROR;
            ^
/home/pi/projects/llvm/llvm/projects/libcxxabi/src/cxa_personality.cpp:1168:1: error: control reaches end of non-void function [-Werror=return-type]
 }
 ^

_URC_FATAL_PHASE1_ERROR and _URC_FATAL_PHASE2_ERROR should be enum values of _Unwind_Reason_Code, but this is defined in unwind-arm-common.h as:

typedef enum
  {
    _URC_OK = 0,       /* operation completed successfully */
    _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
    _URC_END_OF_STACK = 5,
    _URC_HANDLER_FOUND = 6,
    _URC_INSTALL_CONTEXT = 7,
    _URC_CONTINUE_UNWIND = 8,
    _URC_FAILURE = 9   /* unspecified failure of some kind */
  }
_Unwind_Reason_Code;

In other unwind libraries these values are defined: https://github.com/llvm-mirror/libunwind/blob/master/include/unwind.h
In the arm version it isn't: https://github.com/gcc-mirror/gcc/blob/gcc-4_9-branch/gcc/ginclude/unwind-arm-common.h

[avsej]

A modified version of this patch (v8-6.7.17-fix-gcc-unwind-header.patch) has been integrated in Fedora Linux and will be accessible in v8-6.7.17-4.fc28

[mgorny]

@mclow.lists , ping. Any chance to get a proper version upstream? I'd rather not pull patches from Fedora when we can have something official.

[mclow.lists]

In D42242#1257428, @mgorny wrote:

@mclow.lists , ping. Any chance to get a proper version upstream? I'd rather not pull patches from Fedora when we can have something official.

I gave up on this patch several months ago, because no one would say how much work it was.
I fixed one place, and was told "here are several others".
I fixed those, and was told "I get some new errors:" (which were completely unrelated to the previous problems)

[mgorny]

@bebuch, I agree with @mclow.lists here that the new errors are completely unrelated to the problem solved by this patch, and the fix to it belongs in a separate changeset. Can we get the original problem fixed first then?

[bebuch]

Okay, sorry for the blockage!

[mclow.lists]

Committed as revision 344152

src/cxa_default_handlers.cpp

         {
             _Unwind_Exception* unwind_exception =
                 reinterpret_cast<_Unwind_Exception*>(exception_header + 1) - 1;
-            bool native_exception =
-                (unwind_exception->exception_class   & get_vendor_and_language) == 
-                                 (kOurExceptionClass & get_vendor_and_language);
-            if (native_exception)
+            if (__isOurExceptionClass(unwind_exception))
             {
                 void* thrown_object =
-                    unwind_exception->exception_class == kOurDependentExceptionClass ?
+                    __getExceptionClass(unwind_exception) == kOurDependentExceptionClass ?
                         ((__cxa_dependent_exception*)exception_header)->primaryException :
                         exception_header + 1;
                 const __shim_type_info* thrown_type =

src/cxa_exception.hpp

 static const uint64_t kOurDependentExceptionClass = 0x434C4E47432B2B01; // CLNGC++\1
 static const uint64_t get_vendor_and_language     = 0xFFFFFFFFFFFFFF00; // mask for CLNGC++
 
+uint64_t __getExceptionClass  (const _Unwind_Exception*);
+void     __setExceptionClass  (      _Unwind_Exception*, uint64_t);
+bool     __isOurExceptionClass(const _Unwind_Exception*);
+
 struct _LIBCXXABI_HIDDEN __cxa_exception {
 #if defined(__LP64__) || defined(_LIBCXXABI_ARM_EHABI)
     // This is a new field to support C++ 0x exception_ptr.

src/cxa_exception.cpp

                                    alignof(__cxa_exception));
 }
 
-static void setExceptionClass(_Unwind_Exception* unwind_exception) {
-    unwind_exception->exception_class = kOurExceptionClass;
+void __setExceptionClass(_Unwind_Exception* unwind_exception, uint64_t newValue) {
+  ::memcpy(&unwind_exception->exception_class, &newValue, sizeof(newValue));
+  }
+  
+
+static void setOurExceptionClass(_Unwind_Exception* unwind_exception) {
+    __setExceptionClass(unwind_exception, kOurExceptionClass);
 }
 
 static void setDependentExceptionClass(_Unwind_Exception* unwind_exception) {
-    unwind_exception->exception_class = kOurDependentExceptionClass;
+    __setExceptionClass(unwind_exception, kOurDependentExceptionClass);
 }
 
 //  Is it one of ours?
-static bool isOurExceptionClass(const _Unwind_Exception* unwind_exception) {
-    return (unwind_exception->exception_class & get_vendor_and_language) == 
-           (kOurExceptionClass                & get_vendor_and_language);
+uint64_t __getExceptionClass(const _Unwind_Exception* unwind_exception) {
+//  On x86 and some ARM unwinders, unwind_exception->exception_class is
+//    a uint64_t. On other ARM unwinders, it is a char[8]
+//  See: http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf
+//  So we just copy it into a uint64_t to be sure.
+  uint64_t exClass;
+  ::memcpy(&exClass, &unwind_exception->exception_class, sizeof(exClass));
+  return exClass;
 }
 
+bool __isOurExceptionClass(const _Unwind_Exception* unwind_exception) {
+    return (__getExceptionClass(unwind_exception) & get_vendor_and_language) == 
+           (kOurExceptionClass                    & get_vendor_and_language);
+}
+
 static bool isDependentException(_Unwind_Exception* unwind_exception) {
-    return (unwind_exception->exception_class & 0xFF) == 0x01;
+    return (__getExceptionClass(unwind_exception) & 0xFF) == 0x01;
 }
 
 //  This does not need to be atomic

     exception_header->terminateHandler  = std::get_terminate();
     exception_header->exceptionType = tinfo;
     exception_header->exceptionDestructor = dest;
-    setExceptionClass(&exception_header->unwindHeader);
+    setOurExceptionClass(&exception_header->unwindHeader);
     exception_header->referenceCount = 1;  // This is a newly allocated exception, no need for thread safety.
     globals->uncaughtExceptions += 1;   // Not atomically, since globals are thread-local
 

     __cxa_exception* exception_header =
         cxa_exception_from_exception_unwind_exception(unwind_exception);
 
-    if (isOurExceptionClass(unwind_exception))
+    if (__isOurExceptionClass(unwind_exception))
     {
         if (0 == exception_header->propagationCount)
         {

         std::terminate();
     }
 
-    if (isOurExceptionClass(&exception_header->unwindHeader))
+    if (__isOurExceptionClass(&exception_header->unwindHeader))
     {
         --exception_header->propagationCount;
         if (0 == exception_header->propagationCount)

 __cxa_begin_catch(void* unwind_arg) throw()
 {
     _Unwind_Exception* unwind_exception = static_cast<_Unwind_Exception*>(unwind_arg);
-    bool native_exception = isOurExceptionClass(unwind_exception);
+    bool native_exception = __isOurExceptionClass(unwind_exception);
     __cxa_eh_globals* globals = __cxa_get_globals();
     // exception_header is a hackish offset from a foreign exception, but it
     //   works as long as we're careful not to try to access any __cxa_exception

     //    nothing more to be done.  Do nothing!
     if (NULL != exception_header)
     {
-        bool native_exception = isOurExceptionClass(&exception_header->unwindHeader);
+        bool native_exception = __isOurExceptionClass(&exception_header->unwindHeader);
         if (native_exception)
         {
             // This is a native exception

     __cxa_exception *exception_header = globals->caughtExceptions;
     if (NULL == exception_header)
         return NULL;        //  No current exception
-    if (!isOurExceptionClass(&exception_header->unwindHeader))
+    if (!__isOurExceptionClass(&exception_header->unwindHeader))
         return NULL;
     return exception_header->exceptionType;
 }

     __cxa_exception* exception_header = globals->caughtExceptions;
     if (NULL == exception_header)
         std::terminate();      // throw; called outside of a exception handler
-    bool native_exception = isOurExceptionClass(&exception_header->unwindHeader);
+    bool native_exception = __isOurExceptionClass(&exception_header->unwindHeader);
     if (native_exception)
     {
         //  Mark the exception as being rethrown (reverse the effects of __cxa_begin_catch)

     __cxa_exception* exception_header = globals->caughtExceptions;
     if (NULL == exception_header)
         return NULL;        //  No current exception
-    if (!isOurExceptionClass(&exception_header->unwindHeader))
+    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 =

src/cxa_handlers.cpp

         {
             _Unwind_Exception* unwind_exception =
                 reinterpret_cast<_Unwind_Exception*>(exception_header + 1) - 1;
-            bool native_exception =
-                (unwind_exception->exception_class & get_vendor_and_language) ==
-                               (kOurExceptionClass & get_vendor_and_language);
-            if (native_exception)
+            if (__isOurExceptionClass(unwind_exception))
                 __terminate(exception_header->terminateHandler);
         }
     }

src/cxa_personality.cpp

     // Even for foreign exceptions, the exception object is *probably* at unwind_exception + 1
     //    Regardless, this library is prohibited from touching a foreign exception
     void* adjustedPtr = unwind_exception + 1;
-    if (unwind_exception->exception_class == kOurDependentExceptionClass)
+    if (__getExceptionClass(unwind_exception) == kOurDependentExceptionClass)
         adjustedPtr = ((__cxa_dependent_exception*)adjustedPtr - 1)->primaryException;
     return adjustedPtr;
 }

     if (unwind_exception == 0 || context == 0)
         return _URC_FATAL_PHASE1_ERROR;
 
-    bool native_exception = (unwind_exception->exception_class & get_vendor_and_language) ==
-                            (kOurExceptionClass & get_vendor_and_language);
+    bool native_exception = __isOurExceptionClass(unwind_exception);
 
 #if !defined(LIBCXXABI_USE_LLVM_UNWINDER)
     // Copy the address of _Unwind_Control_Block to r12 so that

     if (unwind_exception == 0)
         call_terminate(false, unwind_exception);
     __cxa_begin_catch(unwind_exception);
-    bool native_old_exception =
-        (unwind_exception->exception_class & get_vendor_and_language) ==
-        (kOurExceptionClass                & get_vendor_and_language);
+    bool native_old_exception = __isOurExceptionClass(unwind_exception);
     std::unexpected_handler u_handler;
     std::terminate_handler t_handler;
     __cxa_exception* old_exception_header = 0;

             if (new_exception_header == 0)
                 // This shouldn't be able to happen!
                 std::__terminate(t_handler);
-            bool native_new_exception =
-                (new_exception_header->unwindHeader.exception_class & get_vendor_and_language) ==
-                                                (kOurExceptionClass & get_vendor_and_language);
+            bool native_new_exception = __isOurExceptionClass(&new_exception_header->unwindHeader);
             void* adjustedPtr;
             if (native_new_exception && (new_exception_header != old_exception_header))
             {

                 const __shim_type_info* excpType =
                     static_cast<const __shim_type_info*>(new_exception_header->exceptionType);
                 adjustedPtr =
-                    new_exception_header->unwindHeader.exception_class == kOurDependentExceptionClass ?
+                    __getExceptionClass(&new_exception_header->unwindHeader) == kOurDependentExceptionClass ?
                         ((__cxa_dependent_exception*)new_exception_header)->primaryException :
                         new_exception_header + 1;
                 if (!exception_spec_can_catch(ttypeIndex, classInfo, ttypeEncoding,