[wasm] Better error message for exceeding module size limits.

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 RANGE_ERROR_MSG                                                        \
-  "Wasm compilation exceeds internal limits in this context for the provided " \
-  "arguments"
-
 // 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);
 }
 
 static bool BrandCheck(i::Handle<i::Object> value, i::Handle<i::Symbol> sym,
@@ skipping 32 matching lines @@
 bool IsCompilationAllowed(i::Isolate* isolate, ErrorThrower* thrower,
                           v8::Local<v8::Value> source, bool is_async) {
   // Allow caller to do one final check on thrower state, rather than
   // one at each step. No information is lost - failure reason is captured
   // in the thrower state.
   if (thrower->error()) return false;
 
   AllowWasmCompileCallback callback = isolate->allow_wasm_compile_callback();
   if (callback != nullptr &&
       !callback(reinterpret_cast<v8::Isolate*>(isolate), source, is_async)) {
-    thrower->RangeError(RANGE_ERROR_MSG);
+    thrower->RangeError(
+        "%ssynchronous compilation disallowed due to module size limit set by "
+        "embedder",
+        is_async ? "a" : "");
     return false;
   }
   return true;
 }
 
 bool IsInstantiationAllowed(i::Isolate* isolate, ErrorThrower* thrower,
                             v8::Local<v8::Value> module_or_bytes,
                             i::MaybeHandle<i::JSReceiver> ffi, bool is_async) {
   // Allow caller to do one final check on thrower state, rather than
   // one at each step. No information is lost - failure reason is captured
   // in the thrower state.
   if (thrower->error()) return false;
   v8::MaybeLocal<v8::Value> v8_ffi;
   if (!ffi.is_null()) {
     v8_ffi = v8::Local<v8::Value>::Cast(Utils::ToLocal(ffi.ToHandleChecked()));
   }
   AllowWasmInstantiateCallback callback =
       isolate->allow_wasm_instantiate_callback();
   if (callback != nullptr &&
       !callback(reinterpret_cast<v8::Isolate*>(isolate), module_or_bytes,
                 v8_ffi, is_async)) {
-    thrower->RangeError(RANGE_ERROR_MSG);
+    thrower->RangeError(
+        "%ssynchronous instantiation disallowed due to module size limit set "
+        "by embedder",
+        is_async ? "a" : "");
     return false;
   }
   return true;
 }
 
 i::wasm::ModuleWireBytes GetFirstArgumentAsBytes(
     const v8::FunctionCallbackInfo<v8::Value>& args, ErrorThrower* thrower) {
   if (args.Length() < 1) {
     thrower->TypeError("Argument 0 must be a buffer source");
     return i::wasm::ModuleWireBytes(nullptr, nullptr);
@@ skipping 792 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