Move parts of emscripten exception handling to native code. NFC

Specifically, this change moves the allocation and reference counting
functions.

This saves on code size but more importantly reduces the number and of
complexity of imports/exports, which in turn helps with the wasm64 work
I've been doing.

Author: sbc100

emcc.py

@@ -2444,6 +2444,11 @@ def check_memory_setting(setting):
       '__cxa_is_pointer_type',
       '__cxa_can_catch',
 
+      # __cxa_begin_catch depends on this but we can't use deps info in this
+      # case because that only works for user-level code, and __cxa_begin_catch
+      # can be used by the standard library.
+      '__cxa_increment_exception_refcount',
+
       # Emscripten exception handling can generate invoke calls, and they call
       # setThrew(). We cannot handle this using deps_info as the invokes are not
       # emitted because of library function usage, but by codegen itself.

src/jsifier.js

@@ -174,13 +174,15 @@ function ${name}(${args}) {
             warn('To build in STANDALONE_WASM mode without a main(), use emcc --no-entry');
           }
         }
+        // We have already warned/errored about this function, so for the
+        // purposes of Closure use, mute all type checks regarding this
+        // function, marking as a variadic function that can take in anything
+        // and return anything.
+        // (not useful to warn/error multiple times)
+        LibraryManager.library[ident + '__docs'] = '/** @type {function(...*):?} */';
         if (!RELOCATABLE) {
           // emit a stub that will fail at runtime
           LibraryManager.library[ident] = new Function(`err('missing function: ${ident}'); abort(-1);`);
-          // We have already warned/errored about this function, so for the purposes of Closure use, mute all type checks
-          // regarding this function, marking ot a variadic function that can take in anything and return anything.
-          // (not useful to warn/error multiple times)
-          LibraryManager.library[ident + '__docs'] = '/** @type {function(...*):?} */';
         } else {
           const target = `Module['${finalName}']`;
           let assertion = '';

src/library_exceptions.js

@@ -22,11 +22,9 @@ var LibraryExceptions = {
   //
   // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
   $ExceptionInfo__docs: '/** @constructor */',
-  $ExceptionInfo__deps: ['__cxa_is_pointer_type',
 #if EXCEPTION_DEBUG
-    '$ptrToString',
+  $ExceptionInfo__deps: ['$ptrToString'],
 #endif
-  ],
   $ExceptionInfo: function(excPtr) {
     this.excPtr = excPtr;
     this.ptr = excPtr - {{{ C_STRUCTS.__cxa_exception.__size__ }}};
@@ -47,10 +45,6 @@ var LibraryExceptions = {
       return {{{ makeGetValue('this.ptr', C_STRUCTS.__cxa_exception.exceptionDestructor, '*') }}};
     };
 
-    this.set_refcount = function(refcount) {
-      {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.referenceCount, 'refcount', 'i32') }}};
-    };
-
     this.set_caught = function (caught) {
       caught = caught ? 1 : 0;
       {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.caught, 'caught', 'i8') }}};
@@ -77,34 +71,8 @@ var LibraryExceptions = {
       this.set_adjusted_ptr(0);
       this.set_type(type);
       this.set_destructor(destructor);
-      this.set_refcount(0);
-      this.set_caught(false);
-      this.set_rethrown(false);
     }
 
-    this.add_ref = function() {
-#if SHARED_MEMORY
-      Atomics.add(HEAP32, (this.ptr + {{{ C_STRUCTS.__cxa_exception.referenceCount }}}) >> 2, 1);
-#else
-      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 SHARED_MEMORY
-      var prev = Atomics.sub(HEAP32, (this.ptr + {{{ C_STRUCTS.__cxa_exception.referenceCount }}}) >> 2, 1);
-#else
-      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);
-#endif
-      return prev === 1;
-    };
-
     this.set_adjusted_ptr = function(adjustedPtr) {
       {{{ makeSetValue('this.ptr', C_STRUCTS.__cxa_exception.adjustedPtr, 'adjustedPtr', '*') }}};
     };
@@ -130,73 +98,6 @@ var LibraryExceptions = {
     };
   },
 
-  $exception_addRef: function (info) {
-#if EXCEPTION_DEBUG
-    err('exception_addRef ' + ptrToString(info.excPtr));
-#endif
-    info.add_ref();
-  },
-
-  $exception_decRef__deps: ['__cxa_free_exception'
-#if EXCEPTION_DEBUG
-    , '$exceptionLast', '$exceptionCaught'
-#endif
-  ],
-  $exception_decRef: function(info) {
-#if EXCEPTION_DEBUG
-    err('exception_decRef ' + ptrToString(info.excPtr));
-#endif
-    // A rethrown exception can reach refcount 0; it must not be discarded
-    // Its next handler will clear the rethrown flag and addRef it, prior to
-    // final decRef and destruction here
-    if (info.release_ref() && !info.get_rethrown()) {
-      var destructor = info.get_destructor();
-      if (destructor) {
-        // In Wasm, destructors return 'this' as in ARM
-        {{{ makeDynCall('ii', 'destructor') }}}(info.excPtr);
-      }
-      ___cxa_free_exception(info.excPtr);
-#if EXCEPTION_DEBUG
-      err('decref freeing exception ' + [ptrToString(info.excPtr), exceptionLast, 'stack', exceptionCaught]);
-#endif
-    }
-  },
-
-  // Exceptions
-  __cxa_allocate_exception__sig: 'vi',
-  __cxa_allocate_exception: function(size) {
-    // Thrown object is prepended by exception metadata block
-    return _malloc(size + {{{ C_STRUCTS.__cxa_exception.__size__ }}}) + {{{ C_STRUCTS.__cxa_exception.__size__ }}};
-  },
-
-  __cxa_free_exception__deps: ['$ExceptionInfo'],
-  __cxa_free_exception__sig: 'vi',
-  __cxa_free_exception: function(ptr) {
-#if ABORTING_MALLOC || ASSERTIONS
-    try {
-#endif
-      return _free(new ExceptionInfo(ptr).ptr);
-#if ABORTING_MALLOC || ASSERTIONS
-    } catch(e) {
-#if ASSERTIONS
-      err('exception during __cxa_free_exception: ' + e);
-#endif
-    }
-#endif
-  },
-
-  __cxa_increment_exception_refcount__deps: ['$exception_addRef', '$ExceptionInfo'],
-  __cxa_increment_exception_refcount: function(ptr) {
-    if (!ptr) return;
-    exception_addRef(new ExceptionInfo(ptr));
-  },
-
-  __cxa_decrement_exception_refcount__deps: ['$exception_decRef', '$ExceptionInfo'],
-  __cxa_decrement_exception_refcount: function(ptr) {
-    if (!ptr) return;
-    exception_decRef(new ExceptionInfo(ptr));
-  },
-
   // Here, we throw an exception after recording a couple of values that we need to remember
   // We also remember that it was the last exception thrown as we need to know that later.
   __cxa_throw__sig: 'viii',
@@ -243,7 +144,8 @@ var LibraryExceptions = {
     return type;
   },
 
-  __cxa_begin_catch__deps: ['$exceptionCaught', '$exception_addRef', '$uncaughtExceptionCount'],
+  __cxa_begin_catch__deps: ['$exceptionCaught', '__cxa_increment_exception_refcount',
+                            '$uncaughtExceptionCount'],
   __cxa_begin_catch: function(ptr) {
     var info = new ExceptionInfo(ptr);
     if (!info.get_caught()) {
@@ -255,15 +157,15 @@ var LibraryExceptions = {
 #if EXCEPTION_DEBUG
     err('__cxa_begin_catch ' + [ptrToString(ptr), 'stack', exceptionCaught]);
 #endif
-    exception_addRef(info);
+    ___cxa_increment_exception_refcount(info.excPtr);
     return info.get_exception_ptr();
   },
 
   // We're done with a catch. Now, we can run the destructor if there is one
   // and free the exception. Note that if the dynCall on the destructor fails
   // due to calling apply on undefined, that means that the destructor is
   // an invalid index into the FUNCTION_TABLE, so something has gone wrong.
-  __cxa_end_catch__deps: ['$exceptionCaught', '$exceptionLast', '$exception_decRef'],
+  __cxa_end_catch__deps: ['$exceptionCaught', '$exceptionLast', '__cxa_decrement_exception_refcount', 'setThrew'],
   __cxa_end_catch__sig: 'v',
   __cxa_end_catch: function() {
     // Clear state flag.
@@ -277,16 +179,17 @@ var LibraryExceptions = {
 #if EXCEPTION_DEBUG
     err('__cxa_end_catch popped ' + [info, exceptionLast, 'stack', exceptionCaught]);
 #endif
-    exception_decRef(info);
+    ___cxa_decrement_exception_refcount(info.excPtr);
     exceptionLast = 0; // XXX in decRef?
   },
 
   __cxa_get_exception_ptr__deps: ['$ExceptionInfo'],
   __cxa_get_exception_ptr: function(ptr) {
+    var rtn = new ExceptionInfo(ptr).get_exception_ptr();
 #if EXCEPTION_DEBUG
-    err('__cxa_get_exception_ptr ' + ptrToString(ptr));
+    err('__cxa_get_exception_ptr ' + ptrToString(ptr) + ' -> ' + ptrToString(rtn));
 #endif
-    return new ExceptionInfo(ptr).get_exception_ptr();
+    return rtn;
   },
 
   __cxa_uncaught_exceptions__deps: ['$uncaughtExceptionCount'],
@@ -302,13 +205,13 @@ var LibraryExceptions = {
     throw exception;
   },
 
-  __cxa_current_primary_exception__deps: ['$exceptionCaught', '$exception_addRef'],
+  __cxa_current_primary_exception__deps: ['$exceptionCaught', '__cxa_increment_exception_refcount'],
   __cxa_current_primary_exception: function() {
     if (!exceptionCaught.length) {
       return 0;
     }
     var info = exceptionCaught[exceptionCaught.length - 1];
-    exception_addRef(info);
+    ___cxa_increment_exception_refcount(info.excPtr);
     return info.excPtr;
   },
 

src/library_exceptions_stub.js

@@ -7,10 +7,6 @@
 var LibraryExceptions = {};
 
 [
-  '__cxa_allocate_exception',
-  '__cxa_free_exception',
-  '__cxa_increment_exception_refcount',
-  '__cxa_decrement_exception_refcount',
   '__cxa_throw',
   '__cxa_rethrow',
   'llvm_eh_typeid_for',

system/lib/libcxxabi/src/cxa_emscripten.cpp

@@ -0,0 +1,122 @@
+#include "cxxabi.h"
+#include "cxa_exception.h"
+#include "include/atomic_support.h"
+#include "fallback_malloc.h"
+#include "stdio.h"
+#include "assert.h"
+
+#if 1
+#define DEBUG(...)
+#else
+#define DEBUG printf
+#endif
+
+namespace __cxxabiv1 {
+
+//  Utility routines
+static
+inline
+__cxa_exception*
+cxa_exception_from_thrown_object(void* thrown_object)
+{
+    DEBUG("cxa_exception_from_thrown_object %p -> %p\n", thrown_object, static_cast<__cxa_exception*>(thrown_object) - 1);
+    return static_cast<__cxa_exception*>(thrown_object) - 1;
+}
+
+// Note:  This is never called when exception_header is masquerading as a
+//        __cxa_dependent_exception.
+static
+inline
+void*
+thrown_object_from_cxa_exception(__cxa_exception* exception_header)
+{
+    DEBUG("thrown_object_from_cxa_exception %p -> %p\n", exception_header, static_cast<void*>(exception_header + 1));
+    return static_cast<void*>(exception_header + 1);
+}
+
+// Round s up to next multiple of a.
+static inline
+size_t aligned_allocation_size(size_t s, size_t a) {
+    return (s + a - 1) & ~(a - 1);
+}
+
+static inline
+size_t cxa_exception_size_from_exception_thrown_size(size_t size) {
+    return aligned_allocation_size(size + sizeof (__cxa_exception),
+                                   alignof(__cxa_exception));
+}
+
+extern "C" {
+
+//  Allocate a __cxa_exception object, and zero-fill it.
+//  Reserve "thrown_size" bytes on the end for the user's exception
+//  object. Zero-fill the object. If memory can't be allocated, call
+//  std::terminate. Return a pointer to the memory to be used for the
+//  user's exception object.
+void *__cxa_allocate_exception(size_t thrown_size) _NOEXCEPT {
+    size_t actual_size = cxa_exception_size_from_exception_thrown_size(thrown_size);
+
+    char *raw_buffer =
+        (char *)__aligned_malloc_with_fallback(actual_size);
+    if (NULL == raw_buffer)
+        std::terminate();
+    __cxa_exception *exception_header =
+        static_cast<__cxa_exception *>((void *)(raw_buffer));
+    ::memset(exception_header, 0, actual_size);
+    return thrown_object_from_cxa_exception(exception_header);
+}
+
+
+//  Free a __cxa_exception object allocated with __cxa_allocate_exception.
+void __cxa_free_exception(void *thrown_object) _NOEXCEPT {
+    // Compute the size of the padding before the header.
+    char *raw_buffer =
+        ((char *)cxa_exception_from_thrown_object(thrown_object));
+    __aligned_free_with_fallback((void *)raw_buffer);
+}
+
+/*
+    If thrown_object is not null, atomically increment the referenceCount field
+    of the __cxa_exception header associated with the thrown object referred to
+    by thrown_object.
+
+    Requires:  If thrown_object is not NULL, it is a native exception.
+*/
+void
+__cxa_increment_exception_refcount(void *thrown_object) _NOEXCEPT {
+    if (thrown_object != NULL )
+    {
+        __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
+        DEBUG("INC: %p refcnt=%zu\n", thrown_object, exception_header->referenceCount);
+        std::__libcpp_atomic_add(&exception_header->referenceCount, size_t(1));
+    }
+}
+
+/*
+    If thrown_object is not null, atomically decrement the referenceCount field
+    of the __cxa_exception header associated with the thrown object referred to
+    by thrown_object.  If the referenceCount drops to zero, destroy and
+    deallocate the exception.
+
+    Requires:  If thrown_object is not NULL, it is a native exception.
+*/
+_LIBCXXABI_NO_CFI
+void __cxa_decrement_exception_refcount(void *thrown_object) _NOEXCEPT {
+    if (thrown_object != NULL )
+    {
+        __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
+        DEBUG("DEC: %p refcnt=%zu rethrown=%d\n", thrown_object, exception_header->referenceCount, exception_header->rethrown);
+        assert(exception_header->referenceCount > 0);
+        if (std::__libcpp_atomic_add(&exception_header->referenceCount, size_t(-1)) == 0 && !exception_header->rethrown)
+        {
+            DEBUG("DEL: %p\n", thrown_object);
+            if (NULL != exception_header->exceptionDestructor)
+                exception_header->exceptionDestructor(thrown_object);
+            __cxa_free_exception(thrown_object);
+        }
+    }
+}
+
+}  // extern "C"
+
+}  // abi

system/lib/libcxxabi/src/cxa_noexception.cpp

@@ -43,11 +43,18 @@ __cxa_rethrow_primary_exception(void* thrown_object) {
       std::terminate();
 }
 
-bool
-__cxa_uncaught_exception() throw() { return false; }
+bool __cxa_uncaught_exception() throw() { return false; }
 
-unsigned int
-__cxa_uncaught_exceptions() throw() { return 0; }
+unsigned int __cxa_uncaught_exceptions() throw() { return 0; }
+
+void *__cxa_allocate_exception(size_t thrown_size) _NOEXCEPT {
+  char* allocation = (char*)malloc(thrown_size + sizeof(__cxa_exception));
+  return allocation + sizeof(__cxa_exception);
+}
+
+void __cxa_free_exception(void *thrown_object) _NOEXCEPT {
+  free(((char*)thrown_object) - sizeof(__cxa_exception));
+}
 
 }  // extern "C"