Define emscripten exception struct in native code. NFC (#14431)

This is really step 1 of moving more of this code to be
native.

Author: sbc100

src/library_exceptions.js

@@ -9,20 +9,6 @@ var LibraryExceptions = {
   $exceptionLast: '0',
   $exceptionCaught: ' []',
 
-  // Static fields for ExceptionInfo class.
-  $ExceptionInfoAttrs: {
-    // ExceptionInfo native structure layout.
-    DESTRUCTOR_OFFSET: 0,
-    REFCOUNT_OFFSET: Runtime.POINTER_SIZE,
-    TYPE_OFFSET: Runtime.POINTER_SIZE + 4,
-    CAUGHT_OFFSET: Runtime.POINTER_SIZE + 8,
-    RETHROWN_OFFSET: Runtime.POINTER_SIZE + 9,
-
-    // Total structure size with padding, should be multiple of allocation alignment.
-    SIZE: alignMemory(Runtime.POINTER_SIZE + 10)
-  },
-
-  $ExceptionInfo__deps: ['$ExceptionInfoAttrs'],
   // This class is the exception metadata which is prepended to each thrown object (in WASM memory).
   // It is allocated in one block among with a thrown object in __cxa_allocate_exception and freed
   // in ___cxa_free_exception. It roughly corresponds to __cxa_exception structure in libcxxabi. The
@@ -37,44 +23,44 @@ var LibraryExceptions = {
   // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
   $ExceptionInfo: function(excPtr) {
     this.excPtr = excPtr;
-    this.ptr = excPtr - ExceptionInfoAttrs.SIZE;
+    this.ptr = excPtr - {{{ C_STRUCTS.__cxa_exception.__size__ }}};
 
     this.set_type = function(type) {
-      {{{ makeSetValue('this.ptr', 'ExceptionInfoAttrs.TYPE_OFFSET', 'type', '*') }}};
+      {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionType, 'type', '*') }}};
     };
 
     this.get_type = function() {
-      return {{{ makeGetValue('this.ptr', 'ExceptionInfoAttrs.TYPE_OFFSET', '*') }}};
+      return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionType, '*') }}};
     };
 
     this.set_destructor = function(destructor) {
-      {{{ makeSetValue('this.ptr', 'ExceptionInfoAttrs.DESTRUCTOR_OFFSET', 'destructor', '*') }}};
+      {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionDestructor, 'destructor', '*') }}};
     };
 
     this.get_destructor = function() {
-      return {{{ makeGetValue('this.ptr', 'ExceptionInfoAttrs.DESTRUCTOR_OFFSET', '*') }}};
+      return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionDestructor, '*') }}};
     };
 
     this.set_refcount = function(refcount) {
-      {{{ makeSetValue('this.ptr', 'ExceptionInfoAttrs.REFCOUNT_OFFSET', 'refcount', 'i32') }}};
+      {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.referenceCount, 'refcount', 'i32') }}};
     };
 
     this.set_caught = function (caught) {
       caught = caught ? 1 : 0;
-      {{{ makeSetValue('this.ptr', 'ExceptionInfoAttrs.CAUGHT_OFFSET', 'caught', 'i8') }}};
+      {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.caught, 'caught', 'i8') }}};
     };
 
     this.get_caught = function () {
-      return {{{ makeGetValue('this.ptr', 'ExceptionInfoAttrs.CAUGHT_OFFSET', 'i8') }}} != 0;
+      return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.caught, 'i8') }}} != 0;
     };
 
     this.set_rethrown = function (rethrown) {
       rethrown = rethrown ? 1 : 0;
-      {{{ makeSetValue('this.ptr', 'ExceptionInfoAttrs.RETHROWN_OFFSET', 'rethrown', 'i8') }}};
+      {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.rethrown, 'rethrown', 'i8') }}};
     };
 
     this.get_rethrown = function () {
-      return {{{ makeGetValue('this.ptr', 'ExceptionInfoAttrs.RETHROWN_OFFSET', 'i8') }}} != 0;
+      return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.rethrown, 'i8') }}} != 0;
     };
 
     // Initialize native structure fields. Should be called once after allocated.
@@ -88,20 +74,20 @@ var LibraryExceptions = {
 
     this.add_ref = function() {
 #if USE_PTHREADS
-      Atomics.add(HEAP32, (this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2, 1);
+      Atomics.add(HEAP32, (this.ptr + {{{ C_STRUCTS.__cxa_exception.referenceCount }}}) >> 2, 1);
 #else
-      var value = {{{ makeGetValue('this.ptr', 'ExceptionInfoAttrs.REFCOUNT_OFFSET', 'i32') }}};
-      {{{ makeSetValue('this.ptr', 'ExceptionInfoAttrs.REFCOUNT_OFFSET', 'value + 1', 'i32') }}};
+      var value = {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.referenceCount, 'i32') }}};
+      {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.referenceCount, 'value + 1', 'i32') }}};
 #endif
     };
 
     // Returns true if last reference released.
     this.release_ref = function() {
 #if USE_PTHREADS
-      var prev = Atomics.sub(HEAP32, (this.ptr + ExceptionInfoAttrs.REFCOUNT_OFFSET) >> 2, 1);
+      var prev = Atomics.sub(HEAP32, (this.ptr + {{{ C_STRUCTS.__cxa_exception.referenceCount }}}) >> 2, 1);
 #else
-      var prev = {{{ makeGetValue('this.ptr', 'ExceptionInfoAttrs.REFCOUNT_OFFSET', 'i32') }}};
-      {{{ makeSetValue('this.ptr', 'ExceptionInfoAttrs.REFCOUNT_OFFSET', 'prev - 1', 'i32') }}};
+      var prev = {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.referenceCount, 'i32') }}};
+      {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.referenceCount, 'prev - 1', 'i32') }}};
 #endif
 #if ASSERTIONS
       assert(prev > 0);
@@ -205,11 +191,10 @@ var LibraryExceptions = {
   },
 
   // Exceptions
-  __cxa_allocate_exception__deps: ['$ExceptionInfoAttrs'],
   __cxa_allocate_exception__sig: 'vi',
   __cxa_allocate_exception: function(size) {
     // Thrown object is prepended by exception metadata block
-    return _malloc(size + ExceptionInfoAttrs.SIZE) + ExceptionInfoAttrs.SIZE;
+    return _malloc(size + {{{ C_STRUCTS.__cxa_exception.__size__ }}}) + {{{ C_STRUCTS.__cxa_exception.__size__ }}};
   },
 
   __cxa_free_exception__deps: ['$ExceptionInfo'],

src/struct_info_internal.json

@@ -40,5 +40,17 @@
               "global_locale"
             ]
         }
+    },
+    {
+        "file": "cxa_exception.h",
+        "structs": {
+            "__cxxabiv1::__cxa_exception": [
+              "exceptionDestructor",
+              "referenceCount",
+              "exceptionType",
+              "caught",
+              "rethrown"
+            ]
+        }
     }
 ]

system/lib/libc/musl/arch/emscripten/atomic_arch.h

@@ -36,9 +36,9 @@ static inline void a_or_l(volatile void *p, long v)
 #define a_cas_p a_cas_p
 static inline void *a_cas_p(volatile void *p, void *t, void *s)
 {
-	void* expected = t;
-	__c11_atomic_compare_exchange_strong((_Atomic uintptr_t*)p, &expected, s, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
-	return expected;
+	uintptr_t expected = (uintptr_t)t;
+	__c11_atomic_compare_exchange_strong((_Atomic uintptr_t*)p, &expected, (uintptr_t)s, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+	return (void*)expected;
 }
 
 #define a_cas_l a_cas_l

system/lib/libcxxabi/src/cxa_default_handlers.cpp

@@ -13,13 +13,11 @@
 #include "abort_message.h"
 #include "cxxabi.h"
 #include "cxa_handlers.h"
+#include "cxa_exception.h"
 #include "private_typeinfo.h"
 #include "include/atomic_support.h"
 
 #if !defined(LIBCXXABI_SILENT_TERMINATE)
-// XXX EMSCRIPTEN: this header is not compatible with emscripten exceptions
-// and is only needed when !LIBCXXABI_SILENT_TERMINATE
-#include "cxa_exception.h"
 
 _LIBCPP_SAFE_STATIC
 static const char* cause = "uncaught";

system/lib/libcxxabi/src/cxa_exception.h

@@ -17,14 +17,19 @@
 #include "cxxabi.h"
 #include "unwind.h"
 
+namespace __cxxabiv1 {
+
 #ifdef __USING_EMSCRIPTEN_EXCEPTIONS__
-// Under emscripten-style exception handling the __cxa_exception type is
-// defined in JavaScript in src/library_exceptions.js.
-// Any usage of this header would lead to incompatabilities.
-#error "Not compatible with emscripten-style exception handling"
-#endif
 
-namespace __cxxabiv1 {
+struct _LIBCXXABI_HIDDEN __cxa_exception {
+  size_t referenceCount;
+  std::type_info *exceptionType;
+  void (*exceptionDestructor)(void *);
+  uint8_t caught;
+  uint8_t rethrown;
+};
+
+#else
 
 static const uint64_t kOurExceptionClass          = 0x434C4E47432B2B00; // CLNGC++\0
 static const uint64_t kOurDependentExceptionClass = 0x434C4E47432B2B01; // CLNGC++\1
@@ -171,6 +176,8 @@ extern "C" _LIBCXXABI_FUNC_VIS __cxa_eh_globals * __cxa_get_globals_fast ();
 extern "C" _LIBCXXABI_FUNC_VIS void * __cxa_allocate_dependent_exception ();
 extern "C" _LIBCXXABI_FUNC_VIS void __cxa_free_dependent_exception (void * dependent_exception);
 
+#endif // !__USING_EMSCRIPTEN_EXCEPTIONS__
+
 }  // namespace __cxxabiv1
 
 #endif  // _CXA_EXCEPTION_H

system/lib/libcxxabi/src/cxa_handlers.cpp

@@ -15,9 +15,7 @@
 #include "abort_message.h"
 #include "cxxabi.h"
 #include "cxa_handlers.h"
-#ifndef __USING_EMSCRIPTEN_EXCEPTIONS__
 #include "cxa_exception.h"
-#endif
 #include "private_typeinfo.h"
 #include "include/atomic_support.h"
 

tests/reference_struct_info.json

@@ -1222,6 +1222,14 @@
             "module": 4,
             "nextInChain": 0
         },
+        "__cxa_exception": {
+            "__size__": 16,
+            "caught": 12,
+            "exceptionDestructor": 8,
+            "exceptionType": 4,
+            "referenceCount": 0,
+            "rethrown": 13
+        },
         "__wasi_fdstat_t": {
             "__size__": 24,
             "fs_filetype": 0,

tools/gen_struct_info.py

@@ -141,6 +141,8 @@ def parse_c_output(lines):
 
   for line in lines:
     arg = line[1:].strip()
+    if '::' in arg:
+      arg = arg.split('::', 1)[1]
     if line[0] == 'K':
       # This is a key
       key = arg
@@ -252,7 +254,7 @@ def inspect_headers(headers, cflags):
   show('Compiling generated code...')
 
   # -Oz optimizes enough to avoid warnings on code size/num locals
-  cmd = [shared.EMCC] + cflags + ['-o', js_file[1], src_file[1],
+  cmd = [shared.EMXX] + cflags + ['-o', js_file[1], src_file[1],
                                   '-O0',
                                   '-Werror',
                                   '-Wno-format',
@@ -408,6 +410,8 @@ def main(args):
 
   internal_cflags = [
     '-I' + shared.path_from_root('system', 'lib', 'libc', 'musl', 'src', 'internal'),
+    '-I' + shared.path_from_root('system', 'lib', 'libcxxabi', 'src'),
+    '-D__USING_EMSCRIPTEN_EXCEPTIONS__',
   ]
 
   # Look for structs in all passed headers.