deps: update V8 to 8.7.220

PR-URL: https://github.com/nodejs/node/pull/35700
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: Shelley Vohr <codebytere@gmail.com>

1 files changed, 92 insertions, 65 deletions

diff --git a/deps/v8/test/unittests/wasm/subtyping-unittest.cc b/deps/v8/test/unittests/wasm/subtyping-unittest.cc
index 8be7f808e8..5b43924493 100644
--- a/deps/v8/test/unittests/wasm/subtyping-unittest.cc
+++ b/deps/v8/test/unittests/wasm/subtyping-unittest.cc
@@ -35,20 +35,25 @@ void DefineArray(WasmModule* module, FieldInit element_type) {
 
 TEST_F(WasmSubtypingTest, Subtyping) {
   v8::internal::AccountingAllocator allocator;
-  WasmModule module_(std::make_unique<Zone>(&allocator, ZONE_NAME));
-
-  WasmModule* module = &module_;
-
-  /* 0 */ DefineStruct(module, {mut(ref(2)), immut(optRef(2))});
-  /* 1 */ DefineStruct(module, {mut(ref(2)), immut(ref(2))});
-  /* 2 */ DefineArray(module, immut(ref(0)));
-  /* 3 */ DefineArray(module, immut(ref(1)));
-  /* 4 */ DefineStruct(module, {mut(ref(2)), immut(ref(3)), immut(kWasmF64)});
-  /* 5 */ DefineStruct(module, {mut(optRef(2)), immut(ref(2))});
-  /* 6 */ DefineArray(module, mut(kWasmI32));
-  /* 7 */ DefineArray(module, immut(kWasmI32));
-  /* 8 */ DefineStruct(module, {mut(kWasmI32), immut(optRef(8))});
-  /* 9 */ DefineStruct(module, {mut(kWasmI32), immut(optRef(8))});
+  WasmModule module1_(std::make_unique<Zone>(&allocator, ZONE_NAME));
+  WasmModule module2_(std::make_unique<Zone>(&allocator, ZONE_NAME));
+
+  WasmModule* module1 = &module1_;
+  WasmModule* module2 = &module2_;
+
+  // Set up two identical modules.
+  for (WasmModule* module : {module1, module2}) {
+    /* 0 */ DefineStruct(module, {mut(ref(2)), immut(optRef(2))});
+    /* 1 */ DefineStruct(module, {mut(ref(2)), immut(ref(2))});
+    /* 2 */ DefineArray(module, immut(ref(0)));
+    /* 3 */ DefineArray(module, immut(ref(1)));
+    /* 4 */ DefineStruct(module, {mut(ref(2)), immut(ref(3)), immut(kWasmF64)});
+    /* 5 */ DefineStruct(module, {mut(optRef(2)), immut(ref(2))});
+    /* 6 */ DefineArray(module, mut(kWasmI32));
+    /* 7 */ DefineArray(module, immut(kWasmI32));
+    /* 8 */ DefineStruct(module, {mut(kWasmI32), immut(optRef(8))});
+    /* 9 */ DefineStruct(module, {mut(kWasmI32), immut(optRef(8))});
+  }
 
   ValueType numeric_types[] = {kWasmI32, kWasmI64, kWasmF32, kWasmF64,
                                kWasmS128};
@@ -56,65 +61,87 @@ TEST_F(WasmSubtypingTest, Subtyping) {
                            kWasmEqRef,     kWasmI31Ref,  optRef(0),
                            ref(0),         optRef(2),    ref(2)};
 
-  // Value types are unrelated, except if they are equal.
-  for (ValueType subtype : numeric_types) {
-    for (ValueType supertype : numeric_types) {
-      CHECK_EQ(IsSubtypeOf(subtype, supertype, module), subtype == supertype);
+  // Type judgements across modules should work the same as within one module.
+  for (WasmModule* module : {module1, module2}) {
+    // Value types are unrelated, except if they are equal.
+    for (ValueType subtype : numeric_types) {
+      for (ValueType supertype : numeric_types) {
+        CHECK_EQ(IsSubtypeOf(subtype, supertype, module1, module),
+                 subtype == supertype);
+      }
     }
-  }
 
-  // Value types are unrelated with reference types.
-  for (ValueType value_type : numeric_types) {
-    for (ValueType ref_type : ref_types) {
-      CHECK(!IsSubtypeOf(value_type, ref_type, module));
-      CHECK(!IsSubtypeOf(ref_type, value_type, module));
+    // Value types are unrelated with reference types.
+    for (ValueType value_type : numeric_types) {
+      for (ValueType ref_type : ref_types) {
+        CHECK(!IsSubtypeOf(value_type, ref_type, module1, module));
+        CHECK(!IsSubtypeOf(ref_type, value_type, module1, module));
+      }
     }
-  }
 
-  for (ValueType ref_type : ref_types) {
-    // Concrete reference types and i31ref are subtypes of eqref,
-    // exnref/externref/funcref are not.
-    CHECK_EQ(IsSubtypeOf(ref_type, kWasmEqRef, module),
-             ref_type != kWasmFuncRef && ref_type != kWasmExternRef &&
-                 ref_type != kWasmExnRef);
-    // Each reference type is a subtype of itself.
-    CHECK(IsSubtypeOf(ref_type, ref_type, module));
-  }
+    for (ValueType ref_type : ref_types) {
+      // Concrete reference types and i31ref are subtypes of eqref,
+      // exnref/externref/funcref are not.
+      CHECK_EQ(IsSubtypeOf(ref_type, kWasmEqRef, module1, module),
+               ref_type != kWasmFuncRef && ref_type != kWasmExternRef &&
+                   ref_type != kWasmExnRef);
+      // Each reference type is a subtype of itself.
+      CHECK(IsSubtypeOf(ref_type, ref_type, module1, module));
+    }
 
-  // The rest of ref. types are unrelated.
-  for (ValueType type_1 :
-       {kWasmExternRef, kWasmFuncRef, kWasmExnRef, kWasmI31Ref}) {
-    for (ValueType type_2 :
+    // The rest of ref. types are unrelated.
+    for (ValueType type_1 :
          {kWasmExternRef, kWasmFuncRef, kWasmExnRef, kWasmI31Ref}) {
-      CHECK_EQ(IsSubtypeOf(type_1, type_2, module), type_1 == type_2);
+      for (ValueType type_2 :
+           {kWasmExternRef, kWasmFuncRef, kWasmExnRef, kWasmI31Ref}) {
+        CHECK_EQ(IsSubtypeOf(type_1, type_2, module1, module),
+                 type_1 == type_2);
+      }
     }
-  }
 
-  // Unrelated refs are unrelated.
-  CHECK(!IsSubtypeOf(ref(0), ref(2), module));
-  CHECK(!IsSubtypeOf(optRef(3), optRef(1), module));
-  // ref is a subtype of optref for the same struct/array.
-  CHECK(IsSubtypeOf(ref(0), optRef(0), module));
-  CHECK(IsSubtypeOf(ref(2), optRef(2), module));
-  // optref is not a subtype of ref for the same struct/array.
-  CHECK(!IsSubtypeOf(optRef(0), ref(0), module));
-  CHECK(!IsSubtypeOf(optRef(2), ref(2), module));
-  // ref is a subtype of optref if the same is true for the underlying
-  // structs/arrays.
-  CHECK(IsSubtypeOf(ref(3), optRef(2), module));
-  // Prefix subtyping for structs.
-  CHECK(IsSubtypeOf(optRef(4), optRef(0), module));
-  // Mutable fields are invariant.
-  CHECK(!IsSubtypeOf(ref(0), ref(5), module));
-  // Immutable fields are covariant.
-  CHECK(IsSubtypeOf(ref(1), ref(0), module));
-  // Prefix subtyping + immutable field covariance for structs.
-  CHECK(IsSubtypeOf(optRef(4), optRef(1), module));
-  // No subtyping between mutable/immutable fields.
-  CHECK(!IsSubtypeOf(ref(7), ref(6), module));
-  CHECK(!IsSubtypeOf(ref(6), ref(7), module));
-  // Recursive types.
-  CHECK(IsSubtypeOf(ref(9), ref(8), module));
+    // Unrelated refs are unrelated.
+    CHECK(!IsSubtypeOf(ref(0), ref(2), module1, module));
+    CHECK(!IsSubtypeOf(optRef(3), optRef(1), module1, module));
+    // ref is a subtype of optref for the same struct/array.
+    CHECK(IsSubtypeOf(ref(0), optRef(0), module1, module));
+    CHECK(IsSubtypeOf(ref(2), optRef(2), module1, module));
+    // optref is not a subtype of ref for the same struct/array.
+    CHECK(!IsSubtypeOf(optRef(0), ref(0), module1, module));
+    CHECK(!IsSubtypeOf(optRef(2), ref(2), module1, module));
+    // ref is a subtype of optref if the same is true for the underlying
+    // structs/arrays.
+    CHECK(IsSubtypeOf(ref(3), optRef(2), module1, module));
+    // Prefix subtyping for structs.
+    CHECK(IsSubtypeOf(optRef(4), optRef(0), module1, module));
+    // Mutable fields are invariant.
+    CHECK(!IsSubtypeOf(ref(0), ref(5), module1, module));
+    // Immutable fields are covariant.
+    CHECK(IsSubtypeOf(ref(1), ref(0), module1, module));
+    // Prefix subtyping + immutable field covariance for structs.
+    CHECK(IsSubtypeOf(optRef(4), optRef(1), module1, module));
+    // No subtyping between mutable/immutable fields.
+    CHECK(!IsSubtypeOf(ref(7), ref(6), module1, module));
+    CHECK(!IsSubtypeOf(ref(6), ref(7), module1, module));
+    // Recursive types.
+    CHECK(IsSubtypeOf(ref(9), ref(8), module1, module));
+
+    // Identical rtts are subtypes of each other.
+    CHECK(IsSubtypeOf(ValueType::Rtt(5, 3), ValueType::Rtt(5, 3), module1,
+                      module2));
+    CHECK(IsSubtypeOf(ValueType::Rtt(HeapType::kExn, 3),
+                      ValueType::Rtt(HeapType::kExn, 3), module1, module2));
+    // Rtts of different depth are unrelated.
+    CHECK(!IsSubtypeOf(ValueType::Rtt(5, 1), ValueType::Rtt(5, 3), module1,
+                       module2));
+    CHECK(!IsSubtypeOf(ValueType::Rtt(5, 8), ValueType::Rtt(5, 3), module1,
+                       module2));
+    // Rtts of identical types are subtype-related.
+    CHECK(IsSubtypeOf(ValueType::Rtt(8, 1), ValueType::Rtt(9, 1), module1,
+                      module));
+    // Rtts of subtypes are not related.
+    CHECK(!IsSubtypeOf(ValueType::Rtt(1, 1), ValueType::Rtt(0, 1), module1,
+                       module));
+  }
 }
 
 }  // namespace subtyping_unittest