deps: patch V8 to support compilation with MSVC

This patches V8 v12.4 for Windows, by fixing multiple compilation
errors caused by V8 being a Clang-oriented project. There are various
types of errors fixed by this going from changing `using` directives
and renaming to overcoming the differences in which Clang and MSVC see
templates and metaprogramming.

The changes introduced here are strictly meant as a patch only, so they
shouldn't be pushed upstream.

Refs: targos#13
Refs: targos#14
Refs: targos#15

Author: StefanStojanovic

common.gypi

@@ -286,6 +286,9 @@
       'VCCLCompilerTool': {
         'AdditionalOptions': [
           '/Zc:__cplusplus',
+          # The following option fixes the "error C1060: compiler is out of heap space"
+          '/Zm1000',
+          # The following option enables c++20 on Windows. This is needed for V8 v12.4+
           '-std:c++20'
         ],
         'BufferSecurityCheck': 'true',

deps/v8/src/builtins/builtins-collections-gen.cc

@@ -2784,7 +2784,7 @@ TNode<IntPtrT> WeakCollectionsBuiltinsAssembler::ValueIndexFromKeyIndex(
     TNode<IntPtrT> key_index) {
   return IntPtrAdd(
       key_index,
-      IntPtrConstant(EphemeronHashTable::TodoShape::kEntryValueIndex -
+      IntPtrConstant(EphemeronHashTable::ShapeT::kEntryValueIndex -
                      EphemeronHashTable::kEntryKeyIndex));
 }
 

deps/v8/src/codegen/code-stub-assembler.cc

@@ -9719,7 +9719,7 @@ void CodeStubAssembler::NameDictionaryLookup(
         break;
       case kFindExisting:
       case kFindExistingOrInsertionIndex:
-        if (Dictionary::TodoShape::kMatchNeedsHoleCheck) {
+        if (Dictionary::ShapeT::kMatchNeedsHoleCheck) {
           GotoIf(TaggedEqual(current, TheHoleConstant()), &next_probe);
         }
         current = LoadName<Dictionary>(current);

deps/v8/src/codegen/code-stub-assembler.h

@@ -1577,7 +1577,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
   TNode<Smi> LoadFixedArrayBaseLength(TNode<FixedArrayBase> array);
   template <typename Array>
   TNode<Smi> LoadArrayCapacity(TNode<Array> array) {
-    return LoadObjectField<Smi>(array, Array::Shape::kCapacityOffset);
+    return LoadObjectField<Smi>(array, Array::ShapeT::kCapacityOffset);
   }
   // Load the length of a fixed array base instance.
   TNode<IntPtrT> LoadAndUntagFixedArrayBaseLength(TNode<FixedArrayBase> array);

deps/v8/src/compiler/backend/instruction-selector-adapter.h

@@ -855,12 +855,13 @@ struct TurboshaftAdapter : public turboshaft::OperationMatcher {
           *traps_on_null = load_->kind.trap_on_null;
 #if V8_ENABLE_WEBASSEMBLY
         } else {
-          DCHECK((load_transform_ && !load_transform_->load_kind.trap_on_null)
 #if V8_ENABLE_WASM_SIMD256_REVEC
+          DCHECK((load_transform_ && !load_transform_->load_kind.trap_on_null)
                  || (load_transform256_ &&
-                     !load_transform256_->load_kind.trap_on_null)
+                     !load_transform256_->load_kind.trap_on_null));
+#else
+          DCHECK((load_transform_ && !load_transform_->load_kind.trap_on_null));
 #endif  // V8_ENABLE_WASM_SIMD256_REVEC
-          );
           *traps_on_null = false;
 #endif  // V8_ENABLE_WEBASSEMBLY
         }

deps/v8/src/compiler/turboshaft/assembler.h

@@ -1161,8 +1161,7 @@ class TurboshaftAssemblerOpInterface
 
   template <typename... Args>
   explicit TurboshaftAssemblerOpInterface(Args... args)
-      : GenericAssemblerOpInterface<Next>(args...),
-        matcher_(Asm().output_graph()) {}
+      : matcher_(Asm().output_graph()) {}
 
   const OperationMatcher& matcher() const { return matcher_; }
 
@@ -2420,11 +2419,11 @@ class TurboshaftAssemblerOpInterface
 
   // Helpers to read the most common fields.
   // TODO(nicohartmann@): Strengthen this to `V<HeapObject>`.
-  V<Map> LoadMapField(V<Object> object) {
-    return LoadField<Map>(object, AccessBuilder::ForMap());
+  V<v8::internal::Map> LoadMapField(V<Object> object) {
+    return LoadField<v8::internal::Map>(object, AccessBuilder::ForMap());
   }
 
-  V<Word32> LoadInstanceTypeField(V<Map> map) {
+  V<Word32> LoadInstanceTypeField(V<v8::internal::Map> map) {
     return LoadField<Word32>(map, AccessBuilder::ForMapInstanceType());
   }
 
@@ -3114,7 +3113,7 @@ class TurboshaftAssemblerOpInterface
   V<Object> CallRuntime_TransitionElementsKind(Isolate* isolate,
                                                V<Context> context,
                                                V<HeapObject> object,
-                                               V<Map> target_map) {
+                                               V<v8::internal::Map> target_map) {
     return CallRuntime<typename RuntimeCallDescriptor::TransitionElementsKind>(
         isolate, context, {object, target_map});
   }
@@ -3532,8 +3531,8 @@ class TurboshaftAssemblerOpInterface
 
   void TransitionAndStoreArrayElement(
       V<Object> array, V<WordPtr> index, OpIndex value,
-      TransitionAndStoreArrayElementOp::Kind kind, MaybeHandle<Map> fast_map,
-      MaybeHandle<Map> double_map) {
+      TransitionAndStoreArrayElementOp::Kind kind, MaybeHandle<v8::internal::Map> fast_map,
+      MaybeHandle<v8::internal::Map> double_map) {
     ReduceIfReachableTransitionAndStoreArrayElement(array, index, value, kind,
                                                     fast_map, double_map);
   }
@@ -3546,17 +3545,17 @@ class TurboshaftAssemblerOpInterface
   }
 
   V<Word32> CompareMaps(V<HeapObject> heap_object,
-                        const ZoneRefSet<Map>& maps) {
+                        const ZoneRefSet<v8::internal::Map>& maps) {
     return ReduceIfReachableCompareMaps(heap_object, maps);
   }
 
   void CheckMaps(V<HeapObject> heap_object, OpIndex frame_state,
-                 const ZoneRefSet<Map>& maps, CheckMapsFlags flags,
+                 const ZoneRefSet<v8::internal::Map>& maps, CheckMapsFlags flags,
                  const FeedbackSource& feedback) {
     ReduceIfReachableCheckMaps(heap_object, frame_state, maps, flags, feedback);
   }
 
-  void AssumeMap(V<HeapObject> heap_object, const ZoneRefSet<Map>& maps) {
+  void AssumeMap(V<HeapObject> heap_object, const ZoneRefSet<v8::internal::Map>& maps) {
     ReduceIfReachableAssumeMap(heap_object, maps);
   }
 
@@ -3665,16 +3664,16 @@ class TurboshaftAssemblerOpInterface
     return ReduceIfReachableAssertNotNull(object, type, trap_id);
   }
 
-  V<Map> RttCanon(V<FixedArray> rtts, uint32_t type_index) {
+  V<v8::internal::Map> RttCanon(V<FixedArray> rtts, uint32_t type_index) {
     return ReduceIfReachableRttCanon(rtts, type_index);
   }
 
-  V<Word32> WasmTypeCheck(V<Object> object, OptionalV<Map> rtt,
+  V<Word32> WasmTypeCheck(V<Object> object, OptionalV<v8::internal::Map> rtt,
                           WasmTypeCheckConfig config) {
     return ReduceIfReachableWasmTypeCheck(object, rtt, config);
   }
 
-  V<Object> WasmTypeCast(V<Object> object, OptionalV<Map> rtt,
+  V<Object> WasmTypeCast(V<Object> object, OptionalV<v8::internal::Map> rtt,
                          WasmTypeCheckConfig config) {
     return ReduceIfReachableWasmTypeCast(object, rtt, config);
   }
@@ -3719,12 +3718,12 @@ class TurboshaftAssemblerOpInterface
     return ReduceIfReachableArrayLength(array, null_check);
   }
 
-  V<HeapObject> WasmAllocateArray(V<Map> rtt, ConstOrV<Word32> length,
+  V<HeapObject> WasmAllocateArray(V<v8::internal::Map> rtt, ConstOrV<Word32> length,
                                   const wasm::ArrayType* array_type) {
     return ReduceIfReachableWasmAllocateArray(rtt, resolve(length), array_type);
   }
 
-  V<HeapObject> WasmAllocateStruct(V<Map> rtt,
+  V<HeapObject> WasmAllocateStruct(V<v8::internal::Map> rtt,
                                    const wasm::StructType* struct_type) {
     return ReduceIfReachableWasmAllocateStruct(rtt, struct_type);
   }

deps/v8/src/compiler/turboshaft/machine-optimization-reducer.h

@@ -1467,53 +1467,23 @@ class MachineOptimizationReducer : public Next {
         if (matcher.MatchConstantShiftRightArithmeticShiftOutZeros(
                 left, &x, rep_w, &k1) &&
             matcher.MatchIntegralWordConstant(right, rep_w, &k2) &&
-            CountLeadingSignBits(k2, rep_w) > k1) {
-          if (matcher.Get(left).saturated_use_count.IsZero()) {
-            return __ Comparison(
-                x, __ WordConstant(base::bits::Unsigned(k2) << k1, rep_w), kind,
-                rep_w);
-          } else if constexpr (reducer_list_contains<
-                                   ReducerList, ValueNumberingReducer>::value) {
-            // If the shift has uses, we only apply the transformation if the
-            // result would be GVNed away.
-            OpIndex rhs =
-                __ WordConstant(base::bits::Unsigned(k2) << k1, rep_w);
-            static_assert(ComparisonOp::input_count == 2);
-            static_assert(sizeof(ComparisonOp) == 8);
-            base::SmallVector<OperationStorageSlot, 32> storage;
-            ComparisonOp* cmp =
-                CreateOperation<ComparisonOp>(storage, x, rhs, kind, rep_w);
-            if (__ WillGVNOp(*cmp)) {
-              return __ Comparison(x, rhs, kind, rep_w);
-            }
-          }
+            CountLeadingSignBits(k2, rep_w) > k1 &&
+            matcher.Get(left).saturated_use_count.IsZero()) {
+          return __ Comparison(
+              x, __ WordConstant(base::bits::Unsigned(k2) << k1, rep_w), kind,
+              rep_w);
         }
         // k2 </<= (x >> k1)  =>  (k2 << k1) </<= x  if shifts reversible
         // Only perform the transformation if the shift is not used yet, to
         // avoid keeping both the shift and x alive.
         if (matcher.MatchConstantShiftRightArithmeticShiftOutZeros(
                 right, &x, rep_w, &k1) &&
             matcher.MatchIntegralWordConstant(left, rep_w, &k2) &&
-            CountLeadingSignBits(k2, rep_w) > k1) {
-          if (matcher.Get(right).saturated_use_count.IsZero()) {
-            return __ Comparison(
-                __ WordConstant(base::bits::Unsigned(k2) << k1, rep_w), x, kind,
-                rep_w);
-          } else if constexpr (reducer_list_contains<
-                                   ReducerList, ValueNumberingReducer>::value) {
-            // If the shift has uses, we only apply the transformation if the
-            // result would be GVNed away.
-            OpIndex lhs =
-                __ WordConstant(base::bits::Unsigned(k2) << k1, rep_w);
-            static_assert(ComparisonOp::input_count == 2);
-            static_assert(sizeof(ComparisonOp) == 8);
-            base::SmallVector<OperationStorageSlot, 32> storage;
-            ComparisonOp* cmp =
-                CreateOperation<ComparisonOp>(storage, lhs, x, kind, rep_w);
-            if (__ WillGVNOp(*cmp)) {
-              return __ Comparison(lhs, x, kind, rep_w);
-            }
-          }
+            CountLeadingSignBits(k2, rep_w) > k1 &&
+            matcher.Get(right).saturated_use_count.IsZero()) {
+          return __ Comparison(
+              __ WordConstant(base::bits::Unsigned(k2) << k1, rep_w), x, kind,
+              rep_w);
         }
       }
       // Map 64bit to 32bit comparisons.

deps/v8/src/compiler/turboshaft/simplified-lowering-reducer.h

@@ -32,18 +32,18 @@ class SimplifiedLoweringReducer : public Next {
       OpIndex ig_index, const SpeculativeNumberBinopOp& op) {
     DCHECK_EQ(op.kind, SpeculativeNumberBinopOp::Kind::kSafeIntegerAdd);
 
-    OpIndex frame_state = Map(op.frame_state());
-    V<Word32> left = ProcessInput(Map(op.left()), Rep::Word32(),
+    OpIndex frame_state = MapImpl(op.frame_state());
+    V<Word32> left = ProcessInput(MapImpl(op.left()), Rep::Word32(),
                                   CheckKind::kSigned32, frame_state);
-    V<Word32> right = ProcessInput(Map(op.right()), Rep::Word32(),
+    V<Word32> right = ProcessInput(MapImpl(op.right()), Rep::Word32(),
                                    CheckKind::kSigned32, frame_state);
 
     V<Word32> result = __ OverflowCheckedBinop(
         left, right, OverflowCheckedBinopOp::Kind::kSignedAdd,
         WordRepresentation::Word32());
 
     V<Word32> overflow = __ Projection(result, 1, Rep::Word32());
-    __ DeoptimizeIf(overflow, Map(op.frame_state()),
+    __ DeoptimizeIf(overflow, MapImpl(op.frame_state()),
                     DeoptimizeReason::kOverflow, FeedbackSource{});
     return __ Projection(result, 0, Rep::Word32());
   }
@@ -52,10 +52,10 @@ class SimplifiedLoweringReducer : public Next {
     base::SmallVector<OpIndex, 8> return_values;
     for (OpIndex input : ret.return_values()) {
       return_values.push_back(
-          ProcessInput(Map(input), Rep::Tagged(), CheckKind::kNone, {}));
+          ProcessInput(MapImpl(input), Rep::Tagged(), CheckKind::kNone, {}));
     }
 
-    __ Return(Map(ret.pop_count()), base::VectorOf(return_values));
+    __ Return(MapImpl(ret.pop_count()), base::VectorOf(return_values));
     return OpIndex::Invalid();
   }
 
@@ -94,7 +94,7 @@ class SimplifiedLoweringReducer : public Next {
     }
   }
 
-  inline OpIndex Map(OpIndex ig_index) { return __ MapToNewGraph(ig_index); }
+  inline OpIndex MapImpl(OpIndex ig_index) { return __ MapToNewGraph(ig_index); }
 };
 
 #include "src/compiler/turboshaft/undef-assembler-macros.inc"

deps/v8/src/compiler/turboshaft/variable-reducer.h

@@ -55,9 +55,11 @@ namespace v8::internal::compiler::turboshaft {
 // with constant inputs introduced by `VariableReducer` need to be eliminated.
 template <class AfterNext>
 class VariableReducer : public RequiredOptimizationReducer<AfterNext> {
+protected:
   using Next = RequiredOptimizationReducer<AfterNext>;
   using Snapshot = SnapshotTable<OpIndex, VariableData>::Snapshot;
 
+private:
   struct GetActiveLoopVariablesIndex {
     IntrusiveSetIndex& operator()(Variable var) const {
       return var.data().active_loop_variables_index;

deps/v8/src/heap/heap.cc

@@ -3580,7 +3580,7 @@ void Heap::RightTrimArray(Tagged<Array> object, int new_capacity,
   }
 
   const int bytes_to_trim =
-      (old_capacity - new_capacity) * Array::Shape::kElementSize;
+      (old_capacity - new_capacity) * Array::HotfixShape::kElementSize;
 
   // Calculate location of new array end.
   const int old_size = Array::SizeFor(old_capacity);