deps: update V8 to 10.8.168.20

PR-URL: https://github.com/nodejs/node/pull/45230
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>

4 files changed, 22 insertions, 42 deletions

diff --git a/deps/v8/src/parsing/parse-info.cc b/deps/v8/src/parsing/parse-info.cc
index f773cd5d41..9c0eee6d00 100644
--- a/deps/v8/src/parsing/parse-info.cc
+++ b/deps/v8/src/parsing/parse-info.cc
@@ -28,19 +28,18 @@ UnoptimizedCompileFlags::UnoptimizedCompileFlags(Isolate* isolate,
       function_kind_(FunctionKind::kNormalFunction),
       function_syntax_kind_(FunctionSyntaxKind::kDeclaration),
       parsing_while_debugging_(ParsingWhileDebugging::kNo) {
-  set_collect_type_profile(isolate->is_collecting_type_profile());
   set_coverage_enabled(!isolate->is_best_effort_code_coverage());
   set_block_coverage_enabled(isolate->is_block_code_coverage());
-  set_might_always_turbofan(FLAG_always_turbofan ||
-                            FLAG_prepare_always_turbofan);
-  set_allow_natives_syntax(FLAG_allow_natives_syntax);
+  set_might_always_turbofan(v8_flags.always_turbofan ||
+                            v8_flags.prepare_always_turbofan);
+  set_allow_natives_syntax(v8_flags.allow_natives_syntax);
   set_allow_lazy_compile(true);
-  set_collect_source_positions(!FLAG_enable_lazy_source_positions ||
+  set_collect_source_positions(!v8_flags.enable_lazy_source_positions ||
                                isolate->NeedsDetailedOptimizedCodeLineInfo());
   set_post_parallel_compile_tasks_for_eager_toplevel(
-      FLAG_parallel_compile_tasks_for_eager_toplevel);
+      v8_flags.parallel_compile_tasks_for_eager_toplevel);
   set_post_parallel_compile_tasks_for_lazy(
-      FLAG_parallel_compile_tasks_for_lazy);
+      v8_flags.parallel_compile_tasks_for_lazy);
 }
 
 // static
@@ -60,15 +59,6 @@ UnoptimizedCompileFlags UnoptimizedCompileFlags::ForFunctionCompile(
 #endif  // V8_ENABLE_WEBASSEMBLY
   flags.set_is_repl_mode(shared.is_repl_mode());
 
-  // CollectTypeProfile uses its own feedback slots. If we have existing
-  // FeedbackMetadata, we can only collect type profile if the feedback vector
-  // has the appropriate slots.
-  flags.set_collect_type_profile(
-      isolate->is_collecting_type_profile() &&
-      (shared.HasFeedbackMetadata()
-           ? shared.feedback_metadata().HasTypeProfileSlot()
-           : script.IsUserJavaScript()));
-
   // Do not support re-parsing top-level function of a wrapped script.
   DCHECK_IMPLIES(flags.is_toplevel(), !script.is_wrapped());
 
@@ -82,11 +72,11 @@ UnoptimizedCompileFlags UnoptimizedCompileFlags::ForScriptCompile(
 
   flags.SetFlagsForFunctionFromScript(script);
   flags.SetFlagsForToplevelCompile(
-      isolate->is_collecting_type_profile(), script.IsUserJavaScript(),
-      flags.outer_language_mode(), construct_repl_mode(script.is_repl_mode()),
+      script.IsUserJavaScript(), flags.outer_language_mode(),
+      construct_repl_mode(script.is_repl_mode()),
       script.origin_options().IsModule() ? ScriptType::kModule
                                          : ScriptType::kClassic,
-      FLAG_lazy);
+      v8_flags.lazy);
   if (script.is_wrapped()) {
     flags.set_function_syntax_kind(FunctionSyntaxKind::kWrapped);
   }
@@ -99,8 +89,7 @@ UnoptimizedCompileFlags UnoptimizedCompileFlags::ForToplevelCompile(
     Isolate* isolate, bool is_user_javascript, LanguageMode language_mode,
     REPLMode repl_mode, ScriptType type, bool lazy) {
   UnoptimizedCompileFlags flags(isolate, isolate->GetNextScriptId());
-  flags.SetFlagsForToplevelCompile(isolate->is_collecting_type_profile(),
-                                   is_user_javascript, language_mode, repl_mode,
+  flags.SetFlagsForToplevelCompile(is_user_javascript, language_mode, repl_mode,
                                    type, lazy);
 
   LOG(isolate, ScriptEvent(V8FileLogger::ScriptEventType::kReserveId,
@@ -143,13 +132,11 @@ void UnoptimizedCompileFlags::SetFlagsFromFunction(T function) {
 }
 
 void UnoptimizedCompileFlags::SetFlagsForToplevelCompile(
-    bool is_collecting_type_profile, bool is_user_javascript,
-    LanguageMode language_mode, REPLMode repl_mode, ScriptType type,
-    bool lazy) {
+    bool is_user_javascript, LanguageMode language_mode, REPLMode repl_mode,
+    ScriptType type, bool lazy) {
   set_is_toplevel(true);
   set_allow_lazy_parsing(lazy);
   set_allow_lazy_compile(lazy);
-  set_collect_type_profile(is_user_javascript && is_collecting_type_profile);
   set_outer_language_mode(
       stricter_language_mode(outer_language_mode(), language_mode));
   set_is_repl_mode((repl_mode == REPLMode::kYes));
@@ -278,8 +265,7 @@ Handle<Script> ParseInfo::CreateScript(
   } else if (flags().is_eval()) {
     raw_script.set_compilation_type(Script::COMPILATION_TYPE_EVAL);
   }
-  CheckFlagsForToplevelCompileFromScript(raw_script,
-                                         isolate->is_collecting_type_profile());
+  CheckFlagsForToplevelCompileFromScript(raw_script);
 
   return script;
 }
@@ -309,12 +295,9 @@ void ParseInfo::set_character_stream(
   character_stream_.swap(character_stream);
 }
 
-void ParseInfo::CheckFlagsForToplevelCompileFromScript(
-    Script script, bool is_collecting_type_profile) {
+void ParseInfo::CheckFlagsForToplevelCompileFromScript(Script script) {
   CheckFlagsForFunctionFromScript(script);
   DCHECK(flags().is_toplevel());
-  DCHECK_EQ(flags().collect_type_profile(),
-            is_collecting_type_profile && script.IsUserJavaScript());
   DCHECK_EQ(flags().is_repl_mode(), script.is_repl_mode());
 
   if (script.is_wrapped()) {
diff --git a/deps/v8/src/parsing/parse-info.h b/deps/v8/src/parsing/parse-info.h
index ebf567b1c1..e2e3bdf9d1 100644
--- a/deps/v8/src/parsing/parse-info.h
+++ b/deps/v8/src/parsing/parse-info.h
@@ -48,7 +48,6 @@ class Zone;
   V(is_module, bool, 1, _)                                      \
   V(allow_lazy_parsing, bool, 1, _)                             \
   V(is_lazy_compile, bool, 1, _)                                \
-  V(collect_type_profile, bool, 1, _)                           \
   V(coverage_enabled, bool, 1, _)                               \
   V(block_coverage_enabled, bool, 1, _)                         \
   V(is_asm_wasm_broken, bool, 1, _)                             \
@@ -140,8 +139,7 @@ class V8_EXPORT_PRIVATE UnoptimizedCompileFlags {
   // SharedFunctionInfo |function|
   template <typename T>
   void SetFlagsFromFunction(T function);
-  void SetFlagsForToplevelCompile(bool is_collecting_type_profile,
-                                  bool is_user_javascript,
+  void SetFlagsForToplevelCompile(bool is_user_javascript,
                                   LanguageMode language_mode,
                                   REPLMode repl_mode, ScriptType type,
                                   bool lazy);
@@ -345,8 +343,7 @@ class V8_EXPORT_PRIVATE ParseInfo {
             ReusableUnoptimizedCompileState* reusable_state,
             uintptr_t stack_limit, RuntimeCallStats* runtime_call_stats);
 
-  void CheckFlagsForToplevelCompileFromScript(Script script,
-                                              bool is_collecting_type_profile);
+  void CheckFlagsForToplevelCompileFromScript(Script script);
 
   //------------- Inputs to parsing and scope analysis -----------------------
   const UnoptimizedCompileFlags flags_;
diff --git a/deps/v8/src/parsing/parser-base.h b/deps/v8/src/parsing/parser-base.h
index 786d502ff8..aff9c5f481 100644
--- a/deps/v8/src/parsing/parser-base.h
+++ b/deps/v8/src/parsing/parser-base.h
@@ -459,7 +459,7 @@ class ParserBase {
     }
 
     void set_next_function_is_likely_called() {
-      next_function_is_likely_called_ = !FLAG_max_lazy;
+      next_function_is_likely_called_ = !v8_flags.max_lazy;
     }
 
     void RecordFunctionOrEvalCall() { contains_function_or_eval_ = true; }
@@ -3735,7 +3735,7 @@ ParserBase<Impl>::ParseImportExpressions() {
   AcceptINScope scope(this, true);
   ExpressionT specifier = ParseAssignmentExpressionCoverGrammar();
 
-  if (FLAG_harmony_import_assertions && Check(Token::COMMA)) {
+  if (v8_flags.harmony_import_assertions && Check(Token::COMMA)) {
     if (Check(Token::RPAREN)) {
       // A trailing comma allowed after the specifier.
       return factory()->NewImportCallExpression(specifier, pos);
@@ -4737,7 +4737,7 @@ typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseClassLiteral(
     if (Check(Token::SEMICOLON)) continue;
 
     // Either we're parsing a `static { }` initialization block or a property.
-    if (FLAG_harmony_class_static_blocks && peek() == Token::STATIC &&
+    if (v8_flags.harmony_class_static_blocks && peek() == Token::STATIC &&
         PeekAhead() == Token::LBRACE) {
       BlockT static_block = ParseClassStaticBlock(&class_info);
       impl()->AddClassStaticBlock(static_block, &class_info);
diff --git a/deps/v8/src/parsing/parser.cc b/deps/v8/src/parsing/parser.cc
index bb5e65ec52..aba8ca6271 100644
--- a/deps/v8/src/parsing/parser.cc
+++ b/deps/v8/src/parsing/parser.cc
@@ -379,7 +379,7 @@ Expression* Parser::NewV8Intrinsic(const AstRawString* name,
       Runtime::FunctionForName(name->raw_data(), name->length());
 
   // Be more permissive when fuzzing. Intrinsics are not supported.
-  if (FLAG_fuzzing) {
+  if (v8_flags.fuzzing) {
     return NewV8RuntimeFunctionForFuzzing(function, args, pos);
   }
 
@@ -413,7 +413,7 @@ Expression* Parser::NewV8Intrinsic(const AstRawString* name,
 Expression* Parser::NewV8RuntimeFunctionForFuzzing(
     const Runtime::Function* function, const ScopedPtrList<Expression>& args,
     int pos) {
-  CHECK(FLAG_fuzzing);
+  CHECK(v8_flags.fuzzing);
 
   // Intrinsics are not supported for fuzzing. Only allow allowlisted runtime
   // functions. Also prevent later errors due to too few arguments and just
@@ -1363,7 +1363,7 @@ ImportAssertions* Parser::ParseImportAssertClause() {
 
   auto import_assertions = zone()->New<ImportAssertions>(zone());
 
-  if (!FLAG_harmony_import_assertions) {
+  if (!v8_flags.harmony_import_assertions) {
     return import_assertions;
   }