deps: patch V8 to 12.8.374.31

Refs: v8/v8@12.8.374.22...12.8.374.31
PR-URL: #54682
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

deps/v8/include/v8-version.h

@@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 12
 #define V8_MINOR_VERSION 8
 #define V8_BUILD_NUMBER 374
-#define V8_PATCH_LEVEL 22
+#define V8_PATCH_LEVEL 31
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

deps/v8/src/ast/ast-function-literal-id-reindexer.cc

@@ -31,13 +31,6 @@ void AstFunctionLiteralIdReindexer::VisitFunctionLiteral(FunctionLiteral* lit) {
  lit->set_function_literal_id(lit->function_literal_id() + delta_);
 }
 
-void AstFunctionLiteralIdReindexer::VisitCall(Call* expr) {
- AstTraversalVisitor::VisitCall(expr);
- if (expr->is_possibly_eval()) {
- expr->adjust_eval_scope_info_index(delta_);
- }
-}
-
 void AstFunctionLiteralIdReindexer::VisitClassLiteral(ClassLiteral* expr) {
  // Manually visit the class literal so that we can change the property walk.
  // This should be kept in-sync with AstTraversalVisitor::VisitClassLiteral.

deps/v8/src/ast/ast-function-literal-id-reindexer.h

@@ -30,7 +30,6 @@ class AstFunctionLiteralIdReindexer final
  // AstTraversalVisitor implementation.
  void VisitFunctionLiteral(FunctionLiteral* lit);
  void VisitClassLiteral(ClassLiteral* lit);
- void VisitCall(Call* lit);
 
  private:
  int delta_;

deps/v8/src/ast/ast.h

@@ -1731,7 +1731,7 @@ class CallBase : public Expression {
 class Call final : public CallBase {
  public:
  bool is_possibly_eval() const {
- return EvalScopeInfoIndexField::decode(bit_field_) > 0;
+ return IsPossiblyEvalField::decode(bit_field_);
  }
 
  bool is_tagged_template() const {
@@ -1742,15 +1742,6 @@ class Call final : public CallBase {
  return IsOptionalChainLinkField::decode(bit_field_);
  }
 
- uint32_t eval_scope_info_index() const {
- return EvalScopeInfoIndexField::decode(bit_field_);
- }
-
- void adjust_eval_scope_info_index(int delta) {
- bit_field_ = EvalScopeInfoIndexField::update(
- bit_field_, eval_scope_info_index() + delta);
- }
-
  enum CallType {
  GLOBAL_CALL,
  WITH_CALL,
@@ -1766,6 +1757,11 @@ class Call final : public CallBase {
  OTHER_CALL,
  };
 
+ enum PossiblyEval {
+ IS_POSSIBLY_EVAL,
+ NOT_EVAL,
+ };
+
  // Helpers to determine how to handle the call.
  CallType GetCallType() const;
 
@@ -1777,26 +1773,26 @@ class Call final : public CallBase {
 
  Call(Zone* zone, Expression* expression,
  const ScopedPtrList<Expression>& arguments, int pos, bool has_spread,
- int eval_scope_info_index, bool optional_chain)
+ PossiblyEval possibly_eval, bool optional_chain)
  : CallBase(zone, kCall, expression, arguments, pos, has_spread) {
- bit_field_ |= IsTaggedTemplateField::encode(false) |
-  IsOptionalChainLinkField::encode(optional_chain) |
-  EvalScopeInfoIndexField::encode(eval_scope_info_index);
- DCHECK_EQ(eval_scope_info_index > 0, is_possibly_eval());
+ bit_field_ |=
+ IsPossiblyEvalField::encode(possibly_eval == IS_POSSIBLY_EVAL) |
+ IsTaggedTemplateField::encode(false) |
+  IsOptionalChainLinkField::encode(optional_chain);
  }
 
  Call(Zone* zone, Expression* expression,
  const ScopedPtrList<Expression>& arguments, int pos,
  TaggedTemplateTag tag)
  : CallBase(zone, kCall, expression, arguments, pos, false) {
- bit_field_ |= IsTaggedTemplateField::encode(true) |
- IsOptionalChainLinkField::encode(false) |
- EvalScopeInfoIndexField::encode(0);
+ bit_field_ |= IsPossiblyEvalField::encode(false) |
+ IsTaggedTemplateField::encode(true) |
+ IsOptionalChainLinkField::encode(false);
  }
 
- using IsTaggedTemplateField = CallBase::NextBitField<bool, 1>;
+ using IsPossiblyEvalField = CallBase::NextBitField<bool, 1>;
+ using IsTaggedTemplateField = IsPossiblyEvalField::Next<bool, 1>;
  using IsOptionalChainLinkField = IsTaggedTemplateField::Next<bool, 1>;
- using EvalScopeInfoIndexField = IsOptionalChainLinkField::Next<uint32_t, 20>;
 };
 
 class CallNew final : public CallBase {
@@ -3188,11 +3184,12 @@ class AstNodeFactory final {
 
  Call* NewCall(Expression* expression,
  const ScopedPtrList<Expression>& arguments, int pos,
- bool has_spread, int eval_scope_info_index = 0,
+ bool has_spread,
+ Call::PossiblyEval possibly_eval = Call::NOT_EVAL,
  bool optional_chain = false) {
- DCHECK_IMPLIES(eval_scope_info_index > 0, !optional_chain);
+ DCHECK_IMPLIES(possibly_eval == Call::IS_POSSIBLY_EVAL, !optional_chain);
  return zone_->New<Call>(zone_, expression, arguments, pos, has_spread,
- eval_scope_info_index, optional_chain);
+ possibly_eval, optional_chain);
  }
 
  SuperCallForwardArgs* NewSuperCallForwardArgs(SuperCallReference* expression,

deps/v8/src/ast/scopes.cc

@@ -2607,23 +2607,6 @@ void ModuleScope::AllocateModuleVariables() {
  }
 }
 
-// Needs to be kept in sync with ScopeInfo::UniqueIdInScript.
-int Scope::UniqueIdInScript() const {
- // Script scopes start "before" the script to avoid clashing with a scope that
- // starts on character 0.
- if (is_script_scope() || scope_type() == EVAL_SCOPE ||
- scope_type() == MODULE_SCOPE) {
- return -1;
- }
- if (is_declaration_scope()) {
- // Default constructors have the same start position as their parent class
- // scope. Use the next char position to distinguish this scope.
- return start_position() +
- IsDefaultConstructor(AsDeclarationScope()->function_kind());
- }
- return start_position();
-}
-
 void Scope::AllocateVariablesRecursively() {
  this->ForEach([](Scope* scope) -> Iteration {
  DCHECK(!scope->already_resolved_);
@@ -2675,63 +2658,33 @@ void Scope::AllocateVariablesRecursively() {
 }
 
 template <typename IsolateT>
-void Scope::AllocateScopeInfosRecursively(
- IsolateT* isolate, MaybeHandle<ScopeInfo> outer_scope,
- std::unordered_map<int, Handle<ScopeInfo>>& scope_infos_to_reuse) {
+void Scope::AllocateScopeInfosRecursively(IsolateT* isolate,
+ MaybeHandle<ScopeInfo> outer_scope) {
  DCHECK(scope_info_.is_null());
  MaybeHandle<ScopeInfo> next_outer_scope = outer_scope;
 
- auto it = scope_infos_to_reuse.find(UniqueIdInScript());
- if (it != scope_infos_to_reuse.end()) {
- scope_info_ = it->second;
- CHECK(NeedsContext());
- // The ScopeInfo chain mirrors the context chain, so we only link to the
- // next outer scope that needs a context.
- next_outer_scope = scope_info_;
- DCHECK(!scope_info_.is_null());
- DCHECK(!is_hidden_catch_scope());
- CHECK_EQ(scope_info_->scope_type(), scope_type_);
- CHECK_EQ(scope_info_->ContextLength(), num_heap_slots_);
-#ifdef DEBUG
- // Consume the scope info.
- it->second = {};
-#endif
- } else if (NeedsScopeInfo()) {
-#ifdef DEBUG
- // Mark this ID as being used. Skip hidden scopes because they are
- // synthetic, unreusable, but hard to make unique.
- if (v8_flags.reuse_scope_infos && !is_hidden_catch_scope()) {
- scope_infos_to_reuse[UniqueIdInScript()] = {};
- }
-#endif
+ if (NeedsScopeInfo()) {
  scope_info_ = ScopeInfo::Create(isolate, zone(), this, outer_scope);
- DCHECK_EQ(UniqueIdInScript(), scope_info_->UniqueIdInScript());
- // The ScopeInfo chain mirrors the context chain, so we only link to the
- // next outer scope that needs a context.
+ // The ScopeInfo chain should mirror the context chain, so we only link to
+ // the next outer scope that needs a context.
  if (NeedsContext()) next_outer_scope = scope_info_;
  }
 
  // Allocate ScopeInfos for inner scopes.
  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
- DCHECK_GT(scope->UniqueIdInScript(), UniqueIdInScript());
- DCHECK_IMPLIES(scope->sibling_, scope->sibling_->UniqueIdInScript() !=
- scope->UniqueIdInScript());
  if (!scope->is_function_scope() ||
  scope->AsDeclarationScope()->ShouldEagerCompile()) {
- scope->AllocateScopeInfosRecursively(isolate, next_outer_scope,
- scope_infos_to_reuse);
+ scope->AllocateScopeInfosRecursively(isolate, next_outer_scope);
  }
  }
 }
 
 template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) void Scope::
- AllocateScopeInfosRecursively<Isolate>(
- Isolate* isolate, MaybeHandle<ScopeInfo> outer_scope,
- std::unordered_map<int, Handle<ScopeInfo>>& scope_infos_to_reuse);
+ AllocateScopeInfosRecursively<Isolate>(Isolate* isolate,
+ MaybeHandle<ScopeInfo> outer_scope);
 template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) void Scope::
  AllocateScopeInfosRecursively<LocalIsolate>(
- LocalIsolate* isolate, MaybeHandle<ScopeInfo> outer_scope,
- std::unordered_map<int, Handle<ScopeInfo>>& scope_infos_to_reuse);
+ LocalIsolate* isolate, MaybeHandle<ScopeInfo> outer_scope);
 
 void DeclarationScope::RecalcPrivateNameContextChain() {
  // The outermost scope in a class heritage expression is marked to skip the
@@ -2776,9 +2729,7 @@ void DeclarationScope::RecordNeedsPrivateNameContextChainRecalc() {
 
 // static
 template <typename IsolateT>
-void DeclarationScope::AllocateScopeInfos(ParseInfo* info,
- Handle<Script> script,
- IsolateT* isolate) {
+void DeclarationScope::AllocateScopeInfos(ParseInfo* info, IsolateT* isolate) {
  DeclarationScope* scope = info->literal()->scope();
 
  // No one else should have allocated a scope info for this scope yet.
@@ -2793,49 +2744,7 @@ void DeclarationScope::AllocateScopeInfos(ParseInfo* info,
  if (scope->needs_private_name_context_chain_recalc()) {
  scope->RecalcPrivateNameContextChain();
  }
-
- Tagged<WeakFixedArray> infos = script->infos();
- std::unordered_map<int, Handle<ScopeInfo>> scope_infos_to_reuse;
- if (v8_flags.reuse_scope_infos && infos->length() != 0) {
- Tagged<SharedFunctionInfo> sfi = *info->literal()->shared_function_info();
- Tagged<ScopeInfo> outer = sfi->HasOuterScopeInfo()
- ? sfi->GetOuterScopeInfo()
- : Tagged<ScopeInfo>();
- // Look at all the existing inner functions (they are numbered id+1 until
- // max_id+1) to reattach their outer scope infos to corresponding scopes.
- for (int i = info->literal()->function_literal_id() + 1;
- i < info->max_info_id() + 1; ++i) {
- Tagged<MaybeObject> maybe_info = infos->get(i);
- if (maybe_info.IsWeak()) {
- Tagged<Object> info = maybe_info.GetHeapObjectAssumeWeak();
- Tagged<ScopeInfo> scope_info;
- if (Is<SharedFunctionInfo>(info)) {
- Tagged<SharedFunctionInfo> sfi = Cast<SharedFunctionInfo>(info);
- // Reuse outer scope infos. Don't look at sfi->scope_info() because
- // that might be empty if the sfi isn't compiled yet.
- if (!sfi->HasOuterScopeInfo()) continue;
- scope_info = sfi->GetOuterScopeInfo();
- } else {
- scope_info = Cast<ScopeInfo>(info);
- }
- while (true) {
- if (scope_info == outer) break;
- int id = scope_info->UniqueIdInScript();
- auto it = scope_infos_to_reuse.find(id);
- if (it != scope_infos_to_reuse.end()) {
- CHECK_EQ(*it->second, scope_info);
- break;
- }
- scope_infos_to_reuse[id] = handle(scope_info, isolate);
- if (!scope_info->HasOuterScopeInfo()) break;
- scope_info = scope_info->OuterScopeInfo();
- }
- }
- }
- }
-
- scope->AllocateScopeInfosRecursively(isolate, outer_scope,
- scope_infos_to_reuse);
+ scope->AllocateScopeInfosRecursively(isolate, outer_scope);
 
  // The debugger expects all shared function infos to contain a scope info.
  // Since the top-most scope will end up in a shared function info, make sure
@@ -2854,9 +2763,9 @@ void DeclarationScope::AllocateScopeInfos(ParseInfo* info,
 }
 
 template V8_EXPORT_PRIVATE void DeclarationScope::AllocateScopeInfos(
- ParseInfo* info, Handle<Script> script, Isolate* isolate);
+ ParseInfo* info, Isolate* isolate);
 template V8_EXPORT_PRIVATE void DeclarationScope::AllocateScopeInfos(
- ParseInfo* info, Handle<Script> script, LocalIsolate* isolate);
+ ParseInfo* info, LocalIsolate* isolate);
 
 int Scope::ContextLocalCount() const {
  if (num_heap_slots() == 0) return 0;

deps/v8/src/ast/scopes.h

@@ -101,11 +101,6 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
  }
 #endif
 
- // An ID that uniquely identifies this scope within the script. Inner scopes
- // have a higher ID than their outer scopes. ScopeInfo created from a scope
- // has the same ID as the scope.
- int UniqueIdInScript() const;
-
  DeclarationScope* AsDeclarationScope();
  const DeclarationScope* AsDeclarationScope() const;
  ModuleScope* AsModuleScope();
@@ -339,10 +334,6 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
  bool is_hidden() const { return is_hidden_; }
  void set_is_hidden() { is_hidden_ = true; }
 
- bool is_hidden_catch_scope() const {
- return is_hidden() && scope_type() == CATCH_SCOPE;
- }
-
  void ForceContextAllocationForParameters() {
  DCHECK(!already_resolved_);
  force_context_allocation_for_parameters_ = true;
@@ -728,9 +719,11 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
  void AllocateVariablesRecursively();
 
  template <typename IsolateT>
- void AllocateScopeInfosRecursively(
- IsolateT* isolate, MaybeHandle<ScopeInfo> outer_scope,
- std::unordered_map<int, Handle<ScopeInfo>>& scope_infos_to_reuse);
+ void AllocateScopeInfosRecursively(IsolateT* isolate,
+ MaybeHandle<ScopeInfo> outer_scope);
+
+ void AllocateDebuggerScopeInfos(Isolate* isolate,
+ MaybeHandle<ScopeInfo> outer_scope);
 
  // Construct a scope based on the scope info.
  Scope(Zone* zone, ScopeType type, AstValueFactory* ast_value_factory,
@@ -830,6 +823,10 @@ class V8_EXPORT_PRIVATE Scope : public NON_EXPORTED_BASE(ZoneObject) {
 
  bool must_use_preparsed_scope_data_ : 1;
 
+ // True if this is a script scope that originated from
+ // DebugEvaluate::GlobalREPL().
+ bool is_repl_mode_scope_ : 1;
+
  // True if this is a deserialized scope which caches its lookups on another
  // Scope's variable map. This will be true for every scope above the first
  // non-eval declaration scope above the compilation entry point, e.g. for
@@ -1164,7 +1161,6 @@ class V8_EXPORT_PRIVATE DeclarationScope : public Scope {
  // Does nothing if ScopeInfo is already allocated.
  template <typename IsolateT>
  V8_EXPORT_PRIVATE static void AllocateScopeInfos(ParseInfo* info,
- Handle<Script> script,
  IsolateT* isolate);
 
  // Determine if we can use lazy compilation for this scope.

deps/v8/src/builtins/builtins-function.cc

@@ -84,10 +84,11 @@ MaybeHandle<Object> CreateDynamicFunction(Isolate* isolate,
  // come from here.
  Handle<JSFunction> function;
  {
- ASSIGN_RETURN_ON_EXCEPTION(isolate, function,
- Compiler::GetFunctionFromString(
- handle(target->native_context(), isolate),
- source, parameters_end_pos, is_code_like));
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, function,
+ Compiler::GetFunctionFromString(
+ handle(target->native_context(), isolate), source,
+ ONLY_SINGLE_FUNCTION_LITERAL, parameters_end_pos, is_code_like));
  Handle<Object> result;
  ASSIGN_RETURN_ON_EXCEPTION(
  isolate, result,

deps/v8/src/codegen/background-merge-task.h

@@ -73,7 +73,7 @@ class V8_EXPORT_PRIVATE BackgroundMergeTask {
  // SharedFunctionInfo in the cached script. The main thread must:
  // 1. Check whether the cached script gained corresponding SharedFunctionInfos
  // for any of these, and if so, redo the merge.
- // 2. Update the cached script's infos list to refer to these.
+ // 2. Update the cached script's shared_function_infos list to refer to these.
  std::vector<Handle<SharedFunctionInfo>> used_new_sfis_;
 
  // SharedFunctionInfos from the cached script which were not compiled, with