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

@@ -2791,6 +2791,13 @@ 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',
+      # Same for __cxa_end_catch
+      '__cxa_decrement_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

@@ -292,13 +292,13 @@ 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 ot a variadic function that can take in anything and return anything.
+        // (not useful to warn/error multiple times)
+        LibraryManager.library[symbol + '__docs'] = '/** @type {function(...*):?} */';
         if (!RELOCATABLE) {
           // emit a stub that will fail at runtime
           LibraryManager.library[symbol] = new Function(`err('missing function: ${symbol}'); 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[symbol + '__docs'] = '/** @type {function(...*):?} */';
         } else {
           // Create a stub for this symbol which can later be replaced by the
           // dynamic linker.  If this stub is called before the symbol is

src/library_exceptions.js

@@ -23,11 +23,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__ }}};
@@ -48,10 +46,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') }}};
@@ -78,34 +72,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', '*') }}};
     };
@@ -131,52 +99,6 @@ var LibraryExceptions = {
     };
   },
 
-  $exception_addRef: function (info) {
-#if EXCEPTION_DEBUG
-    dbg('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
-    dbg('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('pp', 'destructor') }}}(info.excPtr);
-      }
-      ___cxa_free_exception(info.excPtr);
-#if EXCEPTION_DEBUG
-      dbg('decref freeing exception ' + [ptrToString(info.excPtr), exceptionLast, 'stack', exceptionCaught]);
-#endif
-    }
-  },
-
-  __cxa_increment_exception_refcount__deps: ['$exception_addRef', '$ExceptionInfo'],
-  __cxa_increment_exception_refcount__sig: 'vp',
-  __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__sig: 'vp',
-  __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: 'vppp',
@@ -224,7 +146,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__sig: 'pp',
   __cxa_begin_catch: function(ptr) {
     var info = new ExceptionInfo(ptr);
@@ -237,15 +160,15 @@ var LibraryExceptions = {
 #if EXCEPTION_DEBUG
     dbg('__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.
@@ -259,17 +182,18 @@ var LibraryExceptions = {
 #if EXCEPTION_DEBUG
     dbg('__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__sig: 'pp',
   __cxa_get_exception_ptr: function(ptr) {
+    var rtn = new ExceptionInfo(ptr).get_exception_ptr();
 #if EXCEPTION_DEBUG
-    dbg('__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'],
@@ -285,13 +209,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',