[wasm] Implement handling of exported/imported exceptions.

This implements the proper semantics for matching exported/imported
exceptions by using the notion of an "exception tag" that is global to
the system. It can be used to match exceptions in one module against
exceptions declared and/or thrown in another module (or instance).

R=clemensh@chromium.org
TEST=mjsunit/wasm/exceptions-shared
BUG=v8:8091

Change-Id: I37586d7be5d5e6169b3418dfbc415b26dd4750dd
Reviewed-on: https://chromium-review.googlesource.com/1226976
Commit-Queue: Michael Starzinger <mstarzinger@chromium.org>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#55940}

src/compiler/wasm-compiler.cc

@@ -2043,13 +2043,13 @@ uint32_t WasmGraphBuilder::GetExceptionEncodedSize(
   return encoded_size;
 }
 
-Node* WasmGraphBuilder::Throw(uint32_t tag,
+Node* WasmGraphBuilder::Throw(uint32_t exception_index,
                               const wasm::WasmException* exception,
                               const Vector<Node*> values) {
   SetNeedsStackCheck();
   uint32_t encoded_size = GetExceptionEncodedSize(exception);
   Node* create_parameters[] = {
-      BuildChangeUint31ToSmi(ConvertExceptionTagToRuntimeId(tag)),
+      LoadExceptionTagFromTable(exception_index),
       BuildChangeUint31ToSmi(Uint32Constant(encoded_size))};
   Node* except_obj =
       BuildCallToRuntime(Runtime::kWasmThrowCreate, create_parameters,
@@ -2126,16 +2126,22 @@ Node* WasmGraphBuilder::Rethrow(Node* except_obj) {
   return result;
 }
 
-Node* WasmGraphBuilder::ConvertExceptionTagToRuntimeId(uint32_t tag) {
-  // TODO(kschimpf): Handle exceptions from different modules, when they are
-  // linked at runtime.
-  return Uint32Constant(tag);
+Node* WasmGraphBuilder::ExceptionTagEqual(Node* caught_tag,
+                                          Node* expected_tag) {
+  MachineOperatorBuilder* machine = mcgraph()->machine();
+  return graph()->NewNode(machine->WordEqual(), caught_tag, expected_tag);
+}
+
+Node* WasmGraphBuilder::LoadExceptionTagFromTable(uint32_t exception_index) {
+  Node* exceptions_table =
+      LOAD_INSTANCE_FIELD(ExceptionsTable, MachineType::TaggedPointer());
+  Node* tag = LOAD_FIXED_ARRAY_SLOT(exceptions_table, exception_index);
+  return tag;
 }
 
-Node* WasmGraphBuilder::GetExceptionRuntimeId(Node* except_obj) {
+Node* WasmGraphBuilder::GetExceptionTag(Node* except_obj) {
   SetNeedsStackCheck();
-  return BuildChangeSmiToInt32(
-      BuildCallToRuntime(Runtime::kWasmGetExceptionRuntimeId, &except_obj, 1));
+  return BuildCallToRuntime(Runtime::kWasmExceptionGetTag, &except_obj, 1);
 }
 
 Node** WasmGraphBuilder::GetExceptionValues(

src/compiler/wasm-compiler.h

@@ -160,11 +160,12 @@ class WasmGraphBuilder {
   Node* Unop(wasm::WasmOpcode opcode, Node* input,
              wasm::WasmCodePosition position = wasm::kNoCodePosition);
   Node* GrowMemory(Node* input);
-  Node* Throw(uint32_t tag, const wasm::WasmException* exception,
+  Node* Throw(uint32_t exception_index, const wasm::WasmException* exception,
               const Vector<Node*> values);
   Node* Rethrow(Node* except_obj);
-  Node* ConvertExceptionTagToRuntimeId(uint32_t tag);
-  Node* GetExceptionRuntimeId(Node* except_obj);
+  Node* ExceptionTagEqual(Node* caught_tag, Node* expected_tag);
+  Node* LoadExceptionTagFromTable(uint32_t exception_index);
+  Node* GetExceptionTag(Node* except_obj);
   Node** GetExceptionValues(Node* except_obj,
                             const wasm::WasmException* except_decl);
   bool IsPhiWithMerge(Node* phi, Node* merge);

src/heap-symbols.h

@@ -288,7 +288,7 @@
   V(sealed_symbol)                     \
   V(stack_trace_symbol)                \
   V(strict_function_transition_symbol) \
-  V(wasm_exception_runtime_id_symbol)  \
+  V(wasm_exception_tag_symbol)         \
   V(wasm_exception_values_symbol)      \
   V(uninitialized_symbol)
 

src/runtime/runtime-test.cc

@@ -844,12 +844,19 @@ RUNTIME_FUNCTION(Runtime_GetWasmRecoveredTrapCount) {
 
 RUNTIME_FUNCTION(Runtime_GetWasmExceptionId) {
   HandleScope scope(isolate);
-  DCHECK_EQ(1, args.length());
+  DCHECK_EQ(2, args.length());
   CONVERT_ARG_HANDLE_CHECKED(JSReceiver, exception, 0);
-  RETURN_RESULT_OR_FAILURE(
-      isolate, JSReceiver::GetProperty(
-                   isolate, exception,
-                   isolate->factory()->wasm_exception_runtime_id_symbol()));
+  CONVERT_ARG_HANDLE_CHECKED(WasmInstanceObject, instance, 1);
+  Handle<Object> tag;
+  if (JSReceiver::GetProperty(isolate, exception,
+                              isolate->factory()->wasm_exception_tag_symbol())
+          .ToHandle(&tag)) {
+    Handle<FixedArray> exceptions_table(instance->exceptions_table(), isolate);
+    for (int index = 0; index < exceptions_table->length(); ++index) {
+      if (exceptions_table->get(index) == *tag) return Smi::FromInt(index);
+    }
+  }
+  return ReadOnlyRoots(isolate).undefined_value();
 }
 
 RUNTIME_FUNCTION(Runtime_GetWasmExceptionValues) {

src/runtime/runtime-wasm.cc

@@ -118,12 +118,12 @@ RUNTIME_FUNCTION(Runtime_WasmThrowCreate) {
   Handle<Object> exception = isolate->factory()->NewWasmRuntimeError(
       static_cast<MessageTemplate::Template>(
           MessageTemplate::kWasmExceptionError));
-  CONVERT_ARG_HANDLE_CHECKED(Smi, id, 0);
-  CHECK(!JSReceiver::SetProperty(
-             isolate, exception,
-             isolate->factory()->wasm_exception_runtime_id_symbol(), id,
-             LanguageMode::kStrict)
-             .is_null());
+  CONVERT_ARG_HANDLE_CHECKED(HeapObject, tag, 0);
+  CHECK(
+      !JSReceiver::SetProperty(isolate, exception,
+                               isolate->factory()->wasm_exception_tag_symbol(),
+                               tag, LanguageMode::kStrict)
+           .is_null());
   CONVERT_SMI_ARG_CHECKED(size, 1);
   Handle<JSTypedArray> values =
       isolate->factory()->NewJSTypedArray(ElementsKind::UINT16_ELEMENTS, size);
@@ -146,7 +146,7 @@ RUNTIME_FUNCTION(Runtime_WasmThrow) {
   return isolate->Throw(*except_obj);
 }
 
-RUNTIME_FUNCTION(Runtime_WasmGetExceptionRuntimeId) {
+RUNTIME_FUNCTION(Runtime_WasmExceptionGetTag) {
   // TODO(kschimpf): Can this be replaced with equivalent TurboFan code/calls.
   HandleScope scope(isolate);
   DCHECK_EQ(1, args.length());
@@ -156,16 +156,13 @@ RUNTIME_FUNCTION(Runtime_WasmGetExceptionRuntimeId) {
   if (!except_obj.is_null() && except_obj->IsJSReceiver()) {
     Handle<JSReceiver> exception(JSReceiver::cast(*except_obj), isolate);
     Handle<Object> tag;
-    if (JSReceiver::GetProperty(
-            isolate, exception,
-            isolate->factory()->wasm_exception_runtime_id_symbol())
+    if (JSReceiver::GetProperty(isolate, exception,
+                                isolate->factory()->wasm_exception_tag_symbol())
             .ToHandle(&tag)) {
-      if (tag->IsSmi()) {
-        return *tag;
-      }
+      return *tag;
     }
   }
-  return Smi::FromInt(wasm::kInvalidExceptionTag);
+  return ReadOnlyRoots(isolate).undefined_value();
 }
 
 RUNTIME_FUNCTION(Runtime_WasmExceptionGetElement) {

src/runtime/runtime.h

@@ -473,7 +473,7 @@ namespace internal {
   F(GetDeoptCount, 1, 1)                      \
   F(GetOptimizationStatus, -1, 1)             \
   F(GetUndetectable, 0, 1)                    \
-  F(GetWasmExceptionId, 1, 1)                 \
+  F(GetWasmExceptionId, 2, 1)                 \
   F(GetWasmExceptionValues, 1, 1)             \
   F(GetWasmRecoveredTrapCount, 0, 1)          \
   F(GlobalPrint, 1, 1)                        \
@@ -541,18 +541,18 @@ namespace internal {
   F(TypedArraySet, 2, 1)                 \
   F(TypedArraySortFast, 1, 1)
 
-#define FOR_EACH_INTRINSIC_WASM(F)   \
-  F(ThrowWasmError, 1, 1)            \
-  F(ThrowWasmStackOverflow, 0, 1)    \
-  F(WasmExceptionGetElement, 2, 1)   \
-  F(WasmExceptionSetElement, 3, 1)   \
-  F(WasmGetExceptionRuntimeId, 1, 1) \
-  F(WasmGrowMemory, 2, 1)            \
-  F(WasmRunInterpreter, 2, 1)        \
-  F(WasmStackGuard, 0, 1)            \
-  F(WasmThrow, 1, 1)                 \
-  F(WasmThrowCreate, 2, 1)           \
-  F(WasmThrowTypeError, 0, 1)        \
+#define FOR_EACH_INTRINSIC_WASM(F) \
+  F(ThrowWasmError, 1, 1)          \
+  F(ThrowWasmStackOverflow, 0, 1)  \
+  F(WasmExceptionGetElement, 2, 1) \
+  F(WasmExceptionSetElement, 3, 1) \
+  F(WasmExceptionGetTag, 1, 1)     \
+  F(WasmGrowMemory, 2, 1)          \
+  F(WasmRunInterpreter, 2, 1)      \
+  F(WasmStackGuard, 0, 1)          \
+  F(WasmThrow, 1, 1)               \
+  F(WasmThrowCreate, 2, 1)         \
+  F(WasmThrowTypeError, 0, 1)      \
   F(WasmCompileLazy, 2, 1)
 
 #define FOR_EACH_INTRINSIC_RETURN_PAIR(F) \

src/wasm/function-body-decoder.cc

@@ -443,11 +443,11 @@ class WasmGraphBuildingInterface {
     TFNode* if_catch = nullptr;
     TFNode* if_no_catch = nullptr;
     if (exception != nullptr) {
-      // Get the exception and see if wanted exception.
-      TFNode* caught_tag = BUILD(GetExceptionRuntimeId, exception);
-      TFNode* exception_tag = BUILD(ConvertExceptionTagToRuntimeId, imm.index);
-      TFNode* compare_i32 = BUILD(Binop, kExprI32Eq, caught_tag, exception_tag);
-      BUILD(BranchNoHint, compare_i32, &if_catch, &if_no_catch);
+      // Get the exception tag and see if it matches the expected one.
+      TFNode* caught_tag = BUILD(GetExceptionTag, exception);
+      TFNode* exception_tag = BUILD(LoadExceptionTagFromTable, imm.index);
+      TFNode* compare = BUILD(ExceptionTagEqual, caught_tag, exception_tag);
+      BUILD(BranchNoHint, compare, &if_catch, &if_no_catch);
     }
 
     SsaEnv* if_no_catch_env = Split(decoder, ssa_env_);

src/wasm/module-compiler.cc

@@ -325,6 +325,10 @@ class InstanceBuilder {
   void InitializeTables(Handle<WasmInstanceObject> instance);
 
   void LoadTableSegments(Handle<WasmInstanceObject> instance);
+
+  // Creates new exception tags for all exceptions. Note that some tags might
+  // already exist if they were imported, those tags will be re-used.
+  void InitializeExceptions(Handle<WasmInstanceObject> instance);
 };
 
 }  // namespace
@@ -1075,6 +1079,17 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
     instance->set_imported_mutable_globals_buffers(*buffers_array);
   }
 
+  //--------------------------------------------------------------------------
+  // Set up the exception table used for exception tag checks.
+  //--------------------------------------------------------------------------
+  int exceptions_count = static_cast<int>(module_->exceptions.size());
+  if (exceptions_count > 0) {
+    Handle<FixedArray> exception_table =
+        isolate_->factory()->NewFixedArray(exceptions_count, TENURED);
+    instance->set_exceptions_table(*exception_table);
+    exception_wrappers_.resize(exceptions_count);
+  }
+
   //--------------------------------------------------------------------------
   // Reserve the metadata for indirect function tables.
   //--------------------------------------------------------------------------
@@ -1099,6 +1114,13 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
     InitializeTables(instance);
   }
 
+  //--------------------------------------------------------------------------
+  // Initialize the exceptions table.
+  //--------------------------------------------------------------------------
+  if (exceptions_count > 0) {
+    InitializeExceptions(instance);
+  }
+
   //--------------------------------------------------------------------------
   // Create the WebAssembly.Memory object.
   //--------------------------------------------------------------------------
@@ -1740,8 +1762,10 @@ int InstanceBuilder::ProcessImports(Handle<WasmInstanceObject> instance) {
                           index, module_name, import_name);
           return -1;
         }
-        // TODO(mstarzinger): Actually add imported exceptions to the instance
-        // exception table, making sure to preserve object identity.
+        Object* exception_tag = imported_exception->exception_tag();
+        DCHECK(instance->exceptions_table()->get(import.index)->IsUndefined());
+        instance->exceptions_table()->set(import.index, exception_tag);
+        exception_wrappers_[import.index] = imported_exception;
         break;
       }
       default:
@@ -1861,10 +1885,6 @@ void InstanceBuilder::ProcessExports(Handle<WasmInstanceObject> instance) {
     }
   }
 
-  // TODO(mstarzinger): The {exception_wrappers_} table is only needed until we
-  // have an exception table per instance which can then be used directly.
-  exception_wrappers_.resize(module_->exceptions.size());
-
   Handle<JSObject> exports_object;
   bool is_asm_js = false;
   switch (module_->origin) {
@@ -2021,7 +2041,11 @@ void InstanceBuilder::ProcessExports(Handle<WasmInstanceObject> instance) {
         const WasmException& exception = module_->exceptions[exp.index];
         Handle<WasmExceptionObject> wrapper = exception_wrappers_[exp.index];
         if (wrapper.is_null()) {
-          wrapper = WasmExceptionObject::New(isolate_, exception.sig);
+          Handle<HeapObject> exception_tag(
+              HeapObject::cast(instance->exceptions_table()->get(exp.index)),
+              isolate_);
+          wrapper =
+              WasmExceptionObject::New(isolate_, exception.sig, exception_tag);
           exception_wrappers_[exp.index] = wrapper;
         }
         desc.set_value(wrapper);
@@ -2143,6 +2167,20 @@ void InstanceBuilder::LoadTableSegments(Handle<WasmInstanceObject> instance) {
   }
 }
 
+void InstanceBuilder::InitializeExceptions(
+    Handle<WasmInstanceObject> instance) {
+  Handle<FixedArray> exceptions_table(instance->exceptions_table(), isolate_);
+  for (int index = 0; index < exceptions_table->length(); ++index) {
+    if (!exceptions_table->get(index)->IsUndefined(isolate_)) continue;
+    // TODO(mstarzinger): Tags provide an object identity for each exception,
+    // using {JSObject} here is gigantic hack and we should use a dedicated
+    // object with a much lighter footprint for this purpose here.
+    Handle<HeapObject> exception_tag =
+        isolate_->factory()->NewJSObjectWithNullProto();
+    exceptions_table->set(index, *exception_tag);
+  }
+}
+
 AsyncCompileJob::AsyncCompileJob(
     Isolate* isolate, const WasmFeatures& enabled,
     std::unique_ptr<byte[]> bytes_copy, size_t length, Handle<Context> context,

src/wasm/wasm-constants.h

@@ -79,7 +79,6 @@ enum NameSectionKindCode : uint8_t { kModule = 0, kFunction = 1, kLocal = 2 };
 constexpr size_t kWasmPageSize = 0x10000;
 constexpr uint32_t kWasmPageSizeLog2 = 16;
 static_assert(kWasmPageSize == size_t{1} << kWasmPageSizeLog2, "consistency");
-constexpr int kInvalidExceptionTag = -1;
 
 // TODO(wasm): Wrap WasmCodePosition in a struct.
 using WasmCodePosition = int;

src/wasm/wasm-objects-inl.h

@@ -185,6 +185,8 @@ OPTIONAL_ACCESSORS(WasmInstanceObject, indirect_function_table_instances,
                    FixedArray, kIndirectFunctionTableInstancesOffset)
 OPTIONAL_ACCESSORS(WasmInstanceObject, managed_native_allocations, Foreign,
                    kManagedNativeAllocationsOffset)
+OPTIONAL_ACCESSORS(WasmInstanceObject, exceptions_table, FixedArray,
+                   kExceptionsTableOffset)
 ACCESSORS(WasmInstanceObject, undefined_value, Oddball, kUndefinedValueOffset)
 ACCESSORS(WasmInstanceObject, null_value, Oddball, kNullValueOffset)
 ACCESSORS(WasmInstanceObject, centry_stub, Code, kCEntryStubOffset)
@@ -210,6 +212,7 @@ ImportedFunctionEntry::ImportedFunctionEntry(
 // WasmExceptionObject
 ACCESSORS(WasmExceptionObject, serialized_signature, PodArray<wasm::ValueType>,
           kSerializedSignatureOffset)
+ACCESSORS(WasmExceptionObject, exception_tag, HeapObject, kExceptionTagOffset)
 
 // WasmExportedFunctionData
 ACCESSORS(WasmExportedFunctionData, wrapper_code, Code, kWrapperCodeOffset)

src/wasm/wasm-objects.cc

@@ -1309,7 +1309,8 @@ Address WasmInstanceObject::GetCallTarget(uint32_t func_index) {
 
 // static
 Handle<WasmExceptionObject> WasmExceptionObject::New(
-    Isolate* isolate, const wasm::FunctionSig* sig) {
+    Isolate* isolate, const wasm::FunctionSig* sig,
+    Handle<HeapObject> exception_tag) {
   Handle<JSFunction> exception_cons(
       isolate->native_context()->wasm_exception_constructor(), isolate);
   Handle<JSObject> exception_object =
@@ -1328,6 +1329,7 @@ Handle<WasmExceptionObject> WasmExceptionObject::New(
     serialized_sig->set(index++, param);
   }
   exception->set_serialized_signature(*serialized_sig);
+  exception->set_exception_tag(*exception_tag);
 
   return exception;
 }

src/wasm/wasm-objects.h

@@ -387,6 +387,7 @@ class WasmInstanceObject : public JSObject {
   DECL_ACCESSORS(imported_function_callables, FixedArray)
   DECL_OPTIONAL_ACCESSORS(indirect_function_table_instances, FixedArray)
   DECL_OPTIONAL_ACCESSORS(managed_native_allocations, Foreign)
+  DECL_OPTIONAL_ACCESSORS(exceptions_table, FixedArray)
   DECL_ACCESSORS(undefined_value, Oddball)
   DECL_ACCESSORS(null_value, Oddball)
   DECL_ACCESSORS(centry_stub, Code)
@@ -422,6 +423,7 @@ class WasmInstanceObject : public JSObject {
   V(kImportedFunctionCallablesOffset, kPointerSize)                     \
   V(kIndirectFunctionTableInstancesOffset, kPointerSize)                \
   V(kManagedNativeAllocationsOffset, kPointerSize)                      \
+  V(kExceptionsTableOffset, kPointerSize)                               \
   V(kUndefinedValueOffset, kPointerSize)                                \
   V(kNullValueOffset, kPointerSize)                                     \
   V(kCEntryStubOffset, kPointerSize)                                    \
@@ -475,10 +477,12 @@ class WasmExceptionObject : public JSObject {
   DECL_CAST(WasmExceptionObject)
 
   DECL_ACCESSORS(serialized_signature, PodArray<wasm::ValueType>)
+  DECL_ACCESSORS(exception_tag, HeapObject)
 
 // Layout description.
 #define WASM_EXCEPTION_OBJECT_FIELDS(V)       \
   V(kSerializedSignatureOffset, kPointerSize) \
+  V(kExceptionTagOffset, kPointerSize)        \
   V(kSize, 0)
 
   DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize,
@@ -490,7 +494,8 @@ class WasmExceptionObject : public JSObject {
   bool IsSignatureEqual(const wasm::FunctionSig* sig);
 
   static Handle<WasmExceptionObject> New(Isolate* isolate,
-                                         const wasm::FunctionSig* sig);
+                                         const wasm::FunctionSig* sig,
+                                         Handle<HeapObject> exception_tag);
 };
 
 // A WASM function that is wrapped and exported to JavaScript.

test/mjsunit/wasm/exceptions-import.js

@@ -40,8 +40,7 @@ function NewExportedException() {
 
   assertTrue(except1 < except3 && except2 < except3);
   assertEquals(undefined, instance.exports.ex1);
-  // TODO(mstarzinger): Enable once identity of imported exception is preserved.
-  //assertSame(exported, instance.exports.ex2);
+  assertSame(exported, instance.exports.ex2);
   assertNotSame(exported, instance.exports.ex3);
 })();
 

test/mjsunit/wasm/exceptions-shared.js

+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --expose-wasm --experimental-wasm-eh
+
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
+// Helper function to return a new exported exception with the {kSig_v_v} type
+// signature from an anonymous module. The underlying module is thrown away.
+function NewExportedException() {
+  let builder = new WasmModuleBuilder();
+  let except = builder.addException(kSig_v_v);
+  builder.addExportOfKind("ex", kExternalException, except);
+  let instance = builder.instantiate();
+  return instance.exports.ex;
+}
+
+// Check that an instance matches an exception thrown by itself, even when the
+// exception is re-thrown by a regular JavaScript function.
+(function TestSingleInstance() {
+  print(arguments.callee.name);
+  let builder = new WasmModuleBuilder();
+  let sig_index = builder.addType(kSig_v_v);
+  let fun = builder.addImport("m", "f", sig_index);
+  let except = builder.addException(kSig_v_v);
+  builder.addFunction("throw", kSig_v_v)
+      .addBody([
+        kExprThrow, except
+      ]).exportFunc();
+  builder.addFunction("catch", kSig_v_v)
+      .addBody([
+        kExprTry, kWasmStmt,
+          kExprCallFunction, fun,
+        kExprCatch, except,
+        kExprEnd,
+      ]).exportFunc();
+  let ex_obj = new Error("my exception");
+  let instance = builder.instantiate({ m: { f: function() { throw ex_obj }}});
+
+  assertThrows(() => instance.exports.throw(), WebAssembly.RuntimeError);
+  assertThrowsEquals(() => instance.exports.catch(), ex_obj);
+  try {
+    instance.exports.throw();
+  } catch (e) {
+    ex_obj = e;
+  }
+  assertDoesNotThrow(() => instance.exports.catch());
+})();
+
+// Check that two instances distinguish their individual exceptions if they are
+// not shared, even when declared by the same underlying module.
+(function TestMultiInstanceNonShared() {
+  print(arguments.callee.name);
+  let builder = new WasmModuleBuilder();
+  let sig_index = builder.addType(kSig_v_v);
+  let fun = builder.addImport("m", "f", sig_index);
+  let except = builder.addException(kSig_v_v);
+  builder.addFunction("throw", kSig_v_v)
+      .addBody([
+        kExprThrow, except
+      ]).exportFunc();
+  builder.addFunction("catch", kSig_v_v)
+      .addBody([
+        kExprTry, kWasmStmt,
+          kExprCallFunction, fun,
+        kExprCatch, except,
+        kExprEnd,
+      ]).exportFunc();
+  let ex_obj = new Error("my exception");
+  let instance1 = builder.instantiate({ m: { f: assertUnreachable }});
+  let instance2 = builder.instantiate({ m: { f: function() { throw ex_obj }}});
+
+  assertThrows(() => instance1.exports.throw(), WebAssembly.RuntimeError);
+  assertThrowsEquals(() => instance2.exports.catch(), ex_obj);
+  try {
+    instance1.exports.throw();
+  } catch (e) {
+    ex_obj = e;
+  }
+  assertThrowsEquals(() => instance2.exports.catch(), ex_obj);
+})();
+
+// Check that two instances match their exceptions if they are shared properly,
+// even if the local exception index of export and import is different.
+(function TestMultiInstanceShared() {
+  print(arguments.callee.name);
+  let builder = new WasmModuleBuilder();
+  let sig_index = builder.addType(kSig_v_v);
+  let fun = builder.addImport("m", "f", sig_index);
+  let except1 = builder.addImportedException("m", "ex1", kSig_v_v);
+  let except2 = builder.addException(kSig_v_v);
+  builder.addExportOfKind("ex2", kExternalException, except2);
+  builder.addFunction("throw", kSig_v_v)
+      .addBody([
+        kExprThrow, except2
+      ]).exportFunc();
+  builder.addFunction("catch", kSig_v_v)
+      .addBody([
+        kExprTry, kWasmStmt,
+          kExprCallFunction, fun,
+        kExprCatch, except1,
+        kExprEnd,
+      ]).exportFunc();
+  let ex_obj = new Error("my exception");
+  let instance1 = builder.instantiate({ m: { f: assertUnreachable,
+                                             ex1: NewExportedException() }});
+  let instance2 = builder.instantiate({ m: { f: function() { throw ex_obj },
+                                             ex1: instance1.exports.ex2 }});
+
+  assertThrows(() => instance1.exports.throw(), WebAssembly.RuntimeError);
+  assertThrowsEquals(() => instance2.exports.catch(), ex_obj);
+  try {
+    instance1.exports.throw();
+  } catch (e) {
+    ex_obj = e;
+  }
+  assertDoesNotThrow(() => instance2.exports.catch());
+})();
+
+// Check that two instances based on different modules match their exceptions if
+// they are shared properly, even if the local exception index is different.
+(function TestMultiModuleShared() {
+  print(arguments.callee.name);
+  let builder1 = new WasmModuleBuilder();
+  let except1 = builder1.addException(kSig_v_v);
+  let except2 = builder1.addException(kSig_v_v);
+  builder1.addExportOfKind("ex", kExternalException, except2);
+  builder1.addFunction("throw", kSig_v_v)
+      .addBody([
+        kExprThrow, except2
+      ]).exportFunc();
+  let builder2 = new WasmModuleBuilder();
+  let sig_index = builder2.addType(kSig_v_v);
+  let fun = builder2.addImport("m", "f", sig_index);
+  let except = builder2.addImportedException("m", "ex", kSig_v_v);
+  builder2.addFunction("catch", kSig_v_v)
+      .addBody([
+        kExprTry, kWasmStmt,
+          kExprCallFunction, fun,
+        kExprCatch, except,
+        kExprEnd,
+      ]).exportFunc();
+  let ex_obj = new Error("my exception");
+  let instance1 = builder1.instantiate();
+  let instance2 = builder2.instantiate({ m: { f: function() { throw ex_obj },
+                                              ex: instance1.exports.ex }});
+
+  assertThrows(() => instance1.exports.throw(), WebAssembly.RuntimeError);
+  assertThrowsEquals(() => instance2.exports.catch(), ex_obj);
+  try {
+    instance1.exports.throw();
+  } catch (e) {
+    ex_obj = e;
+  }
+  assertDoesNotThrow(() => instance2.exports.catch());
+})();

test/mjsunit/wasm/exceptions.js

@@ -7,7 +7,7 @@
 load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
-function assertWasmThrows(runtime_id, values, code) {
+function assertWasmThrows(instance, runtime_id, values, code) {
   try {
     if (typeof code === 'function') {
       code();
@@ -16,7 +16,7 @@ function assertWasmThrows(runtime_id, values, code) {
     }
   } catch (e) {
     assertInstanceof(e, WebAssembly.RuntimeError);
-    var e_runtime_id = %GetWasmExceptionId(e);
+    var e_runtime_id = %GetWasmExceptionId(e, instance);
     assertTrue(Number.isInteger(e_runtime_id));
     assertEquals(e_runtime_id, runtime_id);
     var e_values = %GetWasmExceptionValues(e);
@@ -57,8 +57,8 @@ function assertWasmThrows(runtime_id, values, code) {
   let instance = builder.instantiate();
 
   assertEquals(1, instance.exports.throw_if_param_not_zero(0));
-  assertWasmThrows(except, [], () => instance.exports.throw_if_param_not_zero(10));
-  assertWasmThrows(except, [], () => instance.exports.throw_if_param_not_zero(-1));
+  assertWasmThrows(instance, except, [], () => instance.exports.throw_if_param_not_zero(10));
+  assertWasmThrows(instance, except, [], () => instance.exports.throw_if_param_not_zero(-1));
 })();
 
 // Test that empty try/catch blocks work.
@@ -135,7 +135,7 @@ function assertWasmThrows(runtime_id, values, code) {
 
   assertEquals(3, instance.exports.catch_different_exceptions(0));
   assertEquals(4, instance.exports.catch_different_exceptions(1));
-  assertWasmThrows(except3, [], () => instance.exports.catch_different_exceptions(2));
+  assertWasmThrows(instance, except3, [], () => instance.exports.catch_different_exceptions(2));
 })();
 
 // Test throwing an exception with multiple values.
@@ -150,7 +150,7 @@ function assertWasmThrows(runtime_id, values, code) {
       ]).exportFunc();
   let instance = builder.instantiate();
 
-  assertWasmThrows(except, [0, 1, 0, 2], () => instance.exports.throw_1_2());
+  assertWasmThrows(instance, except, [0, 1, 0, 2], () => instance.exports.throw_1_2());
 })();
 
 // Test throwing/catching the i32 parameter value.
@@ -185,8 +185,8 @@ function assertWasmThrows(runtime_id, values, code) {
       ]).exportFunc();
   let instance = builder.instantiate();
 
-  assertWasmThrows(except, [0, 5], () => instance.exports.throw_param(5));
-  assertWasmThrows(except, [6, 31026], () => instance.exports.throw_param(424242));
+  assertWasmThrows(instance, except, [0, 5], () => instance.exports.throw_param(5));
+  assertWasmThrows(instance, except, [6, 31026], () => instance.exports.throw_param(424242));
 })();
 
 // Test throwing/catching the f32 parameter value.
@@ -220,8 +220,8 @@ function assertWasmThrows(runtime_id, values, code) {
       ]).exportFunc();
   let instance = builder.instantiate();
 
-  assertWasmThrows(except, [16544, 0], () => instance.exports.throw_param(5.0));
-  assertWasmThrows(except, [16680, 0], () => instance.exports.throw_param(10.5));
+  assertWasmThrows(instance, except, [16544, 0], () => instance.exports.throw_param(5.0));
+  assertWasmThrows(instance, except, [16680, 0], () => instance.exports.throw_param(10.5));
 })();
 
 // Test throwing/catching an I64 value
@@ -273,8 +273,8 @@ function assertWasmThrows(runtime_id, values, code) {
       ]).exportFunc();
   let instance = builder.instantiate();
 
-  assertWasmThrows(except, [0, 10, 0, 5], () => instance.exports.throw_param(10, 5));
-  assertWasmThrows(except, [65535, 65535, 0, 13], () => instance.exports.throw_param(-1, 13));
+  assertWasmThrows(instance, except, [0, 10, 0, 5], () => instance.exports.throw_param(10, 5));
+  assertWasmThrows(instance, except, [65535, 65535, 0, 13], () => instance.exports.throw_param(-1, 13));
 })();
 
 // Test throwing/catching the F64 parameter value
@@ -309,8 +309,8 @@ function assertWasmThrows(runtime_id, values, code) {
       ]).exportFunc();
   let instance = builder.instantiate();
 
-  assertWasmThrows(except, [16404, 0, 0, 0], () => instance.exports.throw_param(5.0));
-  assertWasmThrows(except, [16739, 4816, 0, 0], () => instance.exports.throw_param(10000000.5));
+  assertWasmThrows(instance, except, [16404, 0, 0, 0], () => instance.exports.throw_param(5.0));
+  assertWasmThrows(instance, except, [16739, 4816, 0, 0], () => instance.exports.throw_param(10000000.5));
 })();
 
 // Test the encoding of a computed parameter value.
@@ -334,8 +334,8 @@ function assertWasmThrows(runtime_id, values, code) {
       ]).exportFunc()
   let instance = builder.instantiate();
 
-  assertWasmThrows(except, [65535, 65536-8], () => instance.exports.throw_expr_with_params(1.5, 2.5, 4));
-  assertWasmThrows(except, [0, 12], () => instance.exports.throw_expr_with_params(5.7, 2.5, 4));
+  assertWasmThrows(instance, except, [65535, 65536-8], () => instance.exports.throw_expr_with_params(1.5, 2.5, 4));
+  assertWasmThrows(instance, except, [0, 12], () => instance.exports.throw_expr_with_params(5.7, 2.5, 4));
 })();
 
 // Now that we know catching works locally, we test catching exceptions that