Commit 057830c6299 for nodejs

commit 057830c6299ad81f5fc5355471d8eb73e8750c3c
Author: Node.js GitHub Bot <github-bot@iojs.org>
Date:   Mon Nov 16 19:58:14 2026 -0500

    deps: patch V8 to 15.6.75.60

    Refs: https://github.com/v8/v8/compare/15.6.75.50...15.6.75.60
    PR-URL: https://github.com/nodejs/node/pull/67479
    Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
    Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>
    Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
    Reviewed-By: Chengzhong Wu <legendecas@gmail.com>

diff --git a/deps/v8/include/v8-version.h b/deps/v8/include/v8-version.h
index 0101d125766..8d2e7f41771 100644
--- a/deps/v8/include/v8-version.h
+++ b/deps/v8/include/v8-version.h
@@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 15
 #define V8_MINOR_VERSION 6
 #define V8_BUILD_NUMBER 75
-#define V8_PATCH_LEVEL 50
+#define V8_PATCH_LEVEL 60

 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
diff --git a/deps/v8/src/baseline/baseline-compiler.cc b/deps/v8/src/baseline/baseline-compiler.cc
index b09ed33e008..b45a1942ac9 100644
--- a/deps/v8/src/baseline/baseline-compiler.cc
+++ b/deps/v8/src/baseline/baseline-compiler.cc
@@ -1882,27 +1882,25 @@ void BaselineCompiler::VisitIntrinsicAsyncFunctionResolve(

 void BaselineCompiler::VisitIntrinsicGeneratorYieldResult(
     interpreter::RegisterList args) {
-  Register value = WriteBarrierDescriptor::ValueRegister();
   Register generator = WriteBarrierDescriptor::ObjectRegister();
-  DCHECK(!AreAliased(value, generator, kInterpreterAccumulatorRegister));
+  DCHECK(!AreAliased(generator, kInterpreterAccumulatorRegister));

   Label allocate, done;

   __ LoadRegister(generator, args[1]);  // generator

-  // Check whether the generator user asked to skip result allocation
-  // (yielded_value_ == TheHole).
+  // Check whether the caller asked to skip result allocation
+  // (resume_mode_ == kNextTrySkipAlloc).
   __ LoadTaggedField(kInterpreterAccumulatorRegister, generator,
-                     offsetof(JSGeneratorObject, yielded_value_));
-  __ JumpIfNotRoot(kInterpreterAccumulatorRegister, RootIndex::kTheHoleValue,
-                   &allocate);
-
-  // Skip allocation: store value into yielded_value_.
-  __ LoadRegister(value, args[0]);  // value
-  __ StoreTaggedFieldWithWriteBarrier(
-      generator, offsetof(JSGeneratorObject, yielded_value_), value);
-
-  __ LoadRoot(kInterpreterAccumulatorRegister, RootIndex::kTheHoleValue);
+                     offsetof(JSGeneratorObject, resume_mode_));
+  __ JumpIfSmi(kNotEqual, kInterpreterAccumulatorRegister,
+               Smi::FromInt(JSGeneratorObject::kNextTrySkipAlloc), &allocate);
+
+  // Skip allocation: ack handshake and return bare value.
+  __ StoreTaggedSignedField(generator,
+                            offsetof(JSGeneratorObject, resume_mode_),
+                            Smi::FromInt(JSGeneratorObject::kNextAllocSkipped));
+  __ LoadRegister(kInterpreterAccumulatorRegister, args[0]);  // value
   __ Jump(&done);

   __ Bind(&allocate);
diff --git a/deps/v8/src/builtins/builtins-generator-gen.cc b/deps/v8/src/builtins/builtins-generator-gen.cc
index c407accc24a..cce7df4fe5e 100644
--- a/deps/v8/src/builtins/builtins-generator-gen.cc
+++ b/deps/v8/src/builtins/builtins-generator-gen.cc
@@ -122,6 +122,10 @@ void GeneratorBuiltinsAssembler::InnerResume(
       case JSGeneratorObject::kRethrow:
         // Currently only async generators use this mode.
         UNREACHABLE();
+      case JSGeneratorObject::kNextTrySkipAlloc:
+      case JSGeneratorObject::kNextAllocSkipped:
+        // Handshake states only set by optimized callers or the generator body.
+        UNREACHABLE();
     }
     args->PopAndReturn(builtin_result);
   }
diff --git a/deps/v8/src/builtins/generator.tq b/deps/v8/src/builtins/generator.tq
index 8f8fd2d5c97..44cbd2a45ee 100644
--- a/deps/v8/src/builtins/generator.tq
+++ b/deps/v8/src/builtins/generator.tq
@@ -19,8 +19,6 @@ transitioning javascript builtin GeneratorPrototypeNextLazyDeoptContinuation(
     js-implicit context: NativeContext, receiver: JSAny)(generator: JSAny,
     exception: JSAny|TheHole, result: JSAny): JSAny {
   const gen = UnsafeCast<JSGeneratorObject>(generator);
-  const yieldedValue = gen.yielded_value;
-  gen.yielded_value = Undefined;

   // Exception path: close the generator and rethrow.
   typeswitch (exception) {
@@ -36,15 +34,13 @@ transitioning javascript builtin GeneratorPrototypeNextLazyDeoptContinuation(
   // continuation is now kGeneratorExecuting; close it and wrap the result.
   // Otherwise (yielded), return the result as-is.
   if (gen.continuation == SmiConstant(kGeneratorExecuting)) {
-    dcheck(result != TheHole);
     gen.continuation = SmiConstant(kGeneratorClosed);
     return AllocateJSIteratorResult(result, True);
   }

   // Allocating the iterator result object was skipped; allocate it here.
-  if (result == TheHole) {
-    const val = (yieldedValue == TheHole) ? Undefined : yieldedValue;
-    return AllocateJSIteratorResult(val, False);
+  if (gen.resume_mode == SmiConstant(kGeneratorResumeModeNextAllocSkipped)) {
+    return AllocateJSIteratorResult(result, False);
   }

   return result;
diff --git a/deps/v8/src/codegen/compiler.cc b/deps/v8/src/codegen/compiler.cc
index 7a965c17292..378a43860df 100644
--- a/deps/v8/src/codegen/compiler.cc
+++ b/deps/v8/src/codegen/compiler.cc
@@ -2177,6 +2177,11 @@ class ConstantPoolPointerForwarder {
     }
   }

+  bool HasScopeInfoToUpdate(Tagged<ScopeInfo> scope_info) const {
+    return scope_infos_to_update_.find(scope_info->UniqueIdInScript()) !=
+           scope_infos_to_update_.end();
+  }
+
   void UpdateStandaloneScopeInfo(Tagged<ScopeInfo> scope_info) {
     if (!scope_info->HasOuterScopeInfo()) return;

@@ -2354,6 +2359,23 @@ void VerifyCodeMerge(Isolate* isolate, DirectHandle<Script> script) {
   //   * All constant pool SFI entries point to an SFI referring to the old
   //     script (i.e. references were updated correctly).
   std::unordered_map<int, Tagged<ScopeInfo>> scope_infos;
+  auto verify_scope_info = [&](Tagged<ScopeInfo> scope_info) {
+    while (true) {
+      auto it = scope_infos.find(scope_info->UniqueIdInScript());
+      if (it != scope_infos.end()) {
+        if (it->second != scope_info) {
+          isolate->PushParamsAndDie("duplicate scope info unique id",
+                                    reinterpret_cast<void*>(it->second.ptr()),
+                                    reinterpret_cast<void*>(scope_info.ptr()));
+          UNREACHABLE();
+        }
+        break;
+      }
+      scope_infos[scope_info->UniqueIdInScript()] = scope_info;
+      if (!scope_info->HasOuterScopeInfo()) break;
+      scope_info = scope_info->OuterScopeInfo();
+    }
+  };
   uint32_t script_infos_len = script->infos()->ulength().value();
   for (uint32_t info_idx = 0; info_idx < script_infos_len; info_idx++) {
     Tagged<ScopeInfo> scope_info;
@@ -2377,6 +2399,8 @@ void VerifyCodeMerge(Isolate* isolate, DirectHandle<Script> script) {
             int id = inner_sfi->function_literal_id(kRelaxedLoad);
             CHECK_EQ(MakeWeak(inner_sfi), script->infos()->get(id));
             CHECK_EQ(inner_sfi->script(), *script);
+          } else if (Is<ScopeInfo>(entry)) {
+            verify_scope_info(Cast<ScopeInfo>(entry));
           }
         }
       }
@@ -2391,21 +2415,7 @@ void VerifyCodeMerge(Isolate* isolate, DirectHandle<Script> script) {
     } else {
       scope_info = Cast<ScopeInfo>(info);
     }
-    while (true) {
-      auto it = scope_infos.find(scope_info->UniqueIdInScript());
-      if (it != scope_infos.end()) {
-        if (it->second != scope_info) {
-          isolate->PushParamsAndDie("duplicate scope info unique id",
-                                    reinterpret_cast<void*>(it->second.ptr()),
-                                    reinterpret_cast<void*>(scope_info.ptr()));
-          UNREACHABLE();
-        }
-        break;
-      }
-      scope_infos[scope_info->UniqueIdInScript()] = scope_info;
-      if (!scope_info->HasOuterScopeInfo()) break;
-      scope_info = scope_info->OuterScopeInfo();
-    }
+    verify_scope_info(scope_info);
   }
 }
 }  // namespace
@@ -2553,6 +2563,9 @@ void BackgroundMergeTask::BeginMergeInBackground(
     for (DirectHandle<SharedFunctionInfo> new_sfi : used_new_sfis_) {
       forwarder.UpdateScopeInfo(*new_sfi);
     }
+    for (DirectHandle<ScopeInfo> new_scope : used_new_scope_infos_) {
+      forwarder.UpdateStandaloneScopeInfo(*new_scope);
+    }
     for (const auto& new_compiled_data : new_compiled_data_for_cached_sfis_) {
       // It's possible that new_compiled_data.cached_sfi had
       // scope_info()->IsEmpty() while an inner function has scope info if the
@@ -2659,6 +2672,14 @@ Handle<SharedFunctionInfo> BackgroundMergeTask::CompleteMergeInForeground(
         compiled_data_it++;
       }
     } else if (!maybe_old_info.IsWeak()) {
+      // Standalone eval ScopeInfos are only recorded for scopes within their
+      // owning closure, so if the slot in old_script was cleared, the ScopeInfo
+      // itself cannot still be alive in old_script.
+      DCHECK_IMPLIES(
+          maybe_new_info.IsWeak() &&
+              Is<ScopeInfo>(maybe_new_info.GetHeapObjectAssumeWeak()),
+          !forwarder.HasScopeInfoToUpdate(
+              Cast<ScopeInfo>(maybe_new_info.GetHeapObjectAssumeWeak())));
       old_script->infos()->set(i, maybe_new_info, kReleaseStore);
     }
   }
diff --git a/deps/v8/src/common/assert-scope.h b/deps/v8/src/common/assert-scope.h
index ca36c690d4a..2dcb5b05f4c 100644
--- a/deps/v8/src/common/assert-scope.h
+++ b/deps/v8/src/common/assert-scope.h
@@ -75,21 +75,25 @@ class V8_NODISCARD PerThreadAssertScope

 // Per-isolate assert scopes.

-#define PER_ISOLATE_DCHECK_TYPE(V, enable)                              \
-  /* Scope to document where we do not expect javascript execution. */  \
-  /* Scope to introduce an exception to DisallowJavascriptExecution. */ \
-  V(AllowJavascriptExecution, DisallowJavascriptExecution,              \
-    javascript_execution_assert, enable)                                \
-  /* Scope to document where we do not expect deoptimization. */        \
-  /* Scope to introduce an exception to DisallowDeoptimization. */      \
-  V(AllowDeoptimization, DisallowDeoptimization, deoptimization_assert, \
-    enable)                                                             \
-  /* Scope to document where we do not expect deoptimization. */        \
-  /* Scope to introduce an exception to DisallowDeoptimization. */      \
-  V(AllowCompilation, DisallowCompilation, compilation_assert, enable)  \
-  /* Scope to document where we do not expect exceptions. */            \
-  /* Scope to introduce an exception to DisallowExceptions. */          \
-  V(AllowExceptions, DisallowExceptions, no_exception_assert, enable)
+#define PER_ISOLATE_DCHECK_TYPE(V, enable)                                \
+  /* Scope to document where we do not expect javascript execution. */    \
+  /* Scope to introduce an exception to DisallowJavascriptExecution. */   \
+  V(AllowJavascriptExecution, DisallowJavascriptExecution,                \
+    javascript_execution_assert, enable)                                  \
+  /* Scope to document where we do not expect deoptimization. */          \
+  /* Scope to introduce an exception to DisallowDeoptimization. */        \
+  V(AllowDeoptimization, DisallowDeoptimization, deoptimization_assert,   \
+    enable)                                                               \
+  /* Scope to document where we do not expect deoptimization. */          \
+  /* Scope to introduce an exception to DisallowDeoptimization. */        \
+  V(AllowCompilation, DisallowCompilation, compilation_assert, enable)    \
+  /* Scope to document where we do not expect exceptions. */              \
+  /* Scope to introduce an exception to DisallowExceptions. */            \
+  V(AllowExceptions, DisallowExceptions, no_exception_assert, enable)     \
+  /* Scope to document where we do not expect JS object modifications. */ \
+  /* Scope to introduce an exception to DisallowJSObjectModification. */  \
+  V(AllowJSObjectModification, DisallowJSObjectModification,              \
+    js_object_modification_assert, enable)

 #define PER_ISOLATE_CHECK_TYPE(V, enable)                                    \
   /* Scope in which javascript execution leads to exception being thrown. */ \
diff --git a/deps/v8/src/compiler/backend/register-allocator.cc b/deps/v8/src/compiler/backend/register-allocator.cc
index 6e85eca1299..b4bbdbbe72a 100644
--- a/deps/v8/src/compiler/backend/register-allocator.cc
+++ b/deps/v8/src/compiler/backend/register-allocator.cc
@@ -4406,8 +4406,9 @@ void LinearScanAllocator::AllocateBlockedReg(LiveRange* current,
     InstructionBlock* deferred_block =
         code()->GetInstructionBlock(current->Start().ToInstructionIndex());
     new_end =
-        std::min(new_end, LifetimePosition::GapFromInstructionIndex(
-                              LastDeferredInstructionIndex(deferred_block)));
+        std::min(new_end, LifetimePosition::InstructionFromInstructionIndex(
+                              LastDeferredInstructionIndex(deferred_block))
+                              .NextFullStart());
   }

   // We couldn't spill until the next register use. Split before the register
diff --git a/deps/v8/src/compiler/escape-analysis-reducer.cc b/deps/v8/src/compiler/escape-analysis-reducer.cc
index 4d54bdf1baa..1b83aca3b58 100644
--- a/deps/v8/src/compiler/escape-analysis-reducer.cc
+++ b/deps/v8/src/compiler/escape-analysis-reducer.cc
@@ -309,6 +309,7 @@ void EscapeAnalysisReducer::Finalize() {
               NodeProperties::SetType(load, Type::None());
               NodeProperties::SetType(dead_value, Type::None());
               NodeProperties::ReplaceUses(load, dead_value, load);
+              NodeProperties::ReplaceValueInput(dead_value, load, 0);
               continue;
             }

diff --git a/deps/v8/src/compiler/simplified-operator.cc b/deps/v8/src/compiler/simplified-operator.cc
index 80159d7cc65..47a492b0136 100644
--- a/deps/v8/src/compiler/simplified-operator.cc
+++ b/deps/v8/src/compiler/simplified-operator.cc
@@ -1167,9 +1167,12 @@ struct SimplifiedOperatorGlobalCache final {
   DEOPTIMIZE_REASON_LIST(CHECK_IF)
 #undef CHECK_IF

+  // Looking up a string key can internalize it in place into a ThinString,
+  // so Operator::kNoWrite (and thus Operator::kEliminatable) does not hold.
   struct FindOrderedHashMapEntryOperator final : public Operator {
     FindOrderedHashMapEntryOperator()
-        : Operator(IrOpcode::kFindOrderedHashMapEntry, Operator::kEliminatable,
+        : Operator(IrOpcode::kFindOrderedHashMapEntry,
+                   Operator::kNoThrow | Operator::kNoDeopt,
                    "FindOrderedHashMapEntry", 2, 1, 1, 1, 1, 0) {}
   };
   FindOrderedHashMapEntryOperator kFindOrderedHashMapEntry;
@@ -1183,9 +1186,12 @@ struct SimplifiedOperatorGlobalCache final {
   FindOrderedHashMapEntryForInt32KeyOperator
       kFindOrderedHashMapEntryForInt32Key;

+  // Looking up a string key can internalize it in place into a ThinString,
+  // so Operator::kNoWrite (and thus Operator::kEliminatable) does not hold.
   struct FindOrderedHashSetEntryOperator final : public Operator {
     FindOrderedHashSetEntryOperator()
-        : Operator(IrOpcode::kFindOrderedHashSetEntry, Operator::kEliminatable,
+        : Operator(IrOpcode::kFindOrderedHashSetEntry,
+                   Operator::kNoThrow | Operator::kNoDeopt,
                    "FindOrderedHashSetEntry", 2, 1, 1, 1, 1, 0) {}
   };
   FindOrderedHashSetEntryOperator kFindOrderedHashSetEntry;
diff --git a/deps/v8/src/compiler/turboshaft/builtin-call-descriptors.h b/deps/v8/src/compiler/turboshaft/builtin-call-descriptors.h
index 9a72d2862a6..c514fece5b9 100644
--- a/deps/v8/src/compiler/turboshaft/builtin-call-descriptors.h
+++ b/deps/v8/src/compiler/turboshaft/builtin-call-descriptors.h
@@ -300,15 +300,19 @@ struct builtin : CallDescriptorBuilder {
     static constexpr auto kFunction = B;
     struct Arguments : ArgumentsBase {
       ARG(V<Object>, table)
-      ARG(V<Smi>, key)
+      ARG(V<Object>, key)
     };
     using returns_t = std::tuple<V<Smi>>;

     static constexpr bool kCanTriggerLazyDeopt = false;
     static constexpr bool kNeedsContext = true;
-    static constexpr Operator::Properties kProperties = Operator::kEliminatable;
-    static constexpr OpEffects kEffects =
-        base_effects.AssumesConsistentHeap().CanReadMemory().CanAllocate();
+    static constexpr Operator::Properties kProperties =
+        Operator::kNoThrow | Operator::kNoDeopt;
+    // Looking up a string key can internalize it in place into a ThinString.
+    static constexpr OpEffects kEffects = base_effects.AssumesConsistentHeap()
+                                              .CanReadMemory()
+                                              .CanWriteHeapMemory()
+                                              .CanAllocate();
   };
   using FindOrderedHashMapEntry =
       FindOrderedHashEntry<Builtin::kFindOrderedHashMapEntry>;
diff --git a/deps/v8/src/compiler/turboshaft/late-load-elimination-reducer.cc b/deps/v8/src/compiler/turboshaft/late-load-elimination-reducer.cc
index 1a3e7d73aa4..b4e8819028a 100644
--- a/deps/v8/src/compiler/turboshaft/late-load-elimination-reducer.cc
+++ b/deps/v8/src/compiler/turboshaft/late-load-elimination-reducer.cc
@@ -247,6 +247,12 @@ void LateLoadEliminationAnalyzer::ProcessBlock(const Block& block,
         break;

       case Opcode::kCatchBlockBegin:
+        // Throwing an exception can have arbitrary side effects (e.g., via
+        // debugger pause-on-exception), even when the throwing operation itself
+        // does not have `can_write` effects on its non-throwing path.
+        memory_.InvalidateMaybeAliasing();
+        break;
+
       case Opcode::kRetain:
       case Opcode::kDidntThrow:
       case Opcode::kCheckException:
diff --git a/deps/v8/src/compiler/turboshaft/operations.h b/deps/v8/src/compiler/turboshaft/operations.h
index 4d62936f230..6e87f793f6a 100644
--- a/deps/v8/src/compiler/turboshaft/operations.h
+++ b/deps/v8/src/compiler/turboshaft/operations.h
@@ -7478,8 +7478,22 @@ struct FindOrderedHashEntryOp
   };
   Kind kind;

-  static constexpr OpEffects effects =
-      OpEffects().CanDependOnChecks().CanReadMemory().CanAllocate();
+  OpEffects Effects() const {
+    switch (kind) {
+      case Kind::kFindOrderedHashMapEntry:
+      case Kind::kFindOrderedHashSetEntry:
+        // Looking up a string key can internalize it in place into a
+        // ThinString, overwriting its payload (e.g., ConsString::first_).
+        return OpEffects()
+            .CanDependOnChecks()
+            .CanReadMemory()
+            .CanWriteHeapMemory()
+            .CanAllocate();
+      case Kind::kFindOrderedHashMapEntryForInt32Key:
+        return OpEffects().CanDependOnChecks().CanReadMemory();
+    }
+    UNREACHABLE();
+  }
   base::Vector<const RegisterRepresentation> outputs_rep() const {
     switch (kind) {
       case Kind::kFindOrderedHashMapEntry:
@@ -11092,6 +11106,8 @@ inline OpEffects Operation::Effects() const {
       return Cast<StoreOp>().Effects();
     case Opcode::kCall:
       return Cast<CallOp>().Effects();
+    case Opcode::kFindOrderedHashEntry:
+      return Cast<FindOrderedHashEntryOp>().Effects();
     case Opcode::kDidntThrow:
       return Cast<DidntThrowOp>().Effects();
     case Opcode::kTaggedBitcast:
diff --git a/deps/v8/src/compiler/turboshaft/wasm-load-elimination-reducer.cc b/deps/v8/src/compiler/turboshaft/wasm-load-elimination-reducer.cc
index f5de6b1b0fd..7d04cbb2ac6 100644
--- a/deps/v8/src/compiler/turboshaft/wasm-load-elimination-reducer.cc
+++ b/deps/v8/src/compiler/turboshaft/wasm-load-elimination-reducer.cc
@@ -141,11 +141,21 @@ void WasmLoadEliminationAnalyzer::ProcessBlock(const Block& block,
           memory_.InvalidateMutableSharedBase();
         }
         break;
+      case Opcode::kCatchBlockBegin:
+        // Throwing an exception can have arbitrary side effects (e.g., via
+        // debugger pause-on-exception), even when the throwing operation itself
+        // does not have `can_write` effects on its non-throwing path.
+        memory_.InvalidateMaybeAliasing();
+        break;
+
+      case Opcode::kGlobalSet:
+        InvalidateIfAlias(op.Cast<GlobalSetOp>().value());
+        break;
+
       case Opcode::kMemoryCopy:
       case Opcode::kMemoryFill:
         // These should never operate on GC objects.
       case Opcode::kAssumeMap:
-      case Opcode::kCatchBlockBegin:
       case Opcode::kRetain:
       case Opcode::kDidntThrow:
       case Opcode::kCheckException:
@@ -153,7 +163,6 @@ void WasmLoadEliminationAnalyzer::ProcessBlock(const Block& block,
       case Opcode::kJSStackCheck:
       case Opcode::kWasmStackCheck:
       case Opcode::kSimd128LaneMemory:
-      case Opcode::kGlobalSet:
       case Opcode::kWasmIncCoverageCounter:
       case Opcode::kParameter:
       case Opcode::kSetStackPointer:
@@ -360,6 +369,10 @@ void WasmLoadEliminationAnalyzer::ProcessStore(OpIndex op_idx,
     // among threads.
     memory_.InvalidateMutableSharedBase();
   }
+
+  // Updating aliases if the value stored was known as non-aliasing (e.g.,
+  // storing a struct reference into an exception values array).
+  InvalidateIfAlias(op.value());
 }

 void WasmLoadEliminationAnalyzer::ProcessArrayGet(OpIndex op_idx,
@@ -469,9 +482,6 @@ void WasmLoadEliminationAnalyzer::ProcessCall(OpIndex op_idx,
   // Some builtins do not create aliases and do not invalidate existing
   // memory, and some even return fresh objects. For such cases, we don't
   // invalidate the state, and record the non-alias if any.
-  if (!op.Effects().can_write()) {
-    return;
-  }
   // TODO(jkummerow): Add special handling to builtins that are known not to
   // have relevant side effects. Alternatively, specify their effects to not
   // include `CanWriteMemory()`.
@@ -489,9 +499,12 @@ void WasmLoadEliminationAnalyzer::ProcessCall(OpIndex op_idx,
 #endif
   // Not a builtin call, or not a builtin that we know doesn't invalidate
   // memory.
-
   InvalidateAllNonAliasingInputs(op);

+  if (!op.Effects().can_write()) {
+    return;
+  }
+
   // The call could modify arbitrary memory, so we invalidate every
   // potentially-aliasing object.
   memory_.InvalidateMaybeAliasing();
diff --git a/deps/v8/src/compiler/verifier.cc b/deps/v8/src/compiler/verifier.cc
index 39d2dbced49..2552221cd7e 100644
--- a/deps/v8/src/compiler/verifier.cc
+++ b/deps/v8/src/compiler/verifier.cc
@@ -303,6 +303,7 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
       UNREACHABLE();
     case IrOpcode::kDeadValue:
       CheckValueInputIs(node, 0, Type::None());
+      CHECK_NE(NodeProperties::GetValueInput(node, 0), node);
       CheckTypeIs(node, Type::None());
       break;
     case IrOpcode::kUnreachable:
diff --git a/deps/v8/src/diagnostics/objects-printer.cc b/deps/v8/src/diagnostics/objects-printer.cc
index 96fb166732a..6686aeb620a 100644
--- a/deps/v8/src/diagnostics/objects-printer.cc
+++ b/deps/v8/src/diagnostics/objects-printer.cc
@@ -948,16 +948,25 @@ void JSGeneratorObject::JSGeneratorObjectPrint(std::ostream& os) {
     os << "\n - debug pos: " << Brief(input_or_debug_pos());
   }
   const char* mode = "(invalid)";
-  switch (resume_mode()) {
+  switch (static_cast<ResumeMode>(resume_mode())) {
     case kNext:
       mode = ".next()";
       break;
+    case kNextTrySkipAlloc:
+      mode = ".next() (try skip alloc)";
+      break;
     case kReturn:
       mode = ".return()";
       break;
     case kThrow:
       mode = ".throw()";
       break;
+    case kRethrow:
+      mode = ".throw() (rethrow)";
+      break;
+    case kNextAllocSkipped:
+      mode = ".next() (alloc skipped)";
+      break;
   }
   os << "\n - resume mode: " << mode;
   os << "\n - continuation: " << continuation();
diff --git a/deps/v8/src/execution/isolate.h b/deps/v8/src/execution/isolate.h
index f8c0c95e78f..a847348731c 100644
--- a/deps/v8/src/execution/isolate.h
+++ b/deps/v8/src/execution/isolate.h
@@ -544,6 +544,7 @@ using DebugObjectCache = std::vector<Handle<HeapObject>>;
   V(bool, deoptimization_assert, true)                                      \
   V(bool, compilation_assert, true)                                         \
   V(bool, no_exception_assert, true)                                        \
+  V(bool, js_object_modification_assert, true)                              \
   V(uint32_t, wasm_switch_to_the_central_stack_counter, 0)

 #define THREAD_LOCAL_TOP_ACCESSOR(type, name)                         \
diff --git a/deps/v8/src/handles/global-handles.cc b/deps/v8/src/handles/global-handles.cc
index fa3079d554f..33199ff1597 100644
--- a/deps/v8/src/handles/global-handles.cc
+++ b/deps/v8/src/handles/global-handles.cc
@@ -744,6 +744,7 @@ void GlobalHandles::ProcessWeakYoungObjects(

 void GlobalHandles::InvokeSecondPassPhantomCallbacks() {
   DCHECK(!AllowJavascriptExecution::IsAllowed(isolate()));
+  DCHECK(!AllowJSObjectModification::IsAllowed(isolate()));
   DCHECK(AllowGarbageCollection::IsAllowed());

   if (second_pass_callbacks_.empty()) return;
@@ -855,6 +856,8 @@ size_t GlobalHandles::InvokeFirstPassWeakCallbacks() {

 void GlobalHandles::PendingPhantomCallback::Invoke(Isolate* isolate,
                                                    InvocationType type) {
+  DCHECK(!AllowJavascriptExecution::IsAllowed(isolate));
+  DCHECK(!AllowJSObjectModification::IsAllowed(isolate));
   Data::Callback* callback_addr = nullptr;
   if (type == kFirstPass) {
     callback_addr = &callback_;
@@ -894,6 +897,7 @@ void GlobalHandles::PostGarbageCollectionProcessing(
           DCHECK(second_pass_callbacks_task_posted_);
           second_pass_callbacks_task_posted_ = false;
           DisallowJavascriptExecution no_js(isolate());
+          DisallowJSObjectModification no_js_object_modification(isolate());
           InvokeSecondPassPhantomCallbacks();
         }));
   }
diff --git a/deps/v8/src/heap/cppgc-js/cpp-heap.cc b/deps/v8/src/heap/cppgc-js/cpp-heap.cc
index c1de0c1c279..c23ec777922 100644
--- a/deps/v8/src/heap/cppgc-js/cpp-heap.cc
+++ b/deps/v8/src/heap/cppgc-js/cpp-heap.cc
@@ -556,33 +556,42 @@ namespace {

 class SweepingOnMutatorThreadForGlobalHandlesScope final {
  public:
-  explicit SweepingOnMutatorThreadForGlobalHandlesScope(
-      TracedHandles& traced_handles)
-      : traced_handles_(traced_handles) {
-    traced_handles_.SetIsSweepingOnMutatorThread(true);
+  explicit SweepingOnMutatorThreadForGlobalHandlesScope(Isolate& isolate)
+      : isolate_(isolate),
+        no_js_(&isolate),
+        no_js_object_modification_(&isolate) {
+    isolate_.traced_handles()->SetIsSweepingOnMutatorThread(true);
   }
   ~SweepingOnMutatorThreadForGlobalHandlesScope() {
-    traced_handles_.SetIsSweepingOnMutatorThread(false);
+    isolate_.traced_handles()->SetIsSweepingOnMutatorThread(false);
   }

-  TracedHandles& traced_handles_;
+ private:
+  Isolate& isolate_;
+  // Mutator-thread sweeping runs CppHeap pre-finalizers and C++ destructors
+  // (both during the atomic pause and outside it via incremental sweep tasks or
+  // lazy sweeping on Oilpan allocation). Disallow JS execution and JSObject
+  // modification during these embedder finalizers.
+  DisallowJavascriptExecution no_js_;
+  DisallowJSObjectModification no_js_object_modification_;
 };

 class SweepingOnMutatorThreadForGlobalHandlesObserver final
     : public cppgc::internal::Sweeper::SweepingOnMutatorThreadObserver {
  public:
   SweepingOnMutatorThreadForGlobalHandlesObserver(CppHeap& cpp_heap,
-                                                  TracedHandles& traced_handles)
+                                                  Isolate& isolate)
       : cppgc::internal::Sweeper::SweepingOnMutatorThreadObserver(
             cpp_heap.sweeper()),
-        traced_handles_(traced_handles) {}
+        isolate_(isolate) {}

-  void Start() override { traced_handles_.SetIsSweepingOnMutatorThread(true); }
+  void Start() override { scope_.emplace(isolate_); }

-  void End() override { traced_handles_.SetIsSweepingOnMutatorThread(false); }
+  void End() override { scope_.reset(); }

  private:
-  TracedHandles& traced_handles_;
+  Isolate& isolate_;
+  std::optional<SweepingOnMutatorThreadForGlobalHandlesScope> scope_;
 };

 class MoveListenerImpl final : public HeapProfilerNativeMoveListener,
@@ -644,7 +653,7 @@ void CppHeap::AttachIsolate(Isolate* isolate) {
   UpdateGCCapabilitiesFromFlags();
   sweeping_on_mutator_thread_observer_ =
       std::make_unique<SweepingOnMutatorThreadForGlobalHandlesObserver>(
-          *this, *isolate_->traced_handles());
+          *this, *isolate_);
   no_gc_scope_--;

   // Propagate overridden stack state to the attached heap, if necessary.
@@ -994,6 +1003,10 @@ void CppHeap::FinishMarkingAndProcessWeakness() {

   {
     cppgc::subtle::DisallowGarbageCollectionScope disallow_gc_scope(*this);
+    if (isolate_) {
+      DCHECK(!AllowJavascriptExecution::IsAllowed(isolate_));
+      DCHECK(!AllowJSObjectModification::IsAllowed(isolate_));
+    }
     marker_->LeaveAtomicPause();
   }
   marker_.reset();
@@ -1031,7 +1044,7 @@ void CppHeap::CompactAndSweep() {
     std::optional<SweepingOnMutatorThreadForGlobalHandlesScope>
         global_handles_scope;
     if (isolate_) {
-      global_handles_scope.emplace(*isolate_->traced_handles());
+      global_handles_scope.emplace(*isolate_);
     }
     bytes_allocated_in_prefinalizers = ExecutePreFinalizers();
   }
@@ -1058,7 +1071,7 @@ void CppHeap::CompactAndSweep() {
       std::optional<SweepingOnMutatorThreadForGlobalHandlesScope>
           global_handles_scope;
       if (isolate_) {
-        global_handles_scope.emplace(*isolate_->traced_handles());
+        global_handles_scope.emplace(*isolate_);
       }
       compactable_space_handling = compactor_.CompactSpacesIfEnabled();
     }
diff --git a/deps/v8/src/heap/gc-callbacks.h b/deps/v8/src/heap/gc-callbacks.h
index e40e6b7de9b..ddc8c877af2 100644
--- a/deps/v8/src/heap/gc-callbacks.h
+++ b/deps/v8/src/heap/gc-callbacks.h
@@ -39,6 +39,10 @@ class GCCallbacks final {
     AllowGarbageCollection scope;
     for (const CallbackData& callback_data : callbacks_) {
       if (gc_type & callback_data.gc_type) {
+        Isolate* isolate = reinterpret_cast<Isolate*>(callback_data.isolate);
+        USE(isolate);
+        DCHECK(!AllowJavascriptExecution::IsAllowed(isolate));
+        DCHECK(!AllowJSObjectModification::IsAllowed(isolate));
         callback_data.callback(callback_data.isolate, gc_type,
                                gc_callback_flags, callback_data.user_data);
       }
diff --git a/deps/v8/src/heap/heap.cc b/deps/v8/src/heap/heap.cc
index 420c631486d..75481a0745c 100644
--- a/deps/v8/src/heap/heap.cc
+++ b/deps/v8/src/heap/heap.cc
@@ -1419,6 +1419,7 @@ namespace {
 template <typename Callback>
 void InvokeExternalCallbacks(Isolate* isolate, Callback callback) {
   DCHECK(!AllowJavascriptExecution::IsAllowed(isolate));
+  DCHECK(!AllowJSObjectModification::IsAllowed(isolate));
   AllowGarbageCollection allow_gc;
   // Temporary override any embedder stack state as callbacks may create
   // their own state on the stack and recursively trigger GC.
@@ -1466,8 +1467,14 @@ void Heap::CollectGarbage(
   // collection is triggered. Note that these callbacks may trigger another
   // garbage collection since they may allocate.

-  // JS execution is not allowed in any of the callbacks.
+  // JS execution and object modifications are not allowed during GC or in any
+  // of the embedder callbacks triggered below: first-pass weak callbacks
+  // (GlobalHandles::InvokeFirstPassWeakCallbacks), second-pass phantom
+  // callbacks (PostGarbageCollectionProcessing), GC prologue and epilogue
+  // callbacks (v8::Isolate::GCCallback), and CppHeap pre-finalizers and object
+  // finalizers (C++ destructors).
   DisallowJavascriptExecution no_js(isolate());
+  DisallowJSObjectModification no_js_object_modification(isolate());

   // Some custom flushing (currently: FlushBytecodeFromSFI) can create
   // fresh TrustedPointerTableEntries during GC. These must not be affected
@@ -1829,6 +1836,13 @@ void Heap::StartIncrementalMarking(GCFlags gc_flags,
     return;
   }

+  // Completing sweeping below may trigger embedder CppHeap object finalizers
+  // (C++ destructors, via FinishSweepingIfRunning / FinishSweepingIfOutOfWork),
+  // and incremental_marking()->Start() triggers embedder GC prologue and
+  // epilogue callbacks.
+  DisallowJavascriptExecution no_js(isolate());
+  DisallowJSObjectModification no_js_object_modification(isolate());
+
   TRACE_EVENT(
       "v8",
       perfetto::StaticString(IsYoungGenerationCollector(collector)
diff --git a/deps/v8/src/interpreter/bytecode-generator.cc b/deps/v8/src/interpreter/bytecode-generator.cc
index f6651020361..1d5a0334e74 100644
--- a/deps/v8/src/interpreter/bytecode-generator.cc
+++ b/deps/v8/src/interpreter/bytecode-generator.cc
@@ -1618,6 +1618,7 @@ void BytecodeGenerator::AllocateDeferredConstants(IsolateT* isolate,
   }

   for (std::pair<Call*, Scope*> call : eval_calls_) {
+    DCHECK_EQ(call.second->GetClosureScope(), closure_scope());
     Tagged<ScopeInfo> current;
     int index = call.first->eval_scope_info_index();
     if (script->infos()
@@ -6171,11 +6172,16 @@ void BytecodeGenerator::VisitYield(Yield* expr) {
   builder()->StoreAccumulatorInRegister(input).CallRuntime(
       Runtime::kInlineGeneratorGetResumeMode, generator_object());

-  // Now dispatch on resume mode.
-  static_assert(JSGeneratorObject::kNext + 1 == JSGeneratorObject::kReturn);
+  // Now dispatch on resume mode. kNextAllocSkipped is never observed here;
+  // every resume path overwrites resume_mode_ first.
+  static_assert(JSGeneratorObject::kNext + 1 ==
+                JSGeneratorObject::kNextTrySkipAlloc);
+  static_assert(JSGeneratorObject::kNextTrySkipAlloc + 1 ==
+                JSGeneratorObject::kReturn);
   static_assert(JSGeneratorObject::kReturn + 1 == JSGeneratorObject::kThrow);
+  static_assert(JSGeneratorObject::kThrow + 1 == JSGeneratorObject::kRethrow);
   BytecodeJumpTable* jump_table =
-      builder()->AllocateJumpTable(is_async ? 3 : 2, JSGeneratorObject::kNext);
+      builder()->AllocateJumpTable(is_async ? 4 : 3, JSGeneratorObject::kNext);

   builder()->SwitchOnSmiNoFeedback(jump_table);

@@ -6213,6 +6219,7 @@ void BytecodeGenerator::VisitYield(Yield* expr) {
   {
     // Resume with next.
     builder()->Bind(jump_table, JSGeneratorObject::kNext);
+    builder()->Bind(jump_table, JSGeneratorObject::kNextTrySkipAlloc);
     BuildIncrementBlockCoverageCounterIfEnabled(expr,
                                                 SourceRangeKind::kContinuation);
     builder()->LoadAccumulatorWithRegister(input);
@@ -6322,8 +6329,10 @@ void BytecodeGenerator::VisitYieldStar(YieldStar* expr) {

       {
         BytecodeLabels after_switch(zone());
+        // The table is based at kReturn, so every mode below it (the whole
+        // kNext family) falls through to the default case below.
         BytecodeJumpTable* switch_jump_table =
-            builder()->AllocateJumpTable(2, 1);
+            builder()->AllocateJumpTable(2, JSGeneratorObject::kReturn);

         builder()
             ->LoadAccumulatorWithRegister(resume_mode)
@@ -6331,8 +6340,11 @@ void BytecodeGenerator::VisitYieldStar(YieldStar* expr) {

         // Fallthrough to default case.
         // TODO(ignition): Add debug code to check that {resume_mode} really is
-        // {JSGeneratorObject::kNext} in this case.
-        static_assert(JSGeneratorObject::kNext == 0);
+        // {JSGeneratorObject::kNext} or
+        // {JSGeneratorObject::kNextTrySkipAlloc} in this case.
+        static_assert(JSGeneratorObject::kNext < JSGeneratorObject::kReturn);
+        static_assert(JSGeneratorObject::kNextTrySkipAlloc <
+                      JSGeneratorObject::kReturn);
         {
           FeedbackSlot slot = feedback_spec()->AddCallICSlot();
           builder()->CallProperty(iterator.next(), iterator_and_input,
@@ -6340,7 +6352,8 @@ void BytecodeGenerator::VisitYieldStar(YieldStar* expr) {
           builder()->Jump(after_switch.New());
         }

-        static_assert(JSGeneratorObject::kReturn == 1);
+        static_assert(JSGeneratorObject::kReturn + 1 ==
+                      JSGeneratorObject::kThrow);
         builder()->Bind(switch_jump_table, JSGeneratorObject::kReturn);
         {
           const AstRawString* return_string =
@@ -6361,7 +6374,6 @@ void BytecodeGenerator::VisitYieldStar(YieldStar* expr) {
           }
         }

-        static_assert(JSGeneratorObject::kThrow == 2);
         builder()->Bind(switch_jump_table, JSGeneratorObject::kThrow);
         {
           const AstRawString* throw_string =
@@ -6491,7 +6503,8 @@ void BytecodeGenerator::BuildAwait(int position) {
   Register input = register_allocator()->NewRegister();
   Register resume_mode = register_allocator()->NewRegister();

-  // Now dispatch on resume mode.
+  // Now dispatch on resume mode. The skip-allocation handshake is only set on
+  // JS_GENERATOR_OBJECT_TYPE receivers, which never await.
   BytecodeLabel resume_next;
   builder()
       ->StoreAccumulatorInRegister(input)
@@ -7073,7 +7086,8 @@ void BytecodeGenerator::VisitCall(Call* expr) {
       private_name_lookup_skips_outer_class =
           scope_with_context->AsClassScope()->IsParsingHeritage();
     }
-    if (scope_with_context) {
+    if (scope_with_context &&
+        scope_with_context->IsOuterScopeUpToClosureScopeOf(current_scope())) {
       eval_calls_.emplace_back(expr, scope_with_context);
     }
     int eval_flags = ResolveEvalFlags::Encode(
diff --git a/deps/v8/src/interpreter/interpreter-intrinsics-generator.cc b/deps/v8/src/interpreter/interpreter-intrinsics-generator.cc
index 9a2521ddcfe..b3b786851bc 100644
--- a/deps/v8/src/interpreter/interpreter-intrinsics-generator.cc
+++ b/deps/v8/src/interpreter/interpreter-intrinsics-generator.cc
@@ -157,19 +157,20 @@ TNode<Object> IntrinsicsGenerator::GeneratorYieldResult(
   compiler::TypedCodeAssemblerVariable<Object> result(assembler_);
   compiler::CodeAssemblerLabel allocate(assembler_), allocate_done(assembler_);

-  // Check if yielded_value_ is TheHole (signaling to skip allocating the result
-  // object.
-  TNode<Object> current_yielded_value = assembler_->LoadObjectField(
-      assembler_->CAST(generator), offsetof(JSGeneratorObject, yielded_value_));
-  assembler_->GotoIf(assembler_->TaggedNotEqual(current_yielded_value,
-                                                assembler_->TheHoleConstant()),
-                     &allocate);
-
-  // Store value
-  assembler_->StoreObjectField(assembler_->CAST(generator),
-                               offsetof(JSGeneratorObject, yielded_value_),
-                               value);
-  result = assembler_->TheHoleConstant();
+  // Check whether the caller asked to skip result allocation
+  // (resume_mode_ == kNextTrySkipAlloc).
+  TNode<Object> mode = assembler_->LoadObjectField(
+      assembler_->CAST(generator), offsetof(JSGeneratorObject, resume_mode_));
+  assembler_->GotoIf(
+      assembler_->TaggedNotEqual(
+          mode, assembler_->SmiConstant(JSGeneratorObject::kNextTrySkipAlloc)),
+      &allocate);
+
+  // Skip allocation: ack handshake and return bare value.
+  assembler_->StoreObjectField(
+      assembler_->CAST(generator), offsetof(JSGeneratorObject, resume_mode_),
+      assembler_->SmiConstant(JSGeneratorObject::kNextAllocSkipped));
+  result = value;
   assembler_->Goto(&allocate_done);

   assembler_->Bind(&allocate);
diff --git a/deps/v8/src/maglev/maglev-graph-builder.cc b/deps/v8/src/maglev/maglev-graph-builder.cc
index 05a3fa8fcb5..69fe4b26b5e 100644
--- a/deps/v8/src/maglev/maglev-graph-builder.cc
+++ b/deps/v8/src/maglev/maglev-graph-builder.cc
@@ -516,11 +516,13 @@ void MaglevGraphBuilder::MaglevSubGraphBuilder::EndLoop(LoopLabel* loop_label) {

 void MaglevGraphBuilder::MaglevSubGraphBuilder::Bind(Label* label) {
   DCHECK_NULL(builder_->current_block());
+  CHECK_NOT_NULL(label->variable_merge_state_);

   DCHECK_NULL(variable_frame_.known_node_aspects());
   variable_frame_.CopyFrom(*dummy_unit_, *label->variable_merge_state_);

   if (label->ShouldTrackInterpreterFrameState()) {
+    DCHECK_NOT_NULL(label->merge_state_);
     DCHECK_EQ(*label->future_bind_offset_,
               builder_->iterator_.current_offset());
     builder_->current_interpreter_frame_.CopyFrom(*compilation_unit(),
@@ -545,6 +547,9 @@ void MaglevGraphBuilder::MaglevSubGraphBuilder::Bind(Label* label) {
   builder_->ProcessMergePointPredecessors(*label->variable_merge_state_,
                                           label->ref_);
   builder_->StartNewBlock(nullptr, label->variable_merge_state_, label->ref_);
+
+  label->variable_merge_state_ = nullptr;
+  label->merge_state_ = nullptr;
 }

 template <typename FCond, typename FTrue, typename FFalse>
@@ -8421,6 +8426,10 @@ MaybeReduceResult MaglevGraphBuilder::TryReduceGeneratorPrototypeNext(
   ValueNode* executing_constant =
       GetSmiConstant(JSGeneratorObject::kGeneratorExecuting);
   ValueNode* next_constant = GetSmiConstant(JSGeneratorObject::kNext);
+  ValueNode* try_skip_alloc_constant =
+      GetSmiConstant(JSGeneratorObject::kNextTrySkipAlloc);
+  ValueNode* alloc_skipped_constant =
+      GetSmiConstant(JSGeneratorObject::kNextAllocSkipped);

   // If any of the constants have an empty type, we're in dead code, and the
   // write barrier elision logic inside StoreTaggedFieldNoWriteBarrier will be
@@ -8431,13 +8440,14 @@ MaybeReduceResult MaglevGraphBuilder::TryReduceGeneratorPrototypeNext(
   ABORT_IF_EMPTY_TYPE(closed_constant);
   ABORT_IF_EMPTY_TYPE(executing_constant);
   ABORT_IF_EMPTY_TYPE(next_constant);
-
-  // The fast path below asks the generator to store the yielded value into
-  // yielded_value_ rather than allocate a result object, and rebuilds the
-  // object here as a VirtualObject that escape analysis can then elide. A
-  // current try-catch block, either in this function or in a caller we were
-  // inlined into, defeats that as would pay for the protocol and allocate
-  // anyway.
+  ABORT_IF_EMPTY_TYPE(try_skip_alloc_constant);
+  ABORT_IF_EMPTY_TYPE(alloc_skipped_constant);
+
+  // The fast path below asks the generator to hand back the bare yielded value
+  // rather than allocate a result object, and rebuilds the object here as a
+  // VirtualObject that escape analysis can then elide. A current try-catch
+  // block, either in this function or in a caller we were inlined into,
+  // defeats that as would pay for the protocol and allocate anyway.
   const bool can_skip_allocation = GetCurrentTryCatchBlock().ref == nullptr;

   MaglevSubGraphBuilder::Label generator_already_closed(&subgraph, 1);
@@ -8459,19 +8469,12 @@ MaybeReduceResult MaglevGraphBuilder::TryReduceGeneratorPrototypeNext(
       AssertCondition::kNotEqual, DeoptimizeReason::kWrongValue));

   CHECK(BuildStoreTaggedFieldNoWriteBarrier(
-            receiver, next_constant, offsetof(JSGeneratorObject, resume_mode_),
+            receiver,
+            can_skip_allocation ? try_skip_alloc_constant : next_constant,
+            offsetof(JSGeneratorObject, resume_mode_),
             StoreTaggedMode::kDefault)
             .IsDoneWithoutAbort());

-  // Tell the generator to skip allocating the result object if possible.
-  if (can_skip_allocation) {
-    CHECK(BuildStoreTaggedFieldNoWriteBarrier(
-              receiver, GetRootConstant(RootIndex::kTheHoleValue),
-              offsetof(JSGeneratorObject, yielded_value_),
-              StoreTaggedMode::kDefault)
-              .IsDoneWithoutAbort());
-  }
-
   ValueNode* result;
   {
     LazyDeoptFrameScope lazy_deopt_scope(
@@ -8502,33 +8505,23 @@ MaybeReduceResult MaglevGraphBuilder::TryReduceGeneratorPrototypeNext(

   if (can_skip_allocation) {
     MaglevSubGraphBuilder::Label allocation_not_skipped(&subgraph, 1);
-    ValueNode* yielded_value;
-    GET_VALUE(yielded_value,
-              BuildLoadTaggedField(
-                  receiver, offsetof(JSGeneratorObject, yielded_value_)));
-    // We unconditionally clear yielded_value_ here. If the generator did
-    // not hit the GeneratorYieldResult intrinsic (if it suspended via
-    // yield*), yielded_value_ would still hold TheHole. If it leaked to JS
-    // space (e.g., on a subsequent unoptimized next() call), it could cause
-    // a crash when JS attempts to access its properties.
-    CHECK(BuildStoreTaggedFieldNoWriteBarrier(
-              receiver, GetRootConstant(RootIndex::kUndefinedValue),
-              offsetof(JSGeneratorObject, yielded_value_),
-              StoreTaggedMode::kDefault)
-              .IsDoneWithoutAbort());

     // Check whether skipping allocating the result object was successful.
+    ValueNode* generator_mode;
+    GET_VALUE(generator_mode,
+              BuildLoadTaggedField(receiver,
+                                   offsetof(JSGeneratorObject, resume_mode_)));
     CHECK(subgraph
-              .GotoIfFalse<BranchIfRootConstant>(
-                  &allocation_not_skipped, {result}, RootIndex::kTheHoleValue)
+              .GotoIfFalse<BranchIfReferenceEqual>(
+                  &allocation_not_skipped,
+                  {generator_mode, alloc_skipped_constant})
               .IsDoneWithoutAbort());

-    // Was able to avoid allocating the result object. Use
-    // yielded_value from the generator object.
+    // Was able to avoid allocating the result object.
     compiler::MapRef map =
         broker()->target_native_context().iterator_result_map(broker());
-    VirtualObject* iter_result = reducer_.CreateJSIteratorResult(
-        map, yielded_value, GetBooleanConstant(false));
+    VirtualObject* iter_result =
+        reducer_.CreateJSIteratorResult(map, result, GetBooleanConstant(false));
     ValueNode* alloc_result;
     GET_VALUE(alloc_result, reducer_.BuildInlinedAllocation(
                                 iter_result, AllocationType::kYoung));
@@ -12353,12 +12346,12 @@ ReduceResult MaglevGraphBuilder::VisitIntrinsicGeneratorYieldResult(
   compiler::MapRef map =
       broker()->target_native_context().iterator_result_map(broker());

-  // Check if yielded_value_ is TheHole (signaling to skip allocating the result
-  // object).
-  ValueNode* current_yielded_value;
-  GET_VALUE_OR_ABORT(current_yielded_value,
-                     BuildLoadTaggedField(generator, offsetof(JSGeneratorObject,
-                                                              yielded_value_)));
+  // Check whether the caller asked to skip result allocation
+  // (resume_mode_ == kNextTrySkipAlloc).
+  ValueNode* mode;
+  GET_VALUE_OR_ABORT(
+      mode, BuildLoadTaggedField(generator,
+                                 offsetof(JSGeneratorObject, resume_mode_)));

   Subgraph<MaglevGraphBuilder> subgraph(&reducer_, 1);
   Subgraph<MaglevGraphBuilder>::Variable ret_val(0);
@@ -12366,14 +12359,17 @@ ReduceResult MaglevGraphBuilder::VisitIntrinsicGeneratorYieldResult(
   RETURN_IF_ABORT(subgraph.Branch(
       {&ret_val},
       [&](BranchBuilder& builder) {
-        return BuildBranchIfRootConstant(builder, current_yielded_value,
-                                         RootIndex::kTheHoleValue);
+        return BuildBranchIfReferenceEqual(
+            builder, mode,
+            GetSmiConstant(JSGeneratorObject::kNextTrySkipAlloc));
       },
       [&] {
+        // Skip allocation: ack handshake and return bare value.
         RETURN_IF_ABORT(BuildStoreTaggedField(
-            generator, value, offsetof(JSGeneratorObject, yielded_value_),
+            generator, GetSmiConstant(JSGeneratorObject::kNextAllocSkipped),
+            offsetof(JSGeneratorObject, resume_mode_),
             StoreTaggedMode::kDefault));
-        subgraph.set(ret_val, GetRootConstant(RootIndex::kTheHoleValue));
+        subgraph.set(ret_val, value);
         return ReduceResult::Done();
       },
       [&] {
diff --git a/deps/v8/src/maglev/maglev-graph-optimizer.cc b/deps/v8/src/maglev/maglev-graph-optimizer.cc
index e0e64964a52..259732b5a51 100644
--- a/deps/v8/src/maglev/maglev-graph-optimizer.cc
+++ b/deps/v8/src/maglev/maglev-graph-optimizer.cc
@@ -389,8 +389,10 @@ void Subgraph<MaglevGraphOptimizer>::Goto(Label* label) {

 void Subgraph<MaglevGraphOptimizer>::Bind(Label* label) {
   DCHECK_NULL(reducer_->current_block());
-  DCHECK_NOT_NULL(label->variable_merge_state_);
+  CHECK_NOT_NULL(label->variable_merge_state_);
+  DCHECK_NULL(label->merge_state_);
   MergePointInterpreterFrameState* merge_state = label->variable_merge_state_;
+  label->variable_merge_state_ = nullptr;
   DCHECK_EQ(merge_state->predecessors_so_far(), label->predecessor_count_);
   DCHECK_GT(label->predecessor_count_, 0);

diff --git a/deps/v8/src/maglev/maglev-ir.h b/deps/v8/src/maglev/maglev-ir.h
index a2badf6c94c..c1b16a84349 100644
--- a/deps/v8/src/maglev/maglev-ir.h
+++ b/deps/v8/src/maglev/maglev-ir.h
@@ -7975,9 +7975,11 @@ class MapPrototypeGet : public FixedInputValueNodeT<2, MapPrototypeGet> {
  public:
   explicit MapPrototypeGet(uint64_t bitfield) : Base(bitfield) {}

+  // Looking up a string key can allocate and internalize the key in place.
   static constexpr OpProperties kProperties =
       OpProperties::Call() | OpProperties::CanAllocate() |
-      OpProperties::CanRead() | OpProperties::TaggedValue();
+      OpProperties::CanRead() | OpProperties::CanWrite() |
+      OpProperties::TaggedValue();
   DECLARE_INPUTS(Table, Key)
   DECLARE_INPUT_TYPES(Tagged, Tagged)

@@ -8009,11 +8011,11 @@ class SetPrototypeHas : public FixedInputValueNodeT<2, SetPrototypeHas> {
  public:
   explicit SetPrototypeHas(uint64_t bitfield) : Base(bitfield) {}

-  // CanAllocate is needed, since finding strings in hash tables does an
-  // equality comparison which flattens strings.
+  // Looking up a string key can allocate and internalize the key in place.
   static constexpr OpProperties kProperties =
       OpProperties::Call() | OpProperties::CanAllocate() |
-      OpProperties::CanRead() | OpProperties::TaggedValue();
+      OpProperties::CanRead() | OpProperties::CanWrite() |
+      OpProperties::TaggedValue();
   DECLARE_INPUTS(Table, Key)
   DECLARE_INPUT_TYPES(Tagged, Tagged)

diff --git a/deps/v8/src/maglev/maglev-reducer.h b/deps/v8/src/maglev/maglev-reducer.h
index ef286e3e6b1..300a29365fc 100644
--- a/deps/v8/src/maglev/maglev-reducer.h
+++ b/deps/v8/src/maglev/maglev-reducer.h
@@ -1928,6 +1928,21 @@ class SubgraphBase {
     // NOLINTNEXTLINE(runtime/explicit)
     Label(const LabelForTrackingInterpreterFrameState& label);

+    Label(const Label&) = delete;
+    Label(Label&&) = delete;
+    Label& operator=(const Label&) = delete;
+    Label& operator=(Label&&) = delete;
+
+    ~Label() {
+      // If variable_merge_state_ is non-null, at least one finalized BasicBlock
+      // in the graph has a control node whose BasicBlockRef is linked into
+      // `ref_` (in kRefList state) waiting for Bind() to resolve it to a target
+      // BasicBlock*. Destroying an unbound Label with live predecessors would
+      // leave dangling BasicBlockRef* pointers in the graph.
+      CHECK_NULL(variable_merge_state_);
+      DCHECK_NULL(merge_state_);
+    }
+
     BasicBlockRef* ref() { return &ref_; }
     int predecessor_count() const { return predecessor_count_; }
     bool ShouldTrackInterpreterFrameState() const {
diff --git a/deps/v8/src/objects/js-generator.h b/deps/v8/src/objects/js-generator.h
index 874ab784e84..428231e898a 100644
--- a/deps/v8/src/objects/js-generator.h
+++ b/deps/v8/src/objects/js-generator.h
@@ -23,7 +23,14 @@ V8_OBJECT class JSGeneratorObject : public JSObject {
   V8_IT_OWN_TYPE;

  public:
-  enum ResumeMode { kNext, kReturn, kThrow, kRethrow };
+  enum ResumeMode {
+    kNext,
+    kNextTrySkipAlloc,
+    kReturn,
+    kThrow,
+    kRethrow,
+    kNextAllocSkipped
+  };

   inline Tagged<JSFunction> function() const;
   inline void set_function(Tagged<JSFunction> value,
diff --git a/deps/v8/src/objects/js-generator.tq b/deps/v8/src/objects/js-generator.tq
index 77ca66a8167..f4384965c5e 100644
--- a/deps/v8/src/objects/js-generator.tq
+++ b/deps/v8/src/objects/js-generator.tq
@@ -9,6 +9,8 @@ const kGeneratorClosed:
     constexpr int31 generates 'JSGeneratorObject::kGeneratorClosed';
 const kGeneratorResumeModeNext:
     constexpr int31 generates 'JSGeneratorObject::kNext';
+const kGeneratorResumeModeNextAllocSkipped:
+    constexpr int31 generates 'JSGeneratorObject::kNextAllocSkipped';
 const kGeneratorResumeModeThrow:
     constexpr int31 generates 'JSGeneratorObject::kThrow';

diff --git a/deps/v8/src/objects/js-objects.cc b/deps/v8/src/objects/js-objects.cc
index 69e7d3101a5..ce77a72da60 100644
--- a/deps/v8/src/objects/js-objects.cc
+++ b/deps/v8/src/objects/js-objects.cc
@@ -968,6 +968,7 @@ void JSReceiver::DeleteNormalizedProperty(DirectHandle<JSReceiver> object,
                                           InternalIndex entry) {
   DCHECK(!object->HasFastProperties());
   Isolate* isolate = Isolate::Current();
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   DCHECK(entry.is_found());

   if (IsJSGlobalObject(*object)) {
@@ -2866,6 +2867,7 @@ Maybe<bool> JSObject::SetNormalizedProperty(DirectHandle<JSObject> object,
   DCHECK(!object->HasFastProperties());
   DCHECK(IsUniqueName(*name));
   Isolate* isolate = Isolate::Current();
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));

   uint32_t hash = name->hash();

@@ -3557,6 +3559,7 @@ void MigrateFastToSlow(Isolate* isolate, DirectHandle<JSObject> object,
 void JSObject::MigrateToMap(Isolate* isolate, DirectHandle<JSObject> object,
                             DirectHandle<Map> new_map,
                             int expected_additional_properties) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   if (object->map() == *new_map) return;
   DirectHandle<Map> old_map(object->map(), isolate);
   NotifyMapChange(old_map, new_map, isolate);
@@ -3995,9 +3998,10 @@ void JSObject::NormalizeProperties(Isolate* isolate,
 void JSObject::MigrateSlowToFast(DirectHandle<JSObject> object,
                                  int unused_property_fields,
                                  const char* reason) {
+  Isolate* isolate = Isolate::Current();
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   if (object->HasFastProperties()) return;
   DCHECK(!IsJSGlobalObject(*object));
-  Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();

   DirectHandle<NameDictionary> dictionary;
@@ -5515,6 +5519,7 @@ Maybe<bool> JSObject::SetPrototype(Isolate* isolate,
 // static
 void JSObject::SetImmutableProto(Isolate* isolate,
                                  DirectHandle<JSObject> object) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   DirectHandle<Map> map(object->map(), isolate);

   // Nothing to do if prototype is already set.
@@ -5611,6 +5616,7 @@ Maybe<bool> JSObject::AddDataElement(Isolate* isolate,
                                      DirectHandle<JSObject> object,
                                      uint32_t index, DirectHandle<Object> value,
                                      PropertyAttributes attributes) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   DCHECK(object->map()->is_extensible());

   uint32_t old_length = 0;
diff --git a/deps/v8/src/objects/lookup.cc b/deps/v8/src/objects/lookup.cc
index 872d78cc45b..27af06bca45 100644
--- a/deps/v8/src/objects/lookup.cc
+++ b/deps/v8/src/objects/lookup.cc
@@ -433,6 +433,7 @@ void LookupIterator::InternalUpdateProtector(
 }

 void LookupIterator::PrepareForDataProperty(DirectHandle<Object> value) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate_));
   DCHECK(state_ == DATA || state_ == ACCESSOR);
   DCHECK(HolderIsReceiverOrHiddenPrototype());
   DCHECK(!IsWasmObject(*receiver_));
@@ -565,6 +566,7 @@ void LookupIterator::PrepareForDataProperty(DirectHandle<Object> value) {

 void LookupIterator::ReconfigureDataProperty(DirectHandle<Object> value,
                                              PropertyAttributes attributes) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate_));
   DCHECK(state_ == DATA || state_ == ACCESSOR);
   DCHECK(HolderIsReceiverOrHiddenPrototype());

@@ -733,6 +735,7 @@ void LookupIterator::PrepareTransitionToDataProperty(
 Maybe<bool> LookupIterator::ApplyTransitionToDataProperty(
     DirectHandle<JSTransitionableReceiver> receiver,
     Maybe<ShouldThrow> should_throw) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate_));
   DCHECK_EQ(TRANSITION, state_);

   DCHECK_IMPLIES(!receiver.is_identical_to(GetStoreTarget<JSReceiver>()),
@@ -827,6 +830,7 @@ Maybe<bool> LookupIterator::ApplyTransitionToDataProperty(
 }

 void LookupIterator::Delete() {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate_));
   DirectHandle<JSReceiver> holder = Cast<JSReceiver>(holder_);
   if (IsElement(*holder)) {
     DirectHandle<JSObject> object = Cast<JSObject>(holder);
diff --git a/deps/v8/src/objects/map-inl.h b/deps/v8/src/objects/map-inl.h
index 63cfe9edd10..ff8f439cf17 100644
--- a/deps/v8/src/objects/map-inl.h
+++ b/deps/v8/src/objects/map-inl.h
@@ -959,6 +959,7 @@ void Map::clear_padding() {
 }

 void Map::AppendDescriptor(Isolate* isolate, Descriptor* desc) {
+  DCHECK(AllowJSObjectModification::IsAllowed(isolate));
   Tagged<DescriptorArray> descriptors = instance_descriptors();
   int number_of_own_descriptors = NumberOfOwnDescriptors();
   DCHECK(descriptors->number_of_descriptors() == number_of_own_descriptors);
diff --git a/deps/v8/src/objects/map-updater.cc b/deps/v8/src/objects/map-updater.cc
index 84999a3a34d..e9112f7713b 100644
--- a/deps/v8/src/objects/map-updater.cc
+++ b/deps/v8/src/objects/map-updater.cc
@@ -1268,6 +1268,7 @@ void MapUpdater::UpdateFieldType(Isolate* isolate, DirectHandle<Map> map,
                                  PropertyConstness new_constness,
                                  Representation new_representation,
                                  DirectHandle<FieldType> new_type) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   // We store raw pointers in the queue, so no allocations are allowed.
   DisallowGarbageCollection no_gc;
   PropertyDetails details = map->instance_descriptors()->GetDetails(descriptor);
diff --git a/deps/v8/src/objects/map.cc b/deps/v8/src/objects/map.cc
index cdc41455019..f10d4647fd6 100644
--- a/deps/v8/src/objects/map.cc
+++ b/deps/v8/src/objects/map.cc
@@ -709,6 +709,7 @@ Map::FieldCounts Map::GetFieldCounts() const {
 }

 void Map::DeprecateTransitionTree(Isolate* isolate) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   DCHECK(CanBeDeprecated());
   return DeprecateTransitionTreeImpl(isolate);
 }
@@ -736,6 +737,7 @@ void Map::DeprecateTransitionTreeImpl(Isolate* isolate) {
 // proper sharing of descriptor arrays.
 void Map::ReplaceDescriptors(Isolate* isolate,
                              Tagged<DescriptorArray> new_descriptors) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   // Don't overwrite the empty descriptor array or initial map's descriptors.
   if (NumberOfOwnDescriptors() == 0 || IsUndefined(GetBackPointer())) {
     return;
@@ -912,6 +914,7 @@ DirectHandle<Map> Map::Update(Isolate* isolate, DirectHandle<Map> map) {

 void Map::EnsureDescriptorSlack(Isolate* isolate, DirectHandle<Map> map,
                                 int slack) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   // Only supports adding slack to owned descriptors.
   CHECK(map->owns_descriptors());

@@ -1628,6 +1631,7 @@ void Map::ConnectTransition(Isolate* isolate, DirectHandle<Map> parent,
                             DirectHandle<Map> child, DirectHandle<Name> name,
                             TransitionKindFlag transition_kind,
                             bool force_connect) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   DCHECK_EQ(parent->map(), child->map());
   DCHECK_IMPLIES(name->IsInteresting(isolate),
                  child->may_have_interesting_properties());
diff --git a/deps/v8/src/objects/transitions.cc b/deps/v8/src/objects/transitions.cc
index 0c0ac419f30..5f79fea14e8 100644
--- a/deps/v8/src/objects/transitions.cc
+++ b/deps/v8/src/objects/transitions.cc
@@ -413,6 +413,7 @@ bool TransitionsAccessor::PutPrototypeTransition(Isolate* isolate,
                                                  DirectHandle<Map> map,
                                                  DirectHandle<Object> prototype,
                                                  DirectHandle<Map> target_map) {
+  CHECK(AllowJSObjectModification::IsAllowed(isolate));
   DCHECK(IsUndefined(map->GetBackPointer()));
   DCHECK_NE(map->prototype(), *prototype);
   DCHECK(IsMap(Cast<HeapObject>(*prototype)->map()));
diff --git a/deps/v8/src/runtime/runtime-compiler.cc b/deps/v8/src/runtime/runtime-compiler.cc
index f195b42d310..f37efcfbb01 100644
--- a/deps/v8/src/runtime/runtime-compiler.cc
+++ b/deps/v8/src/runtime/runtime-compiler.cc
@@ -857,11 +857,15 @@ static Tagged<Object> CompileGlobalEval(
   DirectHandle<JSFunction> compiled;
   DirectHandle<Context> context(isolate->context(), isolate);
   if (!Is<NativeContext>(*context)) {
-    Tagged<WeakFixedArray> array = Cast<Script>(outer_info->script())->infos();
+    Tagged<Script> script = Cast<Script>(outer_info->script());
+    Tagged<WeakFixedArray> array = script->infos();
     Tagged<ScopeInfo> stored_info;
-    CHECK(array->get(eval_scope_info_index)
-              .GetHeapObjectIfWeak(isolate, &stored_info));
-    CHECK_EQ(stored_info, context->scope_info());
+    if (array->get(eval_scope_info_index)
+            .GetHeapObjectIfWeak(isolate, &stored_info)) {
+      CHECK_EQ(stored_info, context->scope_info());
+    } else {
+      CHECK_EQ(outer_info->GetOuterScopeInfo(), context->scope_info());
+    }
   }
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, compiled,
diff --git a/deps/v8/test/inspector/inspector.status b/deps/v8/test/inspector/inspector.status
index a72ba8c9f1d..2a5bbb71c84 100644
--- a/deps/v8/test/inspector/inspector.status
+++ b/deps/v8/test/inspector/inspector.status
@@ -75,6 +75,7 @@
   'cpu-profiler/console-profile-wasm': [SKIP],
   'runtime/get-properties': [SKIP],
   'regress/regress-577352626': [SKIP],
+  'regress/regress-581361633': [SKIP],
   'regress/regress-crbug-349248170': [SKIP],
 }],  # not has_webassembly or variant == jitless

diff --git a/deps/v8/test/inspector/regress/regress-581361633-expected.txt b/deps/v8/test/inspector/regress/regress-581361633-expected.txt
new file mode 100644
index 00000000000..e6d3b8e67ff
--- /dev/null
+++ b/deps/v8/test/inspector/regress/regress-581361633-expected.txt
@@ -0,0 +1,3 @@
+Regression test for crbug.com/581361633.
+pauseCount: 2
+runProbe() -> 405051
diff --git a/deps/v8/test/inspector/regress/regress-581361633.js b/deps/v8/test/inspector/regress/regress-581361633.js
new file mode 100644
index 00000000000..66d64e41123
--- /dev/null
+++ b/deps/v8/test/inspector/regress/regress-581361633.js
@@ -0,0 +1,141 @@
+// Copyright 2026 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.
+
+// Flags: --allow-natives-syntax --no-wasm-trap-handler
+// Flags: --stress-wasm-memory-moving
+
+const {session, contextGroup, Protocol} =
+    InspectorTest.start('Regression test for crbug.com/581361633.');
+
+contextGroup.addScript(utils.read('test/mjsunit/wasm/wasm-module-builder.js'));
+
+contextGroup.addScript(`
+const builder = new WasmModuleBuilder();
+builder.addMemory(1, 10);
+builder.exportMemoryAs('mem');
+const structType = builder.addStruct([makeField(kWasmI32, true)]);
+const globalStruct =
+    builder.addGlobal(wasmRefNullType(structType), true, false);
+const tag = builder.addTag(kSig_v_v);
+const setupIdx = builder.addImport('env', 'setup', kSig_v_v);
+const intToStringIdx = builder.addImport(
+    'env', 'intToString',
+    makeSig([kWasmI32, kWasmI32], [kWasmExternRef]));
+
+builder.addFunction('mutateStruct', kSig_v_i)
+    .addBody([
+      kExprGlobalGet, globalStruct.index,
+      kExprLocalGet, 0,
+      kGCPrefix, kExprStructSet, structType, 0,
+    ])
+    .exportFunc();
+
+builder.addFunction('probe', kSig_i_v)
+    .addLocals(wasmRefNullType(structType), 1)
+    .addLocals(kWasmI32, 1)
+    .addBody([
+      kExprCallFunction, setupIdx,
+
+      // Allocate a fresh struct, store it in a global, and read its field
+      // before the first try_table so WasmLoadEliminationReducer caches
+      // field 0 = 10.
+      kExprI32Const, 10,
+      kGCPrefix, kExprStructNew, structType,
+      kExprLocalTee, 0,
+      kExprGlobalSet, globalStruct.index,
+      kExprLocalGet, 0,
+      kGCPrefix, kExprStructGet, structType, 0,
+      kExprDrop,
+
+      // Pre-throw memory access so LateLoadEliminationReducer caches
+      // memory0_start before the first try_table.
+      kExprI32Const, 0,
+      kExprI32Const, 0x11,
+      kExprI32StoreMem, 2, 0,
+
+      // 1. Throw via WasmThrow inside try_table.
+      kExprBlock, kWasmVoid,
+        kExprTryTable, kWasmVoid, 1,
+        kCatchAllNoRef, 0,
+          kExprThrow, tag,
+        kExprEnd,
+      kExprEnd,
+
+      // Post-catch memory access and struct field load after WasmThrow:
+      // both must reload after the catch block (and this also re-caches
+      // memory0_start and field 0 before the second try_table).
+      kExprI32Const, 0,
+      kExprI32Const, 0x22,
+      kExprI32StoreMem, 2, 0,
+      kExprLocalGet, 0,
+      kGCPrefix, kExprStructGet, structType, 0,
+      kExprLocalSet, 1,
+
+      // 2. Throw via well-known import WasmIntToString (invalid radix 37)
+      // inside try_table.
+      kExprBlock, kWasmVoid,
+        kExprTryTable, kWasmVoid, 1,
+        kCatchAllNoRef, 0,
+          kExprI32Const, 42,
+          kExprI32Const, 37,
+          kExprCallFunction, intToStringIdx,
+          kExprDrop,
+        kExprEnd,
+      kExprEnd,
+
+      // Post-catch memory access and struct field load after WasmIntToString.
+      kExprI32Const, 0,
+      kExprI32Const, 0x33,
+      kExprI32StoreMem, 2, 0,
+      kExprLocalGet, 1,
+      ...wasmI32Const(100),
+      kExprI32Mul,
+      kExprLocalGet, 0,
+      kGCPrefix, kExprStructGet, structType, 0,
+      kExprI32Add,
+    ])
+    .exportFunc();
+
+function setup() {
+  console.log('setup');
+  inspector.runNestedMessageLoop();
+}
+
+const intToString = Function.prototype.call.bind(Number.prototype.toString);
+const instance = builder.instantiate({env: {setup, intToString}});
+const mem = instance.exports.mem;
+%WasmTierUpFunction(instance.exports.probe);
+
+function runProbe() {
+  const res = instance.exports.probe();
+  return res * 100 + new Uint8Array(mem.buffer)[0];
+}
+`);
+
+let pauseCount = 0;
+Protocol.Debugger.onPaused(async () => {
+  pauseCount++;
+  const newFieldVal = pauseCount === 1 ? 40 : 50;
+  await Protocol.Runtime.evaluate({
+    expression: `mem.grow(1); instance.exports.mutateStruct(${newFieldVal});`
+  });
+  await Protocol.Debugger.resume();
+});
+
+(async () => {
+  await Protocol.Runtime.enable();
+
+  const consolePromise = Protocol.Runtime.onceConsoleAPICalled();
+  const evalPromise = Protocol.Runtime.evaluate({expression: 'runProbe()'});
+
+  await consolePromise;
+  await Protocol.Debugger.enable();
+  await Protocol.Debugger.setPauseOnExceptions({state: 'all'});
+  await Protocol.Runtime.runIfWaitingForDebugger();
+
+  const {result} = await evalPromise;
+  InspectorTest.log('pauseCount: ' + pauseCount);
+  InspectorTest.log('runProbe() -> ' + result.result.value);
+  InspectorTest.completeTest();
+})();
diff --git a/deps/v8/test/mjsunit/compiler/regress-577461556.js b/deps/v8/test/mjsunit/compiler/regress-577461556.js
new file mode 100644
index 00000000000..a3e836aa001
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/regress-577461556.js
@@ -0,0 +1,58 @@
+// Copyright 2026 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.
+
+// Flags: --allow-natives-syntax
+
+const receiver = {prefix_for_key_check_long_enough: 0x1234};
+
+function testMapHas(obj, map, suffix) {
+  const key = 'prefix_for_key_check_long_enough' + suffix;
+  const has = map.has(key);
+  return [obj[key], has];
+}
+
+function testMapGet(obj, map, suffix) {
+  const key = 'prefix_for_key_check_long_enough' + suffix;
+  const val = map.get(key);
+  return [obj[key], val];
+}
+
+function testSetHas(obj, set, suffix) {
+  const key = 'prefix_for_key_check_long_enough' + suffix;
+  const has = set.has(key);
+  return [obj[key], has];
+}
+
+// Map.prototype.has
+{
+  const map = new Map([['prefix_for_key_check_long_enough_hit', 42]]);
+  %PrepareFunctionForOptimization(testMapHas);
+  assertEquals([0x1234, false], testMapHas(receiver, map, ''));
+  assertEquals([0x1234, false], testMapHas(receiver, map, ''));
+  %OptimizeFunctionOnNextCall(testMapHas);
+  assertEquals([undefined, false], testMapHas(receiver, map, '_miss'));
+  assertEquals([undefined, true], testMapHas(receiver, map, '_hit'));
+}
+
+// Map.prototype.get
+{
+  const map = new Map([['prefix_for_key_check_long_enough_hit', 42]]);
+  %PrepareFunctionForOptimization(testMapGet);
+  assertEquals([0x1234, undefined], testMapGet(receiver, map, ''));
+  assertEquals([0x1234, undefined], testMapGet(receiver, map, ''));
+  %OptimizeFunctionOnNextCall(testMapGet);
+  assertEquals([undefined, undefined], testMapGet(receiver, map, '_miss'));
+  assertEquals([undefined, 42], testMapGet(receiver, map, '_hit'));
+}
+
+// Set.prototype.has
+{
+  const set = new Set(['prefix_for_key_check_long_enough_hit']);
+  %PrepareFunctionForOptimization(testSetHas);
+  assertEquals([0x1234, false], testSetHas(receiver, set, ''));
+  assertEquals([0x1234, false], testSetHas(receiver, set, ''));
+  %OptimizeFunctionOnNextCall(testSetHas);
+  assertEquals([undefined, false], testSetHas(receiver, set, '_miss'));
+  assertEquals([undefined, true], testSetHas(receiver, set, '_hit'));
+}
diff --git a/deps/v8/test/mjsunit/compiler/regress-579278668.js b/deps/v8/test/mjsunit/compiler/regress-579278668.js
new file mode 100644
index 00000000000..ae5ba2d6d10
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/regress-579278668.js
@@ -0,0 +1,47 @@
+// Copyright 2026 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.
+
+// Flags: --allow-natives-syntax
+
+class DoubleHolder extends Array {}
+
+const box = { f2: false };
+function double_getter() {
+  let f2 = box.f2;
+  let p0 = this[0];
+  let p1 = f2 ? 1.5 : p0;
+  if (p1 === 0.0) return 1;
+  return p1;
+}
+function array_getter() {
+  return this[0];
+}
+Object.defineProperty(DoubleHolder.prototype, "trigger", { get: double_getter });
+Object.defineProperty(Array.prototype, "trigger", { get: array_getter });
+
+function access(o) {
+  return o.trigger;
+}
+
+function victim(...args) {
+  return access(args);
+}
+
+const double_arr = new DoubleHolder();
+double_arr[0] = 1.1;
+
+%PrepareFunctionForOptimization(double_getter);
+%PrepareFunctionForOptimization(array_getter);
+%PrepareFunctionForOptimization(access);
+%PrepareFunctionForOptimization(victim);
+
+for (let i = 0; i < 10; i++) {
+  box.f2 = (i % 2 === 0);
+  access(double_arr);
+  access([1, 2]);
+}
+
+assertEquals(1, victim(1, 2));
+%OptimizeFunctionOnNextCall(victim);
+assertEquals(1, victim(1, 2));
diff --git a/deps/v8/test/mjsunit/maglev/generator-next-leak-the-hole.js b/deps/v8/test/mjsunit/maglev/generator-next-leak-the-hole.js
index 6f3cd4f2854..c2a0522705a 100644
--- a/deps/v8/test/mjsunit/maglev/generator-next-leak-the-hole.js
+++ b/deps/v8/test/mjsunit/maglev/generator-next-leak-the-hole.js
@@ -4,8 +4,9 @@

 // Flags: --allow-natives-syntax --maglev

-// Test that we do not leak TheHole (which signals to skip IteratorResult
-// allocation) when a generator suspends via yield*.
+// Test that a generator suspending via yield* does not skip result allocation.
+// The body suspends inside the delegated iterator and never hits
+// %GeneratorYieldResult.

 function* inner() {
   yield 2;
@@ -29,10 +30,6 @@ test(generatorObject); // yields 1
 %OptimizeMaglevOnNextCall(test);
 test(generatorObject); // yields 2 (delegated to inner)

-// At this point, yielded_value_ should be cleared.
-// If it wasn't, the next call (unoptimized) will incorrectly see TheHole,
-// skip allocating the IteratorResult, and return TheHole to JS space.
-// This would then cause a crash when the JS code tries to access res.value.
 let res = generatorObject.next();
 assertEquals(3, res.value);
 assertEquals(false, res.done);
diff --git a/deps/v8/test/mjsunit/maglev/generator-next-yield-undefined.js b/deps/v8/test/mjsunit/maglev/generator-next-yield-undefined.js
new file mode 100644
index 00000000000..5f9650c22fa
--- /dev/null
+++ b/deps/v8/test/mjsunit/maglev/generator-next-yield-undefined.js
@@ -0,0 +1,178 @@
+// Copyright 2026 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.
+
+// Flags: --allow-natives-syntax --maglev --sparkplug
+
+// Tests that yielding undefined does not confuse the skip-allocation fast path
+// in inlined Generator.prototype.next.
+
+(function yieldUndefinedOnFastPath() {
+  function* gen() {
+    yield undefined;
+    yield undefined;
+  }
+
+  function callNext(g) {
+    return g.next();
+  }
+  %PrepareFunctionForOptimization(callNext);
+
+  const g = gen();
+  let res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+
+  %OptimizeMaglevOnNextCall(callNext);
+  res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+})();
+
+// Same as above, with the generator body in Sparkplug: covers the baseline ack.
+(function yieldUndefinedOnFastPathBaselineBody() {
+  function* gen() {
+    yield undefined;
+    yield undefined;
+  }
+  %CompileBaseline(gen);
+
+  function callNext(g) {
+    return g.next();
+  }
+  %PrepareFunctionForOptimization(callNext);
+
+  const g = gen();
+  let res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+
+  %OptimizeMaglevOnNextCall(callNext);
+  res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+  assertTrue(%ActiveTierIsSparkplug(gen));
+})();
+
+// Same as above, with the generator body in Maglev: covers the Maglev ack.
+(function yieldUndefinedOnFastPathMaglevBody() {
+  function* gen() {
+    yield undefined;
+    yield undefined;
+  }
+  %PrepareFunctionForOptimization(gen);
+  for (const _ of gen());
+  %OptimizeMaglevOnNextCall(gen);
+
+  function callNext(g) {
+    return g.next();
+  }
+  %PrepareFunctionForOptimization(callNext);
+
+  const g = gen();  // Maglev-compiles the body.
+  let res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+
+  %OptimizeMaglevOnNextCall(callNext);
+  res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+  assertOptimized(gen);
+})();
+
+// Skip path + lazy deopt: the continuation must wrap the returned value, which
+// is the bare yielded value rather than a result object.
+(function lazyDeoptOnFastPath() {
+  function* gen() {
+    yield 1;
+    %DeoptimizeFunction(callNext);
+    yield 42;
+    yield undefined;
+  }
+
+  function callNext(g) {
+    return g.next();
+  }
+  %PrepareFunctionForOptimization(callNext);
+
+  const g = gen();
+  callNext(g);
+
+  %OptimizeMaglevOnNextCall(callNext);
+  let res = callNext(g);
+  assertUnoptimized(callNext);
+  assertEquals(42, res.value);
+  assertFalse(res.done);
+
+  res = g.next();
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+})();
+
+// A try-catch around the call disables the handshake, so the body allocates
+// the result object itself. Yielding `undefined` must still work, including
+// when the call lazy-deopts.
+(function lazyDeoptWithoutHandshake() {
+  function* gen() {
+    yield undefined;
+    %DeoptimizeFunction(callNext);
+    yield undefined;
+  }
+
+  function callNext(g) {
+    try {
+      return g.next();
+    } catch (e) {
+      return e;
+    }
+  }
+  %PrepareFunctionForOptimization(callNext);
+
+  const g = gen();
+  let res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+
+  %OptimizeMaglevOnNextCall(callNext);
+  res = callNext(g);
+  assertUnoptimized(callNext);
+  assertEquals(undefined, res.value);
+  assertFalse(res.done);
+
+  res = g.next();
+  assertEquals(undefined, res.value);
+  assertTrue(res.done);
+})();
+
+// The generator returning `undefined` closes it and must be reported as done,
+// never as a skipped allocation.
+(function returnUndefined() {
+  function* gen() {
+    yield 1;
+    return undefined;
+  }
+
+  function callNext(g) {
+    return g.next();
+  }
+  %PrepareFunctionForOptimization(callNext);
+
+  let g = gen();
+  callNext(g);
+  callNext(g);
+
+  %OptimizeMaglevOnNextCall(callNext);
+  g = gen();
+  let res = callNext(g);
+  assertEquals(1, res.value);
+  assertFalse(res.done);
+
+  res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertTrue(res.done);
+
+  res = callNext(g);
+  assertEquals(undefined, res.value);
+  assertTrue(res.done);
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-577453560.js b/deps/v8/test/mjsunit/regress/regress-577453560.js
new file mode 100644
index 00000000000..2f2c88fe118
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-577453560.js
@@ -0,0 +1,98 @@
+// Copyright 2026 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.
+
+// Flags: --compile-hints-magic --stress-background-compile --stress-flush-code
+// Flags: --expose-gc
+
+function flush() {
+  for (let i = 0; i < 10; i++) gc({type: "major"});
+}
+
+// 1. Contextless arrow calling eval inside a function with context.
+{
+  let code = `//# allFunctionsCalledOnLoad
+  "use strict";
+  function outer() {
+    return function(x) {
+      return () => eval("x");
+    };
+  }
+  outer;`;
+
+  let o = Realm.eval(Realm.current(), code);
+  flush();
+  let f = o()(42);
+  Realm.eval(Realm.current(), code);
+  assertEquals(42, f());
+}
+
+// 2. Contextless arrow calling eval inside a lexical block scope, catch scope,
+// and default parameter scope.
+{
+  let code = `//# allFunctionsCalledOnLoad
+  "use strict";
+  function outer() {
+    return [
+      function() {
+        {
+          let x = 10;
+          return () => eval("x");
+        }
+      },
+      function() {
+        try {
+          throw 20;
+        } catch (x) {
+          return () => eval("x");
+        }
+      },
+      function(x = 30, f = () => eval("x")) {
+        return f;
+      },
+      function(x) {
+        return () => () => eval("() => eval('x')");
+      }
+    ];
+  }
+  outer;`;
+
+  let o = Realm.eval(Realm.current(), code);
+  flush();
+  let [fBlock, fCatch, fParam, fMulti] = o();
+  let b = fBlock();
+  let c = fCatch();
+  let p = fParam();
+  let m = fMulti(40)();
+  Realm.eval(Realm.current(), code);
+  assertEquals(10, b());
+  assertEquals(20, c());
+  assertEquals(30, p());
+  assertEquals(40, m()());
+}
+
+// 3. Standalone block-scoped eval merged while the owning closure's ScopeInfo
+// is kept alive by a sibling closure.
+{
+  let code = `//# allFunctionsCalledOnLoad
+  "use strict";
+  function outer(x) {
+    let keepScopeAlive = () => x;
+    let runBlockEval = function() {
+      {
+        let y = 12;
+        return eval("x + y");
+      }
+    };
+    return [keepScopeAlive, runBlockEval];
+  }
+  outer;`;
+
+  let o = Realm.eval(Realm.current(), code);
+  let [keep, run] = o(30);
+  flush();
+  let o2 = Realm.eval(Realm.current(), code);
+  assertEquals(30, keep());
+  assertEquals(42, run());
+  assertEquals(42, o2(30)[1]());
+}
diff --git a/deps/v8/test/mjsunit/turbolev/regress-577461556.js b/deps/v8/test/mjsunit/turbolev/regress-577461556.js
new file mode 100644
index 00000000000..54cecad7b54
--- /dev/null
+++ b/deps/v8/test/mjsunit/turbolev/regress-577461556.js
@@ -0,0 +1,48 @@
+// Copyright 2026 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.
+
+// Flags: --allow-natives-syntax --turbolev --turbofan
+
+const prefix = 'ABCDEFGHIJKLMNO';
+const key = %ConstructInternalizedString(prefix + 'P');
+
+function inspect(s, expected) {
+  return [s === expected, s.length, s.charCodeAt(15)];
+}
+%PrepareFunctionForOptimization(inspect);
+inspect(key, prefix);
+%OptimizeFunctionOnNextCall(inspect);
+inspect(key, prefix);
+
+function testMapGet(map, suffix) {
+  const s = prefix + ('P' + suffix);
+  const found = map.get(s);
+  return [found, ...inspect(s, prefix)];
+}
+
+function testSetHas(set, suffix) {
+  const s = prefix + ('P' + suffix);
+  const found = set.has(s);
+  return [found, ...inspect(s, prefix)];
+}
+
+// Map.prototype.get
+{
+  const map = new Map([[key, 42]]);
+  %PrepareFunctionForOptimization(testMapGet);
+  assertEquals([42, false, 16, 80], testMapGet(map, ''));
+  assertEquals([42, false, 16, 80], testMapGet(map, ''));
+  %OptimizeFunctionOnNextCall(testMapGet);
+  assertEquals([42, false, 16, 80], testMapGet(map, ''));
+}
+
+// Set.prototype.has
+{
+  const set = new Set([key]);
+  %PrepareFunctionForOptimization(testSetHas);
+  assertEquals([true, false, 16, 80], testSetHas(set, ''));
+  assertEquals([true, false, 16, 80], testSetHas(set, ''));
+  %OptimizeFunctionOnNextCall(testSetHas);
+  assertEquals([true, false, 16, 80], testSetHas(set, ''));
+}
diff --git a/deps/v8/test/unittests/api/gc-callbacks-unittest.cc b/deps/v8/test/unittests/api/gc-callbacks-unittest.cc
index 572799d4765..ae4a55e64fd 100644
--- a/deps/v8/test/unittests/api/gc-callbacks-unittest.cc
+++ b/deps/v8/test/unittests/api/gc-callbacks-unittest.cc
@@ -163,6 +163,95 @@ TEST_F(GCCallbacksTest, GCCallbacks) {
   isolate->RemoveGCEpilogueCallback(EpilogueCallbackAlloc);
 }

+TEST_F(GCCallbacksTest, DisallowJSObjectModification) {
+  // `v8_unittests` runs death tests in "threadsafe" mode, which re-spawns the
+  // process and re-runs the test from `main()` for every
+  // `EXPECT_DEATH_IF_SUPPORTED` check. Ensure `i::v8_flags.hard_abort = true`
+  // so each expected `CHECK` failure terminates immediately without `abort()` /
+  // core-dump overhead.
+  i::v8_flags.hard_abort = true;
+
+  v8::Isolate* isolate = v8_isolate();
+  v8::HandleScope scope(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::String> existing_key = NewString("existing");
+  v8::Local<v8::String> new_key = NewString("new_prop");
+  v8::Local<v8::Value> value = v8::Integer::New(isolate, 42);
+
+  v8::Local<v8::Object> fast_obj = v8::Object::New(isolate);
+  CHECK(fast_obj->CreateDataProperty(context, existing_key, value).FromJust());
+  CHECK(Utils::OpenDirectHandle(*fast_obj)->HasFastProperties());
+
+  v8::Local<v8::Object> dict_obj = v8::Object::New(isolate);
+  CHECK(dict_obj->CreateDataProperty(context, existing_key, value).FromJust());
+  i::JSObject::NormalizeProperties(
+      i_isolate(), i::Cast<i::JSObject>(Utils::OpenDirectHandle(*dict_obj)),
+      i::KEEP_INOBJECT_PROPERTIES, 0, "test");
+  CHECK(!Utils::OpenDirectHandle(*dict_obj)->HasFastProperties());
+
+#if !defined(DEBUG) && defined(OFFICIAL_BUILD)
+  constexpr const char* kExpectedDeathMessage = "";
+#else
+  constexpr const char* kExpectedDeathMessage =
+      "Check failed: AllowJSObjectModification::IsAllowed";
+#endif
+
+  size_t prologue_count = 0;
+  size_t epilogue_count = 0;
+  using CallbackFn =
+      std::function<void(v8::Isolate*, v8::GCType, v8::GCCallbackFlags)>;
+  CallbackFn on_prologue = [&](v8::Isolate*, v8::GCType, v8::GCCallbackFlags) {
+    // Adding a new property to a fast-mode JSObject.
+    EXPECT_DEATH_IF_SUPPORTED(
+        fast_obj->CreateDataProperty(context, new_key, value).Check(),
+        kExpectedDeathMessage);
+    // Adding an indexed element to a fast-mode JSObject.
+    EXPECT_DEATH_IF_SUPPORTED(
+        fast_obj->CreateDataProperty(context, 0, value).Check(),
+        kExpectedDeathMessage);
+    // Reconfiguring an existing property on a fast-mode JSObject.
+    EXPECT_DEATH_IF_SUPPORTED(
+        fast_obj->DefineOwnProperty(context, existing_key, value, v8::ReadOnly)
+            .Check(),
+        kExpectedDeathMessage);
+    // Deleting a property from a fast-mode JSObject.
+    EXPECT_DEATH_IF_SUPPORTED(fast_obj->Delete(context, existing_key).Check(),
+                              kExpectedDeathMessage);
+    // Adding a property to a dictionary-mode JSObject.
+    EXPECT_DEATH_IF_SUPPORTED(
+        dict_obj->CreateDataProperty(context, new_key, value).Check(),
+        kExpectedDeathMessage);
+    // Deleting a property from a dictionary-mode JSObject.
+    EXPECT_DEATH_IF_SUPPORTED(dict_obj->Delete(context, existing_key).Check(),
+                              kExpectedDeathMessage);
+    prologue_count++;
+  };
+  CallbackFn on_epilogue = [&](v8::Isolate*, v8::GCType, v8::GCCallbackFlags) {
+    // Run a single representative check in epilogue to avoid spawning 6 more
+    // "threadsafe" death-test subprocesses.
+    EXPECT_DEATH_IF_SUPPORTED(
+        fast_obj->CreateDataProperty(context, new_key, value).Check(),
+        kExpectedDeathMessage);
+    epilogue_count++;
+  };
+
+  auto callback_thunk = [](v8::Isolate* isolate, v8::GCType type,
+                           v8::GCCallbackFlags flags, void* data) {
+    auto* fn = static_cast<CallbackFn*>(data);
+    (*fn)(isolate, type, flags);
+  };
+
+  isolate->AddGCPrologueCallback(callback_thunk, &on_prologue);
+  isolate->AddGCEpilogueCallback(callback_thunk, &on_epilogue);
+  InvokeMajorGC();
+  isolate->RemoveGCPrologueCallback(callback_thunk, &on_prologue);
+  isolate->RemoveGCEpilogueCallback(callback_thunk, &on_epilogue);
+
+  EXPECT_EQ(1u, prologue_count);
+  EXPECT_EQ(1u, epilogue_count);
+}
+
 }  // namespace
 }  // namespace v8

diff --git a/deps/v8/test/unittests/compiler/regalloc/register-allocator-unittest.cc b/deps/v8/test/unittests/compiler/regalloc/register-allocator-unittest.cc
index 875088a20cd..b0627fff43e 100644
--- a/deps/v8/test/unittests/compiler/regalloc/register-allocator-unittest.cc
+++ b/deps/v8/test/unittests/compiler/regalloc/register-allocator-unittest.cc
@@ -813,6 +813,48 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::Combine(::testing::ValuesIn(kParameterTypes),
                        ::testing::Range(0, SlotConstraintTest::kMaxVariant)));

+TEST_F(RegisterAllocatorTest, AllocateBlockedRegDeferredClampBelowStart) {
+  SetNumRegs(3, 1);
+
+  // B0 (non-deferred): branch selector `c`, value `d` used at the deferred
+  // jump, and phi inputs `w0..w2` creating register pressure.
+  StartBlock();
+  VReg c = Parameter(Reg());
+  VReg d = Define(Reg());
+  VReg w0 = Define(Reg());
+  VReg w1 = Define(Reg());
+  VReg w2 = Define(Reg());
+  EndBlock(Branch(Reg(c), 1, 2));  // succs: B1 (deferred), B2
+
+  // B1 (deferred): a call clobbers all registers, defs re-occupy all
+  // registers, ending with a jump that uses `d` in a register. The next block
+  // in RPO order (B2) is not deferred.
+  StartBlock(true);
+  EmitCall(Slot(-1));
+  VReg z0 = Define(Reg());
+  VReg z1 = Define(Reg());
+  VReg z2 = Define(Reg());
+  EndBlock(Jump(2, Reg(d)));  // succ: B3
+
+  // B2 (non-deferred; predecessor B0).
+  StartBlock();
+  EmitNop();
+  EndBlock(Jump(1));  // succ: B3
+
+  // B3: merge with phis keeping `z0..z2` live out of B1, and a late use of `d`
+  // so that its split child survives past the B2 block boundary.
+  StartBlock();
+  VReg p0 = Phi(z0, w0);
+  VReg p1 = Phi(z1, w1);
+  VReg p2 = Phi(z2, w2);
+  EmitI(Use(d));
+  EmitI(Use(p0), Use(p1), Use(p2));
+  Return(p0);
+  EndBlock(Last());
+
+  Allocate();
+}
+
 }  // namespace
 }  // namespace compiler
 }  // namespace internal
diff --git a/deps/v8/test/unittests/compiler/turboshaft/late-load-elimination-reducer-unittest.cc b/deps/v8/test/unittests/compiler/turboshaft/late-load-elimination-reducer-unittest.cc
index 56dacca7d57..fbbdf0c863e 100644
--- a/deps/v8/test/unittests/compiler/turboshaft/late-load-elimination-reducer-unittest.cc
+++ b/deps/v8/test/unittests/compiler/turboshaft/late-load-elimination-reducer-unittest.cc
@@ -8,7 +8,9 @@
 #include "src/compiler/turboshaft/wasm-load-elimination-reducer.h"
 #endif

+#include "src/compiler/access-builder.h"
 #include "src/compiler/turboshaft/assembler.h"
+#include "src/compiler/turboshaft/builtin-call-descriptors.h"
 #include "src/compiler/turboshaft/copying-phase.h"
 #include "src/compiler/turboshaft/machine-optimization-reducer.h"
 #include "src/compiler/turboshaft/operations.h"
@@ -18,6 +20,7 @@
 #include "src/compiler/turboshaft/required-optimization-reducer.h"
 #include "src/compiler/turboshaft/variable-reducer.h"
 #include "src/flags/flags.h"
+#include "src/objects/string.h"
 #include "test/common/flag-utils.h"
 #include "test/unittests/compiler/turboshaft/reducer-test.h"

@@ -528,6 +531,81 @@ TEST_F(LateLoadEliminationReducerTest,
   ASSERT_NE(load1, nullptr);
 }

+TEST_F(LateLoadEliminationReducerTest,
+       FindOrderedHashEntry_Invalidates_String_First_Load) {
+  {
+    auto effects_test = CreateFromGraph(2, [](auto& Asm) {
+      V<Object> table = Asm.GetParameter(0);
+      V<Smi> key = V<Smi>::Cast(Asm.GetParameter(1));
+      V<Smi> C(map_op) = __ FindOrderedHashMapEntry(table, key);
+      V<Smi> C(set_op) = __ FindOrderedHashSetEntry(table, key);
+      V<WordPtr> C(int32_op) =
+          __ FindOrderedHashMapEntryForInt32Key(table, __ Word32Constant(0));
+      __ Return(__ Word32Constant(0),
+                base::VectorOf<OpIndex>({map_op, set_op, int32_op}));
+    });
+    const Operation* map_op = effects_test.GetCapture("map_op").Get();
+    EXPECT_TRUE(map_op->Effects().can_write());
+    EXPECT_TRUE(map_op->Effects().can_allocate);
+
+    const Operation* set_op = effects_test.GetCapture("set_op").Get();
+    EXPECT_TRUE(set_op->Effects().can_write());
+    EXPECT_TRUE(set_op->Effects().can_allocate);
+
+    const Operation* int32_op = effects_test.GetCapture("int32_op").Get();
+    EXPECT_FALSE(int32_op->Effects().can_write());
+    EXPECT_FALSE(int32_op->Effects().can_allocate);
+    EXPECT_TRUE(int32_op->Effects().produces.load_heap_memory);
+  }
+
+  EXPECT_EQ(AccessBuilder::ForConsStringFirst().offset,
+            AccessBuilder::ForThinStringActual().offset);
+
+  auto test = CreateFromGraph(3, [](auto& Asm) {
+    V<Object> table = Asm.GetParameter(0);
+    V<String> first0 = V<String>::Cast(Asm.GetParameter(1));
+    V<String> first1 = V<String>::Cast(Asm.GetParameter(2));
+
+    auto escaped_alloc = __ template Allocate<ConsString>(
+        __ WordPtrConstant(sizeof(ConsString)), AllocationType::kYoung,
+        AllocationAlignment::kTaggedAligned);
+    __ InitializeField(escaped_alloc, AccessBuilder::ForConsStringFirst(),
+                       first0);
+    V<ConsString> escaped_str =
+        __ FinishInitialization(std::move(escaped_alloc));
+
+    auto local_alloc = __ template Allocate<ConsString>(
+        __ WordPtrConstant(sizeof(ConsString)), AllocationType::kYoung,
+        AllocationAlignment::kTaggedAligned);
+    __ InitializeField(local_alloc, AccessBuilder::ForConsStringFirst(),
+                       first1);
+    V<ConsString> local_str = __ FinishInitialization(std::move(local_alloc));
+
+    V<Smi> entry = __ template CallBuiltin<builtin::FindOrderedHashMapEntry>(
+        Asm.context(), {.table = table, .key = escaped_str});
+
+    // String::MakeThin overwrites ConsString::first_ with ThinString::actual_.
+    V<String> C(escaped_load) = __ template LoadField<String>(
+        escaped_str, AccessBuilder::ForThinStringActual());
+    V<String> C(local_load) = __ template LoadField<String>(
+        local_str, AccessBuilder::ForConsStringFirst());
+
+    __ Return(__ Word32Constant(0),
+              base::VectorOf<OpIndex>({entry, escaped_load, local_load}));
+  });
+
+  test.Run<LateLoadEliminationReducer>();
+
+  // The load from the escaped ConsString must NOT be replaced with `first0`.
+  const LoadOp* escaped_load = test.GetCapturedAs<LoadOp>("escaped_load");
+  ASSERT_NE(escaped_load, nullptr);
+
+  // Non-escaping allocations remain eligible for load elimination.
+  if (!LATE_LOAD_ELIM_VERIFY) {
+    ASSERT_TRUE(test.GetCapture("local_load").IsEmpty());
+  }
+}
+
 #if V8_ENABLE_WEBASSEMBLY

 class WasmLateLoadEliminationReducerTest
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/AsyncGenerators.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/AsyncGenerators.golden
index 4abee933391..897eee2790c 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/AsyncGenerators.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/AsyncGenerators.golden
@@ -29,7 +29,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(6),
                 B(Star6),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [18]), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [18]), U8(4), I8(0),
                 B(Ldar), R(6),
   /*   17 E> */ B(ReThrow),
                 B(Ldar), R(6),
@@ -60,7 +60,7 @@ bytecodes: [
                 B(Star3),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorClose), R(0), RegCount8(1),
                 B(Ldar), R(1),
-                B(SwitchOnSmiNoFeedback), U8(4:Smi [10]), U8(2), I8(1),
+                B(SwitchOnSmiNoFeedback), U8(5:Smi [10]), U8(2), I8(1),
                 B(Ldar), R(3),
                 B(SetPendingMessage),
                 B(Ldar), R(2),
@@ -77,6 +77,7 @@ bytecodes: [
 constant pool: [
   Smi [30],
   Smi [18],
+  Smi [18],
   Smi [10],
   Smi [7],
   Smi [10],
@@ -110,7 +111,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(6),
                 B(Star6),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [18]), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [18]), U8(4), I8(0),
                 B(Ldar), R(6),
   /*   17 E> */ B(ReThrow),
                 B(Ldar), R(6),
@@ -127,7 +128,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(6),
                 B(Star6),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(5:Smi [18]), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(6:Smi [18]), U8(4), I8(0),
                 B(Ldar), R(6),
   /*   22 E> */ B(ReThrow),
                 B(Ldar), R(6),
@@ -158,7 +159,7 @@ bytecodes: [
                 B(Star3),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorClose), R(0), RegCount8(1),
                 B(Ldar), R(1),
-                B(SwitchOnSmiNoFeedback), U8(8:Smi [10]), U8(2), I8(1),
+                B(SwitchOnSmiNoFeedback), U8(10:Smi [10]), U8(2), I8(1),
                 B(Ldar), R(3),
                 B(SetPendingMessage),
                 B(Ldar), R(2),
@@ -176,9 +177,11 @@ constant pool: [
   Smi [30],
   Smi [72],
   Smi [18],
+  Smi [18],
   Smi [10],
   Smi [7],
   Smi [18],
+  Smi [18],
   Smi [10],
   Smi [7],
   Smi [10],
@@ -212,7 +215,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(9),
                 B(Star9),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [18]), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [18]), U8(4), I8(0),
                 B(Ldar), R(9),
   /*   17 E> */ B(ReThrow),
                 B(Ldar), R(9),
@@ -221,11 +224,11 @@ bytecodes: [
                 B(Star4),
                 B(Mov), R(9), R(5),
                 B(Jump), U8(209),
-  /*   36 S> */ B(CreateArrayLiteral), U8(5:ARRAY_BOILERPLATE_DESCRIPTION_TYPE), FBV(0), Flag8(0x25),
+  /*   36 S> */ B(CreateArrayLiteral), U8(6:ARRAY_BOILERPLATE_DESCRIPTION_TYPE), FBV(0), Flag8(0x25),
                 B(Star11),
                 B(GetIterator), R(11), FBV(1), FBV(3),
                 B(Star10),
-                B(GetNamedProperty), R(10), U8(6:"next"), FBV(5),
+                B(GetNamedProperty), R(10), U8(7:"next"), FBV(5),
                 B(Star9),
                 B(LdaFalse),
                 B(Star12),
@@ -238,9 +241,9 @@ bytecodes: [
                 B(Star11),
                 B(JumpIfJSReceiver), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(11), RegCount8(1),
-                B(GetNamedProperty), R(11), U8(7:"done"), FBV(9),
+                B(GetNamedProperty), R(11), U8(8:"done"), FBV(9),
                 B(JumpIfToBooleanTrue), U8(64),
-                B(GetNamedProperty), R(11), U8(8:"value"), FBV(11),
+                B(GetNamedProperty), R(11), U8(9:"value"), FBV(11),
                 B(Star11),
                 B(LdaFalse),
   /*   31 S> */ B(Star12),
@@ -253,7 +256,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(17),
                 B(Star), R(17),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(9:Smi [18]), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(10:Smi [18]), U8(4), I8(0),
                 B(Ldar), R(17),
   /*   42 E> */ B(ReThrow),
                 B(Ldar), R(17),
@@ -277,7 +280,7 @@ bytecodes: [
                 B(Ldar), R(12),
                 B(JumpIfToBooleanTrue), U8(38),
                 B(Mov), R(context), R(17),
-                B(GetNamedProperty), R(10), U8(12:"return"), FBV(15),
+                B(GetNamedProperty), R(10), U8(14:"return"), FBV(15),
                 B(JumpIfUndefinedOrNull), U8(29),
                 B(Star), R(18),
                 B(CallProperty0), R(18), R(10), FBV(17),
@@ -292,7 +295,7 @@ bytecodes: [
                 B(Ldar), R(17),
                 B(ReThrow),
                 B(Ldar), R(13),
-                B(SwitchOnSmiNoFeedback), U8(13:Smi [6]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(15:Smi [6]), U8(2), I8(0),
                 B(Jump), U8(16),
                 B(Ldar), R(15),
                 B(SetPendingMessage),
@@ -324,7 +327,7 @@ bytecodes: [
                 B(Star6),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorClose), R(0), RegCount8(1),
                 B(Ldar), R(4),
-                B(SwitchOnSmiNoFeedback), U8(15:Smi [10]), U8(2), I8(1),
+                B(SwitchOnSmiNoFeedback), U8(17:Smi [10]), U8(2), I8(1),
                 B(Ldar), R(6),
                 B(SetPendingMessage),
                 B(Ldar), R(5),
@@ -342,6 +345,7 @@ constant pool: [
   Smi [30],
   Smi [127],
   Smi [18],
+  Smi [18],
   Smi [10],
   Smi [7],
   ARRAY_BOILERPLATE_DESCRIPTION_TYPE,
@@ -349,6 +353,7 @@ constant pool: [
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["done"],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["value"],
   Smi [18],
+  Smi [18],
   Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["return"],
@@ -388,7 +393,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(6),
                 B(Star6),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(5:Smi [18]), U8(3), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(5:Smi [18]), U8(4), I8(0),
                 B(Ldar), R(6),
   /*   44 E> */ B(ReThrow),
                 B(Ldar), R(6),
@@ -396,34 +401,34 @@ bytecodes: [
                 B(LdaSmi), I8(1),
                 B(Star1),
                 B(Mov), R(6), R(2),
-                B(JumpConstant), U8(18:Smi [325]),
-  /*   49 S> */ B(LdaGlobal), U8(8:"g"), FBV(0),
+                B(JumpConstant), U8(19:Smi [325]),
+  /*   49 S> */ B(LdaGlobal), U8(9:"g"), FBV(0),
                 B(Star10),
   /*   56 E> */ B(CallUndefinedReceiver0), R(10), FBV(2),
                 B(Star11),
-                B(GetNamedProperty), R(11), U8(9:SYMBOL_TYPE), FBV(4),
+                B(GetNamedProperty), R(11), U8(10:SYMBOL_TYPE), FBV(4),
                 B(JumpIfUndefinedOrNull), U8(14),
                 B(Star12),
                 B(CallProperty0), R(12), R(11), FBV(6),
                 B(JumpIfJSReceiver), U8(21),
                 B(CallRuntime), U16(Runtime::kThrowSymbolAsyncIteratorInvalid), R(0), RegCount8(0),
-                B(GetNamedProperty), R(11), U8(10:SYMBOL_TYPE), FBV(8),
+                B(GetNamedProperty), R(11), U8(11:SYMBOL_TYPE), FBV(8),
                 B(Star12),
                 B(CallProperty0), R(12), R(11), FBV(10),
                 B(Star12),
                 B(InvokeIntrinsic), U8(Runtime::k_CreateAsyncFromSyncIterator), R(12), RegCount8(1),
                 B(Star8),
-                B(GetNamedProperty), R(8), U8(11:"next"), FBV(12),
+                B(GetNamedProperty), R(8), U8(12:"next"), FBV(12),
                 B(Star10),
                 B(LdaUndefined),
                 B(Star9),
                 B(LdaZero),
                 B(Star7),
                 B(Ldar), R(7),
-                B(SwitchOnSmiNoFeedback), U8(12:Smi [11]), U8(2), I8(1),
+                B(SwitchOnSmiNoFeedback), U8(13:Smi [11]), U8(2), I8(2),
                 B(CallProperty1), R(10), R(8), R(9), FBV(14),
                 B(Jump), U8(130),
-                B(GetNamedProperty), R(8), U8(14:"return"), FBV(16),
+                B(GetNamedProperty), R(8), U8(15:"return"), FBV(16),
                 B(JumpIfUndefinedOrNull), U8(10),
                 B(Star11),
                 B(CallProperty1), R(11), R(8), R(9), FBV(18),
@@ -445,12 +450,12 @@ bytecodes: [
                 B(Star1),
                 B(Mov), R(11), R(2),
                 B(Jump), U8(207),
-                B(GetNamedProperty), R(8), U8(15:"throw"), FBV(20),
+                B(GetNamedProperty), R(8), U8(16:"throw"), FBV(20),
                 B(JumpIfUndefinedOrNull), U8(10),
                 B(Star13),
                 B(CallProperty1), R(13), R(8), R(9), FBV(22),
                 B(Jump), U8(61),
-                B(GetNamedProperty), R(8), U8(14:"return"), FBV(24),
+                B(GetNamedProperty), R(8), U8(15:"return"), FBV(24),
                 B(JumpIfUndefinedOrNull), U8(50),
                 B(Star13),
                 B(CallProperty0), R(13), R(8), FBV(26),
@@ -490,9 +495,9 @@ bytecodes: [
                 B(Mov), R(13), R(6),
                 B(JumpIfJSReceiver), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(6), RegCount8(1),
-                B(GetNamedProperty), R(6), U8(16:"done"), FBV(28),
+                B(GetNamedProperty), R(6), U8(17:"done"), FBV(28),
                 B(JumpIfToBooleanTrue), U8(37),
-                B(GetNamedProperty), R(6), U8(17:"value"), FBV(30),
+                B(GetNamedProperty), R(6), U8(18:"value"), FBV(30),
                 B(Star), R(16),
                 B(LdaFalse),
                 B(Star), R(17),
@@ -504,9 +509,9 @@ bytecodes: [
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
                 B(Star7),
                 B(JumpLoop), U8(221), I8(0), FBV(32),
-                B(GetNamedProperty), R(6), U8(17:"value"), FBV(34),
+                B(GetNamedProperty), R(6), U8(18:"value"), FBV(34),
                 B(Star8),
-                B(LdaSmi), I8(1),
+                B(LdaSmi), I8(2),
                 B(TestReferenceEqual), R(7),
                 B(JumpIfFalse), U8(10),
                 B(LdaSmi), I8(1),
@@ -535,7 +540,7 @@ bytecodes: [
                 B(Star3),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorClose), R(0), RegCount8(1),
                 B(Ldar), R(1),
-                B(SwitchOnSmiNoFeedback), U8(19:Smi [10]), U8(2), I8(1),
+                B(SwitchOnSmiNoFeedback), U8(20:Smi [10]), U8(2), I8(1),
                 B(Ldar), R(3),
                 B(SetPendingMessage),
                 B(Ldar), R(2),
@@ -556,6 +561,7 @@ constant pool: [
   Smi [261],
   Smi [318],
   Smi [18],
+  Smi [18],
   Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["g"],
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/AsyncModules.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/AsyncModules.golden
index 1880b2c60ad..1e637beb564 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/AsyncModules.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/AsyncModules.golden
@@ -26,7 +26,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(2),
@@ -61,6 +61,7 @@ constant pool: [
   Smi [25],
   Smi [59],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -86,12 +87,12 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(2),
                 B(Return),
-  /*    0 S> */ B(LdaConstant), U8(4:"foo"),
+  /*    0 S> */ B(LdaConstant), U8(5:"foo"),
                 B(Star3),
                 B(LdaSmi), I8(2),
                 B(Star4),
@@ -126,6 +127,7 @@ constant pool: [
   Smi [25],
   Smi [71],
   Smi [10],
+  Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["foo"],
 ]
@@ -158,7 +160,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(3),
                 B(Star3),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(3:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(3:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(3),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(3),
@@ -195,6 +197,7 @@ constant pool: [
   Smi [64],
   SHARED_FUNCTION_INFO_TYPE,
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -221,12 +224,12 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(2),
                 B(Return),
-  /*   28 S> */ B(LdaConstant), U8(4:"goo"),
+  /*   28 S> */ B(LdaConstant), U8(5:"goo"),
                 B(Star3),
                 B(LdaSmi), I8(2),
                 B(Star4),
@@ -261,6 +264,7 @@ constant pool: [
   Smi [25],
   Smi [71],
   Smi [10],
+  Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["goo"],
 ]
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/ForOfLoop.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/ForOfLoop.golden
index ee6263cdeb1..3a9f2550b3c 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/ForOfLoop.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/ForOfLoop.golden
@@ -425,14 +425,14 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(5),
                 B(Star5),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(5),
   /*   11 E> */ B(Throw),
                 B(Ldar), R(5),
                 B(Return),
   /*   35 S> */ B(GetIterator), R(arg0), FBV(0), FBV(2),
                 B(Star6),
-                B(GetNamedProperty), R(6), U8(3:"next"), FBV(4),
+                B(GetNamedProperty), R(6), U8(4:"next"), FBV(4),
                 B(Star5),
                 B(LdaFalse),
                 B(Star8),
@@ -445,9 +445,9 @@ bytecodes: [
                 B(Star7),
                 B(JumpIfJSReceiver), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(7), RegCount8(1),
-                B(GetNamedProperty), R(7), U8(4:"done"), FBV(8),
+                B(GetNamedProperty), R(7), U8(5:"done"), FBV(8),
                 B(JumpIfToBooleanTrue), U8(24),
-                B(GetNamedProperty), R(7), U8(5:"value"), FBV(10),
+                B(GetNamedProperty), R(7), U8(6:"value"), FBV(10),
                 B(Star7),
                 B(LdaFalse),
   /*   30 S> */ B(Star8),
@@ -469,7 +469,7 @@ bytecodes: [
                 B(Ldar), R(8),
                 B(JumpIfToBooleanTrue), U8(35),
                 B(Mov), R(context), R(13),
-                B(GetNamedProperty), R(6), U8(6:"return"), FBV(14),
+                B(GetNamedProperty), R(6), U8(7:"return"), FBV(14),
                 B(JumpIfUndefinedOrNull), U8(26),
                 B(Star14),
                 B(CallProperty0), R(14), R(6), FBV(16),
@@ -496,6 +496,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["next"],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["done"],
@@ -527,14 +528,14 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(4),
                 B(Star4),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(4),
   /*   11 E> */ B(Throw),
                 B(Ldar), R(4),
                 B(Return),
   /*   35 S> */ B(GetIterator), R(arg0), FBV(0), FBV(2),
                 B(Star5),
-                B(GetNamedProperty), R(5), U8(4:"next"), FBV(4),
+                B(GetNamedProperty), R(5), U8(5:"next"), FBV(4),
                 B(Star4),
                 B(LdaFalse),
                 B(Star7),
@@ -547,9 +548,9 @@ bytecodes: [
                 B(Star6),
                 B(JumpIfJSReceiver), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(6), RegCount8(1),
-                B(GetNamedProperty), R(6), U8(5:"done"), FBV(8),
+                B(GetNamedProperty), R(6), U8(6:"done"), FBV(8),
                 B(JumpIfToBooleanTrue), U8(60),
-                B(GetNamedProperty), R(6), U8(6:"value"), FBV(10),
+                B(GetNamedProperty), R(6), U8(7:"value"), FBV(10),
                 B(Star6),
                 B(LdaFalse),
   /*   30 S> */ B(Star7),
@@ -562,7 +563,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(12),
                 B(Star12),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(7:Smi [15]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(8:Smi [15]), U8(3), I8(0),
                 B(Ldar), R(12),
   /*   40 E> */ B(Throw),
                 B(LdaSmi), I8(1),
@@ -584,7 +585,7 @@ bytecodes: [
                 B(Ldar), R(7),
                 B(JumpIfToBooleanTrue), U8(35),
                 B(Mov), R(context), R(12),
-                B(GetNamedProperty), R(5), U8(9:"return"), FBV(14),
+                B(GetNamedProperty), R(5), U8(11:"return"), FBV(14),
                 B(JumpIfUndefinedOrNull), U8(26),
                 B(Star13),
                 B(CallProperty0), R(13), R(5), FBV(16),
@@ -599,7 +600,7 @@ bytecodes: [
                 B(Ldar), R(12),
                 B(ReThrow),
                 B(Ldar), R(8),
-                B(SwitchOnSmiNoFeedback), U8(10:Smi [6]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(12:Smi [6]), U8(2), I8(0),
                 B(Jump), U8(11),
                 B(Ldar), R(10),
                 B(SetPendingMessage),
@@ -614,11 +615,13 @@ constant pool: [
   Smi [20],
   Smi [104],
   Smi [10],
+  Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["next"],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["done"],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["value"],
   Smi [15],
+  Smi [15],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["return"],
   Smi [6],
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/Generators.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/Generators.golden
index f4b7ed48280..fd0b813a7a2 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/Generators.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/Generators.golden
@@ -24,7 +24,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*   11 E> */ B(Throw),
                 B(Ldar), R(1),
@@ -35,6 +35,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -58,7 +59,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*   11 E> */ B(Throw),
                 B(Ldar), R(1),
@@ -71,7 +72,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(4:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(5:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*   16 E> */ B(Throw),
                 B(Ldar), R(1),
@@ -83,8 +84,10 @@ constant pool: [
   Smi [20],
   Smi [54],
   Smi [10],
+  Smi [10],
   Smi [7],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -108,16 +111,16 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(4),
                 B(Star4),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(4),
   /*   11 E> */ B(Throw),
                 B(Ldar), R(4),
                 B(Return),
-  /*   30 S> */ B(CreateArrayLiteral), U8(4:ARRAY_BOILERPLATE_DESCRIPTION_TYPE), FBV(0), Flag8(0x25),
+  /*   30 S> */ B(CreateArrayLiteral), U8(5:ARRAY_BOILERPLATE_DESCRIPTION_TYPE), FBV(0), Flag8(0x25),
                 B(Star6),
                 B(GetIterator), R(6), FBV(1), FBV(3),
                 B(Star5),
-                B(GetNamedProperty), R(5), U8(5:"next"), FBV(5),
+                B(GetNamedProperty), R(5), U8(6:"next"), FBV(5),
                 B(Star4),
                 B(LdaFalse),
                 B(Star7),
@@ -130,9 +133,9 @@ bytecodes: [
                 B(Star6),
                 B(JumpIfJSReceiver), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(6), RegCount8(1),
-                B(GetNamedProperty), R(6), U8(6:"done"), FBV(9),
+                B(GetNamedProperty), R(6), U8(7:"done"), FBV(9),
                 B(JumpIfToBooleanTrue), U8(60),
-                B(GetNamedProperty), R(6), U8(7:"value"), FBV(11),
+                B(GetNamedProperty), R(6), U8(8:"value"), FBV(11),
                 B(Star6),
                 B(LdaFalse),
   /*   25 S> */ B(Star7),
@@ -145,7 +148,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(12),
                 B(Star12),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(8:Smi [15]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(9:Smi [15]), U8(3), I8(0),
                 B(Ldar), R(12),
   /*   36 E> */ B(Throw),
                 B(LdaSmi), I8(1),
@@ -167,7 +170,7 @@ bytecodes: [
                 B(Ldar), R(7),
                 B(JumpIfToBooleanTrue), U8(35),
                 B(Mov), R(context), R(12),
-                B(GetNamedProperty), R(5), U8(10:"return"), FBV(15),
+                B(GetNamedProperty), R(5), U8(12:"return"), FBV(15),
                 B(JumpIfUndefinedOrNull), U8(26),
                 B(Star13),
                 B(CallProperty0), R(13), R(5), FBV(17),
@@ -182,7 +185,7 @@ bytecodes: [
                 B(Ldar), R(12),
                 B(ReThrow),
                 B(Ldar), R(8),
-                B(SwitchOnSmiNoFeedback), U8(11:Smi [6]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(13:Smi [6]), U8(2), I8(0),
                 B(Jump), U8(11),
                 B(Ldar), R(10),
                 B(SetPendingMessage),
@@ -197,12 +200,14 @@ constant pool: [
   Smi [20],
   Smi [109],
   Smi [10],
+  Smi [10],
   Smi [7],
   ARRAY_BOILERPLATE_DESCRIPTION_TYPE,
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["next"],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["done"],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["value"],
   Smi [15],
+  Smi [15],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["return"],
   Smi [6],
@@ -232,40 +237,40 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*   38 E> */ B(Throw),
                 B(Ldar), R(1),
                 B(Return),
-  /*   43 S> */ B(LdaGlobal), U8(4:"g"), FBV(0),
+  /*   43 S> */ B(LdaGlobal), U8(5:"g"), FBV(0),
                 B(Star5),
   /*   50 E> */ B(CallUndefinedReceiver0), R(5), FBV(2),
                 B(Star6),
                 B(GetIterator), R(6), FBV(4), FBV(6),
                 B(Star3),
-                B(GetNamedProperty), R(3), U8(5:"next"), FBV(8),
+                B(GetNamedProperty), R(3), U8(6:"next"), FBV(8),
                 B(Star5),
                 B(LdaUndefined),
                 B(Star4),
                 B(LdaZero),
                 B(Star2),
                 B(Ldar), R(2),
-                B(SwitchOnSmiNoFeedback), U8(6:Smi [11]), U8(2), I8(1),
+                B(SwitchOnSmiNoFeedback), U8(7:Smi [11]), U8(2), I8(2),
                 B(CallProperty1), R(5), R(3), R(4), FBV(10),
                 B(Jump), U8(59),
-                B(GetNamedProperty), R(3), U8(8:"return"), FBV(12),
+                B(GetNamedProperty), R(3), U8(9:"return"), FBV(12),
                 B(JumpIfUndefinedOrNull), U8(10),
                 B(Star6),
                 B(CallProperty1), R(6), R(3), R(4), FBV(14),
                 B(Jump), U8(45),
                 B(Ldar), R(4),
                 B(Return),
-                B(GetNamedProperty), R(3), U8(9:"throw"), FBV(16),
+                B(GetNamedProperty), R(3), U8(10:"throw"), FBV(16),
                 B(JumpIfUndefinedOrNull), U8(10),
                 B(Star6),
                 B(CallProperty1), R(6), R(3), R(4), FBV(18),
                 B(Jump), U8(28),
-                B(GetNamedProperty), R(3), U8(8:"return"), FBV(20),
+                B(GetNamedProperty), R(3), U8(9:"return"), FBV(20),
                 B(JumpIfUndefinedOrNull), U8(17),
                 B(Star6),
                 B(CallProperty0), R(6), R(3), FBV(22),
@@ -277,7 +282,7 @@ bytecodes: [
                 B(Star1),
                 B(JumpIfJSReceiver), U8(7),
                 B(CallRuntime), U16(Runtime::kThrowIteratorResultNotAnObject), R(1), RegCount8(1),
-                B(GetNamedProperty), R(1), U8(10:"done"), FBV(24),
+                B(GetNamedProperty), R(1), U8(11:"done"), FBV(24),
                 B(JumpIfToBooleanTrue), U8(23),
                 B(Ldar), R(1),
   /*   43 E> */ B(SuspendGenerator), R(0), R(0), RegCount8(6), U8(1),
@@ -286,9 +291,9 @@ bytecodes: [
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
                 B(Star2),
                 B(JumpLoop), U8(101), I8(0), FBV(26),
-                B(GetNamedProperty), R(1), U8(11:"value"), FBV(28),
+                B(GetNamedProperty), R(1), U8(12:"value"), FBV(28),
                 B(Star3),
-                B(LdaSmi), I8(1),
+                B(LdaSmi), I8(2),
                 B(TestReferenceEqual), R(2),
                 B(JumpIfFalse), U8(5),
                 B(Ldar), R(3),
@@ -300,6 +305,7 @@ constant pool: [
   Smi [20],
   Smi [152],
   Smi [10],
+  Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["g"],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["next"],
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/Modules.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/Modules.golden
index 5f885b398b6..993353056b2 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/Modules.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/Modules.golden
@@ -24,7 +24,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(1),
@@ -35,6 +35,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -57,7 +58,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(1),
@@ -68,6 +69,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -92,13 +94,13 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(2),
                 B(Return),
   /*   32 S> */ B(LdaModuleVariable), I8(-1), U8(0),
-                B(ThrowReferenceErrorIfTdzHole), U8(3:"goo"),
+                B(ThrowReferenceErrorIfTdzHole), U8(4:"goo"),
                 B(Star2),
                 B(LdaSmi), I8(42),
                 B(Star3),
@@ -116,6 +118,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["goo"],
 ]
@@ -141,7 +144,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(2),
@@ -162,6 +165,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -190,7 +194,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(2),
@@ -212,6 +216,7 @@ constant pool: [
   Smi [31],
   FIXED_ARRAY_TYPE,
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -240,7 +245,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(2),
@@ -262,6 +267,7 @@ constant pool: [
   Smi [31],
   FIXED_ARRAY_TYPE,
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -288,12 +294,12 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(1),
                 B(Return),
-                B(CreateClosure), U8(4:SHARED_FUNCTION_INFO_TYPE), FBV(0), Flag8(0x0),
+                B(CreateClosure), U8(5:SHARED_FUNCTION_INFO_TYPE), FBV(0), Flag8(0x0),
                 B(StaModuleVariable), I8(1), U8(0),
                 B(LdaUndefined),
   /*   33 S> */ B(Return),
@@ -302,6 +308,7 @@ constant pool: [
   Smi [31],
   FIXED_ARRAY_TYPE,
   Smi [10],
+  Smi [10],
   Smi [7],
   SHARED_FUNCTION_INFO_TYPE,
 ]
@@ -329,16 +336,16 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(1),
                 B(Return),
                 B(LdaTheHole),
                 B(Star4),
-                B(CreateClosure), U8(5:SHARED_FUNCTION_INFO_TYPE), FBV(0), Flag8(0x0),
+                B(CreateClosure), U8(6:SHARED_FUNCTION_INFO_TYPE), FBV(0), Flag8(0x0),
                 B(Star1),
-                B(LdaConstant), U8(4:CLASS_BOILERPLATE_TYPE),
+                B(LdaConstant), U8(5:CLASS_BOILERPLATE_TYPE),
                 B(Star2),
                 B(Mov), R(1), R(3),
                 B(CallRuntime), U16(Runtime::kDefineClass), R(2), RegCount8(3),
@@ -351,6 +358,7 @@ constant pool: [
   Smi [31],
   FIXED_ARRAY_TYPE,
   Smi [10],
+  Smi [10],
   Smi [7],
   CLASS_BOILERPLATE_TYPE,
   SHARED_FUNCTION_INFO_TYPE,
@@ -375,7 +383,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(1),
@@ -386,6 +394,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -408,7 +417,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(1),
                 B(Star1),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(1),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(1),
@@ -419,6 +428,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -446,14 +456,14 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*    0 E> */ B(Throw),
                 B(Ldar), R(2),
                 B(Return),
-  /*   31 S> */ B(GetNamedProperty), R(1), U8(3:"f"), FBV(0),
+  /*   31 S> */ B(GetNamedProperty), R(1), U8(4:"f"), FBV(0),
                 B(Star2),
-  /*   42 E> */ B(GetNamedProperty), R(1), U8(4:"x"), FBV(2),
+  /*   42 E> */ B(GetNamedProperty), R(1), U8(5:"x"), FBV(2),
                 B(Star5),
   /*   31 E> */ B(CallProperty2), R(2), R(1), R(1), R(5), FBV(4),
                 B(LdaUndefined),
@@ -462,6 +472,7 @@ bytecodes: [
 constant pool: [
   Smi [28],
   Smi [10],
+  Smi [10],
   Smi [7],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["f"],
   INTERNALIZED_ONE_BYTE_STRING_TYPE ["x"],
diff --git a/deps/v8/test/unittests/interpreter/bytecode_expectations/StandardForLoop.golden b/deps/v8/test/unittests/interpreter/bytecode_expectations/StandardForLoop.golden
index e0e42d1bd62..c35e8c1b385 100644
--- a/deps/v8/test/unittests/interpreter/bytecode_expectations/StandardForLoop.golden
+++ b/deps/v8/test/unittests/interpreter/bytecode_expectations/StandardForLoop.golden
@@ -261,7 +261,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(3),
                 B(Star3),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(1:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(3),
   /*   11 E> */ B(Throw),
                 B(Ldar), R(3),
@@ -282,6 +282,7 @@ bytecodes: [
 constant pool: [
   Smi [20],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [
@@ -307,7 +308,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(2:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*   11 E> */ B(Throw),
                 B(Ldar), R(2),
@@ -324,7 +325,7 @@ bytecodes: [
                 B(ResumeGenerator), R(0), R(0), RegCount8(2),
                 B(Star2),
                 B(InvokeIntrinsic), U8(Runtime::k_GeneratorGetResumeMode), R(0), RegCount8(1),
-                B(SwitchOnSmiNoFeedback), U8(4:Smi [10]), U8(2), I8(0),
+                B(SwitchOnSmiNoFeedback), U8(5:Smi [10]), U8(3), I8(0),
                 B(Ldar), R(2),
   /*   47 E> */ B(Throw),
                 B(Ldar), R(2),
@@ -340,8 +341,10 @@ constant pool: [
   Smi [20],
   Smi [63],
   Smi [10],
+  Smi [10],
   Smi [7],
   Smi [10],
+  Smi [10],
   Smi [7],
 ]
 handlers: [