[wasm] Fix DCHECK handiling pending exceptions.

src/wasm/wasm-js.cc

 // Copyright 2015 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.
 
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/asmjs/asm-js.h"
 #include "src/asmjs/asm-typer.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/assert-scope.h"
@@ skipping 14 matching lines @@
 #include "src/wasm/wasm-result.h"
 
 typedef uint8_t byte;
 
 using v8::internal::wasm::ErrorThrower;
 
 namespace v8 {
 
 namespace {
 
-#define ASSIGN(type, var, expr)                   \
-  Local<type> var;                                \
-  do {                                            \
-    if (!expr.ToLocal(&var)) {                    \
-      DCHECK(i_isolate->has_pending_exception()); \
-    }                                             \
+#define ASSIGN(type, var, expr)                      \
+  Local<type> var;                                   \
+  do {                                               \
+    if (!expr.ToLocal(&var)) {                       \
+      DCHECK(i_isolate->has_scheduled_exception());  \
+      return;                                        \
+    } else {                                         \
+      DCHECK(!i_isolate->has_scheduled_exception()); \
+    }                                                \
   } while (false)
 
 // TODO(wasm): move brand check to the respective types, and don't throw
 // in it, rather, use a provided ErrorThrower, or let caller handle it.
 static bool HasBrand(i::Handle<i::Object> value, i::Handle<i::Symbol> sym) {
   if (!value->IsJSObject()) return false;
   i::Handle<i::JSObject> object = i::Handle<i::JSObject>::cast(value);
   Maybe<bool> has_brand = i::JSObject::HasOwnProperty(object, sym);
   return has_brand.FromMaybe(false);
 }
@@ skipping 67 matching lines @@
   }
   if (length > i::wasm::kV8MaxWasmModuleSize) {
     thrower->RangeError("buffer source exceeds maximum size of %zu (is %zu)",
                         i::wasm::kV8MaxWasmModuleSize, length);
   }
   if (thrower->error()) return i::wasm::ModuleWireBytes(nullptr, nullptr);
   // TODO(titzer): use the handle as well?
   return i::wasm::ModuleWireBytes(start, start + length);
 }
 
-i::MaybeHandle<i::JSReceiver> GetValueAsImports(const Local<Value>& arg,
+i::MaybeHandle<i::JSReceiver> GetValueAsImports(Local<Value> arg,
                                                 ErrorThrower* thrower) {
   if (arg->IsUndefined()) return {};
 
   if (!arg->IsObject()) {
     thrower->TypeError("Argument 1 must be an object");
     return {};
   }
   Local<Object> obj = Local<Object>::Cast(arg);
   return i::Handle<i::JSReceiver>::cast(v8::Utils::OpenHandle(*obj));
 }
@@ skipping 174 matching lines @@
 
   HandleScope scope(args.GetIsolate());
 
   Local<Context> context = isolate->GetCurrentContext();
   Local<Value> module = args[0];
 
   const uint8_t* instance_str = reinterpret_cast<const uint8_t*>("instance");
   const uint8_t* module_str = reinterpret_cast<const uint8_t*>("module");
   Local<Value> instance;
   if (!WebAssemblyInstantiateImpl(isolate, module, args.Data())
-           .ToLocal(&instance))
+           .ToLocal(&instance)) {
     return;
+  }
 
   Local<Object> ret = Object::New(isolate);
   Local<String> instance_name =
       String::NewFromOneByte(isolate, instance_str,
                              NewStringType::kInternalized)
           .ToLocalChecked();
   Local<String> module_name =
       String::NewFromOneByte(isolate, module_str, NewStringType::kInternalized)
           .ToLocalChecked();
 
@@ skipping 633 matching lines @@
   i::Handle<i::Symbol> symbol(isolate->context()->wasm_memory_sym(), isolate);
   return HasBrand(value, symbol);
 }
 
 bool WasmJs::IsWasmTableObject(Isolate* isolate, Handle<Object> value) {
   i::Handle<i::Symbol> symbol(isolate->context()->wasm_table_sym(), isolate);
   return HasBrand(value, symbol);
 }
 }  // namespace internal
 }  // namespace v8