| // Copyright 2020 the V8 project authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "src/wasm/wasm-subtyping.h" | |
| #include "src/wasm/canonical-types.h" | |
| #include "src/wasm/wasm-module.h" | |
| namespace v8::internal::wasm { | |
| namespace { | |
| V8_INLINE bool EquivalentIndices(uint32_t index1, uint32_t index2, | |
| const WasmModule* module1, | |
| const WasmModule* module2) { | |
| DCHECK(index1 != index2 || module1 != module2); | |
| return module1->isorecursive_canonical_type_ids[index1] == | |
| module2->isorecursive_canonical_type_ids[index2]; | |
| } | |
| bool ValidStructSubtypeDefinition(uint32_t subtype_index, | |
| uint32_t supertype_index, | |
| const WasmModule* sub_module, | |
| const WasmModule* super_module) { | |
| const StructType* sub_struct = sub_module->types[subtype_index].struct_type; | |
| const StructType* super_struct = | |
| super_module->types[supertype_index].struct_type; | |
| if (sub_struct->field_count() < super_struct->field_count()) { | |
| return false; | |
| } | |
| for (uint32_t i = 0; i < super_struct->field_count(); i++) { | |
| bool sub_mut = sub_struct->mutability(i); | |
| bool super_mut = super_struct->mutability(i); | |
| if (sub_mut != super_mut || | |
| (sub_mut && | |
| !EquivalentTypes(sub_struct->field(i), super_struct->field(i), | |
| sub_module, super_module)) || | |
| (!sub_mut && !IsSubtypeOf(sub_struct->field(i), super_struct->field(i), | |
| sub_module, super_module))) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| bool ValidArraySubtypeDefinition(uint32_t subtype_index, | |
| uint32_t supertype_index, | |
| const WasmModule* sub_module, | |
| const WasmModule* super_module) { | |
| const ArrayType* sub_array = sub_module->types[subtype_index].array_type; | |
| const ArrayType* super_array = | |
| super_module->types[supertype_index].array_type; | |
| bool sub_mut = sub_array->mutability(); | |
| bool super_mut = super_array->mutability(); | |
| return (sub_mut && super_mut && | |
| EquivalentTypes(sub_array->element_type(), | |
| super_array->element_type(), sub_module, | |
| super_module)) || | |
| (!sub_mut && !super_mut && | |
| IsSubtypeOf(sub_array->element_type(), super_array->element_type(), | |
| sub_module, super_module)); | |
| } | |
| bool ValidFunctionSubtypeDefinition(uint32_t subtype_index, | |
| uint32_t supertype_index, | |
| const WasmModule* sub_module, | |
| const WasmModule* super_module) { | |
| const FunctionSig* sub_func = sub_module->types[subtype_index].function_sig; | |
| const FunctionSig* super_func = | |
| super_module->types[supertype_index].function_sig; | |
| if (sub_func->parameter_count() != super_func->parameter_count() || | |
| sub_func->return_count() != super_func->return_count()) { | |
| return false; | |
| } | |
| for (uint32_t i = 0; i < sub_func->parameter_count(); i++) { | |
| // Contravariance for params. | |
| if (!IsSubtypeOf(super_func->parameters()[i], sub_func->parameters()[i], | |
| super_module, sub_module)) { | |
| return false; | |
| } | |
| } | |
| for (uint32_t i = 0; i < sub_func->return_count(); i++) { | |
| // Covariance for returns. | |
| if (!IsSubtypeOf(sub_func->returns()[i], super_func->returns()[i], | |
| sub_module, super_module)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| HeapType::Representation NullSentinelImpl(HeapType type, | |
| const WasmModule* module) { | |
| switch (type.representation()) { | |
| case HeapType::kI31: | |
| case HeapType::kNone: | |
| case HeapType::kEq: | |
| case HeapType::kStruct: | |
| case HeapType::kArray: | |
| case HeapType::kAny: | |
| case HeapType::kString: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kStringViewIter: | |
| return HeapType::kNone; | |
| case HeapType::kExtern: | |
| case HeapType::kNoExtern: | |
| case HeapType::kExternString: | |
| return HeapType::kNoExtern; | |
| case HeapType::kExn: | |
| case HeapType::kNoExn: | |
| return HeapType::kNoExn; | |
| case HeapType::kFunc: | |
| case HeapType::kNoFunc: | |
| return HeapType::kNoFunc; | |
| case HeapType::kI31Shared: | |
| case HeapType::kNoneShared: | |
| case HeapType::kEqShared: | |
| case HeapType::kStructShared: | |
| case HeapType::kArrayShared: | |
| case HeapType::kAnyShared: | |
| case HeapType::kStringShared: | |
| case HeapType::kStringViewWtf8Shared: | |
| case HeapType::kStringViewWtf16Shared: | |
| case HeapType::kStringViewIterShared: | |
| return HeapType::kNoneShared; | |
| case HeapType::kExternShared: | |
| case HeapType::kNoExternShared: | |
| case HeapType::kExternStringShared: | |
| return HeapType::kNoExternShared; | |
| case HeapType::kExnShared: | |
| case HeapType::kNoExnShared: | |
| return HeapType::kNoExnShared; | |
| case HeapType::kFuncShared: | |
| case HeapType::kNoFuncShared: | |
| return HeapType::kNoFuncShared; | |
| default: { | |
| bool is_shared = module->types[type.ref_index()].is_shared; | |
| return module->has_signature(type.ref_index()) | |
| ? (is_shared ? HeapType::kNoFuncShared : HeapType::kNoFunc) | |
| : (is_shared ? HeapType::kNoneShared : HeapType::kNone); | |
| } | |
| } | |
| } | |
| bool IsNullSentinel(HeapType type) { | |
| switch (type.representation()) { | |
| case HeapType::kNone: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kNoExn: | |
| case HeapType::kNoneShared: | |
| case HeapType::kNoExternShared: | |
| case HeapType::kNoFuncShared: | |
| case HeapType::kNoExnShared: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| } // namespace | |
| bool ValidSubtypeDefinition(uint32_t subtype_index, uint32_t supertype_index, | |
| const WasmModule* sub_module, | |
| const WasmModule* super_module) { | |
| const TypeDefinition& subtype = sub_module->types[subtype_index]; | |
| const TypeDefinition& supertype = super_module->types[supertype_index]; | |
| if (subtype.kind != supertype.kind) return false; | |
| if (supertype.is_final) return false; | |
| if (subtype.is_shared != supertype.is_shared) return false; | |
| switch (subtype.kind) { | |
| case TypeDefinition::kFunction: | |
| return ValidFunctionSubtypeDefinition(subtype_index, supertype_index, | |
| sub_module, super_module); | |
| case TypeDefinition::kStruct: | |
| return ValidStructSubtypeDefinition(subtype_index, supertype_index, | |
| sub_module, super_module); | |
| case TypeDefinition::kArray: | |
| return ValidArraySubtypeDefinition(subtype_index, supertype_index, | |
| sub_module, super_module); | |
| } | |
| } | |
| namespace { | |
| bool IsShared(HeapType type, const WasmModule* module) { | |
| return type.is_abstract_shared() || | |
| (type.is_index() && module->types[type.ref_index()].is_shared); | |
| } | |
| HeapType::Representation MaybeShared(HeapType::Representation base, | |
| bool shared) { | |
| DCHECK(HeapType(base).is_abstract_non_shared()); | |
| if (!shared) return base; | |
| switch (base) { | |
| case HeapType::kFunc: | |
| return HeapType::kFuncShared; | |
| case HeapType::kEq: | |
| return HeapType::kEqShared; | |
| case HeapType::kI31: | |
| return HeapType::kI31Shared; | |
| case HeapType::kStruct: | |
| return HeapType::kStructShared; | |
| case HeapType::kArray: | |
| return HeapType::kArrayShared; | |
| case HeapType::kAny: | |
| return HeapType::kAnyShared; | |
| case HeapType::kExtern: | |
| return HeapType::kExternShared; | |
| case HeapType::kExternString: | |
| return HeapType::kExternStringShared; | |
| case HeapType::kExn: | |
| return HeapType::kExnShared; | |
| case HeapType::kString: | |
| return HeapType::kStringShared; | |
| case HeapType::kStringViewWtf8: | |
| return HeapType::kStringViewWtf8Shared; | |
| case HeapType::kStringViewWtf16: | |
| return HeapType::kStringViewWtf16Shared; | |
| case HeapType::kStringViewIter: | |
| return HeapType::kStringViewIterShared; | |
| case HeapType::kNone: | |
| return HeapType::kNoneShared; | |
| case HeapType::kNoFunc: | |
| return HeapType::kNoFuncShared; | |
| case HeapType::kNoExtern: | |
| return HeapType::kNoExternShared; | |
| case HeapType::kNoExn: | |
| return HeapType::kNoExnShared; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| } | |
| } // namespace | |
| V8_EXPORT_PRIVATE bool IsShared(ValueType type, const WasmModule* module) { | |
| switch (type.kind()) { | |
| case kRef: | |
| case kRefNull: | |
| return IsShared(type.heap_type(), module); | |
| default: | |
| return true; | |
| } | |
| } | |
| V8_NOINLINE V8_EXPORT_PRIVATE bool IsSubtypeOfImpl( | |
| ValueType subtype, ValueType supertype, const WasmModule* sub_module, | |
| const WasmModule* super_module) { | |
| DCHECK(subtype != supertype || sub_module != super_module); | |
| switch (subtype.kind()) { | |
| case kI32: | |
| case kI64: | |
| case kF32: | |
| case kF64: | |
| case kS128: | |
| case kI8: | |
| case kI16: | |
| case kVoid: | |
| case kBottom: | |
| return subtype == supertype; | |
| case kRtt: | |
| return supertype.kind() == kRtt && | |
| EquivalentIndices(subtype.ref_index(), supertype.ref_index(), | |
| sub_module, super_module); | |
| case kRef: | |
| case kRefNull: | |
| break; | |
| } | |
| DCHECK(subtype.is_object_reference()); | |
| bool compatible_references = subtype.is_nullable() | |
| ? supertype.is_nullable() | |
| : supertype.is_object_reference(); | |
| if (!compatible_references) return false; | |
| DCHECK(supertype.is_object_reference()); | |
| // Now check that sub_heap and super_heap are subtype-related. | |
| HeapType sub_heap = subtype.heap_type(); | |
| HeapType super_heap = supertype.heap_type(); | |
| return IsHeapSubtypeOfImpl(sub_heap, super_heap, sub_module, super_module); | |
| } | |
| V8_NOINLINE V8_EXPORT_PRIVATE bool IsHeapSubtypeOfImpl( | |
| HeapType sub_heap, HeapType super_heap, const WasmModule* sub_module, | |
| const WasmModule* super_module) { | |
| if (IsShared(sub_heap, sub_module) != IsShared(super_heap, super_module)) { | |
| return false; | |
| } | |
| HeapType::Representation sub_repr_non_shared = | |
| sub_heap.representation_non_shared(); | |
| HeapType::Representation super_repr_non_shared = | |
| super_heap.representation_non_shared(); | |
| switch (sub_repr_non_shared) { | |
| case HeapType::kFunc: | |
| case HeapType::kAny: | |
| case HeapType::kExtern: | |
| case HeapType::kExn: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kStringViewIter: | |
| return sub_repr_non_shared == super_repr_non_shared; | |
| case HeapType::kEq: | |
| case HeapType::kString: | |
| return sub_repr_non_shared == super_repr_non_shared || | |
| super_repr_non_shared == HeapType::kAny; | |
| case HeapType::kExternString: | |
| return super_repr_non_shared == sub_repr_non_shared || | |
| super_repr_non_shared == HeapType::kExtern; | |
| case HeapType::kI31: | |
| case HeapType::kStruct: | |
| case HeapType::kArray: | |
| return super_repr_non_shared == sub_repr_non_shared || | |
| super_repr_non_shared == HeapType::kEq || | |
| super_repr_non_shared == HeapType::kAny; | |
| case HeapType::kBottom: | |
| UNREACHABLE(); | |
| case HeapType::kNone: | |
| // none is a subtype of every non-func, non-extern and non-exn reference | |
| // type under wasm-gc. | |
| if (super_heap.is_index()) { | |
| return !super_module->has_signature(super_heap.ref_index()); | |
| } | |
| return super_repr_non_shared == HeapType::kAny || | |
| super_repr_non_shared == HeapType::kEq || | |
| super_repr_non_shared == HeapType::kI31 || | |
| super_repr_non_shared == HeapType::kArray || | |
| super_repr_non_shared == HeapType::kStruct || | |
| super_repr_non_shared == HeapType::kString || | |
| super_repr_non_shared == HeapType::kStringViewWtf16 || | |
| super_repr_non_shared == HeapType::kStringViewWtf8 || | |
| super_repr_non_shared == HeapType::kStringViewIter || | |
| super_repr_non_shared == HeapType::kNone; | |
| case HeapType::kNoExtern: | |
| return super_repr_non_shared == HeapType::kNoExtern || | |
| super_repr_non_shared == HeapType::kExtern || | |
| super_repr_non_shared == HeapType::kExternString; | |
| case HeapType::kNoExn: | |
| return super_repr_non_shared == HeapType::kExn || | |
| super_repr_non_shared == HeapType::kNoExn; | |
| case HeapType::kNoFunc: | |
| // nofunc is a subtype of every funcref type under wasm-gc. | |
| if (super_heap.is_index()) { | |
| return super_module->has_signature(super_heap.ref_index()); | |
| } | |
| return super_repr_non_shared == HeapType::kNoFunc || | |
| super_repr_non_shared == HeapType::kFunc; | |
| default: | |
| break; | |
| } | |
| DCHECK(sub_heap.is_index()); | |
| uint32_t sub_index = sub_heap.ref_index(); | |
| DCHECK(sub_module->has_type(sub_index)); | |
| switch (super_repr_non_shared) { | |
| case HeapType::kFunc: | |
| return sub_module->has_signature(sub_index); | |
| case HeapType::kStruct: | |
| return sub_module->has_struct(sub_index); | |
| case HeapType::kEq: | |
| case HeapType::kAny: | |
| return !sub_module->has_signature(sub_index); | |
| case HeapType::kArray: | |
| return sub_module->has_array(sub_index); | |
| case HeapType::kI31: | |
| case HeapType::kExtern: | |
| case HeapType::kExternString: | |
| case HeapType::kExn: | |
| case HeapType::kString: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kStringViewIter: | |
| case HeapType::kNone: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kNoExn: | |
| return false; | |
| case HeapType::kBottom: | |
| UNREACHABLE(); | |
| default: | |
| break; | |
| } | |
| DCHECK(super_heap.is_index()); | |
| uint32_t super_index = super_heap.ref_index(); | |
| DCHECK(super_module->has_type(super_index)); | |
| // The {IsSubtypeOf} entry point already has a fast path checking ValueType | |
| // equality; here we catch (ref $x) being a subtype of (ref null $x). | |
| if (sub_module == super_module && sub_index == super_index) return true; | |
| return GetTypeCanonicalizer()->IsCanonicalSubtype(sub_index, super_index, | |
| sub_module, super_module); | |
| } | |
| V8_NOINLINE bool EquivalentTypes(ValueType type1, ValueType type2, | |
| const WasmModule* module1, | |
| const WasmModule* module2) { | |
| if (type1 == type2 && module1 == module2) return true; | |
| if (!type1.has_index() || !type2.has_index()) return type1 == type2; | |
| if (type1.kind() != type2.kind()) return false; | |
| DCHECK(type1 != type2 || module1 != module2); | |
| DCHECK(type1.has_index() && module1->has_type(type1.ref_index()) && | |
| type2.has_index() && module2->has_type(type2.ref_index())); | |
| return EquivalentIndices(type1.ref_index(), type2.ref_index(), module1, | |
| module2); | |
| } | |
| namespace { | |
| // Returns the least common ancestor of two type indices, as a type index in | |
| // {module1}. | |
| HeapType::Representation CommonAncestor(uint32_t type_index1, | |
| uint32_t type_index2, | |
| const WasmModule* module1, | |
| const WasmModule* module2) { | |
| TypeDefinition::Kind kind1 = module1->types[type_index1].kind; | |
| TypeDefinition::Kind kind2 = module2->types[type_index2].kind; | |
| if (module1->types[type_index1].is_shared != | |
| module2->types[type_index2].is_shared) { | |
| return HeapType::kBottom; | |
| } | |
| bool both_shared = module1->types[type_index1].is_shared; | |
| { | |
| int depth1 = GetSubtypingDepth(module1, type_index1); | |
| int depth2 = GetSubtypingDepth(module2, type_index2); | |
| while (depth1 > depth2) { | |
| type_index1 = module1->supertype(type_index1); | |
| depth1--; | |
| } | |
| while (depth2 > depth1) { | |
| type_index2 = module2->supertype(type_index2); | |
| depth2--; | |
| } | |
| } | |
| DCHECK_NE(type_index1, kNoSuperType); | |
| DCHECK_NE(type_index2, kNoSuperType); | |
| while (type_index1 != kNoSuperType && | |
| !(type_index1 == type_index2 && module1 == module2) && | |
| !EquivalentIndices(type_index1, type_index2, module1, module2)) { | |
| type_index1 = module1->supertype(type_index1); | |
| type_index2 = module2->supertype(type_index2); | |
| } | |
| DCHECK_EQ(type_index1 == kNoSuperType, type_index2 == kNoSuperType); | |
| if (type_index1 != kNoSuperType) { | |
| return static_cast<HeapType::Representation>(type_index1); | |
| } | |
| switch (kind1) { | |
| case TypeDefinition::kFunction: | |
| switch (kind2) { | |
| case TypeDefinition::kFunction: | |
| return MaybeShared(HeapType::kFunc, both_shared); | |
| case TypeDefinition::kStruct: | |
| case TypeDefinition::kArray: | |
| return HeapType::kBottom; | |
| } | |
| case TypeDefinition::kStruct: | |
| switch (kind2) { | |
| case TypeDefinition::kFunction: | |
| return HeapType::kBottom; | |
| case TypeDefinition::kStruct: | |
| return MaybeShared(HeapType::kStruct, both_shared); | |
| case TypeDefinition::kArray: | |
| return MaybeShared(HeapType::kEq, both_shared); | |
| } | |
| case TypeDefinition::kArray: | |
| switch (kind2) { | |
| case TypeDefinition::kFunction: | |
| return HeapType::kBottom; | |
| case TypeDefinition::kStruct: | |
| return MaybeShared(HeapType::kEq, both_shared); | |
| case TypeDefinition::kArray: | |
| return MaybeShared(HeapType::kArray, both_shared); | |
| } | |
| } | |
| } | |
| // Returns the least common ancestor of a abstract HeapType {heap1}, and | |
| // another HeapType {heap2}. | |
| HeapType::Representation CommonAncestorWithAbstract(HeapType heap1, | |
| HeapType heap2, | |
| const WasmModule* module2) { | |
| DCHECK(heap1.is_abstract()); | |
| // Passing {module2} with {heap1} below is fine since {heap1} is abstract. | |
| bool is_shared = IsShared(heap1, module2); | |
| if (is_shared != IsShared(heap2, module2)) { | |
| return HeapType::kBottom; | |
| } | |
| HeapType::Representation repr_non_shared2 = heap2.representation_non_shared(); | |
| switch (heap1.representation_non_shared()) { | |
| case HeapType::kFunc: { | |
| if (repr_non_shared2 == HeapType::kFunc || | |
| repr_non_shared2 == HeapType::kNoFunc || | |
| (heap2.is_index() && module2->has_signature(heap2.ref_index()))) { | |
| return MaybeShared(HeapType::kFunc, is_shared); | |
| } else { | |
| return HeapType::kBottom; | |
| } | |
| } | |
| case HeapType::kAny: { | |
| switch (repr_non_shared2) { | |
| case HeapType::kI31: | |
| case HeapType::kNone: | |
| case HeapType::kEq: | |
| case HeapType::kStruct: | |
| case HeapType::kArray: | |
| case HeapType::kAny: | |
| case HeapType::kString: | |
| return MaybeShared(HeapType::kAny, is_shared); | |
| case HeapType::kFunc: | |
| case HeapType::kExtern: | |
| case HeapType::kExternString: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kStringViewIter: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kExn: | |
| case HeapType::kNoExn: | |
| case HeapType::kBottom: | |
| return HeapType::kBottom; | |
| default: | |
| return module2->has_signature(heap2.ref_index()) | |
| ? HeapType::kBottom | |
| : MaybeShared(HeapType::kAny, is_shared); | |
| } | |
| } | |
| case HeapType::kEq: { | |
| switch (repr_non_shared2) { | |
| case HeapType::kI31: | |
| case HeapType::kNone: | |
| case HeapType::kEq: | |
| case HeapType::kStruct: | |
| case HeapType::kArray: | |
| return MaybeShared(HeapType::kEq, is_shared); | |
| case HeapType::kAny: | |
| case HeapType::kString: | |
| return MaybeShared(HeapType::kAny, is_shared); | |
| case HeapType::kFunc: | |
| case HeapType::kExtern: | |
| case HeapType::kExternString: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kStringViewIter: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kExn: | |
| case HeapType::kNoExn: | |
| case HeapType::kBottom: | |
| return HeapType::kBottom; | |
| default: | |
| return module2->has_signature(heap2.ref_index()) | |
| ? HeapType::kBottom | |
| : MaybeShared(HeapType::kEq, is_shared); | |
| } | |
| } | |
| case HeapType::kI31: | |
| switch (repr_non_shared2) { | |
| case HeapType::kI31: | |
| case HeapType::kNone: | |
| return MaybeShared(HeapType::kI31, is_shared); | |
| case HeapType::kEq: | |
| case HeapType::kStruct: | |
| case HeapType::kArray: | |
| return MaybeShared(HeapType::kEq, is_shared); | |
| case HeapType::kAny: | |
| case HeapType::kString: | |
| return MaybeShared(HeapType::kAny, is_shared); | |
| case HeapType::kFunc: | |
| case HeapType::kExtern: | |
| case HeapType::kExternString: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kStringViewIter: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kExn: | |
| case HeapType::kNoExn: | |
| case HeapType::kBottom: | |
| return HeapType::kBottom; | |
| default: | |
| return module2->has_signature(heap2.ref_index()) | |
| ? HeapType::kBottom | |
| : MaybeShared(HeapType::kEq, is_shared); | |
| } | |
| case HeapType::kStruct: | |
| switch (repr_non_shared2) { | |
| case HeapType::kStruct: | |
| case HeapType::kNone: | |
| return MaybeShared(HeapType::kStruct, is_shared); | |
| case HeapType::kArray: | |
| case HeapType::kI31: | |
| case HeapType::kEq: | |
| return MaybeShared(HeapType::kEq, is_shared); | |
| case HeapType::kAny: | |
| case HeapType::kString: | |
| return MaybeShared(HeapType::kAny, is_shared); | |
| case HeapType::kFunc: | |
| case HeapType::kExtern: | |
| case HeapType::kExternString: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kStringViewIter: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kExn: | |
| case HeapType::kNoExn: | |
| case HeapType::kBottom: | |
| return HeapType::kBottom; | |
| default: | |
| return module2->has_struct(heap2.ref_index()) | |
| ? MaybeShared(HeapType::kStruct, is_shared) | |
| : module2->has_array(heap2.ref_index()) | |
| ? MaybeShared(HeapType::kEq, is_shared) | |
| : HeapType::kBottom; | |
| } | |
| case HeapType::kArray: | |
| switch (repr_non_shared2) { | |
| case HeapType::kArray: | |
| case HeapType::kNone: | |
| return MaybeShared(HeapType::kArray, is_shared); | |
| case HeapType::kStruct: | |
| case HeapType::kI31: | |
| case HeapType::kEq: | |
| return MaybeShared(HeapType::kEq, is_shared); | |
| case HeapType::kAny: | |
| case HeapType::kString: | |
| return MaybeShared(HeapType::kAny, is_shared); | |
| case HeapType::kFunc: | |
| case HeapType::kExtern: | |
| case HeapType::kExternString: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kStringViewIter: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kExn: | |
| case HeapType::kNoExn: | |
| case HeapType::kBottom: | |
| return HeapType::kBottom; | |
| default: | |
| return module2->has_array(heap2.ref_index()) | |
| ? MaybeShared(HeapType::kArray, is_shared) | |
| : module2->has_struct(heap2.ref_index()) | |
| ? MaybeShared(HeapType::kEq, is_shared) | |
| : HeapType::kBottom; | |
| } | |
| case HeapType::kBottom: | |
| return HeapType::kBottom; | |
| case HeapType::kNone: | |
| switch (repr_non_shared2) { | |
| case HeapType::kArray: | |
| case HeapType::kNone: | |
| case HeapType::kStruct: | |
| case HeapType::kI31: | |
| case HeapType::kEq: | |
| case HeapType::kAny: | |
| case HeapType::kString: | |
| return heap2.representation(); | |
| case HeapType::kExtern: | |
| case HeapType::kExternString: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kFunc: | |
| case HeapType::kStringViewIter: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kExn: | |
| case HeapType::kNoExn: | |
| case HeapType::kBottom: | |
| return HeapType::kBottom; | |
| default: | |
| return module2->has_signature(heap2.ref_index()) | |
| ? HeapType::kBottom | |
| : heap2.representation(); | |
| } | |
| case HeapType::kNoFunc: | |
| return (repr_non_shared2 == HeapType::kNoFunc || | |
| repr_non_shared2 == HeapType::kFunc || | |
| (heap2.is_index() && module2->has_signature(heap2.ref_index()))) | |
| ? heap2.representation() | |
| : HeapType::kBottom; | |
| case HeapType::kNoExtern: | |
| return repr_non_shared2 == HeapType::kExtern || | |
| repr_non_shared2 == HeapType::kNoExtern || | |
| repr_non_shared2 == HeapType::kExternString | |
| ? heap2.representation() | |
| : HeapType::kBottom; | |
| case HeapType::kExtern: | |
| return repr_non_shared2 == HeapType::kExtern || | |
| repr_non_shared2 == HeapType::kNoExtern || | |
| repr_non_shared2 == HeapType::kExternString | |
| ? MaybeShared(HeapType::kExtern, is_shared) | |
| : HeapType::kBottom; | |
| case HeapType::kExternString: | |
| return repr_non_shared2 == HeapType::kExtern | |
| ? MaybeShared(HeapType::kExtern, is_shared) | |
| : (repr_non_shared2 == HeapType::kNoExtern || | |
| repr_non_shared2 == HeapType::kExternString) | |
| ? MaybeShared(HeapType::kExternString, is_shared) | |
| : HeapType::kBottom; | |
| case HeapType::kNoExn: | |
| return repr_non_shared2 == HeapType::kExn || | |
| repr_non_shared2 == HeapType::kNoExn | |
| ? heap1.representation() | |
| : HeapType::kBottom; | |
| case HeapType::kExn: | |
| return repr_non_shared2 == HeapType::kExn || | |
| repr_non_shared2 == HeapType::kNoExn | |
| ? MaybeShared(HeapType::kExn, is_shared) | |
| : HeapType::kBottom; | |
| case HeapType::kString: { | |
| switch (repr_non_shared2) { | |
| case HeapType::kI31: | |
| case HeapType::kEq: | |
| case HeapType::kStruct: | |
| case HeapType::kArray: | |
| case HeapType::kAny: | |
| return MaybeShared(HeapType::kAny, is_shared); | |
| case HeapType::kNone: | |
| case HeapType::kString: | |
| return MaybeShared(HeapType::kString, is_shared); | |
| case HeapType::kFunc: | |
| case HeapType::kExtern: | |
| case HeapType::kExternString: | |
| case HeapType::kNoExtern: | |
| case HeapType::kNoFunc: | |
| case HeapType::kStringViewIter: | |
| case HeapType::kStringViewWtf8: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kExn: | |
| case HeapType::kBottom: | |
| return HeapType::kBottom; | |
| default: | |
| return module2->has_signature(heap2.ref_index()) | |
| ? HeapType::kBottom | |
| : MaybeShared(HeapType::kAny, is_shared); | |
| } | |
| } | |
| case HeapType::kStringViewIter: | |
| case HeapType::kStringViewWtf16: | |
| case HeapType::kStringViewWtf8: | |
| return heap1 == heap2 ? heap1.representation() : HeapType::kBottom; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| } | |
| } // namespace | |
| V8_EXPORT_PRIVATE TypeInModule Union(ValueType type1, ValueType type2, | |
| const WasmModule* module1, | |
| const WasmModule* module2) { | |
| if (!type1.is_object_reference() || !type2.is_object_reference()) { | |
| return { | |
| EquivalentTypes(type1, type2, module1, module2) ? type1 : kWasmBottom, | |
| module1}; | |
| } | |
| Nullability nullability = | |
| type1.is_nullable() || type2.is_nullable() ? kNullable : kNonNullable; | |
| HeapType heap1 = type1.heap_type(); | |
| HeapType heap2 = type2.heap_type(); | |
| if (heap1 == heap2 && module1 == module2) { | |
| return {ValueType::RefMaybeNull(heap1, nullability), module1}; | |
| } | |
| HeapType::Representation result_repr; | |
| const WasmModule* result_module; | |
| if (heap1.is_abstract()) { | |
| result_repr = CommonAncestorWithAbstract(heap1, heap2, module2); | |
| result_module = module2; | |
| } else if (heap2.is_abstract()) { | |
| result_repr = CommonAncestorWithAbstract(heap2, heap1, module1); | |
| result_module = module1; | |
| } else { | |
| result_repr = | |
| CommonAncestor(heap1.ref_index(), heap2.ref_index(), module1, module2); | |
| result_module = module1; | |
| } | |
| return {result_repr == HeapType::kBottom | |
| ? kWasmBottom | |
| : ValueType::RefMaybeNull(result_repr, nullability), | |
| result_module}; | |
| } | |
| TypeInModule Intersection(ValueType type1, ValueType type2, | |
| const WasmModule* module1, | |
| const WasmModule* module2) { | |
| if (!type1.is_object_reference() || !type2.is_object_reference()) { | |
| return { | |
| EquivalentTypes(type1, type2, module1, module2) ? type1 : kWasmBottom, | |
| module1}; | |
| } | |
| Nullability nullability = | |
| type1.is_nullable() && type2.is_nullable() ? kNullable : kNonNullable; | |
| // non-nullable null type is not a valid type. | |
| if (nullability == kNonNullable && (IsNullSentinel(type1.heap_type()) || | |
| IsNullSentinel(type2.heap_type()))) { | |
| return {kWasmBottom, module1}; | |
| } | |
| if (IsHeapSubtypeOf(type1.heap_type(), type2.heap_type(), module1, module2)) { | |
| return TypeInModule{ValueType::RefMaybeNull(type1.heap_type(), nullability), | |
| module1}; | |
| } | |
| if (IsHeapSubtypeOf(type2.heap_type(), type1.heap_type(), module2, module1)) { | |
| return TypeInModule{ValueType::RefMaybeNull(type2.heap_type(), nullability), | |
| module2}; | |
| } | |
| if (nullability == kNonNullable) { | |
| return {kWasmBottom, module1}; | |
| } | |
| // Check for common null representation. | |
| ValueType null_type1 = ToNullSentinel({type1, module1}); | |
| if (null_type1 == ToNullSentinel({type2, module2})) { | |
| return {null_type1, module1}; | |
| } | |
| return {kWasmBottom, module1}; | |
| } | |
| ValueType ToNullSentinel(TypeInModule type) { | |
| HeapType::Representation null_heap = | |
| NullSentinelImpl(type.type.heap_type(), type.module); | |
| DCHECK( | |
| IsHeapSubtypeOf(HeapType(null_heap), type.type.heap_type(), type.module)); | |
| return ValueType::RefNull(null_heap); | |
| } | |
| bool IsSameTypeHierarchy(HeapType type1, HeapType type2, | |
| const WasmModule* module) { | |
| return NullSentinelImpl(type1, module) == NullSentinelImpl(type2, module); | |
| } | |
| } // namespace v8::internal::wasm |