[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.

250

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

972

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

972

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

654–655

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).

684

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)

972

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.

1200–1201

ditto on adding base argument to this call.

[xingxue]

Addressed comments:

• Added parameter base to readEncodedPointer() calls.

[xingxue]

libcxxabi/src/cxa_personality.cpp

654–655

Added parameter base as suggested, thanks!

684

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.

1200–1201

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

1281

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

[xingxue]

libcxxabi/src/cxa_personality.cpp

1281

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__
 +---------------------------------------------------------------------+
 | 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  | |
 | +--------------+-----------+--------------------------------------+ |

 /// 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 /*base*/ = 0)
+readEncodedPointer(const uint8_t** data, uint8_t encoding, uintptr_t base = 0)
 {
     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);
readEncodedPointer(const uint8_t** data, uint8_t encoding, uintptr_t base = 0)
     {
     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:
+        assert((base != 0) && "DW_EH_PE_datarel is invalid with a base of 0");
+        if (result)
+            result += base;
+        break;
+    case DW_EH_PE_textrel:
     case DW_EH_PE_funcrel:
     case DW_EH_PE_aligned:
     default:
         // not supported
         abort();
         break;
     }
     // then apply indirection
#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, uintptr_t base = 0)
+                   _Unwind_Exception* unwind_exception, uintptr_t /*base*/ = 0)
 {
     if (classInfo == 0)
     {
         // this should not happen.  Indicates corrupted eh_table.
         call_terminate(native_exception, unwind_exception);
     }
 
     assert(((ttypeEncoding == DW_EH_PE_absptr) ||  // LLVM or GCC 4.6
/*
     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,
-                         uintptr_t base = 0)
+                         uintptr_t /*base*/ = 0)
 {
     if (classInfo == 0)
     {
         // this should not happen.   Indicates corrupted eh_table.
         call_terminate(false, unwind_exception);
     }
 
     assert(((ttypeEncoding == DW_EH_PE_absptr) ||  // LLVM or GCC 4.6

 
 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);
+    const uint8_t* lpStart =
+        (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding, base);
     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 (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);
+        // Cache base for calculating the address of ttype in
+        // __cxa_call_unexpected.
+        if (results.ttypeIndex < 0) {
+#if defined(_AIX)
+          exception_header->catchTemp = (void *)_Unwind_GetDataRelBase(context);
+#else
+          exception_header->catchTemp = 0;
+#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);
+    // Cache base for calculating the address of ttype in __cxa_call_unexpected.
+    if (results.ttypeIndex < 0) {
+      __cxa_exception* exception_header =
+            (__cxa_exception*)(unwind_exception + 1) - 1;
+#if defined(_AIX)
+      exception_header->catchTemp = (void *)_Unwind_GetDataRelBase(context);
+#else
+      exception_header->catchTemp = 0;
+#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 (native_old_exception)
         // 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
+            //   old_exception_header->catchTemp, base for calculating ttype
             // Need
             //   const uint8_t* classInfo
             //   uint8_t ttypeEncoding
             uint8_t lpStartEncoding = *lsda++;
-            const uint8_t* lpStart = (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);
+            const uint8_t* lpStart =
+                (const uint8_t*)readEncodedPointer(&lsda, lpStartEncoding, base);
             (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
catch (...)
                 //   old_exception_header
                 throw be;
             }
         }
     }
     std::__terminate(t_handler);
 }
 
+#if defined(_AIX)
+// Personality routine for EH using the range table. Make it an alias of
+// __gxx_personality_v0().
+_LIBCXXABI_FUNC_VIS _Unwind_Reason_Code __xlcxx_personality_v1(
+    int version, _Unwind_Action actions, uint64_t exceptionClass,
+    _Unwind_Exception* unwind_exception, _Unwind_Context* context)
+    __attribute__((alias("__gxx_personality_v0")));
+#endif
+
 }  // extern "C"
 
 }  // __cxxabiv1