deps: patch V8 13.4 to support compilation with MSVC

Author: StefanStojanovic

common.gypi

@@ -38,7 +38,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.9',
+    'v8_embedder_string': '-node.10',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/src/base/fpu.cc

@@ -57,13 +57,21 @@ void FPU::SetFlushDenormals(bool value) {
 #elif defined(V8_HOST_ARCH_ARM64) || defined(V8_HOST_ARCH_ARM)
 
 namespace {
+#if defined(V8_HOST_ARCH_ARM64) && defined(_MSC_VER) && !defined(__clang__)
+#include <intrin.h>
+#endif
+
 // Bit 24 is the flush-to-zero mode control bit. Setting it to 1 flushes
 // denormals to 0.
 constexpr int kFlushDenormToZeroBit = (1 << 24);
 int GetStatusWord() {
   int result;
 #if defined(V8_HOST_ARCH_ARM64)
-  asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
+# if defined(_MSC_VER) && !defined(__clang__)
+    result = _ReadStatusReg(ARM64_FPCR);
+# else
+    asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
+# endif
 #else
   asm volatile("vmrs %[result], FPSCR" : [result] "=r"(result));
 #endif
@@ -72,7 +80,11 @@ int GetStatusWord() {
 
 void SetStatusWord(int a) {
 #if defined(V8_HOST_ARCH_ARM64)
-  asm volatile("msr FPCR, %x[src]" : : [src] "r"(a));
+# if defined(_MSC_VER) && !defined(__clang__)
+    _WriteStatusReg(ARM64_FPCR, a);
+# else
+    asm volatile("msr FPCR, %x[src]" : : [src] "r"(a));
+# endif
 #else
   asm volatile("vmsr FPSCR, %[src]" : : [src] "r"(a));
 #endif

deps/v8/src/codegen/arm64/assembler-arm64.h

@@ -168,14 +168,10 @@ class AssemblerZone {
  public:
   explicit AssemblerZone(const MaybeAssemblerZone& zone)
       // Create a fresh Zone unless one is already provided.
-      : maybe_local_zone_(
-            std::holds_alternative<Zone*>(zone)
-                ? std::nullopt
-                : std::make_optional<Zone>(std::get<AccountingAllocator*>(zone),
-                                           ZONE_NAME)),
+      : maybe_local_zone_(),
         zone_(std::holds_alternative<Zone*>(zone)
                   ? std::get<Zone*>(zone)
-                  : &maybe_local_zone_.value()) {}
+                  : &maybe_local_zone_.emplace(std::get<AccountingAllocator*>(zone), ZONE_NAME)) {}
 
   Zone* get() const { return zone_; }
 

deps/v8/src/compiler/backend/instruction-selector.cc

@@ -1009,6 +1009,8 @@ struct InstructionSelectorT<Adapter>::CachedStateValues : public ZoneObject {
 
 template <>
 class InstructionSelectorT<TurbofanAdapter>::CachedStateValuesBuilder {
+  using StateObjectDeduplicator = InstructionSelectorT<TurbofanAdapter>::StateObjectDeduplicator;
+
  public:
   explicit CachedStateValuesBuilder(StateValueList* values,
                                     InstructionOperandVector* inputs,

deps/v8/src/heap/base/asm/arm64/push_registers_masm.S

@@ -0,0 +1,32 @@
+; Copyright 2020 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.
+
+; This file is exactly the same as push_registers_asm.cc, just formatted for
+; the Microsoft Arm Assembler.
+
+    AREA |.text|, CODE, ALIGN=4, READONLY
+    EXPORT PushAllRegistersAndIterateStack
+PushAllRegistersAndIterateStack
+    ; x19-x29 are callee-saved
+    STP x19, x20, [sp, #-16]!
+    STP x21, x22, [sp, #-16]!
+    STP x23, x24, [sp, #-16]!
+    STP x25, x26, [sp, #-16]!
+    STP x27, x28, [sp, #-16]!
+    STP fp, lr, [sp, #-16]!
+    ; Maintain frame pointer
+    MOV fp, sp
+    ; Pass 1st parameter (x0) unchanged (Stack*).
+    ; Pass 2nd parameter (x1) unchanged (StackVisitor*).
+    ; Save 3rd parameter (x2; IterateStackCallback)
+    MOV x7, x2
+    ; Pass 3rd parameter as sp (stack pointer)
+    MOV x2, sp
+    BLR x7
+    ; Load return address
+    LDR lr, [sp, #8]
+    ; Restore frame pointer and pop all callee-saved registers.
+    LDR fp, [sp], #96
+    RET
+    END

deps/v8/src/maglev/maglev-graph-builder.cc

@@ -10206,13 +10206,19 @@ MaybeReduceResult MaglevGraphBuilder::TryReduceCallForNewClosure(
       return BuildCallRuntime(Runtime::kThrowConstructorNonCallableError,
                               {target_node});
     }
-    RETURN_IF_DONE(TryBuildCallKnownJSFunction(
+
+#ifdef V8_ENABLE_LEAPTIERING
+      RETURN_IF_DONE(TryBuildCallKnownJSFunction(
         target_context, target_node,
         GetRootConstant(RootIndex::kUndefinedValue),
-#ifdef V8_ENABLE_LEAPTIERING
         dispatch_handle,
-#endif
         shared, feedback_vector, args, feedback_source));
+#else
+    RETURN_IF_DONE(TryBuildCallKnownJSFunction(
+        target_context, target_node,
+        GetRootConstant(RootIndex::kUndefinedValue),
+        shared, feedback_vector, args, feedback_source));
+#endif
   }
   return BuildGenericCall(target_node, Call::TargetType::kJSFunction, args);
 }

deps/v8/src/objects/instance-type-inl.h

@@ -39,13 +39,13 @@ HEAP_OBJECT_TYPE_LIST(DECL_TYPE)
 // Instance types which are associated with one unique map.
 
 template <class type>
-V8_INLINE consteval std::optional<RootIndex> UniqueMapOfInstanceTypeCheck() {
+V8_INLINE constexpr std::optional<RootIndex> UniqueMapOfInstanceTypeCheck() {
   return {};
 }
 
 #define INSTANCE_TYPE_MAP(V, rootIndexName, rootAccessorName, class_name) \
   template <>                                                             \
-  V8_INLINE consteval std::optional<RootIndex>                            \
+  V8_INLINE constexpr std::optional<RootIndex>                            \
   UniqueMapOfInstanceTypeCheck<InstanceTypeTraits::class_name>() {        \
     return {RootIndex::k##rootIndexName};                                 \
   }

deps/v8/src/runtime/runtime-test.cc

@@ -1197,8 +1197,8 @@ RUNTIME_FUNCTION(Runtime_SetAllocationTimeout) {
 namespace {
 
 int FixedArrayLenFromSize(int size) {
-  return std::min({(size - OFFSET_OF_DATA_START(FixedArray)) / kTaggedSize,
-                   FixedArray::kMaxRegularLength});
+return std::min<int>((size - OFFSET_OF_DATA_START(FixedArray)) / kTaggedSize,
+                     static_cast<int>(FixedArray::kMaxRegularLength));
 }
 
 void FillUpOneNewSpacePage(Isolate* isolate, Heap* heap,

deps/v8/third_party/rapidhash-v8/rapidhash.h

@@ -153,8 +153,13 @@ struct PlainHashReader {
 /*
  *  Likely and unlikely macros.
  */
-#define _likely_(x) __builtin_expect(x, 1)
-#define _unlikely_(x) __builtin_expect(x, 0)
+#if defined(_MSC_VER) && !defined(__clang__)
+  #define _likely_(x) (x)
+  #define _unlikely_(x) (x)
+#else
+  #define _likely_(x) __builtin_expect(x, 1)
+  #define _unlikely_(x) __builtin_expect(x, 0)
+#endif
 
 /*
  *  Default seed.

test/addons/esm/binding-export-default.cc renamed to test/addons/esm-export/binding-export-default.cc

@@ -0,0 +1,14 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding-export-default',
+      'sources': [ 'binding-export-default.cc' ],
+      'includes': ['../common.gypi'],
+    },
+    {
+      'target_name': 'binding-export-primitive',
+      'sources': [ 'binding-export-primitive.cc' ],
+      'includes': ['../common.gypi'],
+    },
+  ]
+}

test/addons/esm/binding-export-primitive.cc renamed to test/addons/esm-export/binding-export-primitive.cc

@@ -0,0 +1,37 @@
+/**
+ * This file is supposed to be loaded by `test-import.js` and `test-require.js`
+ * to verify that `import('*.node')` is working properly either been loaded with
+ * the ESM loader or the CJS loader.
+ */
+
+import { buildType } from '../../common/index.mjs';
+import assert from 'node:assert';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+const require = createRequire(import.meta.url);
+
+export async function run() {
+  // binding-export-default.node
+  {
+    const bindingPath = require.resolve(`./build/${buildType}/binding-export-default.node`);
+    // Test with order of require+import
+    const bindingRequire = require(bindingPath);
+    const ns = await import(pathToFileURL(bindingPath));
+    assert.strictEqual(ns.default, bindingRequire);
+
+    // As same as ESM-import-CJS, the default export is the value of `module.exports`.
+    assert.strictEqual(ns.default, ns['module.exports']);
+    assert.strictEqual(ns.default.default(), 'hello world');
+  }
+
+  // binding-export-primitive.node
+  {
+    const bindingPath = require.resolve(`./build/${buildType}/binding-export-primitive.node`);
+    const ns = await import(pathToFileURL(bindingPath));
+
+    // As same as ESM-import-CJS, the default export is the value of `module.exports`.
+    assert.strictEqual(ns.default, ns['module.exports']);
+    assert.strictEqual(ns.default, 'hello world');
+  }
+}

test/addons/esm-export/binding.gyp

@@ -0,0 +1,6 @@
+// Flags: --experimental-addon-modules
+'use strict';
+const common = require('../../common');
+
+require('./test-esm.mjs')
+  .run().then(common.mustCall());

test/addons/esm-export/test-esm.mjs

@@ -1,23 +1,13 @@
 {
   'variables': {
-    'source_dir': '<!(<(python) -c "import os; print(os.getcwd())")',
+    'source_dir': '<!("<(python)" -c "import os; print(os.getcwd())")',
   },
   'targets': [
     {
       'target_name': 'binding',
       'sources': [ 'binding.cc' ],
       'includes': ['../common.gypi'],
     },
-    {
-      'target_name': 'binding-export-default',
-      'sources': [ 'binding-export-default.cc' ],
-      'includes': ['../common.gypi'],
-    },
-    {
-      'target_name': 'binding-export-primitive',
-      'sources': [ 'binding-export-primitive.cc' ],
-      'includes': ['../common.gypi'],
-    },
     {
       'target_name': 'node_modules',
       'type': 'none',

test/addons/esm-export/test-require.js

@@ -31,27 +31,4 @@ export async function run() {
     assert.strictEqual(rebinding.hello(), 'world');
     assert.strictEqual(binding.hello, rebinding.hello);
   }
-
-  // binding-export-default.node
-  {
-    const bindingPath = require.resolve(`./build/${buildType}/binding-export-default.node`);
-    // Test with order of require+import
-    const bindingRequire = require(bindingPath);
-    const ns = await import(pathToFileURL(bindingPath));
-    assert.strictEqual(ns.default, bindingRequire);
-
-    // As same as ESM-import-CJS, the default export is the value of `module.exports`.
-    assert.strictEqual(ns.default, ns['module.exports']);
-    assert.strictEqual(ns.default.default(), 'hello world');
-  }
-
-  // binding-export-primitive.node
-  {
-    const bindingPath = require.resolve(`./build/${buildType}/binding-export-primitive.node`);
-    const ns = await import(pathToFileURL(bindingPath));
-
-    // As same as ESM-import-CJS, the default export is the value of `module.exports`.
-    assert.strictEqual(ns.default, ns['module.exports']);
-    assert.strictEqual(ns.default, 'hello world');
-  }
 }