Return a pair [type, what] from getExceptionMessage (#17386)

As discussed in #17362, this changes `getExceptionMessage` to return a pair, the exception type and the exception `what()` if available. If no exception description is available, the second entry will be undefined. 

This is an API break so we may want to give the new function a different name and keep the old one or something. The behavior of `__get_exception_terminate_message` should be unchanged. This change adds a few extra heap allocations but this is not supposed to be hot code.

Author: hoodmane

src/library_exceptions.js

@@ -393,6 +393,26 @@ var LibraryExceptions = {
   },
 
 #endif
+#if WASM_EXCEPTIONS || !DISABLE_EXCEPTION_CATCHING
+  $getExceptionMessageCommon__deps: ['__get_exception_message', 'free'],
+  $getExceptionMessageCommon: function(ptr) {
+    return withStackSave(function() {
+      var type_addr_addr = stackAlloc(4);
+      var message_addr_addr = stackAlloc(4);
+      ___get_exception_message(ptr, type_addr_addr, message_addr_addr);
+      var type_addr = HEAP32[type_addr_addr >> 2];
+      var message_addr = HEAP32[message_addr_addr >> 2];
+      var type = UTF8ToString(type_addr);
+      _free(type_addr);
+      var message;
+      if (message_addr) {
+        message = UTF8ToString(message_addr);
+        _free(message_addr);
+      }
+      return [type, message];
+    });
+  },
+#endif
 #if WASM_EXCEPTIONS
   $getCppExceptionTag: function() {
     return Module['asm']['__cpp_exception'];
@@ -423,15 +443,10 @@ var LibraryExceptions = {
     ___cxa_decrement_exception_refcount(ptr);
   },
 
-  $getExceptionMessage__deps: ['__get_exception_message', 'free', '$getCppExceptionThrownObjectFromWebAssemblyException'],
+  $getExceptionMessage__deps: ['$getCppExceptionThrownObjectFromWebAssemblyException', '$getExceptionMessageCommon'],
   $getExceptionMessage: function(ex) {
-    // In Wasm EH, the thrown object is a WebAssembly.Exception. Extract the
-    // thrown value from it.
     var ptr = getCppExceptionThrownObjectFromWebAssemblyException(ex);
-    var utf8_addr = ___get_exception_message(ptr);
-    var result = UTF8ToString(utf8_addr);
-    _free(utf8_addr);
-    return result;
+    return getExceptionMessageCommon(ptr);
   },
 
 #elif !DISABLE_EXCEPTION_CATCHING
@@ -444,14 +459,12 @@ var LibraryExceptions = {
   $decrementExceptionRefcount: function(ptr) {
     ___cxa_decrement_exception_refcount(ptr);
   },
-
-  $getExceptionMessage__deps: ['__get_exception_message', 'free'],
+  $getExceptionMessage__deps: ['$getExceptionMessageCommon'],
   $getExceptionMessage: function(ptr) {
-    var utf8_addr = ___get_exception_message(ptr);
-    var result = UTF8ToString(utf8_addr);
-    _free(utf8_addr);
-    return result;
+    return getExceptionMessageCommon(ptr);
   },
+
+
 #endif
 };
 

system/lib/libcxxabi/src/cxa_exception_emscripten.cpp

@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 
 #if !defined(__USING_WASM_EXCEPTIONS__)
 // Until recently, Rust's `rust_eh_personality` for emscripten referred to this
@@ -71,7 +72,14 @@ void* __thrown_object_from_unwind_exception(
   return thrown_object_from_unwind_exception(unwind_exception);
 }
 
-char* __get_exception_message(void* thrown_object, bool terminate=false) {
+// Given a thrown_object, puts the information about its type and message into  
+// 'type' and 'message' output parameters. 'type' will contain the string        
+// representation of the type of the exception, e.g., 'int'. 'message' will      
+// contain the result of 'std::exception::what()' method if the type of the      
+// exception is a subclass of std::exception; otherwise it will be NULL. The     
+// caller is responsible for freeing 'type' buffer and also 'message' buffer, if 
+// it is not NULL.
+void __get_exception_message(void* thrown_object, char** type, char** message) {
   __cxa_exception* exception_header =
     cxa_exception_from_thrown_object(thrown_object);
   const __shim_type_info* thrown_type =
@@ -81,38 +89,44 @@ char* __get_exception_message(void* thrown_object, bool terminate=false) {
   int status = 0;
   char* demangled_buf = __cxa_demangle(type_name, 0, 0, &status);
   if (status == 0 && demangled_buf) {
-    type_name = demangled_buf;
+    *type = demangled_buf;
+  } else {
+    if (demangled_buf) {
+      free(demangled_buf);
+    }
+    *type = (char*)malloc(strlen(type_name) + 1);
+    strcpy(*type, type_name);
   }
 
+  *message = NULL;
   const __shim_type_info* catch_type =
     static_cast<const __shim_type_info*>(&typeid(std::exception));
   int can_catch = catch_type->can_catch(thrown_type, thrown_object);
-  char* result = NULL;
   if (can_catch) {
     const char* what =
       static_cast<const std::exception*>(thrown_object)->what();
-    asprintf(&result,
-             (terminate ? "terminating with uncaught exception of type %s: %s"
-                        : "exception of type %s: %s"),
-             type_name,
-             what);
-  } else {
-    asprintf(&result,
-             (terminate ? "terminating with uncaught exception of type %s"
-                        : "exception of type %s"),
-             type_name);
+    *message = (char*)malloc(strlen(what) + 1);
+    strcpy(*message, what);
   }
+}
 
-  if (demangled_buf) {
-    free(demangled_buf);
+// Returns a message saying that execution was terminated due to an exception.
+// This message is freshly malloc'd and should be freed.
+char* __get_exception_terminate_message(void* thrown_object) {
+  char* type;
+  char* message;
+  __get_exception_message(thrown_object, &type, &message);
+  char* result;
+  if (message != NULL) {
+    asprintf(
+      &result, "terminating with uncaught exception %s: %s", type, message);
+    free(message);
+  } else {
+    asprintf(&result, "terminating with uncaught exception of type %s", type);
   }
+  free(type);
   return result;
 }
-
-char* __get_exception_terminate_message(void *thrown_object) {
-  return __get_exception_message(thrown_object, true);
-}
-
 }
 
 #endif // __USING_EMSCRIPTEN_EXCEPTIONS__ || __USING_WASM_EXCEPTIONS__

tests/test_core.py

@@ -1681,19 +1681,19 @@ class myexception : public exception {
                   // __cxa_end_catch. Fix this inconsistency later.
                   incrementExceptionRefcount(p);
 #endif
-                  console.log(getExceptionMessage(p));
+                  console.log(getExceptionMessage(p).toString());
                   decrementExceptionRefcount(p);
               }
             }
           });
       }
     '''
     expected = '''\
-exception of type int
-exception of type char
-exception of type std::runtime_error: abc
-exception of type myexception: My exception happened
-exception of type char const*
+int,
+char,
+std::runtime_error,abc
+myexception,My exception happened
+char const*,
 '''
 
     self.do_run(src, expected)