deps: V8: cherry-pick ee2873a6303d

Original commit message:

    Fix GCC Build

    Move explicit specializations of Utf8::IsAsciiOneByteString to namespace scope

    C++ forbids explicit template specializations inside class scope.
    The specializations for IsAsciiOneByteString<uint8_t> and
    IsAsciiOneByteString<uint16_t> were defined inside class unibrow::Utf8,
    riggering "explicit specialization in non-namespace scope"
    compile errors.

    Fix type mismatch in EXPECT_EQ comparisons for std::pair values

    The tests failed because EXPECT_EQ was comparing pairs with mismatched
    template parameters — std::pair<int, unsigned int> vs.
    std::pair<unsigned int, unsigned char> — which have no valid operator==.
    I corrected the expected values to use the same unsigned types as the
    actual data, ensuring the pair comparison compiles cleanly.

    Fix build failure on GCC 12 by replacing std::format with ostringstream

    GCC 12's libstdc++ does not implement <format>, causing compile errors when
    using std::format. Replaced all std::format calls with equivalent

    Change-Id: I5c31f91065eccf6f4c14172902ffcd99863ebbb9
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/7138905
    Commit-Queue: Clemens Backes <[email protected]>
    Reviewed-by: Jakob Kummerow <[email protected]>
    Reviewed-by: Clemens Backes <[email protected]>
    Commit-Queue: Jakob Kummerow <[email protected]>
    Cr-Commit-Position: refs/heads/main@{#104280}

Refs: v8/v8@ee2873a

Author: abmusse

common.gypi

@@ -38,7 +38,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.7',
+    'v8_embedder_string': '-node.8',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/src/strings/unicode.h

@@ -215,14 +215,6 @@ class V8_EXPORT_PRIVATE Utf8 {
   template <typename Char>
   static size_t WriteLeadingAscii(const Char* src, char* dest, size_t size);
 
-  template <>
-  size_t WriteLeadingAscii<uint8_t>(const uint8_t* src, char* dest,
-                                    size_t size);
-
-  template <>
-  size_t WriteLeadingAscii<uint16_t>(const uint16_t* src, char* dest,
-                                     size_t size);
-
   // Encode the given characters as Utf8 into the provided output buffer.
   struct EncodingResult {
     size_t bytes_written;
@@ -234,6 +226,14 @@ class V8_EXPORT_PRIVATE Utf8 {
                                bool replace_invalid_utf8);
 };
 
+template <>
+size_t unibrow::Utf8::WriteLeadingAscii<uint8_t>(const uint8_t* src, char* dest,
+                                                 size_t size);
+
+template <>
+size_t unibrow::Utf8::WriteLeadingAscii<uint16_t>(const uint16_t* src,
+                                                  char* dest, size_t size);
+
 #if V8_ENABLE_WEBASSEMBLY
 class V8_EXPORT_PRIVATE Wtf8 {
  public:

deps/v8/test/unittests/heap/heap-unittest.cc

@@ -1511,12 +1511,13 @@ TEST_F(HeapTest, ReportStatsAsCrashKeys) {
     const size_t bytes = size.value();
 
     if (bytes >= MB) {
-      return std::format("{:.2f}MB", static_cast<double>(bytes) / MB);
+      return absl::StrFormat("%.2fMB", static_cast<double>(bytes) / MB);
     } else if (bytes >= KB) {
-      return std::format("{:.2f}KB", static_cast<double>(bytes) / KB);
+      return absl::StrFormat("%.2fKB", static_cast<double>(bytes) / KB);
     } else {
-      return std::format("{}B", bytes);
+      return absl::StrFormat("%zuB", bytes);
     }
+
   };
 
   const std::vector<std::pair<std::string, ByteSize>>

deps/v8/test/unittests/wasm/module-decoder-unittest.cc

@@ -2551,10 +2551,10 @@ TEST_F(WasmModuleVerifyTest, InstructionFrequencies) {
   InstructionFrequencies& frequencies = result.value()->instruction_frequencies;
   EXPECT_EQ(2U, frequencies.size());
   EXPECT_EQ(2U, frequencies.at(0).size());
-  EXPECT_EQ(std::pair(5, 31U), frequencies.at(0)[0]);
-  EXPECT_EQ(std::pair(11, 31U), frequencies.at(0)[1]);
+  EXPECT_EQ((std::make_pair(uint32_t{5}, uint8_t{31})), frequencies.at(0)[0]);
+  EXPECT_EQ((std::make_pair(uint32_t{11}, uint8_t{31})), frequencies.at(0)[1]);
   EXPECT_EQ(1U, frequencies.at(1).size());
-  EXPECT_EQ(std::pair(1, 32U), frequencies.at(1)[0]);
+  EXPECT_EQ((std::make_pair(uint32_t{1}, uint8_t{32})), frequencies.at(1)[0]);
 }
 
 TEST_F(WasmModuleVerifyTest, InstructionFrequenciesOutOfOrderFunctions) {
@@ -2649,7 +2649,7 @@ TEST_F(WasmModuleVerifyTest, InstructionFrequenciesHintLengthGreaterThanOne) {
   InstructionFrequencies& frequencies = result.value()->instruction_frequencies;
   EXPECT_EQ(1U, frequencies.size());
   EXPECT_EQ(1U, frequencies.at(0).size());
-  EXPECT_EQ(std::pair(11, 31U), frequencies.at(0)[0]);
+  EXPECT_EQ((std::make_pair(uint32_t{11}, uint8_t{31})), frequencies.at(0)[0]);
 }
 
 TEST_F(WasmModuleVerifyTest, InstructionFrequenciesHintLengthZero) {