Revert "V8 v12.2 Windows patch (#13)"

targos · targos · commit 28bf2cab8165 · 2024-01-30T12:45:25.000+01:00
This reverts commit 1b8b110.
diff --git a/deps/v8/src/builtins/builtins-collections-gen.cc b/deps/v8/src/builtins/builtins-collections-gen.cc
@@ -2782,9 +2782,10 @@ TNode<Word32T> WeakCollectionsBuiltinsAssembler::ShouldShrink(
 
 TNode<IntPtrT> WeakCollectionsBuiltinsAssembler::ValueIndexFromKeyIndex(
     TNode<IntPtrT> key_index) {
-  return IntPtrAdd(key_index,
-                   IntPtrConstant(EphemeronHashTable::ShapeT::kEntryValueIndex -
-                                  EphemeronHashTable::kEntryKeyIndex));
+  return IntPtrAdd(
+      key_index,
+      IntPtrConstant(EphemeronHashTable::TodoShape::kEntryValueIndex -
+                     EphemeronHashTable::kEntryKeyIndex));
 }
 
 TF_BUILTIN(WeakMapConstructor, WeakCollectionsBuiltinsAssembler) {
diff --git a/deps/v8/src/codegen/code-stub-assembler.cc b/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::ShapeT::kMatchNeedsHoleCheck) {
+      if (Dictionary::TodoShape::kMatchNeedsHoleCheck) {
         GotoIf(TaggedEqual(current, TheHoleConstant()), &next_probe);
       }
       current = LoadName<Dictionary>(current);
diff --git a/deps/v8/src/compiler/turboshaft/assembler.h b/deps/v8/src/compiler/turboshaft/assembler.h
@@ -3934,9 +3934,8 @@ class TSAssembler
     : public Assembler<reducer_list<TurboshaftAssemblerOpInterface, Reducers...,
                                     TSReducerBase>> {
  public:
-  explicit TSAssembler(Graph& input_graph, Graph& output_graph,
-                       Zone* phase_zone)
-      : Assembler(input_graph, output_graph, phase_zone) {}
+  using Assembler<reducer_list<TurboshaftAssemblerOpInterface, Reducers...,
+                               TSReducerBase>>::Assembler;
 };
 
 #include "src/compiler/turboshaft/undef-assembler-macros.inc"
diff --git a/deps/v8/src/compiler/turboshaft/code-elimination-and-simplification-phase.cc b/deps/v8/src/compiler/turboshaft/code-elimination-and-simplification-phase.cc
@@ -32,8 +32,7 @@ void CodeEliminationAndSimplificationPhase::Run(Zone* temp_zone) {
                // (which, for simplificy, doesn't use the Assembler helper
                // methods, but only calls Next::ReduceLoad/Store).
                DuplicationOptimizationReducer,
-               ValueNumberingReducer,
-               VariableReducerHotfix>::Run<false>(temp_zone);
+               ValueNumberingReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/copying-phase.h b/deps/v8/src/compiler/turboshaft/copying-phase.h
@@ -36,16 +36,6 @@ struct PaddingSpace {
 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                            PaddingSpace padding);
 
-template <class Next>
-class VariableReducerHotfix : public Next {
-public:
-  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>
@@ -56,9 +46,6 @@ class GraphVisitor : public Next {
   template <typename N>
   friend class ReducerBaseForwarder;
 
- private:
-  bool contains_variable_reducer_;
-
  public:
   TURBOSHAFT_REDUCER_BOILERPLATE()
 
@@ -79,8 +66,7 @@ class GraphVisitor : public Next {
   // `trace_reduction` is a template parameter to avoid paying for tracing at
   // runtime.
   template <bool trace_reduction>
-  void VisitGraph(bool contains_variable_reducer) {
-    contains_variable_reducer_ = contains_variable_reducer;
+  void VisitGraph() {
     Asm().Analyze();
 
     // Creating initial old-to-new Block mapping.
@@ -191,7 +177,8 @@ class GraphVisitor : public Next {
     DCHECK(old_index.valid());
     OpIndex result = op_mapping_[old_index];
 
-    if (contains_variable_reducer_) {
+    if constexpr (reducer_list_contains<typename Next::ReducerList,
+                                        VariableReducer>::value) {
       if (!result.valid()) {
         // {op_mapping} doesn't have a mapping for {old_index}. The assembler
         // should provide the mapping.
@@ -1307,7 +1294,8 @@ class GraphVisitor : public Next {
     DCHECK(Asm().input_graph().BelongsToThisGraph(old_index));
     DCHECK_IMPLIES(new_index.valid(),
                    Asm().output_graph().BelongsToThisGraph(new_index));
-    if (contains_variable_reducer_) {
+    if constexpr (reducer_list_contains<typename Next::ReducerList,
+                                        VariableReducer>::value) {
       if (current_block_needs_variables_) {
         MaybeVariable var = GetVariableFor(old_index);
         if (!var.has_value()) {
@@ -1404,31 +1392,29 @@ class TSAssembler;
 template <template <class> class... Reducers>
 class CopyingPhaseImpl {
  public:
-  template <bool contains_variable_reducer>
   static void Run(Graph& input_graph, Zone* phase_zone,
                   bool trace_reductions = false) {
     TSAssembler<GraphVisitor, Reducers...> phase(
         input_graph, input_graph.GetOrCreateCompanion(), phase_zone);
 #ifdef DEBUG
     if (trace_reductions) {
-      phase.template VisitGraph<true>(contains_variable_reducer);
+      phase.template VisitGraph<true>();
     } else {
-      phase.template VisitGraph<false>(contains_variable_reducer);
+      phase.template VisitGraph<false>();
     }
 #else
-    phase.template VisitGraph<false>(contains_variable_reducer);
+    phase.template VisitGraph<false>();
 #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<contains_variable_reducer>(
+    CopyingPhaseImpl<Reducers...>::Run(
         input_graph, phase_zone, data.info()->turboshaft_trace_reduction());
   }
 };
diff --git a/deps/v8/src/compiler/turboshaft/csa-optimize-phase.cc b/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<true>(temp_zone);
+               ValueNumberingReducer>::Run(temp_zone);
 
   CopyingPhase<VariableReducer, LateLoadEliminationReducer,
                MachineOptimizationReducer, RequiredOptimizationReducer,
-               ValueNumberingReducer>::Run<true>(temp_zone);
+               ValueNumberingReducer>::Run(temp_zone);
 }
 
 void CsaLateEscapeAnalysisPhase::Run(Zone* temp_zone) {
   CopyingPhase<VariableReducer, LateEscapeAnalysisReducer,
                MachineOptimizationReducer, RequiredOptimizationReducer,
-               ValueNumberingReducer>::Run<true>(temp_zone);
+               ValueNumberingReducer>::Run(temp_zone);
 }
 
 void CsaBranchEliminationPhase::Run(Zone* temp_zone) {
   CopyingPhase<VariableReducer, MachineOptimizationReducer,
                BranchEliminationReducer, RequiredOptimizationReducer,
-               ValueNumberingReducer>::Run<true>(temp_zone);
+               ValueNumberingReducer>::Run(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<true>(temp_zone);
+               ValueNumberingReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/debug-feature-lowering-phase.cc b/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<false>(
+  turboshaft::CopyingPhase<turboshaft::DebugFeatureLoweringReducer>::Run(
       temp_zone);
 #endif
 }
diff --git a/deps/v8/src/compiler/turboshaft/int64-lowering-phase.cc b/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<true>(temp_zone);
+      turboshaft::RequiredOptimizationReducer>::Run(temp_zone);
 #else
   UNREACHABLE();
 #endif
diff --git a/deps/v8/src/compiler/turboshaft/loop-peeling-phase.cc b/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<true>(temp_zone);
+                           turboshaft::ValueNumberingReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/loop-unrolling-phase.cc b/deps/v8/src/compiler/turboshaft/loop-unrolling-phase.cc
@@ -22,7 +22,7 @@ void LoopUnrollingPhase::Run(Zone* temp_zone) {
                              turboshaft::VariableReducer,
                              turboshaft::MachineOptimizationReducer,
                              turboshaft::RequiredOptimizationReducer,
-                             turboshaft::ValueNumberingReducer>::Run<true>(temp_zone);
+                             turboshaft::ValueNumberingReducer>::Run(temp_zone);
     PipelineData::Get().clear_loop_unrolling_analyzer();
   }
 }
diff --git a/deps/v8/src/compiler/turboshaft/machine-lowering-phase.cc b/deps/v8/src/compiler/turboshaft/machine-lowering-phase.cc
@@ -20,11 +20,11 @@ void MachineLoweringPhase::Run(Zone* temp_zone) {
     CopyingPhase<DataViewReducer, VariableReducer, MachineLoweringReducer,
                  FastApiCallReducer, RequiredOptimizationReducer,
                  SelectLoweringReducer,
-                 MachineOptimizationReducer>::Run<true>(temp_zone);
+                 MachineOptimizationReducer>::Run(temp_zone);
   } else {
     CopyingPhase<DataViewReducer, VariableReducer, MachineLoweringReducer,
                  FastApiCallReducer, RequiredOptimizationReducer,
-                 SelectLoweringReducer>::Run<true>(temp_zone);
+                 SelectLoweringReducer>::Run(temp_zone);
   }
 }
 
diff --git a/deps/v8/src/compiler/turboshaft/machine-optimization-reducer.h b/deps/v8/src/compiler/turboshaft/machine-optimization-reducer.h
@@ -1333,23 +1333,53 @@ class MachineOptimizationReducer : public Next {
         if (matcher.MatchConstantShiftRightArithmeticShiftOutZeros(
                 left, &x, rep_w, &k1) &&
             matcher.MatchIntegralWordConstant(right, rep_w, &k2) &&
-            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);
+            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);
+            }
+          }
         }
         // 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 &&
-            matcher.Get(right).saturated_use_count.IsZero()) {
-          return __ Comparison(
-              __ WordConstant(base::bits::Unsigned(k2) << k1, rep_w), x, kind,
-              rep_w);
+            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);
+            }
+          }
         }
       }
       // Map 64bit to 32bit comparisons.
diff --git a/deps/v8/src/compiler/turboshaft/optimize-phase.cc b/deps/v8/src/compiler/turboshaft/optimize-phase.cc
@@ -30,7 +30,7 @@ void OptimizePhase::Run(Zone* temp_zone) {
                            turboshaft::MemoryOptimizationReducer,
                            turboshaft::MachineOptimizationReducer,
                            turboshaft::RequiredOptimizationReducer,
-                           turboshaft::ValueNumberingReducer>::Run<true>(temp_zone);
+                           turboshaft::ValueNumberingReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/simplified-lowering-phase.cc b/deps/v8/src/compiler/turboshaft/simplified-lowering-phase.cc
@@ -10,7 +10,7 @@
 namespace v8::internal::compiler::turboshaft {
 
 void SimplifiedLoweringPhase::Run(Zone* temp_zone) {
-  CopyingPhase<SimplifiedLoweringReducer, VariableReducerHotfix>::Run<false>(temp_zone);
+  CopyingPhase<SimplifiedLoweringReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/simplified-lowering-reducer.h b/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 = MapImpl(op.frame_state());
-    V<Word32> left = ProcessInput(MapImpl(op.left()), Rep::Word32(),
+    OpIndex frame_state = Map(op.frame_state());
+    V<Word32> left = ProcessInput(Map(op.left()), Rep::Word32(),
                                   CheckKind::kSigned32, frame_state);
-    V<Word32> right = ProcessInput(MapImpl(op.right()), Rep::Word32(),
+    V<Word32> right = ProcessInput(Map(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, MapImpl(op.frame_state()),
+    __ DeoptimizeIf(overflow, Map(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(MapImpl(input), Rep::Tagged(), CheckKind::kNone, {}));
+          ProcessInput(Map(input), Rep::Tagged(), CheckKind::kNone, {}));
     }
 
-    __ Return(MapImpl(ret.pop_count()), base::VectorOf(return_values));
+    __ Return(Map(ret.pop_count()), base::VectorOf(return_values));
     return OpIndex::Invalid();
   }
 
@@ -94,7 +94,7 @@ class SimplifiedLoweringReducer : public Next {
     }
   }
 
-  inline OpIndex MapImpl(OpIndex ig_index) { return __ MapToNewGraph(ig_index); }
+  inline OpIndex Map(OpIndex ig_index) { return __ MapToNewGraph(ig_index); }
 };
 
 #include "src/compiler/turboshaft/undef-assembler-macros.inc"
diff --git a/deps/v8/src/compiler/turboshaft/store-store-elimination-phase.cc b/deps/v8/src/compiler/turboshaft/store-store-elimination-phase.cc
@@ -23,7 +23,7 @@ void StoreStoreEliminationPhase::Run(Zone* temp_zone) {
                            turboshaft::MachineOptimizationReducer,
                            turboshaft::RequiredOptimizationReducer,
                            turboshaft::BranchEliminationReducer,
-                           turboshaft::ValueNumberingReducer>::Run<true>(temp_zone);
+                           turboshaft::ValueNumberingReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/type-assertions-phase.cc b/deps/v8/src/compiler/turboshaft/type-assertions-phase.cc
@@ -23,8 +23,7 @@ void TypeAssertionsPhase::Run(Zone* temp_zone) {
 
   turboshaft::CopyingPhase<turboshaft::AssertTypesReducer,
                            turboshaft::ValueNumberingReducer,
-                           turboshaft::VariableReducerHotfix,
-                           turboshaft::TypeInferenceReducer>::Run<false>(temp_zone);
+                           turboshaft::TypeInferenceReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/typed-optimizations-phase.cc b/deps/v8/src/compiler/turboshaft/typed-optimizations-phase.cc
@@ -23,8 +23,7 @@ void TypedOptimizationsPhase::Run(Zone* temp_zone) {
       turboshaft::TypeInferenceReducerArgs::OutputGraphTyping::kNone};
 
   turboshaft::CopyingPhase<turboshaft::TypedOptimizationsReducer,
-                           turboshaft::VariableReducerHotfix,
-                           turboshaft::TypeInferenceReducer>::Run<false>(temp_zone);
+                           turboshaft::TypeInferenceReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/wasm-dead-code-elimination-phase.cc b/deps/v8/src/compiler/turboshaft/wasm-dead-code-elimination-phase.cc
@@ -28,8 +28,7 @@ void WasmDeadCodeEliminationPhase::Run(Zone* temp_zone) {
                // (which, for simplificy, doesn't use the Assembler helper
                // methods, but only calls Next::ReduceLoad/Store).
                DuplicationOptimizationReducer,
-               ValueNumberingReducer,
-               VariableReducerHotfix>::Run<false>(temp_zone);
+               ValueNumberingReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/wasm-gc-optimize-phase.cc b/deps/v8/src/compiler/turboshaft/wasm-gc-optimize-phase.cc
@@ -15,7 +15,7 @@ namespace v8::internal::compiler::turboshaft {
 void WasmGCOptimizePhase::Run(Zone* temp_zone) {
   UnparkedScopeIfNeeded scope(PipelineData::Get().broker(),
                               v8_flags.turboshaft_trace_reduction);
-  CopyingPhase<WasmLoadEliminationReducer, WasmGCTypeReducer, VariableReducerHotfix>::Run<false>(temp_zone);
+  CopyingPhase<WasmLoadEliminationReducer, WasmGCTypeReducer>::Run(temp_zone);
 }
 
 }  // namespace v8::internal::compiler::turboshaft
diff --git a/deps/v8/src/compiler/turboshaft/wasm-lowering-phase.cc b/deps/v8/src/compiler/turboshaft/wasm-lowering-phase.cc
diff --git a/deps/v8/src/compiler/turboshaft/wasm-optimize-phase.cc b/deps/v8/src/compiler/turboshaft/wasm-optimize-phase.cc
diff --git a/deps/v8/src/compiler/turboshaft/wasm-revec-phase.cc b/deps/v8/src/compiler/turboshaft/wasm-revec-phase.cc
diff --git a/deps/v8/src/heap/heap.cc b/deps/v8/src/heap/heap.cc
diff --git a/deps/v8/src/objects/dictionary.h b/deps/v8/src/objects/dictionary.h
diff --git a/deps/v8/src/objects/fixed-array.h b/deps/v8/src/objects/fixed-array.h
diff --git a/deps/v8/src/objects/hash-table-inl.h b/deps/v8/src/objects/hash-table-inl.h
diff --git a/deps/v8/src/objects/hash-table.h b/deps/v8/src/objects/hash-table.h
diff --git a/deps/v8/src/objects/objects.cc b/deps/v8/src/objects/objects.cc
diff --git a/deps/v8/src/objects/template-objects.cc b/deps/v8/src/objects/template-objects.cc

Original file line number	Diff line number	Diff line change
`@@ -9455,7 +9455,7 @@ void CodeStubAssembler::NameDictionaryLookup(`
`9455`	`9455`	`CAST(UnsafeLoadFixedArrayElement(dictionary, index));`
`9456`	`9456`	`GotoIf(TaggedEqual(current, undefined), if_not_found);`
`9457`	`9457`	`if (mode == kFindExisting) {`
`9458`		`- if (Dictionary::ShapeT::kMatchNeedsHoleCheck) {`
	`9458`	`+ if (Dictionary::TodoShape::kMatchNeedsHoleCheck) {`
`9459`	`9459`	`GotoIf(TaggedEqual(current, TheHoleConstant()), &next_probe);`
`9460`	`9460`	`}`
`9461`	`9461`	`current = LoadName<Dictionary>(current);`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,7 @@ void CodeEliminationAndSimplificationPhase::Run(Zone* temp_zone) {`
`32`	`32`	`// (which, for simplificy, doesn't use the Assembler helper`
`33`	`33`	`// methods, but only calls Next::ReduceLoad/Store).`
`34`	`34`	`DuplicationOptimizationReducer,`
`35`		`- ValueNumberingReducer,`
`36`		`- VariableReducerHotfix>::Run<false>(temp_zone);`
	`35`	`+ ValueNumberingReducer>::Run(temp_zone);`
`37`	`36`	`}`
`38`	`37`
`39`	`38`	`} // namespace v8::internal::compiler::turboshaft`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace v8::internal::compiler::turboshaft {`
`11`	`11`
`12`	`12`	`void DebugFeatureLoweringPhase::Run(Zone* temp_zone) {`
`13`	`13`	`#ifdef V8_ENABLE_DEBUG_CODE`
`14`		`- turboshaft::CopyingPhase<turboshaft::DebugFeatureLoweringReducer>::Run<false>(`
	`14`	`+ turboshaft::CopyingPhase<turboshaft::DebugFeatureLoweringReducer>::Run(`
`15`	`15`	`temp_zone);`
`16`	`16`	`#endif`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ void LoopPeelingPhase::Run(Zone* temp_zone) {`
`23`	`23`	`turboshaft::VariableReducer,`
`24`	`24`	`turboshaft::MachineOptimizationReducer,`
`25`	`25`	`turboshaft::RequiredOptimizationReducer,`
`26`		`- turboshaft::ValueNumberingReducer>::Run<true>(temp_zone);`
	`26`	`+ turboshaft::ValueNumberingReducer>::Run(temp_zone);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`} // namespace v8::internal::compiler::turboshaft`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ void LoopUnrollingPhase::Run(Zone* temp_zone) {`
`22`	`22`	`turboshaft::VariableReducer,`
`23`	`23`	`turboshaft::MachineOptimizationReducer,`
`24`	`24`	`turboshaft::RequiredOptimizationReducer,`
`25`		`- turboshaft::ValueNumberingReducer>::Run<true>(temp_zone);`
	`25`	`+ turboshaft::ValueNumberingReducer>::Run(temp_zone);`
`26`	`26`	`PipelineData::Get().clear_loop_unrolling_analyzer();`
`27`	`27`	`}`
`28`	`28`	`}`