From 48db20f6f53060e38b2272566b014741eb4f519f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= Date: Fri, 13 Nov 2020 12:51:53 +0100 Subject: deps: update V8 to 8.7.220 PR-URL: https://github.com/nodejs/node/pull/35700 Reviewed-By: Rich Trott Reviewed-By: Colin Ihrig Reviewed-By: Joyee Cheung Reviewed-By: Matteo Collina Reviewed-By: Jiawen Geng Reviewed-By: Shelley Vohr --- deps/v8/test/unittests/wasm/subtyping-unittest.cc | 157 +++++++++++++--------- 1 file changed, 92 insertions(+), 65 deletions(-) (limited to 'deps/v8/test/unittests/wasm/subtyping-unittest.cc') 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(&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(&allocator, ZONE_NAME)); + WasmModule module2_(std::make_unique(&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 -- cgit v1.2.1