deps: patch V8 to support compilation with MSVC

This patches V8 v12.2 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
PR-URL: #51362
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>

Author: StefanStojanovic

common.gypi

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

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

@@ -2782,10 +2782,9 @@ TNode<Word32T> WeakCollectionsBuiltinsAssembler::ShouldShrink(
 
 TNode<IntPtrT> WeakCollectionsBuiltinsAssembler::ValueIndexFromKeyIndex(
     TNode<IntPtrT> key_index) {
-  return IntPtrAdd(
-      key_index,
-      IntPtrConstant(EphemeronHashTable::TodoShape::kEntryValueIndex -
-                     EphemeronHashTable::kEntryKeyIndex));
+  return IntPtrAdd(key_index,
+                   IntPtrConstant(EphemeronHashTable::ShapeT::kEntryValueIndex -
+                                  EphemeronHashTable::kEntryKeyIndex));
 }
 
 TF_BUILTIN(WeakMapConstructor, WeakCollectionsBuiltinsAssembler) {

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

@@ -9455,7 +9455,7 @@ void CodeStubAssembler::NameDictionaryLookup(
         CAST(UnsafeLoadFixedArrayElement(dictionary, index));
     GotoIf(TaggedEqual(current, undefined), if_not_found);
     if (mode == kFindExisting) {
-      if (Dictionary::TodoShape::kMatchNeedsHoleCheck) {
+      if (Dictionary::ShapeT::kMatchNeedsHoleCheck) {
         GotoIf(TaggedEqual(current, TheHoleConstant()), &next_probe);
       }
       current = LoadName<Dictionary>(current);

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

@@ -3934,8 +3934,14 @@ class TSAssembler
     : public Assembler<reducer_list<TurboshaftAssemblerOpInterface, Reducers...,
                                     TSReducerBase>> {
  public:
+#ifdef _WIN32
+  explicit TSAssembler(Graph& input_graph, Graph& output_graph,
+                       Zone* phase_zone)
+      : Assembler(input_graph, output_graph, phase_zone) {}
+#else
   using Assembler<reducer_list<TurboshaftAssemblerOpInterface, Reducers...,
                                TSReducerBase>>::Assembler;
+#endif
 };
 
 #include "src/compiler/turboshaft/undef-assembler-macros.inc"

deps/v8/src/compiler/turboshaft/code-elimination-and-simplification-phase.cc

@@ -32,7 +32,8 @@ void CodeEliminationAndSimplificationPhase::Run(Zone* temp_zone) {
                // (which, for simplificy, doesn't use the Assembler helper
                // methods, but only calls Next::ReduceLoad/Store).
                DuplicationOptimizationReducer,
-               ValueNumberingReducer>::Run(temp_zone);
+               VariableReducerHotfix,
+               ValueNumberingReducer>::Run<false>(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft

deps/v8/src/compiler/turboshaft/copying-phase.h

@@ -36,6 +36,18 @@ struct PaddingSpace {
 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                            PaddingSpace padding);
 
+template <class Next>
+class VariableReducerHotfix : public Next {
+public:
+  TURBOSHAFT_REDUCER_BOILERPLATE()
+
+  void SetVariable(Variable var, OpIndex new_index) {}
+  Variable NewLoopInvariantVariable(MaybeRegisterRepresentation rep) { return Variable(); }
+
+  OpIndex GetVariable(Variable var) { return OpIndex(); }
+  OpIndex GetPredecessorValue(Variable var, int predecessor_index) { return OpIndex(); }
+};
+
 template <typename Next>
 class ReducerBaseForwarder;
 template <typename Next>
@@ -46,6 +58,9 @@ class GraphVisitor : public Next {
   template <typename N>
   friend class ReducerBaseForwarder;
 
+ private:
+  bool contains_variable_reducer_;
+
  public:
   TURBOSHAFT_REDUCER_BOILERPLATE()
 
@@ -66,7 +81,8 @@ class GraphVisitor : public Next {
   // `trace_reduction` is a template parameter to avoid paying for tracing at
   // runtime.
   template <bool trace_reduction>
-  void VisitGraph() {
+  void VisitGraph(bool contains_variable_reducer) {
+    contains_variable_reducer_ = contains_variable_reducer;
     Asm().Analyze();
 
     // Creating initial old-to-new Block mapping.
@@ -177,8 +193,7 @@ class GraphVisitor : public Next {
     DCHECK(old_index.valid());
     OpIndex result = op_mapping_[old_index];
 
-    if constexpr (reducer_list_contains<typename Next::ReducerList,
-                                        VariableReducer>::value) {
+    if (contains_variable_reducer_) {
       if (!result.valid()) {
         // {op_mapping} doesn't have a mapping for {old_index}. The assembler
         // should provide the mapping.
@@ -1294,8 +1309,7 @@ class GraphVisitor : public Next {
     DCHECK(Asm().input_graph().BelongsToThisGraph(old_index));
     DCHECK_IMPLIES(new_index.valid(),
                    Asm().output_graph().BelongsToThisGraph(new_index));
-    if constexpr (reducer_list_contains<typename Next::ReducerList,
-                                        VariableReducer>::value) {
+    if (contains_variable_reducer_) {
       if (current_block_needs_variables_) {
         MaybeVariable var = GetVariableFor(old_index);
         if (!var.has_value()) {
@@ -1393,29 +1407,30 @@ template <template <class> class... Reducers>
 class CopyingPhaseImpl {
  public:
   static void Run(Graph& input_graph, Zone* phase_zone,
-                  bool trace_reductions = false) {
+                  bool contains_variable_reducer, bool trace_reductions = false) {
     TSAssembler<GraphVisitor, Reducers...> phase(
         input_graph, input_graph.GetOrCreateCompanion(), phase_zone);
 #ifdef DEBUG
     if (trace_reductions) {
-      phase.template VisitGraph<true>();
+      phase.template VisitGraph<true>(contains_variable_reducer);
     } else {
-      phase.template VisitGraph<false>();
+      phase.template VisitGraph<false>(contains_variable_reducer);
     }
 #else
-    phase.template VisitGraph<false>();
+    phase.template VisitGraph<false>(contains_variable_reducer);
 #endif  // DEBUG
   }
 };
 
 template <template <typename> typename... Reducers>
 class CopyingPhase {
  public:
+  template <bool contains_variable_reducer>
   static void Run(Zone* phase_zone) {
     PipelineData& data = PipelineData::Get();
     Graph& input_graph = data.graph();
     CopyingPhaseImpl<Reducers...>::Run(
-        input_graph, phase_zone, data.info()->turboshaft_trace_reduction());
+        input_graph, phase_zone, contains_variable_reducer, data.info()->turboshaft_trace_reduction());
   }
 };
 

deps/v8/src/compiler/turboshaft/csa-optimize-phase.cc

@@ -25,23 +25,23 @@ namespace v8::internal::compiler::turboshaft {
 void CsaLoadEliminationPhase::Run(Zone* temp_zone) {
   CopyingPhase<VariableReducer, MachineOptimizationReducer,
                RequiredOptimizationReducer,
-               ValueNumberingReducer>::Run(temp_zone);
+               ValueNumberingReducer>::Run<true>(temp_zone);
 
   CopyingPhase<VariableReducer, LateLoadEliminationReducer,
                MachineOptimizationReducer, RequiredOptimizationReducer,
-               ValueNumberingReducer>::Run(temp_zone);
+               ValueNumberingReducer>::Run<true>(temp_zone);
 }
 
 void CsaLateEscapeAnalysisPhase::Run(Zone* temp_zone) {
   CopyingPhase<VariableReducer, LateEscapeAnalysisReducer,
                MachineOptimizationReducer, RequiredOptimizationReducer,
-               ValueNumberingReducer>::Run(temp_zone);
+               ValueNumberingReducer>::Run<true>(temp_zone);
 }
 
 void CsaBranchEliminationPhase::Run(Zone* temp_zone) {
   CopyingPhase<VariableReducer, MachineOptimizationReducer,
                BranchEliminationReducer, RequiredOptimizationReducer,
-               ValueNumberingReducer>::Run(temp_zone);
+               ValueNumberingReducer>::Run<true>(temp_zone);
 }
 
 void CsaOptimizePhase::Run(Zone* temp_zone) {
@@ -51,7 +51,7 @@ void CsaOptimizePhase::Run(Zone* temp_zone) {
   CopyingPhase<VariableReducer, PretenuringPropagationReducer,
                MachineOptimizationReducer, MemoryOptimizationReducer,
                RequiredOptimizationReducer,
-               ValueNumberingReducer>::Run(temp_zone);
+               ValueNumberingReducer>::Run<true>(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft

deps/v8/src/compiler/turboshaft/debug-feature-lowering-phase.cc

@@ -11,7 +11,7 @@ namespace v8::internal::compiler::turboshaft {
 
 void DebugFeatureLoweringPhase::Run(Zone* temp_zone) {
 #ifdef V8_ENABLE_DEBUG_CODE
-  turboshaft::CopyingPhase<turboshaft::DebugFeatureLoweringReducer>::Run(
+  turboshaft::CopyingPhase<turboshaft::DebugFeatureLoweringReducer>::Run<false>(
       temp_zone);
 #endif
 }

deps/v8/src/compiler/turboshaft/int64-lowering-phase.cc

@@ -16,7 +16,7 @@ void Int64LoweringPhase::Run(Zone* temp_zone) {
 #if V8_TARGET_ARCH_32_BIT
   turboshaft::CopyingPhase<
       turboshaft::Int64LoweringReducer, turboshaft::VariableReducer,
-      turboshaft::RequiredOptimizationReducer>::Run(temp_zone);
+      turboshaft::RequiredOptimizationReducer>::Run<true>(temp_zone);
 #else
   UNREACHABLE();
 #endif

deps/v8/src/compiler/turboshaft/loop-peeling-phase.cc

@@ -23,7 +23,7 @@ void LoopPeelingPhase::Run(Zone* temp_zone) {
                            turboshaft::VariableReducer,
                            turboshaft::MachineOptimizationReducer,
                            turboshaft::RequiredOptimizationReducer,
-                           turboshaft::ValueNumberingReducer>::Run(temp_zone);
+                           turboshaft::ValueNumberingReducer>::Run<true>(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft