[libc++abi][WebAssembly] Support Wasm EH

[aheejin]

Summary

This adds Wasm-specific libc++abi changes to support Wasm exception
handling (https://github.com/WebAssembly/exception-handling).

Wasm EH requires __USING_WASM_EXCEPTIONS__ to be defined. Wasm EH's
LSDA handling mostly shares that of SjLj EH.
Changes are:

• In Wasm, a destructor returns its argument.
• Wasm EH currently only has one phase (search) that does both search and cleanup. So added an additional set_registers to support that.

The bulk of these changes was added back in Mar 2020 in
https://github.com/emscripten-core/emscripten/pull/10577 to emscripten
repo and has been used ever since. Now we'd like to upstream this so
that other toolchains that don't use emscripten libraries, e.g., WASI,
can use this too.

Companion patch: D158919

[dschuff]

Thanks for posting this.
I don't really have any new comments about the code itself (I guess that's not surprising since I reviewed it before ...)
I notice there are no changes to the build system for this; presumably that's just because we don't have CMake support for building LLVM libraries for wasm in general. I wonder whether LLVM or the libc++abi maintainers have any policies about that.
Also, regarding the __USING_WASM_EXCEPTIONS__ macro: this is not predefined by the compiler but needs to be defined by the builder/build system, right? I wonder if that's something that belongs in <__cxxabi_config.h>

[aheejin]

@dschuff

I notice there are no changes to the build system for this; presumably that's just because we don't have CMake support for building LLVM libraries for wasm in general. I wonder whether LLVM or the libc++abi maintainers have any policies about that.
Also, regarding the __USING_WASM_EXCEPTIONS__ macro: this is not predefined by the compiler but needs to be defined by the builder/build system, right? I wonder if that's something that belongs in <__cxxabi_config.h>

We currently define it in the library building script: https://github.com/emscripten-core/emscripten/blob/df74d74f5dfce1c2128fdb0dde1b09c178f7a38a/tools/system_libs.py#L1505-L1506

__USING_SJLJ_EXCEPTIONS__, a preexisting macro, seems to be defined here: https://github.com/llvm/llvm-project/blob/15b5ac38cf5d2272e28076357c207194f0ef6a6c/clang/lib/Frontend/InitPreprocessor.cpp#L913-L914; It's not defined in either __cxxabi_config.h or CMakeLists.txt.
We can maybe add something like

if (LangOpts.hasWasmExceptions())
  Builder.defineMacro("__USING_WASM_EXCEPTIONS__");

in InitProcessor.cpp too, like __USING_SJLJ_EXCEPTIONS__. So far it has not really necessary because we only use it within libraries and the libraries are built with system_libs.py, which defines it.

[dschuff]

I see. It makes sense that this likely wouldn't be needed other than for building support libraries, but maybe we should just handle this similarly to the other EH styles and make a clang predefine as you showed.

[aheejin]

Yeah we can do it, but that can be a different patch.

[aheejin]

Fix bug in defining __USING_SJLJ_OR_WASM_EXCEPTIONS__

[aheejin]

Gentle ping 😀

[dschuff]

This LGTM from the wasm side. perhaps @phosek can just verify that there's not something weird that doesn't fit with how things are done in the library more generally

[phosek]

LGTM

libcxxabi/src/cxa_personality.cpp

35

I'd slightly prefer inlining this as #if defined(__USING_SJLJ_EXCEPTIONS__) || defined (__USING_WASM_EXCEPTIONS__) to avoid introducing another define since it's only used in a handful of places.

[aheejin]

Remove __USING_SJLJ_OR_WASM_EXCEPTIONS__

[aheejin]

Thanks!

libcxxabi/include/cxxabi.h

 extern _LIBCXXABI_FUNC_VIS void *
 __cxa_allocate_exception(size_t thrown_size) throw();
 extern _LIBCXXABI_FUNC_VIS void
 __cxa_free_exception(void *thrown_exception) throw();
 
 // 2.4.3 Throwing the Exception Object
 extern _LIBCXXABI_FUNC_VIS _LIBCXXABI_NORETURN void
 __cxa_throw(void *thrown_exception, std::type_info *tinfo,
+#ifdef __USING_WASM_EXCEPTIONS__
+            // In Wasm, a destructor returns its argument
+            void *(_LIBCXXABI_DTOR_FUNC *dest)(void *));
+#else
             void (_LIBCXXABI_DTOR_FUNC *dest)(void *));
+#endif
 
 // 2.5.3 Exception Handlers
 extern _LIBCXXABI_FUNC_VIS void *
 __cxa_get_exception_ptr(void *exceptionObject) throw();
 extern _LIBCXXABI_FUNC_VIS void *
 __cxa_begin_catch(void *exceptionObject) throw();
 extern _LIBCXXABI_FUNC_VIS void __cxa_end_catch();
 #if defined(_LIBCXXABI_ARM_EHABI)

libcxxabi/src/cxa_exception.h

#if defined(__LP64__) || defined(_WIN64) || defined(_LIBCXXABI_ARM_EHABI)
     // For binary compatibility it is at the start of this
     // struct which is prepended to the object thrown in
     // __cxa_allocate_exception.
     size_t referenceCount;
 #endif
 
     //  Manage the exception object itself.
     std::type_info *exceptionType;
+#ifdef __USING_WASM_EXCEPTIONS__
+    // In Wasm, a destructor returns its argument
+    void *(_LIBCXXABI_DTOR_FUNC *exceptionDestructor)(void *);
+#else
     void (_LIBCXXABI_DTOR_FUNC *exceptionDestructor)(void *);
+#endif
     std::unexpected_handler unexpectedHandler;
     std::terminate_handler  terminateHandler;
 
     __cxa_exception *nextException;
 
     int handlerCount;
 
 #if defined(_LIBCXXABI_ARM_EHABI)

libcxxabi/src/cxa_exception.cpp

 pointer to the thrown exception, which __cxa_throw itself received as an argument.
 __Unwind_RaiseException begins the process of stack unwinding, described
 in Section 2.5. In special cases, such as an inability to find a
 handler, _Unwind_RaiseException may return. In that case, __cxa_throw
 will call terminate, assuming that there was no handler for the
 exception.
 */
 void
+#ifdef __USING_WASM_EXCEPTIONS__
+// In Wasm, a destructor returns its argument
+__cxa_throw(void *thrown_object, std::type_info *tinfo, void *(_LIBCXXABI_DTOR_FUNC *dest)(void *)) {
+#else
 __cxa_throw(void *thrown_object, std::type_info *tinfo, void (_LIBCXXABI_DTOR_FUNC *dest)(void *)) {
+#endif
     __cxa_eh_globals *globals = __cxa_get_globals();
     __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
 
     exception_header->unexpectedHandler = std::get_unexpected();
     exception_header->terminateHandler  = std::get_terminate();
     exception_header->exceptionType = tinfo;
     exception_header->exceptionDestructor = dest;
     setOurExceptionClass(&exception_header->unwindHeader);

libcxxabi/src/cxa_personality.cpp

 // built against LLVM's libunwind. LLVM's libunwind started reporting _LIBUNWIND_VERSION
 // in LLVM 15 -- we can remove this workaround after shipping LLVM 17. Once we remove
 // this workaround, it won't be possible to build libc++abi against libunwind headers
 // from LLVM 14 and before anymore.
 #if defined(____LIBUNWIND_CONFIG_H__) && !defined(_LIBUNWIND_VERSION)
 #   define _LIBUNWIND_VERSION
 #endif
 
+#if defined(__USING_SJLJ_EXCEPTIONS__) || defined (__USING_WASM_EXCEPTIONS__)
+#define __USING_SJLJ_OR_WASM_EXCEPTIONS__
+#endif
+
 #if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
 #include <windows.h>
 #include <winnt.h>
 
 extern "C" EXCEPTION_DISPOSITION _GCC_specific_handler(PEXCEPTION_RECORD,
                                                        void *, PCONTEXT,
                                                        PDISPATCHER_CONTEXT,
                                                        _Unwind_Personality_Fn);

 | ttypeEncoding | (char) | Encoding of the type_info table |
 +---------------+-+------+----+----------------------------+----------------+
 | classInfoOffset | (ULEB128) | Offset to type_info table, defaults to null |
 +-----------------++--------+-+----------------------------+----------------+
 | callSiteEncoding | (char) | Encoding for Call Site Table |
 +------------------+--+-----+-----+------------------------+--------------------------+
 | callSiteTableLength | (ULEB128) | Call Site Table length, used to find Action table |
 +---------------------+-----------+---------------------------------------------------+
-#ifndef __USING_SJLJ_EXCEPTIONS__
+#ifndef __USING_SJLJ_OR_WASM_EXCEPTIONS__
 +---------------------+-----------+------------------------------------------------+
 | Beginning of Call Site Table            The current ip lies within the           |
 | ...                                     (start, length) range of one of these    |
 |                                         call sites. There may be action needed.  |
 | +-------------+---------------------------------+------------------------------+ |
 | | start       | (encoded with callSiteEncoding) | offset relative to funcStart | |
 | | length      | (encoded with callSiteEncoding) | length of code fragment      | |
 | | landingPad  | (encoded with callSiteEncoding) | offset relative to lpStart   | |
 | | actionEntry | (ULEB128)                       | Action Table Index 1-based   | |
 | |             |                                 | actionEntry == 0 -> cleanup  | |
 | +-------------+---------------------------------+------------------------------+ |
 | ...                                                                              |
 +----------------------------------------------------------------------------------+
-#else  // __USING_SJLJ_EXCEPTIONS__
+#else  // !__USING_SJLJ_OR_WASM_EXCEPTIONS__
 +---------------------+-----------+------------------------------------------------+
 | Beginning of Call Site Table            The current ip is a 1-based index into   |
 | ...                                     this table.  Or it is -1 meaning no      |
 |                                         action is needed.  Or it is 0 meaning    |
 |                                         terminate.                               |
 | +-------------+---------------------------------+------------------------------+ |
 | | landingPad  | (ULEB128)                       | offset relative to lpStart   | |
 | | actionEntry | (ULEB128)                       | Action Table Index 1-based   | |
 | |             |                                 | actionEntry == 0 -> cleanup  | |
 | +-------------+---------------------------------+------------------------------+ |
 | ...                                                                              |
 +----------------------------------------------------------------------------------+
-#endif // __USING_SJLJ_EXCEPTIONS__
+#endif // __USING_SJLJ_OR_WASM_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  | |
 | +--------------+-----------+--------------------------------------+ |

 
 }  // unnamed namespace
 
 static
 void
 set_registers(_Unwind_Exception* unwind_exception, _Unwind_Context* context,
               const scan_results& results)
 {
-#if defined(__USING_SJLJ_EXCEPTIONS__)
+#ifdef __USING_SJLJ_OR_WASM_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),
#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__
+#ifdef __USING_SJLJ_OR_WASM_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__
+#else  // !__USING_SJLJ_OR_WASM_EXCEPTIONS__
     uintptr_t ipOffset = ip - funcStart;
-#endif // !defined(_USING_SLJL_EXCEPTIONS__)
+#endif // !defined(__USING_SJLJ_OR_WASM_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, 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
         uintptr_t classInfoOffset = readULEB128(&lsda);
         classInfo = lsda + classInfoOffset;
     }
     // Walk call-site table looking for range that
     // includes current PC.
     uint8_t callSiteEncoding = *lsda++;
-#ifdef __USING_SJLJ_EXCEPTIONS__
-    (void)callSiteEncoding;  // When using SjLj exceptions, callSiteEncoding is never used
+#ifdef __USING_SJLJ_OR_WASM_EXCEPTIONS__
+    (void)callSiteEncoding;  // When using SjLj/Wasm exceptions, callSiteEncoding is never used
 #endif
     uint32_t callSiteTableLength = static_cast<uint32_t>(readULEB128(&lsda));
     const uint8_t* callSiteTableStart = lsda;
     const uint8_t* callSiteTableEnd = callSiteTableStart + callSiteTableLength;
     const uint8_t* actionTableStart = callSiteTableEnd;
     const uint8_t* callSitePtr = callSiteTableStart;
     while (callSitePtr < callSiteTableEnd)
     {
         // There is one entry per call site.
-#ifndef __USING_SJLJ_EXCEPTIONS__
+#ifndef __USING_SJLJ_OR_WASM_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__
+#else  // __USING_SJLJ_OR_WASM_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__
+#endif // __USING_SJLJ_OR_WASM_EXCEPTIONS__
         {
             // Found the call site containing ip.
-#ifndef __USING_SJLJ_EXCEPTIONS__
+#ifndef __USING_SJLJ_OR_WASM_EXCEPTIONS__
             if (landingPad == 0)
             {
                 // No handler here
                 results.reason = _URC_CONTINUE_UNWIND;
                 return;
             }
             landingPad = (uintptr_t)lpStart + landingPad;
-#else  // __USING_SJLJ_EXCEPTIONS__
+#else  // __USING_SJLJ_OR_WASM_EXCEPTIONS__
             ++landingPad;
-#endif // __USING_SJLJ_EXCEPTIONS__
+#endif // __USING_SJLJ_OR_WASM_EXCEPTIONS__
             results.landingPad = landingPad;
             if (actionEntry == 0)
             {
                 // Found a cleanup
                 results.reason = actions & _UA_SEARCH_PHASE
                                      ? _URC_CONTINUE_UNWIND
                                      : _URC_HANDLER_FOUND;
                 return;
#endif // __USING_SJLJ_OR_WASM_EXCEPTIONS__
                                          ? _URC_HANDLER_FOUND
                                          : _URC_CONTINUE_UNWIND;
                     return;
                 }
                 // Go to next action
                 action += actionOffset;
             }  // there is no break out of this loop, only return
         }
-#ifndef __USING_SJLJ_EXCEPTIONS__
+#ifndef __USING_SJLJ_OR_WASM_EXCEPTIONS__
         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__
+#endif // !__USING_SJLJ_OR_WASM_EXCEPTIONS__
     }  // there might be some tricky cases which break out of this loop
 
     // It is possible that no eh table entry specify how to handle
     // this exception. By spec, terminate it immediately.
     call_terminate(native_exception, unwind_exception);
 }
 
 // public API
Else
             1.  A cleanup.
 
         If a cleanup is found
             transfer control to it. return _URC_INSTALL_CONTEXT
         Else a cleanup is not found: return _URC_CONTINUE_UNWIND
 */
 
 #if !defined(_LIBCXXABI_ARM_EHABI)
-#if defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
+#ifdef __USING_WASM_EXCEPTIONS__
+_Unwind_Reason_Code __gxx_personality_wasm0
+#elif defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
 static _Unwind_Reason_Code __gxx_personality_imp
 #else
 _LIBCXXABI_FUNC_VIS _Unwind_Reason_Code
 #ifdef __USING_SJLJ_EXCEPTIONS__
 __gxx_personality_sj0
 #elif defined(__MVS__)
 __zos_cxx_personality_v2
 #else
if (actions & _UA_SEARCH_PHASE)
         if (native_exception) {
             // For a native exception, cache the LSDA result.
             __cxa_exception* exc = (__cxa_exception*)(unwind_exception + 1) - 1;
             exc->handlerSwitchValue = static_cast<int>(results.ttypeIndex);
             exc->actionRecord = results.actionRecord;
             exc->languageSpecificData = results.languageSpecificData;
             exc->catchTemp = reinterpret_cast<void*>(results.landingPad);
             exc->adjustedPtr = results.adjustedPtr;
+#ifdef __USING_WASM_EXCEPTIONS__
+            // Wasm only uses a single phase (_UA_SEARCH_PHASE), so save the
+            // results here.
+            set_registers(unwind_exception, context, results);
+#endif
         }
         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.