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: [