Improve C++ exception handling.

We now allocate extra bytes before the exception data and use that,
rather than globals, to store the exception type and destructor
information.  This is step one towards having multiple exceptions
in flight at once.

We also track what exceptions are currently being caught in a stack
maintained in __cxa_begin_catch and __cxa_end_catch. This is used
for ensuring that we handle nested exception catch blocks correctly.

1 files changed, 61 insertions, 31 deletions

diff --git a/src/library.js b/src/library.js
index bc577e78..fc2e8a64 100644
--- a/src/library.js
+++ b/src/library.js
@@ -4318,21 +4318,36 @@ LibraryManager.library = {
   _ZTVN10__cxxabiv120__si_class_type_infoE: [2], // yes inherited classes
 #endif
 
+  // We store an extra header in front of the exception data provided
+  // by the user.
+  // This header is:
+  // * type
+  // * destructor function pointer
+  // This is then followed by the actual exception data.
+  __cxa_exception_header_size: 8,
+  __cxa_last_thrown_exception: 0,
+  __cxa_caught_exceptions: [],
+
   // Exceptions
+  __cxa_allocate_exception__deps: ['__cxa_exception_header_size'],
   __cxa_allocate_exception: function(size) {
-    return _malloc(size);
+    var ptr = _malloc(size + ___cxa_exception_header_size);
+    return ptr + ___cxa_exception_header_size;
   },
+  __cxa_free_exception__deps: ['__cxa_exception_header_size'],
   __cxa_free_exception: function(ptr) {
     try {
-      return _free(ptr);
+      return _free(ptr - ___cxa_exception_header_size);
     } catch(e) { // XXX FIXME
 #if ASSERTIONS
       Module.printErr('exception during cxa_free_exception: ' + e);
 #endif
     }
   },
+  // 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',
-  __cxa_throw__deps: ['llvm_eh_exception', '_ZSt18uncaught_exceptionv', '__cxa_find_matching_catch'],
+  __cxa_throw__deps: ['_ZSt18uncaught_exceptionv', '__cxa_find_matching_catch', '__cxa_exception_header_size', '__cxa_last_thrown_exception'],
   __cxa_throw: function(ptr, type, destructor) {
     if (!___cxa_throw.initialized) {
       try {
@@ -4349,28 +4364,34 @@ LibraryManager.library = {
 #if EXCEPTION_DEBUG
     Module.printErr('Compiled code throwing an exception, ' + [ptr,type,destructor] + ', at ' + stackTrace());
 #endif
-    {{{ makeSetValue('_llvm_eh_exception.buf', '0', 'ptr', 'void*') }}};
-    {{{ makeSetValue('_llvm_eh_exception.buf', QUANTUM_SIZE, 'type', 'void*') }}};
-    {{{ makeSetValue('_llvm_eh_exception.buf', 2 * QUANTUM_SIZE, 'destructor', 'void*') }}};
+    var header = ptr - ___cxa_exception_header_size;
+    {{{ makeSetValue('header', 0, 'type', 'void*') }}}
+    {{{ makeSetValue('header', 4, 'destructor', 'void*') }}}
+    ___cxa_last_thrown_exception = ptr;
     if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
       __ZSt18uncaught_exceptionv.uncaught_exception = 1;
     } else {
       __ZSt18uncaught_exceptionv.uncaught_exception++;
     }
-    {{{ makeThrow('ptr') }}};
+    {{{ makeThrow('ptr') }}}
   },
-  __cxa_rethrow__deps: ['llvm_eh_exception', '__cxa_end_catch'],
+  // This exception will be caught twice, but while begin_catch runs twice,
+  // we early-exit from end_catch when the exception has been rethrown, so
+  // pop that here from the caught exceptions.
+  __cxa_rethrow__deps: ['__cxa_end_catch', '__cxa_caught_exceptions'],
   __cxa_rethrow: function() {
     ___cxa_end_catch.rethrown = true;
-    {{{ makeThrow(makeGetValue('_llvm_eh_exception.buf', '0', 'void*')) }}};
+    var ptr = ___cxa_caught_exceptions.pop();
+    {{{ makeThrow('ptr') }}}
   },
-  llvm_eh_exception__postset: '_llvm_eh_exception.buf = allocate(12, "void*", ALLOC_STATIC);',
+  llvm_eh_exception__deps: ['__cxa_last_thrown_exception'],
   llvm_eh_exception: function() {
-    return {{{ makeGetValue('_llvm_eh_exception.buf', '0', 'void*') }}};
+    return ___cxa_last_thrown_exception;
   },
   llvm_eh_selector__jsargs: true,
+  llvm_eh_selector__deps: ['__cxa_last_thrown_exception'],
   llvm_eh_selector: function(unused_exception_value, personality/*, varargs*/) {
-    var type = {{{ makeGetValue('_llvm_eh_exception.buf', QUANTUM_SIZE, 'void*') }}}
+    var type = ___cxa_last_thrown_exception;
     for (var i = 2; i < arguments.length; i++) {
       if (arguments[i] ==  type) return type;
     }
@@ -4379,12 +4400,22 @@ LibraryManager.library = {
   llvm_eh_typeid_for: function(type) {
     return type;
   },
-  __cxa_begin_catch__deps: ['_ZSt18uncaught_exceptionv'],
+  // Note that we push the last thrown exception here rather than the ptr.
+  // This is because if the exception is a pointer (as in test 3 of test_exceptions_typed),
+  // we don't actually get the value that we allocated, but something else. Easiest
+  // to remember that the last exception thrown is going to be the first to be caught,
+  // so just use that value instead as it is what we're really looking for.
+  __cxa_begin_catch__deps: ['_ZSt18uncaught_exceptionv', '__cxa_caught_exceptions'],
   __cxa_begin_catch: function(ptr) {
     __ZSt18uncaught_exceptionv.uncaught_exception--;
+    ___cxa_caught_exceptions.push(___cxa_last_thrown_exception);
     return ptr;
   },
-  __cxa_end_catch__deps: ['llvm_eh_exception', '__cxa_free_exception'],
+  // 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: ['__cxa_free_exception', '__cxa_last_thrown_exception', '___cxa_exception_header_size', '__cxa_caught_exceptions'],
   __cxa_end_catch: function() {
     if (___cxa_end_catch.rethrown) {
       ___cxa_end_catch.rethrown = false;
@@ -4396,22 +4427,20 @@ LibraryManager.library = {
 #else
     __THREW__ = 0;
 #endif
-    // Clear type.
-    {{{ makeSetValue('_llvm_eh_exception.buf', QUANTUM_SIZE, '0', 'void*') }}};
     // Call destructor if one is registered then clear it.
-    var ptr = {{{ makeGetValue('_llvm_eh_exception.buf', '0', 'void*') }}};
-    var destructor = {{{ makeGetValue('_llvm_eh_exception.buf', 2 * QUANTUM_SIZE, 'void*') }}};
-    if (destructor) {
-      Runtime.dynCall('vi', destructor, [ptr]);
-      {{{ makeSetValue('_llvm_eh_exception.buf', 2 * QUANTUM_SIZE, '0', 'i32') }}};
-    }
-    // Free ptr if it isn't null.
+    var ptr = ___cxa_caught_exceptions.pop();
     if (ptr) {
+      header = ptr - ___cxa_exception_header_size;
+      var destructor = {{{ makeGetValue('header', 4, 'void*') }}};
+      if (destructor) {
+        Runtime.dynCall('vi', destructor, [ptr]);
+        {{{ makeSetValue('header', 4, '0', 'i32') }}}
+      }
       ___cxa_free_exception(ptr);
-      {{{ makeSetValue('_llvm_eh_exception.buf', '0', '0', 'void*') }}};
+      ___cxa_last_thrown_exception = 0;
     }
   },
-  __cxa_get_exception_ptr__deps: ['llvm_eh_exception'],
+  __cxa_get_exception_ptr__deps: ['___cxa_last_thrown_exception'],
   __cxa_get_exception_ptr: function(ptr) {
     return ptr;
   },
@@ -4431,7 +4460,7 @@ LibraryManager.library = {
 
   terminate: '__cxa_call_unexpected',
 
-  __gxx_personality_v0__deps: ['llvm_eh_exception', '_ZSt18uncaught_exceptionv', '__cxa_find_matching_catch'],
+  __gxx_personality_v0__deps: ['_ZSt18uncaught_exceptionv', '__cxa_find_matching_catch'],
   __gxx_personality_v0: function() {
   },
 
@@ -4464,10 +4493,11 @@ LibraryManager.library = {
   // functionality boils down to picking a suitable 'catch' block.
   // We'll do that here, instead, to keep things simpler.
 
-  __cxa_find_matching_catch__deps: ['__cxa_does_inherit', '__cxa_is_number_type', '__resumeException'],
+  __cxa_find_matching_catch__deps: ['__cxa_does_inherit', '__cxa_is_number_type', '__resumeException', '__cxa_last_thrown_exception', '__cxa_exception_header_size'],
   __cxa_find_matching_catch: function(thrown, throwntype) {
-    if (thrown == -1) thrown = {{{ makeGetValue('_llvm_eh_exception.buf', '0', 'void*') }}};
-    if (throwntype == -1) throwntype = {{{ makeGetValue('_llvm_eh_exception.buf', QUANTUM_SIZE, 'void*') }}};
+    if (thrown == -1) thrown = ___cxa_last_thrown_exception;
+    header = thrown - ___cxa_exception_header_size;
+    if (throwntype == -1) throwntype = {{{ makeGetValue('header', 0, 'void*') }}};
     var typeArray = Array.prototype.slice.call(arguments, 2);
 
     // If throwntype is a pointer, this means a pointer has been
@@ -4498,8 +4528,8 @@ LibraryManager.library = {
 #if EXCEPTION_DEBUG
     Module.print("Resuming exception");
 #endif
-    if ({{{ makeGetValue('_llvm_eh_exception.buf', 0, 'void*') }}} == 0) {{{ makeSetValue('_llvm_eh_exception.buf', 0, 'ptr', 'void*') }}};
-    {{{ makeThrow('ptr') }}};
+    if (!___cxa_last_thrown_exception) { ___cxa_last_thrown_exception = ptr; }
+    {{{ makeThrow('ptr') }}}
   },
 
   // Recursively walks up the base types of 'possibilityType'