[libc++abi][AIX] Use _LIBCXXABI_FUNC_VIS for exported routines

[xingxue]

Summary

This patch adds _LIBCXXABI_FUNC_VIS to the definitions of the personality and helper routines for the state table based EH, now that the support of the visibility attribute is being added to AIX Clang. Currently an export list is generated in the absence of the visibility attribute support downstream.

[MaskRay]

I see that https://discourse.llvm.org/t/rfc-adding-exported-visibility-style-to-the-ir-to-model-xcoff-exported-visibility/61853 says if no visibility bit (I assume n_type & SYM_V_MASK == 0) is set, the symbols need an export list.
I don't see how you use an export list for the libc++abi code, perhaps you maintain a down stream patch.

[NFC]

I assume that getting #define _LIBCXXABI_FUNC_VIS __attribute__((__visibility__("default"))) will have side effects, so [NFC] is inappropriate.

[xingxue]

In D126915#3559129, @MaskRay wrote:

I see that https://discourse.llvm.org/t/rfc-adding-exported-visibility-style-to-the-ir-to-model-xcoff-exported-visibility/61853 says if no visibility bit (I assume n_type & SYM_V_MASK == 0) is set, the symbols need an export list.
I don't see how you use an export list for the libc++abi code, perhaps you maintain a down stream patch.

Thanks for your comments! Yes, export lists are currently used on AIX for libc++abi as well as other libraries downstream in the absence of attribute visibility.

[NFC]

I assume that getting #define _LIBCXXABI_FUNC_VIS __attribute__((__visibility__("default"))) will have side effects, so [NFC] is inappropriate.

I agree it is not [NFC] from the perspective of upstream, although _LIBCXXABI_FUNC_VIS has the same effect as the export list that has been used downstream.

[xingxue]

Hi @ldionne, Would you please take a look and if no further comments, accept for #libc_abi? Thanks!

[daltenty]

LGTM, thanks!

libcxxabi/src/aix_state_tab_eh.inc

static void scan_state_tab(scan_results& results, _Unwind_Action actions, bool native_exception,
   }
   _LIBCXXABI_TRACE_STATETAB0("No state table entry for this exception, call_terminate()\n");
   // It is possible that no state table entry specify how to handle
   // this exception. By spec, terminate it immediately.
   call_terminate(native_exception, unwind_exception);
 }
 
 // Personality routine for EH using the state table.
-_Unwind_Reason_Code __xlcxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionClass,
-                                           _Unwind_Exception* unwind_exception, _Unwind_Context* context) {
+_LIBCXXABI_FUNC_VIS _Unwind_Reason_Code
+__xlcxx_personality_v0(int version, _Unwind_Action actions, uint64_t exceptionClass,
   if (version != 1 || unwind_exception == 0 || context == 0)
     return _URC_FATAL_PHASE1_ERROR;
 
   bool native_exception = (exceptionClass & get_vendor_and_language) == (kOurExceptionClass & get_vendor_and_language);
   scan_results results;
   scan_state_tab(results, actions, native_exception, unwind_exception, context);
   if (actions & _UA_SEARCH_PHASE) {
     // Phase 1 search:  All we're looking for in phase 1 is a handler that

 } // namespace __state_table_eh
 
 // The following are EH helper functions for xlclang++ compiled code.
 
 // __xlc_catch_matchv2
 // Check whether the thrown object matches the catch handler's exception
 // declaration. If there is a match, the function returns true with adjusted
 // address of the thrown object. Otherwise, returns false.
-bool __xlc_catch_matchv2(_Unwind_Exception* exceptionObject, std::type_info* catchTypeInfo, void*& obj) {
+_LIBCXXABI_FUNC_VIS bool
+__xlc_catch_matchv2(_Unwind_Exception* exceptionObject, std::type_info* catchTypeInfo, void*& obj) {
   _LIBCXXABI_TRACE_STATETAB("Entering %s, exceptionObject=%p\n", __func__, reinterpret_cast<void*>(exceptionObject));
 
   if (!__isOurExceptionClass(exceptionObject)) {
     _LIBCXXABI_TRACE_STATETAB0("No match, not a C++ exception\n");
     return false;
   }
 
   __cxa_exception* exceptionHeader = 0;
__xlc_catch_matchv2(_Unwind_Exception* exceptionObject, std::type_info* catchTypeInfo, void*& obj) {
   return false;
 }
 
 // __xlc_throw_badexception
 // This function is for xlclang++. It allocates and throws a bad_exception.
 // During unwinding for this bad_exception, the previous exception which is
 // not matching the throw spec will be cleaned up. Thus having the same
 // effect as replace the top most exception (which is bad) with a bad_exception.
-void __xlc_throw_badexception() {
+_LIBCXXABI_FUNC_VIS void __xlc_throw_badexception() {
   _LIBCXXABI_TRACE_STATETAB("Entering function: %s\n\n", __func__);
   void* newexception = new (__cxa_allocate_exception(sizeof(std::bad_exception))) std::bad_exception;
   __cxa_throw(newexception, const_cast<std::type_info*>(&typeid(std::bad_exception)), 0);
 }
 
 // __xlc_exception_handle
 // This function is for xlclang++. It returns the address of the exception
 // object set in gpr14 by the personality routine for xlclang++ compiled code.
-uintptr_t __xlc_exception_handle() {
+_LIBCXXABI_FUNC_VIS uintptr_t __xlc_exception_handle() {
   uintptr_t exceptionObject;
   asm("mr %0, 14" : "=r"(exceptionObject));
   return exceptionObject;
 }
 
 // xlclang++ may generate calls to __Deleted_Virtual.
-void __Deleted_Virtual() { abort(); }
+_LIBCXXABI_FUNC_VIS void __Deleted_Virtual() { abort(); }
 
 // __catchThrownException is called during AIX library initialization and
 // termination to handle exceptions.  An implementation is also provided in
 // libC.a(shrcore.o).  This implementation is provided for applications that
 // link with -lc++ (the xlclang++ or ibm-clang++ link default.)
-int __catchThrownException(void (*cdfunc)(void),   // function which may fail
-                           void (*cleanup)(void*), // cleanup function
-                           void* cleanuparg,       // parameter to cleanup function
-                           int action) {           // control exception throwing and termination
+_LIBCXXABI_FUNC_VIS int
+__catchThrownException(void (*cdfunc)(void),   // function which may fail
   enum Action : int { None = 0, Rethrow = 1, Terminate = 2 };
   if (!cdfunc)
     return 0;
   if (action == Action::Rethrow && !cleanup) {
     // No cleanup and rethrow is effectively no-op.
     // Avoid the catch handler when possible to allow exceptions generated
     // from xlC binaries to flow through.
     (*cdfunc)();