[libc++abi][AIX] Enable calculating addresses with DW_EH_PE_datarel

[xingxue]

Summary

This patch enables calculating relative addresses with the DW_EH_PE_datarel encoding using a base for AIX. After setting registers for jumping to the user code in gxx_personality_v0(), base is cached in exception_header member catchTemp for use in __cxa_call_unexpected if ttypeIndex is less than 0 (exception spec).

[xingxue]

Removed the incorrect setting of parent revision. Reload the patch to trigger the pre-merge check. Sorry for the noise.

[sfertile]

libcxxabi/src/cxa_personality.cpp

91

errant whitespace change.

249

I'm guessing these indentation changes, and brace placement changes are from clang format, but it no longer matches the formatting of the rest of the file. We shouldn't be changing formatting on otherwise untouched lines, and the changes we do make should match the formatting of the rest of the file.

[xingxue]

This version is clean of format changes made by clang-format.

[xingxue]

Refreshed to base on the split out NFC patch https://reviews.llvm.org/D101545.

[sfertile]

In D101298#2723019, @xingxue wrote:

This version is clean of format changes made by clang-format.

Thanks Xing, this is much better.

[xingxue]

Refreshed after changes in the base NFC patch https://reviews.llvm.org/D101545.

[MaskRay]

libcxxabi/src/cxa_personality.cpp

942

Normal Itanium doesn't need/shouldn't have this code. _UA_CLEANUP_PHASE doesn't need caching.

Can you re-confirm AIX needs this? (I suspect this is not the right place to add the code.)

[xingxue]

libcxxabi/src/cxa_personality.cpp

942

For AIX EH, the DW_EH_PE_datarel encoding is used in the range table to calculate relative addresses with a base. So, parameter base is added to functions invoked by scan_eh_tab() and readEncodedPointer() is extended to enable the DW_EH_PE_datarel encoding.

For code such as the segment below, the landingpad calls __cxa_call_unexpected() which in turn calls the unexpected exception handler. When __cxa_call_unexpected() handles the exception thrown from the unexpected exception handler, it calls exception_spec_can_catch() where a base is needed for the DW_EH_PE_datarel encoding. __cxa_call_unexpected() takes one parameter which is the pointer to the exception object. So, we need a way to communicate the base to __cxa_call_unexpected(). catchTemp is used for caching the landingpad but after get_registers() sets the landingpad into the IP register, the landingpad cached in catchTemp is no longer useful. This is why this location is chosen. The __cxa_exception structure has being used in communicating lsda, ttypeIndex, etc. between the personality routine and __cxa_call_unexpected(). So, I think it makes sense to use catchTemp which is also a member of __cxa_exception for this purpose as well but I am open to suggestions.

struct E {
        int i;
        E() { i=0; }
};

struct S {
        S() {}
        S(int i) {}
        ~S() { ret = std::uncaught_exception(); }
};

void f(void) throw (E) {
    register S s;
    throw 1;
}

[xingxue]

Hi @MaskRay, Do you have any further comments/concerns? Thanks!

[sfertile]

libcxxabi/src/cxa_personality.cpp

632

IIUC this is going to work for AIX because the encoding is DW_EH_PE_omit, but if we are adding support for `DW_EH_PE_datarel then we need to pass base in here. If someone comes along and adds a target that uses data relative encoding for the offset to the lsda then it should already work (after this patch).

661

Does it make sense to add an assert here that callSiteEncoding is not data relative for documentation as why we use the default value of base=0. (Sorry this should;ld have probably gone in the previous patch)

942

Normal Itanium doesn't need/shouldn't have this code. _UA_CLEANUP_PHASE doesn't need caching.

Can you re-confirm AIX needs this? (I suspect this is not the right place to add the code.)

FWIW it makes sense that targets that use DW_EH_PE_pcrel or DW_EH_PE_absptr don't need the caching. The absptr encoding you don't add any base address, and the pcrel encoding you use the data pointer you just read from as the base address.

1159–1160

ditto on adding base argument to this call.

[xingxue]

Addressed comments:

• Added parameter base to readEncodedPointer() calls.

[xingxue]

libcxxabi/src/cxa_personality.cpp

632

Added parameter base as suggested, thanks!

661

There is an assert inside readEncodedPointer() in line 300 for using the DW_EH_PE_datarel encoding with base=0. That should serve the same purpose.

1159–1160

Added parameter base as suggested, thanks!

[xingxue]

Removed the dependent patch which has landed. Try to trigger the pre-merge check.

[sfertile]

Thanks for the updates Xing, LGTM.

[xingxue]

Minor changes related to the -Wunused-parameter warning.

• Reverted the change in D104235 that was to avoid the warning because the parameter is used in this patch.
• Changed from uintptr_t base = 0 to uintptr_t /*base*/ = 0 in 2 places to avoid the warning.

[compnerd]

libcxxabi/src/cxa_personality.cpp

1252

It would be nice to use the reserved spelling (__attribute__((__alias__("__gxx_personality_v0"))))

[xingxue]

libcxxabi/src/cxa_personality.cpp

1252

Changed as suggested, thanks!

libcxxabi/src/cxa_personality.cpp

 |                                         terminate.                               |
 | +-------------+---------------------------------+------------------------------+ |
 | | landingPad  | (ULEB128)                       | offset relative to lpStart   | |
 | | actionEntry | (ULEB128)                       | Action Table Index 1-based   | |
 | |             |                                 | actionEntry == 0 -> cleanup  | |
 | +-------------+---------------------------------+------------------------------+ |
 | ...                                                                              |
 +----------------------------------------------------------------------------------+
-#endif // __USING_SJLJ_EXCEPTIONS__
+#endif  // __USING_SJLJ_EXCEPTIONS__
 +---------------------------------------------------------------------+
 | Beginning of Action Table       ttypeIndex == 0 : cleanup           |
 | ...                             ttypeIndex  > 0 : catch             |
 |                                 ttypeIndex  < 0 : exception spec    |
 | +--------------+-----------+--------------------------------------+ |
 | | ttypeIndex   | (SLEB128) | Index into type_info Table (1-based) | |
 | | actionOffset | (SLEB128) | Offset into next Action Table entry  | |
 | +--------------+-----------+--------------------------------------+ |
readSLEB128(const uint8_t** data)
     return static_cast<intptr_t>(result);
 }
 
 /// Read a pointer encoded value and advance pointer
 /// See Variable Length Data in:
 /// @link http://dwarfstd.org/Dwarf3.pdf @unlink
 /// @param data reference variable holding memory pointer to decode from
 /// @param encoding dwarf encoding type
+/// @param base for adding relative offset, default to 0
 /// @returns decoded value
-static
-uintptr_t
-readEncodedPointer(const uint8_t** data, uint8_t encoding)
-{
-    uintptr_t result = 0;
-    if (encoding == DW_EH_PE_omit)
-        return result;
-    const uint8_t* p = *data;
-    // first get value
-    switch (encoding & 0x0F)
-    {
-    case DW_EH_PE_absptr:
-        result = readPointerHelper<uintptr_t>(p);
-        break;
-    case DW_EH_PE_uleb128:
-        result = readULEB128(&p);
-        break;
-    case DW_EH_PE_sleb128:
-        result = static_cast<uintptr_t>(readSLEB128(&p));
-        break;
-    case DW_EH_PE_udata2:
-        result = readPointerHelper<uint16_t>(p);
-        break;
-    case DW_EH_PE_udata4:
-        result = readPointerHelper<uint32_t>(p);
-        break;
-    case DW_EH_PE_udata8:
-        result = readPointerHelper<uint64_t>(p);
-        break;
-    case DW_EH_PE_sdata2:
-        result = readPointerHelper<int16_t>(p);
-        break;
-    case DW_EH_PE_sdata4:
-        result = readPointerHelper<int32_t>(p);
-        break;
-    case DW_EH_PE_sdata8:
-        result = readPointerHelper<int64_t>(p);
-        break;
-    default:
-        // not supported
-        abort();
-        break;
-    }
-    // then add relative offset
-    switch (encoding & 0x70)
-    {
-    case DW_EH_PE_absptr:
-        // do nothing
-        break;
-    case DW_EH_PE_pcrel:
-        if (result)
-            result += (uintptr_t)(*data);
-        break;
-    case DW_EH_PE_textrel:
-    case DW_EH_PE_datarel:
-    case DW_EH_PE_funcrel:
-    case DW_EH_PE_aligned:
-    default:
-        // not supported
-        abort();
-        break;
-    }
-    // then apply indirection
-    if (result && (encoding & DW_EH_PE_indirect))
-        result = *((uintptr_t*)result);
-    *data = p;
-    return result;
+static uintptr_t readEncodedPointer(const uint8_t** data, uint8_t encoding,
+                                    uintptr_t base = 0) {
+  switch (encoding & 0x0F) {
+  switch (encoding & 0x70) {
+    assert((base != 0) && "DW_EH_PE_datarel is invalid with a base of 0");
+    if (result)
+      result += base;
+    break;
+  case DW_EH_PE_textrel:
 }
 
 static
 void
 call_terminate(bool native_exception, _Unwind_Exception* unwind_exception)
 {
     __cxa_begin_catch(unwind_exception);
     if (native_exception)
#else
     return *reinterpret_cast<const void **>(reinterpret_cast<uintptr_t>(ptr) +
                                             offset);
 #endif
 }
 
 static const __shim_type_info*
 get_shim_type_info(uint64_t ttypeIndex, const uint8_t* classInfo,
                    uint8_t ttypeEncoding, bool native_exception,
-                   _Unwind_Exception* unwind_exception)
-{
-    if (classInfo == 0)
-    {
-        // this should not happen.  Indicates corrupted eh_table.
-        call_terminate(native_exception, unwind_exception);
-    }
+                   _Unwind_Exception* unwind_exception, uintptr_t base = 0) {
+  if (classInfo == 0) {
 
-    assert(((ttypeEncoding == DW_EH_PE_absptr) ||  // LLVM or GCC 4.6
-            (ttypeEncoding == DW_EH_PE_pcrel) ||  // GCC 4.7 baremetal
-            (ttypeEncoding == (DW_EH_PE_pcrel | DW_EH_PE_indirect))) &&  // GCC 4.7 linux
-           "Unexpected TTypeEncoding");
-    (void)ttypeEncoding;
+  assert(((ttypeEncoding == DW_EH_PE_absptr) || // LLVM or GCC 4.6
+          (ttypeEncoding ==
+           (DW_EH_PE_pcrel | DW_EH_PE_indirect))) && // GCC 4.7 linux
 
-    const uint8_t* ttypePtr = classInfo - ttypeIndex * sizeof(uintptr_t);
-    return reinterpret_cast<const __shim_type_info *>(
-        read_target2_value(ttypePtr));
+  return reinterpret_cast<const __shim_type_info*>(
 }
 #else // !defined(_LIBCXXABI_ARM_EHABI)
-static
-const __shim_type_info*
+static const __shim_type_info*
 get_shim_type_info(uint64_t ttypeIndex, const uint8_t* classInfo,
                    uint8_t ttypeEncoding, bool native_exception,
-                   _Unwind_Exception* unwind_exception)
-{
-    if (classInfo == 0)
-    {
-        // this should not happen.  Indicates corrupted eh_table.
-        call_terminate(native_exception, unwind_exception);
-    }
-    switch (ttypeEncoding & 0x0F)
-    {
-    case DW_EH_PE_absptr:
-        ttypeIndex *= sizeof(void*);
-        break;
-    case DW_EH_PE_udata2:
-    case DW_EH_PE_sdata2:
-        ttypeIndex *= 2;
-        break;
-    case DW_EH_PE_udata4:
-    case DW_EH_PE_sdata4:
-        ttypeIndex *= 4;
-        break;
-    case DW_EH_PE_udata8:
-    case DW_EH_PE_sdata8:
-        ttypeIndex *= 8;
-        break;
-    default:
-        // this should not happen.   Indicates corrupted eh_table.
-        call_terminate(native_exception, unwind_exception);
-    }
-    classInfo -= ttypeIndex;
-    return (const __shim_type_info*)readEncodedPointer(&classInfo, ttypeEncoding);
+                   _Unwind_Exception* unwind_exception, uintptr_t base = 0) {
+  if (classInfo == 0) {
+  switch (ttypeEncoding & 0x0F) {
+  return (const __shim_type_info*)readEncodedPointer(&classInfo, ttypeEncoding,
+                                                     base);
 }
 #endif // !defined(_LIBCXXABI_ARM_EHABI)
 
 /*
     This is checking a thrown exception type, excpType, against a possibly empty
     list of catchType's which make up an exception spec.
 
     An exception spec acts like a catch handler, but in reverse.  This "catch
     handler" will catch an excpType if and only if none of the catchType's in
     the list will catch a excpType.  If any catchType in the list can catch an
     excpType, then this exception spec does not catch the excpType.
 */
 #if defined(_LIBCXXABI_ARM_EHABI)
-static
-bool
-exception_spec_can_catch(int64_t specIndex, const uint8_t* classInfo,
-                         uint8_t ttypeEncoding, const __shim_type_info* excpType,
-                         void* adjustedPtr, _Unwind_Exception* unwind_exception)
-{
-    if (classInfo == 0)
-    {
-        // this should not happen.   Indicates corrupted eh_table.
-        call_terminate(false, unwind_exception);
-    }
+static bool exception_spec_can_catch(
+    int64_t specIndex, const uint8_t* classInfo, uint8_t ttypeEncoding,
+    const __shim_type_info* excpType, void* adjustedPtr,
+    _Unwind_Exception* unwind_exception, uintptr_t base = 0) {
+  if (classInfo == 0) {
 
-    assert(((ttypeEncoding == DW_EH_PE_absptr) ||  // LLVM or GCC 4.6
-            (ttypeEncoding == DW_EH_PE_pcrel) ||  // GCC 4.7 baremetal
-            (ttypeEncoding == (DW_EH_PE_pcrel | DW_EH_PE_indirect))) &&  // GCC 4.7 linux
-           "Unexpected TTypeEncoding");
-    (void)ttypeEncoding;
+  assert(((ttypeEncoding == DW_EH_PE_absptr) || // LLVM or GCC 4.6
+          (ttypeEncoding ==
+           (DW_EH_PE_pcrel | DW_EH_PE_indirect))) && // GCC 4.7 linux
 
-    // specIndex is negative of 1-based byte offset into classInfo;
-    specIndex = -specIndex;
-    --specIndex;
-    const void** temp = reinterpret_cast<const void**>(
-        reinterpret_cast<uintptr_t>(classInfo) +
-        static_cast<uintptr_t>(specIndex) * sizeof(uintptr_t));
-    // If any type in the spec list can catch excpType, return false, else return true
-    //    adjustments to adjustedPtr are ignored.
-    while (true)
-    {
-        // ARM EHABI exception specification table (filter table) consists of
-        // several pointers which will directly point to the type info object
-        // (instead of ttypeIndex).  The table will be terminated with 0.
-        const void** ttypePtr = temp++;
-        if (*ttypePtr == 0)
-            break;
-        // We can get the __shim_type_info simply by performing a
-        // R_ARM_TARGET2 relocation, and cast the result to __shim_type_info.
-        const __shim_type_info* catchType =
-            static_cast<const __shim_type_info*>(read_target2_value(ttypePtr));
-        void* tempPtr = adjustedPtr;
-        if (catchType->can_catch(excpType, tempPtr))
-            return false;
-    }
-    return true;
+  while (true) {
 }
 #else
-static
-bool
-exception_spec_can_catch(int64_t specIndex, const uint8_t* classInfo,
-                         uint8_t ttypeEncoding, const __shim_type_info* excpType,
-                         void* adjustedPtr, _Unwind_Exception* unwind_exception)
-{
-    if (classInfo == 0)
-    {
-        // this should not happen.   Indicates corrupted eh_table.
-        call_terminate(false, unwind_exception);
-    }
-    // specIndex is negative of 1-based byte offset into classInfo;
-    specIndex = -specIndex;
-    --specIndex;
-    const uint8_t* temp = classInfo + specIndex;
-    // If any type in the spec list can catch excpType, return false, else return true
-    //    adjustments to adjustedPtr are ignored.
-    while (true)
-    {
-        uint64_t ttypeIndex = readULEB128(&temp);
-        if (ttypeIndex == 0)
-            break;
-        const __shim_type_info* catchType = get_shim_type_info(ttypeIndex,
-                                                               classInfo,
-                                                               ttypeEncoding,
-                                                               true,
-                                                               unwind_exception);
-        void* tempPtr = adjustedPtr;
-        if (catchType->can_catch(excpType, tempPtr))
-            return false;
-    }
-    return true;
+static bool exception_spec_can_catch(
+    int64_t specIndex, const uint8_t* classInfo, uint8_t ttypeEncoding,
+    const __shim_type_info* excpType, void* adjustedPtr,
+    _Unwind_Exception* unwind_exception, uintptr_t base = 0) {
+  if (classInfo == 0) {
+  while (true) {
+    const __shim_type_info* catchType = get_shim_type_info(
+        ttypeIndex, classInfo, ttypeEncoding, true, unwind_exception, base);
 }
 #endif
 
 static
 void*
 get_thrown_object_ptr(_Unwind_Exception* unwind_exception)
 {
     // Even for foreign exceptions, the exception object is *probably* at unwind_exception + 1

 
 static
 void
 set_registers(_Unwind_Exception* unwind_exception, _Unwind_Context* context,
               const scan_results& results)
 {
 #if defined(__USING_SJLJ_EXCEPTIONS__)
 #define __builtin_eh_return_data_regno(regno) regno
+#elif defined(__ibmxl__)
+// IBM xlclang++ compiler does not support __builtin_eh_return_data_regno.
+#define __builtin_eh_return_data_regno(regno) regno + 3
 #endif
   _Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
                 reinterpret_cast<uintptr_t>(unwind_exception));
   _Unwind_SetGR(context, __builtin_eh_return_data_regno(1),
                 static_cast<uintptr_t>(results.ttypeIndex));
   _Unwind_SetIP(context, results.landingPad);
 }
 
static void scan_eh_tab(scan_results &results, _Unwind_Action actions,
     const uint8_t *lsda = (const uint8_t *)_Unwind_GetLanguageSpecificData(context);
     if (lsda == 0)
     {
         // There is no exception table
         results.reason = _URC_CONTINUE_UNWIND;
         return;
     }
     results.languageSpecificData = lsda;
+#if defined(_AIX)
+    uintptr_t base = _Unwind_GetDataRelBase(context);
+#else
+    uintptr_t base = 0;
+#endif
     // Get the current instruction pointer and offset it before next
     // instruction in the current frame which threw the exception.
     uintptr_t ip = _Unwind_GetIP(context) - 1;
     // Get beginning current frame's code (as defined by the
     // emitted dwarf code)
     uintptr_t funcStart = _Unwind_GetRegionStart(context);
 #ifdef __USING_SJLJ_EXCEPTIONS__
     if (ip == uintptr_t(-1))
     {
         // no action
         results.reason = _URC_CONTINUE_UNWIND;
         return;
     }
     else if (ip == 0)
         call_terminate(native_exception, unwind_exception);
     // ip is 1-based index into call site table
 #else  // !__USING_SJLJ_EXCEPTIONS__
     uintptr_t ipOffset = ip - funcStart;
 #endif // !defined(_USING_SLJL_EXCEPTIONS__)
     const uint8_t* classInfo = NULL;
     // Note: See JITDwarfEmitter::EmitExceptionTable(...) for corresponding
     //       dwarf emission
     // Parse LSDA header.
     uint8_t lpStartEncoding = *lsda++;
     const uint8_t* lpStart = (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);
     if (lpStart == 0)
         lpStart = (const uint8_t*)funcStart;
     uint8_t ttypeEncoding = *lsda++;
     if (ttypeEncoding != DW_EH_PE_omit)
     {
         // Calculate type info locations in emitted dwarf code which
         // were flagged by type info arguments to llvm.eh.selector
         // intrinsic
#endif
     const uint8_t* actionTableStart = callSiteTableEnd;
     const uint8_t* callSitePtr = callSiteTableStart;
     while (callSitePtr < callSiteTableEnd)
     {
         // There is one entry per call site.
 #ifndef __USING_SJLJ_EXCEPTIONS__
         // The call sites are non-overlapping in [start, start+length)
         // The call sites are ordered in increasing value of start
         uintptr_t start = readEncodedPointer(&callSitePtr, callSiteEncoding);
         uintptr_t length = readEncodedPointer(&callSitePtr, callSiteEncoding);
         uintptr_t landingPad = readEncodedPointer(&callSitePtr, callSiteEncoding);
         uintptr_t actionEntry = readULEB128(&callSitePtr);
         if ((start <= ipOffset) && (ipOffset < (start + length)))
 #else  // __USING_SJLJ_EXCEPTIONS__
         // ip is 1-based index into this table
         uintptr_t landingPad = readULEB128(&callSitePtr);
         uintptr_t actionEntry = readULEB128(&callSitePtr);
         if (--ip == 0)
 #endif // __USING_SJLJ_EXCEPTIONS__
         {
-            // Found the call site containing ip.
 #ifndef __USING_SJLJ_EXCEPTIONS__
             if (landingPad == 0)
             {
                 // No handler here
                 results.reason = _URC_CONTINUE_UNWIND;
                 return;
             }
             landingPad = (uintptr_t)lpStart + landingPad;
#endif // __USING_SJLJ_EXCEPTIONS__
             while (true)
             {
                 const uint8_t* actionRecord = action;
                 int64_t ttypeIndex = readSLEB128(&action);
                 if (ttypeIndex > 0)
                 {
                     // Found a catch, does it actually catch?
                     // First check for catch (...)
-                    const __shim_type_info* catchType =
-                        get_shim_type_info(static_cast<uint64_t>(ttypeIndex),
-                                           classInfo, ttypeEncoding,
-                                           native_exception, unwind_exception);
+                    const __shim_type_info* catchType = get_shim_type_info(
+                        static_cast<uint64_t>(ttypeIndex), classInfo,
+                        ttypeEncoding, native_exception, unwind_exception,
+                        base);
                     if (catchType == 0)
                     {
                         // Found catch (...) catches everything, including
                         // foreign exceptions. This is search phase, cleanup
                         // phase with foreign exception, or forced unwinding.
                         assert(actions & (_UA_SEARCH_PHASE | _UA_HANDLER_FRAME |
                                           _UA_FORCE_UNWIND));
                         results.ttypeIndex = ttypeIndex;
#endif // __USING_SJLJ_EXCEPTIONS__
                         void* adjustedPtr = get_thrown_object_ptr(unwind_exception);
                         const __shim_type_info* excpType =
                             static_cast<const __shim_type_info*>(exception_header->exceptionType);
                         if (adjustedPtr == 0 || excpType == 0)
                         {
                             // Something very bad happened
                             call_terminate(native_exception, unwind_exception);
                         }
-                        if (exception_spec_can_catch(ttypeIndex, classInfo,
-                                                     ttypeEncoding, excpType,
-                                                     adjustedPtr, unwind_exception))
-                        {
-                            // Native exception caught by exception
-                            // specification.
-                            assert(actions & _UA_SEARCH_PHASE);
-                            results.ttypeIndex = ttypeIndex;
-                            results.actionRecord = actionRecord;
-                            results.adjustedPtr = adjustedPtr;
-                            results.reason = _URC_HANDLER_FOUND;
-                            return;
+                        if (exception_spec_can_catch(
+                                ttypeIndex, classInfo, ttypeEncoding, excpType,
+                                adjustedPtr, unwind_exception, base)) {
                         }
                     } else {
                         // foreign exception caught by exception spec
                         results.ttypeIndex = ttypeIndex;
                         results.actionRecord = actionRecord;
                         results.adjustedPtr =
                             get_thrown_object_ptr(unwind_exception);
                         results.reason = _URC_HANDLER_FOUND;
#endif // __USING_SJLJ_EXCEPTIONS__
                                          : _URC_CONTINUE_UNWIND;
                     return;
                 }
                 // Go to next action
                 action += actionOffset;
             }  // there is no break out of this loop, only return
         }
 #ifndef __USING_SJLJ_EXCEPTIONS__
-        else if (ipOffset < start)
-        {
+        else if (ipOffset < start) {
             // There is no call site for this ip
             // Something bad has happened.  We should never get here.
             // Possible stack corruption.
             call_terminate(native_exception, unwind_exception);
         }
 #endif // !__USING_SJLJ_EXCEPTIONS__
     }  // there might be some tricky cases which break out of this loop
 
if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME) &&
         results.actionRecord = exception_header->actionRecord;
         results.languageSpecificData = exception_header->languageSpecificData;
         results.landingPad =
             reinterpret_cast<uintptr_t>(exception_header->catchTemp);
         results.adjustedPtr = exception_header->adjustedPtr;
 
         // Jump to the handler.
         set_registers(unwind_exception, context, results);
+#if defined(_AIX)
+        // Cache ttype base for __cxa_call_unexpected.
+        if (results.ttypeIndex < 0) {
+          exception_header->catchTemp = (void*)_Unwind_GetDataRelBase(context);
+        }
+#endif
         return _URC_INSTALL_CONTEXT;
     }
 
     // In other cases we need to scan LSDA.
     scan_eh_tab(results, actions, native_exception, unwind_exception, context);
     if (results.reason == _URC_CONTINUE_UNWIND ||
         results.reason == _URC_FATAL_PHASE1_ERROR)
         return results.reason;
if (actions & _UA_SEARCH_PHASE)
             exc->adjustedPtr = results.adjustedPtr;
         }
         return _URC_HANDLER_FOUND;
     }
 
     assert(actions & _UA_CLEANUP_PHASE);
     assert(results.reason == _URC_HANDLER_FOUND);
     set_registers(unwind_exception, context, results);
+#if defined(_AIX)
+    // Cache ttype base for __cxa_call_unexpected.
+    if (results.ttypeIndex < 0) {
+      __cxa_exception* exception_header =
+          (__cxa_exception*)(unwind_exception + 1) - 1;
+      exception_header->catchTemp = (void*)_Unwind_GetDataRelBase(context);
+    }
+#endif
     return _URC_INSTALL_CONTEXT;
 }
 
 #if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
 extern "C" _LIBCXXABI_FUNC_VIS EXCEPTION_DISPOSITION
 __gxx_personality_seh0(PEXCEPTION_RECORD ms_exc, void *this_frame,
                        PCONTEXT ms_orig_context, PDISPATCHER_CONTEXT ms_disp)
 {
if (unwind_exception == 0)
         call_terminate(false, unwind_exception);
     __cxa_begin_catch(unwind_exception);
     bool native_old_exception = __isOurExceptionClass(unwind_exception);
     std::unexpected_handler u_handler;
     std::terminate_handler t_handler;
     __cxa_exception* old_exception_header = 0;
     int64_t ttypeIndex;
     const uint8_t* lsda;
+    uintptr_t base = 0;
+
     if (native_old_exception)
     {
         old_exception_header = (__cxa_exception*)(unwind_exception+1) - 1;
         t_handler = old_exception_header->terminateHandler;
         u_handler = old_exception_header->unexpectedHandler;
         // If std::__unexpected(u_handler) rethrows the same exception,
         //   these values get overwritten by the rethrow.  So save them now:
 #if defined(_LIBCXXABI_ARM_EHABI)
         ttypeIndex = (int64_t)(int32_t)unwind_exception->barrier_cache.bitpattern[4];
         lsda = (const uint8_t*)unwind_exception->barrier_cache.bitpattern[2];
 #else
         ttypeIndex = old_exception_header->handlerSwitchValue;
         lsda = old_exception_header->languageSpecificData;
+        base = (uintptr_t)old_exception_header->catchTemp;
 #endif
     }
     else
     {
         t_handler = std::get_terminate();
         u_handler = std::get_unexpected();
     }
     try
     {
         std::__unexpected(u_handler);
     }
     catch (...)
     {
         // If the old exception is foreign, then all we can do is terminate.
         //   We have no way to recover the needed old exception spec.  There's
         //   no way to pass that information here.  And the personality routine
         //   can't call us directly and do anything but terminate() if we throw
         //   from here.
         if (native_old_exception)
         {
-            // Have:
-            //   old_exception_header->languageSpecificData
-            //   old_exception_header->actionRecord
-            // Need
-            //   const uint8_t* classInfo
-            //   uint8_t ttypeEncoding
-            uint8_t lpStartEncoding = *lsda++;
-            const uint8_t* lpStart = (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);
-            (void)lpStart;  // purposefully unused.  Just needed to increment lsda.
-            uint8_t ttypeEncoding = *lsda++;
-            if (ttypeEncoding == DW_EH_PE_omit)
-                std::__terminate(t_handler);
-            uintptr_t classInfoOffset = readULEB128(&lsda);
-            const uint8_t* classInfo = lsda + classInfoOffset;
-            // Is this new exception catchable by the exception spec at ttypeIndex?
-            // The answer is obviously yes if the new and old exceptions are the same exception
-            // If no
-            //    throw;
-            __cxa_eh_globals* globals = __cxa_get_globals_fast();
-            __cxa_exception* new_exception_header = globals->caughtExceptions;
-            if (new_exception_header == 0)
-                // This shouldn't be able to happen!
-                std::__terminate(t_handler);
-            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 =
-                    __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,
-                                              excpType, adjustedPtr, unwind_exception))
-                {
-                    // We need to __cxa_end_catch, but for the old exception,
-                    //   not the new one.  This is a little tricky ...
-                    // Disguise new_exception_header as a rethrown exception, but
-                    //   don't actually rethrow it.  This means you can temporarily
-                    //   end the catch clause enclosing new_exception_header without
-                    //   __cxa_end_catch destroying new_exception_header.
-                    new_exception_header->handlerCount = -new_exception_header->handlerCount;
-                    globals->uncaughtExceptions += 1;
-                    // Call __cxa_end_catch for new_exception_header
-                    __cxa_end_catch();
-                    // Call __cxa_end_catch for old_exception_header
-                    __cxa_end_catch();
-                    // Renter this catch clause with new_exception_header
-                    __cxa_begin_catch(&new_exception_header->unwindHeader);
-                    // Rethrow new_exception_header
-                    throw;
-                }
-            }
+          //   old_exception_header->catchTemp, i.e., ttype_base
+          const uint8_t* lpStart =
+              (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);
+          (void)lpStart; // purposefully unused.  Just needed to increment lsda.
+          bool native_new_exception =
+              __isOurExceptionClass(&new_exception_header->unwindHeader);
+          if (native_new_exception &&
+              (new_exception_header != old_exception_header)) {
+                static_cast<const __shim_type_info*>(
+                    new_exception_header->exceptionType);
+                __getExceptionClass(&new_exception_header->unwindHeader) ==
+                        kOurDependentExceptionClass
+                    ? ((__cxa_dependent_exception*)new_exception_header)
+                          ->primaryException
+                    : new_exception_header + 1;
+                                          excpType, adjustedPtr,
+                                          unwind_exception, base)) {
+              new_exception_header->handlerCount =
+                  -new_exception_header->handlerCount;
             // Will a std::bad_exception be catchable by the exception spec at
             //   ttypeIndex?
             // If no
             //    throw std::bad_exception();
             const __shim_type_info* excpType =
                 static_cast<const __shim_type_info*>(&typeid(std::bad_exception));
             std::bad_exception be;
             adjustedPtr = &be;
             if (!exception_spec_can_catch(ttypeIndex, classInfo, ttypeEncoding,
-                                          excpType, adjustedPtr, unwind_exception))
-            {
-                // We need to __cxa_end_catch for both the old exception and the
-                //   new exception.  Technically we should do it in that order.
-                //   But it is expedient to do it in the opposite order:
-                // Call __cxa_end_catch for new_exception_header
-                __cxa_end_catch();
-                // Throw std::bad_exception will __cxa_end_catch for
-                //   old_exception_header
-                throw be;
+                                          excpType, adjustedPtr,
+                                          unwind_exception, base)) {
             }
         }
     }
     std::__terminate(t_handler);
 }
 
 }  // extern "C"
 
 }  // __cxxabiv1