deps: V8: cherry-pick 5f8109fccf06 and 7bd6db9dfd8a

Original commit messages:

    [wasm] Add WasmModuleObject::Compile overload with compile-time imports

    Expose a public API to compile a Wasm module with compile-time imports
    with a flag type for the builtins and a specifier name for imported
    string constants.

    The existing single-argument WasmModuleObject::Compile is refactored to
    delegate to a shared helper, and a new overload accepts a CompileTimeImports
    struct mirroring the `{ builtins, importedStringConstants }` constructor
    options.

    Bug: v8:14179
    Change-Id: I9877e8ea4d620152e98954c948ff9dc5eeb6577c
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/7970437
    Reviewed-by: Leszek Swirski <leszeks@chromium.org>
    Commit-Queue: Jakob Kummerow <jkummerow@chromium.org>
    Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
    Cr-Commit-Position: refs/heads/main@{#108394}

    [wasm] Generalize WasmModuleObject::Compile options with source URL

    Replaces the recently-added WasmModuleObject::CompileTimeImports struct
    with a CompileOptions struct carrying the compile-time import options
    plus a new source_url option, threading through to the existing
    source_url handling of SyncCompile for the script URL. This allows
    embedders compiling modules synchronously from bytes to attach a
    meaningful URL, as already possible for streaming compilation via
    WasmStreaming::SetUrl, for use in stack traces and developer tooling.

    Refactoring now to a single options struct mirrors the JS
    `WebAssembly.Module(bytes, compileOptions)` API, while enabling
    future compatibility.

    Change-Id: I4052f4a97e072467c00082df388e2eb4cb504cf6
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8127096
    Commit-Queue: Dan Carney <dcarney@chromium.org>
    Reviewed-by: Dan Carney <dcarney@chromium.org>
    Reviewed-by: Leszek Swirski <leszeks@chromium.org>
    Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
    Cr-Commit-Position: refs/heads/main@{#109045}

The two commits are squashed since the second replaces the struct
introduced by the first. Adapted to MemorySpan (pre-std::span API) and
includes the optional source_url parameter of WasmEngine::SyncCompile
from c0f790f1379 that the second commit depends on.

Refs: v8/v8@5f8109f
Refs: v8/v8@7bd6db9

Author: guybedford

common.gypi

@@ -43,7 +43,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.34',
+    'v8_embedder_string': '-node.35',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/include/v8-wasm.h

@@ -8,6 +8,7 @@
 #include <functional>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <variant>
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
@@ -106,12 +107,48 @@ class V8_EXPORT WasmModuleObject : public Object {
    */
   CompiledWasmModule GetCompiledModule();
 
+  /**
+   * Options that influence how a Wasm module is compiled. The compile-time
+   * import options mirror those accepted by the JS `WebAssembly.Module`
+   * constructor (`{ builtins, importedStringConstants }`).
+   */
+  struct CompileOptions {
+    // Builtin compile-time imports, mirroring the strings accepted in the
+    // `builtins` array of the JS `WebAssembly.Module` constructor options.
+    // Combine values with bitwise-or to enable multiple builtins.
+    struct Builtins {
+      enum {
+        kNone = 0,
+        kJsString = 1 << 0,  // "js-string"
+      };
+    };
+    // Bitwise-or of `Builtins` values to enable as compile-time imports.
+    int builtins = Builtins::kNone;
+    // If non-null, enable imported string constants from the named module
+    // (e.g. "wasm:js/string-constants"). The string must be null-terminated and
+    // remain valid for the duration of the compile call.
+    const char* imported_string_constants_module = nullptr;
+    // If non-empty, associated with the module's script as its source URL, for
+    // use in stack traces and developer tooling. If a script already exists in
+    // the isolate for the same module, its existing URL is retained. The
+    // string must remain valid for the duration of the compile call.
+    std::string_view source_url = {};
+  };
+
   /**
    * Compile a Wasm module from the provided uncompiled bytes.
    */
   static MaybeLocal<WasmModuleObject> Compile(
       Isolate* isolate, MemorySpan<const uint8_t> wire_bytes);
 
+  /**
+   * Compile a Wasm module from the provided uncompiled bytes, applying the
+   * given compile options.
+   */
+  static MaybeLocal<WasmModuleObject> Compile(
+      Isolate* isolate, MemorySpan<const uint8_t> wire_bytes,
+      const CompileOptions& options);
+
   V8_INLINE static WasmModuleObject* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);
@@ -224,13 +261,15 @@ class V8_EXPORT WasmStreaming final {
 class V8_EXPORT WasmModuleCompilation final {
  public:
   using ModuleCachingCallback = WasmStreaming::ModuleCachingCallback;
+  using CompileOptions = WasmModuleObject::CompileOptions;
 
   /**
-   * Start an asynchronous module compilation. This can be called on any thread.
+   * Start an asynchronous module compilation, applying the given compile
+   * options. This can be called on any thread. Providing
+   * {CompileOptions::source_url} is equivalent to calling {SetUrl}.
    * TODO(clemensb): Add some way to pass enabled features.
-   * TODO(clemensb): Add some way to pass compile time imports.
    */
-  WasmModuleCompilation();
+  explicit WasmModuleCompilation(const CompileOptions& options = {});
 
   ~WasmModuleCompilation();
 

deps/v8/src/api/api.cc

@@ -8853,7 +8853,15 @@ MaybeLocal<WasmModuleObject> WasmModuleObject::FromCompiledModule(
 
 MaybeLocal<WasmModuleObject> WasmModuleObject::Compile(
     Isolate* v8_isolate, MemorySpan<const uint8_t> wire_bytes) {
+  return Compile(v8_isolate, wire_bytes, CompileOptions{});
+}
+
+MaybeLocal<WasmModuleObject> WasmModuleObject::Compile(
+    Isolate* v8_isolate, MemorySpan<const uint8_t> wire_bytes,
+    const CompileOptions& options) {
 #if V8_ENABLE_WEBASSEMBLY
+  i::wasm::CompileTimeImports compile_imports =
+      i::wasm::CompileTimeImportsFromOptions(options);
   base::OwnedVector<const uint8_t> bytes = base::OwnedCopyOf(wire_bytes);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   // We don't check for `IsWasmCodegenAllowed` here, because this function is
@@ -8864,10 +8872,11 @@ MaybeLocal<WasmModuleObject> WasmModuleObject::Compile(
     i::wasm::ErrorThrower thrower(i_isolate, "WasmModuleObject::Compile()");
     auto enabled_features =
         i::wasm::WasmEnabledFeatures::FromIsolate(i_isolate);
-    // TODO(14179): Provide an API method that supports compile options.
     maybe_compiled = i::wasm::GetWasmEngine()->SyncCompile(
-        i_isolate, enabled_features, i::wasm::CompileTimeImports{}, &thrower,
-        std::move(bytes));
+        i_isolate, enabled_features, std::move(compile_imports), &thrower,
+        std::move(bytes),
+        base::Vector<const char>(options.source_url.data(),
+                                 options.source_url.size()));
   }
   CHECK_EQ(maybe_compiled.is_null(), i_isolate->has_exception());
   if (maybe_compiled.is_null()) return {};

deps/v8/src/wasm/wasm-engine.cc

@@ -666,7 +666,8 @@ DirectHandle<WasmModuleObject> WasmEngine::FinalizeTranslatedAsmJs(
 MaybeDirectHandle<WasmModuleObject> WasmEngine::SyncCompile(
     Isolate* isolate, WasmEnabledFeatures enabled_features,
     CompileTimeImports compile_imports, ErrorThrower* thrower,
-    base::OwnedVector<const uint8_t> bytes) {
+    base::OwnedVector<const uint8_t> bytes,
+    base::Vector<const char> source_url) {
   int compilation_id = next_compilation_id_.fetch_add(1);
   TRACE_EVENT1("v8.wasm", "wasm.SyncCompile", "id", compilation_id);
   v8::metrics::Recorder::ContextId context_id =
@@ -718,9 +719,8 @@ MaybeDirectHandle<WasmModuleObject> WasmEngine::SyncCompile(
   }
 #endif
 
-  constexpr base::Vector<const char> kNoSourceUrl;
   DirectHandle<Script> script =
-      GetOrCreateScript(isolate, native_module, kNoSourceUrl);
+      GetOrCreateScript(isolate, native_module, source_url);
 
   native_module->LogWasmCodes(isolate, *script);
 

deps/v8/src/wasm/wasm-engine.h

@@ -192,7 +192,8 @@ class V8_EXPORT_PRIVATE WasmEngine {
   MaybeDirectHandle<WasmModuleObject> SyncCompile(
       Isolate* isolate, WasmEnabledFeatures enabled,
       CompileTimeImports compile_imports, ErrorThrower* thrower,
-      base::OwnedVector<const uint8_t> bytes);
+      base::OwnedVector<const uint8_t> bytes,
+      base::Vector<const char> source_url = {});
 
   // Synchronously instantiate the given Wasm module with the given imports.
   // If the module represents an asm.js module, then the supplied {memory}

deps/v8/src/wasm/wasm-js.cc

@@ -232,11 +232,16 @@ class WasmModuleCompilation::Impl {
   const std::shared_ptr<i::wasm::StreamingDecoder> streaming_decoder_;
 };
 
-// TODO(clemensb): Pass enabled features and compile time imports.
-WasmModuleCompilation::WasmModuleCompilation()
-    : impl_(std::make_unique<Impl>(WasmEnabledFeatures::FromFlags(),
-                                   CompileTimeImports{})) {
+// TODO(clemensb): Pass enabled features.
+WasmModuleCompilation::WasmModuleCompilation(const CompileOptions& options)
+    : impl_(std::make_unique<Impl>(
+          WasmEnabledFeatures::FromFlags(),
+          i::wasm::CompileTimeImportsFromOptions(options))) {
   TRACE_EVENT0("v8.wasm", "wasm.ModuleCompilation");
+  if (!options.source_url.empty()) {
+    impl_->SetUrl(
+        base::VectorOf(options.source_url.data(), options.source_url.size()));
+  }
 }
 
 WasmModuleCompilation::~WasmModuleCompilation() = default;
@@ -3959,6 +3964,27 @@ void WasmJs::InstallResizableBufferIntegration(
               wasm::WebAssemblyMemoryToResizableBuffer, 0);
 }
 
+namespace wasm {
+CompileTimeImports CompileTimeImportsFromOptions(
+    const v8::WasmModuleObject::CompileOptions& options) {
+  CompileTimeImports result;
+  using Builtins = v8::WasmModuleObject::CompileOptions::Builtins;
+  if (options.builtins & Builtins::kJsString) {
+    result.Add(CompileTimeImport::kJsString);
+  }
+  if (options.imported_string_constants_module != nullptr) {
+    result.constants_module() = options.imported_string_constants_module;
+    result.Add(CompileTimeImport::kStringConstants);
+  }
+  // Mirror the JS `WebAssembly.Module` constructor, which disables denormal
+  // floats at compile time when the host FPU flushes them.
+  if (base::FPU::GetFlushDenormals()) {
+    result.Add(CompileTimeImport::kDisableDenormalFloats);
+  }
+  return result;
+}
+}  // namespace wasm
+
 // static
 CompileTimeImports WasmJs::CompileTimeImportsFromArgument(
     DirectHandle<Object> arg, Isolate* isolate,

deps/v8/src/wasm/wasm-js.h

@@ -11,14 +11,14 @@
 
 #include <memory>
 
+#include "include/v8-wasm.h"
 #include "src/common/globals.h"
 #include "src/wasm/wasm-features.h"
 
 namespace v8 {
 class Value;
 template <typename T>
 class FunctionCallbackInfo;
-class WasmStreaming;
 }  // namespace v8
 
 namespace v8::internal {
@@ -30,6 +30,11 @@ class StreamingDecoder;
 V8_EXPORT_PRIVATE std::unique_ptr<WasmStreaming> StartStreamingForTesting(
     Isolate*, std::shared_ptr<wasm::CompilationResultResolver>);
 
+// Convert compile options from the public API into compile-time imports,
+// including the host-FPU denormal handling applied to all compilations.
+V8_EXPORT_PRIVATE CompileTimeImports
+CompileTimeImportsFromOptions(const v8::WasmModuleObject::CompileOptions&);
+
 #define WASM_JS_EXTERNAL_REFERENCE_LIST(V) \
   V(WebAssemblyCompile)                    \
   V(WebAssemblyException)                  \