diff --git a/include/v8-internal.h b/include/v8-internal.h index b67924381e..2e8859a243 100644 --- a/include/v8-internal.h +++ b/include/v8-internal.h @@ -172,9 +172,9 @@ class Internals { static const int kNodeIsIndependentShift = 3; static const int kNodeIsActiveShift = 4; - static const int kFirstNonstringType = 0x80; - static const int kOddballType = 0x83; - static const int kForeignType = 0x87; + static const int kFirstNonstringType = 0x40; + static const int kOddballType = 0x43; + static const int kForeignType = 0x47; static const int kJSSpecialApiObjectType = 0x410; static const int kJSApiObjectType = 0x420; static const int kJSObjectType = 0x421; diff --git a/src/api.cc b/src/api.cc index 8a986220fc..168522f8c3 100644 --- a/src/api.cc +++ b/src/api.cc @@ -5153,7 +5153,7 @@ int String::Length() const { bool String::IsOneByte() const { i::Handle str = Utils::OpenHandle(this); - return str->HasOnlyOneByteChars(); + return str->IsOneByteRepresentation(); } @@ -5266,7 +5266,7 @@ class ContainsOnlyOneByteHelper { bool String::ContainsOnlyOneByte() const { i::Handle str = Utils::OpenHandle(this); - if (str->HasOnlyOneByteChars()) return true; + if (str->IsOneByteRepresentation()) return true; ContainsOnlyOneByteHelper helper; return helper.Check(*str); } diff --git a/src/builtins/array-join.tq b/src/builtins/array-join.tq index 6c32afcce7..f29f6694d4 100644 --- a/src/builtins/array-join.tq +++ b/src/builtins/array-join.tq @@ -162,7 +162,8 @@ namespace array_join { AddStringLength(this.totalStringLength, str.length); this.fixedArray = StoreAndGrowFixedArray(this.fixedArray, this.index++, str); - this.isOneByte = HasOnlyOneByteChars(str.instanceType) & this.isOneByte; + this.isOneByte = + IsOneByteStringInstanceType(str.instanceType) & this.isOneByte; } AddSeparators(implicit context: Context)( @@ -221,7 +222,7 @@ namespace array_join { AllocateZeroedFixedArray(cappedBufferSize), 0, 0, - HasOnlyOneByteChars(sep.instanceType) + IsOneByteStringInstanceType(sep.instanceType) }; } diff --git a/src/builtins/base.tq b/src/builtins/base.tq index 41225bf132..4f96e6c29b 100644 --- a/src/builtins/base.tq +++ b/src/builtins/base.tq @@ -1802,7 +1802,7 @@ transitioning macro GetLengthProperty(implicit context: Context)(o: Object): } extern macro NumberToString(Number): String; -extern macro HasOnlyOneByteChars(InstanceType): bool; +extern macro IsOneByteStringInstanceType(InstanceType): bool; extern macro AllocateSeqOneByteString(implicit context: Context)(uint32): String; extern macro AllocateSeqTwoByteString(implicit context: Context)(uint32): diff --git a/src/code-stub-assembler.cc b/src/code-stub-assembler.cc index c7566edc87..a7383c14c9 100644 --- a/src/code-stub-assembler.cc +++ b/src/code-stub-assembler.cc @@ -3315,53 +3315,18 @@ TNode CodeStubAssembler::AllocateConsString(TNode length, Node* left_instance_type = LoadInstanceType(left); Node* right_instance_type = LoadInstanceType(right); - // Compute intersection and difference of instance types. - Node* anded_instance_types = - Word32And(left_instance_type, right_instance_type); - Node* xored_instance_types = - Word32Xor(left_instance_type, right_instance_type); - - // We create a one-byte cons string if - // 1. both strings are one-byte, or - // 2. at least one of the strings is two-byte, but happens to contain only - // one-byte characters. - // To do this, we check - // 1. if both strings are one-byte, or if the one-byte data hint is set in - // both strings, or - // 2. if one of the strings has the one-byte data hint set and the other - // string is one-byte. + // Determine the resulting ConsString map to use depending on whether + // any of {left} or {right} has two byte encoding. STATIC_ASSERT(kOneByteStringTag != 0); - STATIC_ASSERT(kOneByteDataHintTag != 0); - Label one_byte_map(this); - Label two_byte_map(this); - TVARIABLE(Map, result_map); - Label done(this, &result_map); - GotoIf(IsSetWord32(anded_instance_types, - kStringEncodingMask | kOneByteDataHintTag), - &one_byte_map); - Branch(Word32NotEqual(Word32And(xored_instance_types, - Int32Constant(kStringEncodingMask | - kOneByteDataHintMask)), - Int32Constant(kOneByteStringTag | kOneByteDataHintTag)), - &two_byte_map, &one_byte_map); - - BIND(&one_byte_map); - { - Comment("One-byte ConsString"); - result_map = CAST(LoadRoot(RootIndex::kConsOneByteStringMap)); - Goto(&done); - } - - BIND(&two_byte_map); - { - Comment("Two-byte ConsString"); - result_map = CAST(LoadRoot(RootIndex::kConsStringMap)); - Goto(&done); - } - - BIND(&done); + STATIC_ASSERT(kTwoByteStringTag == 0); + Node* combined_instance_type = + Word32And(left_instance_type, right_instance_type); + TNode result_map = CAST(Select( + IsSetWord32(combined_instance_type, kStringEncodingMask), + [=] { return LoadRoot(RootIndex::kConsOneByteStringMap); }, + [=] { return LoadRoot(RootIndex::kConsStringMap); })); Node* result = AllocateInNewSpace(ConsString::kSize); - StoreMapNoWriteBarrier(result, result_map.value()); + StoreMapNoWriteBarrier(result, result_map); StoreObjectFieldNoWriteBarrier(result, ConsString::kLengthOffset, length, MachineRepresentation::kWord32); StoreObjectFieldNoWriteBarrier(result, ConsString::kHashFieldOffset, @@ -6085,12 +6050,6 @@ TNode CodeStubAssembler::IsOneByteStringInstanceType( Int32Constant(kOneByteStringTag)); } -TNode CodeStubAssembler::HasOnlyOneByteChars( - TNode instance_type) { - CSA_ASSERT(this, IsStringInstanceType(instance_type)); - return IsSetWord32(instance_type, kStringEncodingMask | kOneByteDataHintMask); -} - TNode CodeStubAssembler::IsSequentialStringInstanceType( SloppyTNode instance_type) { CSA_ASSERT(this, IsStringInstanceType(instance_type)); diff --git a/src/code-stub-assembler.h b/src/code-stub-assembler.h index 71616a0576..0863e5f049 100644 --- a/src/code-stub-assembler.h +++ b/src/code-stub-assembler.h @@ -2141,7 +2141,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler TNode IsNullOrUndefined(SloppyTNode object); TNode IsNumberDictionary(SloppyTNode object); TNode IsOneByteStringInstanceType(SloppyTNode instance_type); - TNode HasOnlyOneByteChars(TNode instance_type); TNode IsPrimitiveInstanceType(SloppyTNode instance_type); TNode IsPrivateSymbol(SloppyTNode object); TNode IsPromiseCapability(SloppyTNode object); diff --git a/src/compiler/types.cc b/src/compiler/types.cc index f9fb60db89..f5106fb2d5 100644 --- a/src/compiler/types.cc +++ b/src/compiler/types.cc @@ -145,19 +145,15 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) { case SLICED_ONE_BYTE_STRING_TYPE: case EXTERNAL_STRING_TYPE: case EXTERNAL_ONE_BYTE_STRING_TYPE: - case EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE: case UNCACHED_EXTERNAL_STRING_TYPE: case UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE: - case UNCACHED_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE: case STRING_TYPE: case ONE_BYTE_STRING_TYPE: return kString; case EXTERNAL_INTERNALIZED_STRING_TYPE: case EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE: - case EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE: case UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE: case UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE: - case UNCACHED_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE: case INTERNALIZED_STRING_TYPE: case ONE_BYTE_INTERNALIZED_STRING_TYPE: return kInternalizedString; diff --git a/src/counters.h b/src/counters.h index c86f2fd90f..5c08557ccd 100644 --- a/src/counters.h +++ b/src/counters.h @@ -1429,7 +1429,6 @@ class RuntimeCallTimerScope { SC(fast_new_closure_total, V8.FastNewClosureTotal) \ SC(string_add_runtime, V8.StringAddRuntime) \ SC(string_add_native, V8.StringAddNative) \ - SC(string_add_runtime_ext_to_one_byte, V8.StringAddRuntimeExtToOneByte) \ SC(sub_string_runtime, V8.SubStringRuntime) \ SC(sub_string_native, V8.SubStringNative) \ SC(regexp_entry_runtime, V8.RegExpEntryRuntime) \ diff --git a/src/heap/factory.cc b/src/heap/factory.cc index 740a86d105..48957b3c96 100644 --- a/src/heap/factory.cc +++ b/src/heap/factory.cc @@ -991,14 +991,10 @@ MaybeHandle GetInternalizedStringMap(Factory* f, Handle string) { return f->external_internalized_string_map(); case EXTERNAL_ONE_BYTE_STRING_TYPE: return f->external_one_byte_internalized_string_map(); - case EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE: - return f->external_internalized_string_with_one_byte_data_map(); case UNCACHED_EXTERNAL_STRING_TYPE: return f->uncached_external_internalized_string_map(); case UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE: return f->uncached_external_one_byte_internalized_string_map(); - case UNCACHED_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE: - return f->uncached_external_internalized_string_with_one_byte_data_map(); default: return MaybeHandle(); // No match found. } @@ -1176,17 +1172,6 @@ MaybeHandle Factory::NewConsString(Handle left, bool left_is_one_byte = left->IsOneByteRepresentation(); bool right_is_one_byte = right->IsOneByteRepresentation(); bool is_one_byte = left_is_one_byte && right_is_one_byte; - bool is_one_byte_data_in_two_byte_string = false; - if (!is_one_byte) { - // At least one of the strings uses two-byte representation so we - // can't use the fast case code for uncached one-byte strings below, but - // we can try to save memory if all chars actually fit in one-byte. - is_one_byte_data_in_two_byte_string = - left->HasOnlyOneByteChars() && right->HasOnlyOneByteChars(); - if (is_one_byte_data_in_two_byte_string) { - isolate()->counters()->string_add_runtime_ext_to_one_byte()->Increment(); - } - } // If the resulting string is small make a flat string. if (length < ConsString::kMinLength) { @@ -1215,16 +1200,11 @@ MaybeHandle Factory::NewConsString(Handle left, return result; } - return (is_one_byte_data_in_two_byte_string) - ? ConcatStringContent( - NewRawOneByteString(length).ToHandleChecked(), left, right) - : ConcatStringContent( - NewRawTwoByteString(length).ToHandleChecked(), left, - right); + return ConcatStringContent( + NewRawTwoByteString(length).ToHandleChecked(), left, right); } - bool one_byte = (is_one_byte || is_one_byte_data_in_two_byte_string); - return NewConsString(left, right, length, one_byte); + return NewConsString(left, right, length, is_one_byte); } Handle Factory::NewConsString(Handle left, Handle right, @@ -1339,12 +1319,9 @@ MaybeHandle Factory::NewExternalStringFromOneByte( } if (length == 0) return empty_string(); - Handle map; - if (!resource->IsCacheable()) { - map = uncached_external_one_byte_string_map(); - } else { - map = external_one_byte_string_map(); - } + Handle map = resource->IsCacheable() + ? external_one_byte_string_map() + : uncached_external_one_byte_string_map(); Handle external_string( ExternalOneByteString::cast(New(map, TENURED)), isolate()); external_string->set_length(static_cast(length)); @@ -1363,20 +1340,8 @@ MaybeHandle Factory::NewExternalStringFromTwoByte( } if (length == 0) return empty_string(); - // For small strings we check whether the resource contains only - // one byte characters. If yes, we use a different string map. - static const size_t kOneByteCheckLengthLimit = 32; - bool is_one_byte = - length <= kOneByteCheckLengthLimit && - String::IsOneByte(resource->data(), static_cast(length)); - Handle map; - if (!resource->IsCacheable()) { - map = is_one_byte ? uncached_external_string_with_one_byte_data_map() - : uncached_external_string_map(); - } else { - map = is_one_byte ? external_string_with_one_byte_data_map() - : external_string_map(); - } + Handle map = resource->IsCacheable() ? external_string_map() + : uncached_external_string_map(); Handle external_string( ExternalTwoByteString::cast(New(map, TENURED)), isolate()); external_string->set_length(static_cast(length)); diff --git a/src/objects-definitions.h b/src/objects-definitions.h index 00f6767932..f79f16b636 100644 --- a/src/objects-definitions.h +++ b/src/objects-definitions.h @@ -43,10 +43,8 @@ namespace internal { V(EXTERNAL_INTERNALIZED_STRING_TYPE) \ V(ONE_BYTE_INTERNALIZED_STRING_TYPE) \ V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE) \ - V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE) \ V(UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE) \ V(UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE) \ - V(UNCACHED_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE) \ V(STRING_TYPE) \ V(CONS_STRING_TYPE) \ V(EXTERNAL_STRING_TYPE) \ @@ -57,10 +55,8 @@ namespace internal { V(EXTERNAL_ONE_BYTE_STRING_TYPE) \ V(SLICED_ONE_BYTE_STRING_TYPE) \ V(THIN_ONE_BYTE_STRING_TYPE) \ - V(EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE) \ V(UNCACHED_EXTERNAL_STRING_TYPE) \ V(UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE) \ - V(UNCACHED_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE) \ \ V(SYMBOL_TYPE) \ V(HEAP_NUMBER_TYPE) \ @@ -265,17 +261,11 @@ namespace internal { ExternalString) \ V(EXTERNAL_ONE_BYTE_STRING_TYPE, ExternalOneByteString::kSize, \ external_one_byte_string, ExternalOneByteString) \ - V(EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, ExternalTwoByteString::kSize, \ - external_string_with_one_byte_data, ExternalStringWithOneByteData) \ V(UNCACHED_EXTERNAL_STRING_TYPE, ExternalTwoByteString::kUncachedSize, \ uncached_external_string, UncachedExternalString) \ V(UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE, \ ExternalOneByteString::kUncachedSize, uncached_external_one_byte_string, \ UncachedExternalOneByteString) \ - V(UNCACHED_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE, \ - ExternalTwoByteString::kUncachedSize, \ - uncached_external_string_with_one_byte_data, \ - UncachedExternalStringWithOneByteData) \ \ V(INTERNALIZED_STRING_TYPE, kVariableSizeSentinel, internalized_string, \ InternalizedString) \ @@ -285,10 +275,6 @@ namespace internal { external_internalized_string, ExternalInternalizedString) \ V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE, ExternalOneByteString::kSize, \ external_one_byte_internalized_string, ExternalOneByteInternalizedString) \ - V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE, \ - ExternalTwoByteString::kSize, \ - external_internalized_string_with_one_byte_data, \ - ExternalInternalizedStringWithOneByteData) \ V(UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE, \ ExternalTwoByteString::kUncachedSize, \ uncached_external_internalized_string, UncachedExternalInternalizedString) \ @@ -296,10 +282,6 @@ namespace internal { ExternalOneByteString::kUncachedSize, \ uncached_external_one_byte_internalized_string, \ UncachedExternalOneByteInternalizedString) \ - V(UNCACHED_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE, \ - ExternalTwoByteString::kUncachedSize, \ - uncached_external_internalized_string_with_one_byte_data, \ - UncachedExternalInternalizedStringWithOneByteData) \ V(THIN_STRING_TYPE, ThinString::kSize, thin_string, ThinString) \ V(THIN_ONE_BYTE_STRING_TYPE, ThinString::kSize, thin_one_byte_string, \ ThinOneByteString) diff --git a/src/objects-printer.cc b/src/objects-printer.cc index 9c52413f0b..d3603631f2 100644 --- a/src/objects-printer.cc +++ b/src/objects-printer.cc @@ -423,10 +423,8 @@ void HeapObject::HeapObjectPrint(std::ostream& os) { // NOLINT case EXTERNAL_INTERNALIZED_STRING_TYPE: case ONE_BYTE_INTERNALIZED_STRING_TYPE: case EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE: - case EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE: case UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE: case UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE: - case UNCACHED_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE: case STRING_TYPE: case CONS_STRING_TYPE: case EXTERNAL_STRING_TYPE: @@ -437,10 +435,8 @@ void HeapObject::HeapObjectPrint(std::ostream& os) { // NOLINT case EXTERNAL_ONE_BYTE_STRING_TYPE: case SLICED_ONE_BYTE_STRING_TYPE: case THIN_ONE_BYTE_STRING_TYPE: - case EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE: case UNCACHED_EXTERNAL_STRING_TYPE: case UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE: - case UNCACHED_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE: case SMALL_ORDERED_HASH_MAP_TYPE: case SMALL_ORDERED_HASH_SET_TYPE: case SMALL_ORDERED_NAME_DICTIONARY_TYPE: @@ -1196,7 +1192,7 @@ void JSMessageObject::JSMessageObjectPrint(std::ostream& os) { // NOLINT void String::StringPrint(std::ostream& os) { // NOLINT - if (!HasOnlyOneByteChars()) { + if (!IsOneByteRepresentation()) { os << "u"; } if (StringShape(*this).IsInternalized()) { diff --git a/src/objects.cc b/src/objects.cc index 78956816ef..eb81d35042 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -4588,7 +4588,7 @@ void IteratingStringHasher::VisitConsString(ConsString cons_string) { // Slow case. const int max_length = String::kMaxHashCalcLength; int length = std::min(cons_string->length(), max_length); - if (cons_string->HasOnlyOneByteChars()) { + if (cons_string->IsOneByteRepresentation()) { uint8_t* buffer = new uint8_t[length]; String::WriteToFlat(cons_string, buffer, 0, length); AddCharacters(buffer, length); @@ -6889,7 +6889,7 @@ class StringTableNoAllocateKey : public StringTableKey { StringTableNoAllocateKey(String string, uint64_t seed) : StringTableKey(0), string_(string) { StringShape shape(string); - one_byte_ = shape.HasOnlyOneByteChars(); + one_byte_ = shape.encoding_tag() == kOneByteStringTag; DCHECK(!shape.IsInternalized()); DCHECK(!shape.IsThin()); int length = string->length(); diff --git a/src/objects/instance-type.h b/src/objects/instance-type.h index 79a422044d..e57c0b443f 100644 --- a/src/objects/instance-type.h +++ b/src/objects/instance-type.h @@ -15,15 +15,15 @@ namespace v8 { namespace internal { // We use the full 16 bits of the instance_type field to encode heap object -// instance types. All the high-order bits (bit 7-15) are cleared if the object +// instance types. All the high-order bits (bit 6-15) are cleared if the object // is a string, and contain set bits if it is not a string. -const uint32_t kIsNotStringMask = 0xff80; +const uint32_t kIsNotStringMask = 0xffc0; const uint32_t kStringTag = 0x0; -// Bit 6 indicates that the object is an internalized string (if set) or not. +// Bit 5 indicates that the object is an internalized string (if set) or not. // Bit 7 has to be clear as well. -const uint32_t kIsNotInternalizedMask = 0x40; -const uint32_t kNotInternalizedTag = 0x40; +const uint32_t kIsNotInternalizedMask = 0x20; +const uint32_t kNotInternalizedTag = 0x20; const uint32_t kInternalizedTag = 0x0; // If bit 7 is clear then bit 3 indicates whether the string consists of @@ -52,15 +52,10 @@ STATIC_ASSERT((kSlicedStringTag & kIsIndirectStringMask) == kIsIndirectStringTag); // NOLINT STATIC_ASSERT((kThinStringTag & kIsIndirectStringMask) == kIsIndirectStringTag); -// If bit 7 is clear, then bit 4 indicates whether this two-byte -// string actually contains one byte data. -const uint32_t kOneByteDataHintMask = 0x10; -const uint32_t kOneByteDataHintTag = 0x10; - -// If bit 7 is clear and string representation indicates an external string, +// If bit 6 is clear and string representation indicates an external string, // then bit 5 indicates whether the data pointer is cached. -const uint32_t kUncachedExternalStringMask = 0x20; -const uint32_t kUncachedExternalStringTag = 0x20; +const uint32_t kUncachedExternalStringMask = 0x10; +const uint32_t kUncachedExternalStringTag = 0x10; // A ConsString with an empty string as the right side is a candidate // for being shortcut by the garbage collector. We don't allocate any @@ -86,18 +81,12 @@ enum InstanceType : uint16_t { kTwoByteStringTag | kExternalStringTag | kInternalizedTag, EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE = kOneByteStringTag | kExternalStringTag | kInternalizedTag, - EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE = - EXTERNAL_INTERNALIZED_STRING_TYPE | kOneByteDataHintTag | - kInternalizedTag, UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE = EXTERNAL_INTERNALIZED_STRING_TYPE | kUncachedExternalStringTag | kInternalizedTag, UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE = EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kUncachedExternalStringTag | kInternalizedTag, - UNCACHED_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE = - EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE | - kUncachedExternalStringTag | kInternalizedTag, STRING_TYPE = INTERNALIZED_STRING_TYPE | kNotInternalizedTag, ONE_BYTE_STRING_TYPE = ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag, @@ -112,16 +101,10 @@ enum InstanceType : uint16_t { EXTERNAL_INTERNALIZED_STRING_TYPE | kNotInternalizedTag, EXTERNAL_ONE_BYTE_STRING_TYPE = EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag, - EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE = - EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE | - kNotInternalizedTag, UNCACHED_EXTERNAL_STRING_TYPE = UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE | kNotInternalizedTag, UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE = UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE | kNotInternalizedTag, - UNCACHED_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE = - UNCACHED_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE | - kNotInternalizedTag, THIN_STRING_TYPE = kTwoByteStringTag | kThinStringTag | kNotInternalizedTag, THIN_ONE_BYTE_STRING_TYPE = kOneByteStringTag | kThinStringTag | kNotInternalizedTag, @@ -129,7 +112,7 @@ enum InstanceType : uint16_t { // Non-string names SYMBOL_TYPE = 1 + (kIsNotInternalizedMask | kUncachedExternalStringMask | - kOneByteDataHintMask | kStringEncodingMask | + kStringEncodingMask | kStringRepresentationMask), // FIRST_NONSTRING_TYPE, LAST_NAME_TYPE // Other primitives (cannot contain non-map-word pointers to heap objects). diff --git a/src/objects/intl-objects.cc b/src/objects/intl-objects.cc index 36596753f9..b990a85bed 100644 --- a/src/objects/intl-objects.cc +++ b/src/objects/intl-objects.cc @@ -255,7 +255,7 @@ MaybeHandle LocaleConvertCase(Isolate* isolate, Handle s, // Called from TF builtins. String Intl::ConvertOneByteToLower(String src, String dst) { DCHECK_EQ(src->length(), dst->length()); - DCHECK(src->HasOnlyOneByteChars()); + DCHECK(src->IsOneByteRepresentation()); DCHECK(src->IsFlat()); DCHECK(dst->IsSeqOneByteString()); @@ -299,7 +299,7 @@ String Intl::ConvertOneByteToLower(String src, String dst) { } MaybeHandle Intl::ConvertToLower(Isolate* isolate, Handle s) { - if (!s->HasOnlyOneByteChars()) { + if (!s->IsOneByteRepresentation()) { // Use a slower implementation for strings with characters beyond U+00FF. return LocaleConvertCase(isolate, s, false, ""); } @@ -331,7 +331,7 @@ MaybeHandle Intl::ConvertToLower(Isolate* isolate, Handle s) { MaybeHandle Intl::ConvertToUpper(Isolate* isolate, Handle s) { int32_t length = s->length(); - if (s->HasOnlyOneByteChars() && length > 0) { + if (s->IsOneByteRepresentation() && length > 0) { Handle result = isolate->factory()->NewRawOneByteString(length).ToHandleChecked(); diff --git a/src/objects/string-inl.h b/src/objects/string-inl.h index 6292584540..8ae2ad405c 100644 --- a/src/objects/string-inl.h +++ b/src/objects/string-inl.h @@ -81,11 +81,6 @@ bool StringShape::IsInternalized() { (kStringTag | kInternalizedTag); } -bool StringShape::HasOnlyOneByteChars() { - return (type_ & kStringEncodingMask) == kOneByteStringTag || - (type_ & kOneByteDataHintMask) == kOneByteDataHintTag; -} - bool StringShape::IsCons() { return (type_ & kStringRepresentationMask) == kConsStringTag; } @@ -180,12 +175,6 @@ bool String::IsOneByteRepresentationUnderneath(String string) { } } -bool String::HasOnlyOneByteChars() { - uint32_t type = map()->instance_type(); - return (type & kOneByteDataHintMask) == kOneByteDataHintTag || - IsOneByteRepresentation(); -} - uc32 FlatStringReader::Get(int index) { if (is_one_byte_) { return Get(index); diff --git a/src/objects/string.cc b/src/objects/string.cc index 002795be10..a735d038fd 100644 --- a/src/objects/string.cc +++ b/src/objects/string.cc @@ -87,7 +87,6 @@ bool String::MakeExternal(v8::String::ExternalStringResource* resource) { // string. if (!GetIsolateFromWritableObject(*this, &isolate)) return false; Heap* heap = isolate->heap(); - bool is_one_byte = this->IsOneByteRepresentation(); bool is_internalized = this->IsInternalizedString(); bool has_pointers = StringShape(*this).IsIndirect(); if (has_pointers) { @@ -103,26 +102,13 @@ bool String::MakeExternal(v8::String::ExternalStringResource* resource) { ReadOnlyRoots roots(heap); if (size < ExternalString::kSize) { if (is_internalized) { - if (is_one_byte) { - new_map = - roots - .uncached_external_internalized_string_with_one_byte_data_map(); - } else { - new_map = roots.uncached_external_internalized_string_map(); - } + new_map = roots.uncached_external_internalized_string_map(); } else { - new_map = is_one_byte - ? roots.uncached_external_string_with_one_byte_data_map() - : roots.uncached_external_string_map(); + new_map = roots.uncached_external_string_map(); } } else { - new_map = - is_internalized - ? (is_one_byte - ? roots.external_internalized_string_with_one_byte_data_map() - : roots.external_internalized_string_map()) - : (is_one_byte ? roots.external_string_with_one_byte_data_map() - : roots.external_string_map()); + new_map = is_internalized ? roots.external_internalized_string_map() + : roots.external_string_map(); } // Byte size of the external String object. diff --git a/src/objects/string.h b/src/objects/string.h index 5f76ff4567..e0b34f7a0e 100644 --- a/src/objects/string.h +++ b/src/objects/string.h @@ -52,7 +52,6 @@ class StringShape { inline StringRepresentationTag representation_tag(); inline uint32_t encoding_tag(); inline uint32_t full_representation_tag(); - inline bool HasOnlyOneByteChars(); #ifdef DEBUG inline uint32_t type() { return type_; } inline void invalidate() { valid_ = false; } @@ -168,10 +167,6 @@ class String : public Name { // Requires: string.IsFlat() static inline bool IsOneByteRepresentationUnderneath(String string); - // NOTE: this should be considered only a hint. False negatives are - // possible. - inline bool HasOnlyOneByteChars(); - // Get and set individual two byte chars in the string. inline void Set(int index, uint16_t value); // Get individual two byte char in the string. Repeated calls diff --git a/src/roots.h b/src/roots.h index e8363e04ae..4e841d52f6 100644 --- a/src/roots.h +++ b/src/roots.h @@ -135,22 +135,14 @@ class RootVisitor; V(Map, sliced_string_map, SlicedStringMap) \ V(Map, sliced_one_byte_string_map, SlicedOneByteStringMap) \ V(Map, external_string_map, ExternalStringMap) \ - V(Map, external_string_with_one_byte_data_map, \ - ExternalStringWithOneByteDataMap) \ V(Map, external_one_byte_string_map, ExternalOneByteStringMap) \ V(Map, uncached_external_string_map, UncachedExternalStringMap) \ - V(Map, uncached_external_string_with_one_byte_data_map, \ - UncachedExternalStringWithOneByteDataMap) \ V(Map, internalized_string_map, InternalizedStringMap) \ V(Map, external_internalized_string_map, ExternalInternalizedStringMap) \ - V(Map, external_internalized_string_with_one_byte_data_map, \ - ExternalInternalizedStringWithOneByteDataMap) \ V(Map, external_one_byte_internalized_string_map, \ ExternalOneByteInternalizedStringMap) \ V(Map, uncached_external_internalized_string_map, \ UncachedExternalInternalizedStringMap) \ - V(Map, uncached_external_internalized_string_with_one_byte_data_map, \ - UncachedExternalInternalizedStringWithOneByteDataMap) \ V(Map, uncached_external_one_byte_internalized_string_map, \ UncachedExternalOneByteInternalizedStringMap) \ V(Map, uncached_external_one_byte_string_map, \ diff --git a/src/runtime/runtime-regexp.cc b/src/runtime/runtime-regexp.cc index 8ba5d80999..67bb8642c3 100644 --- a/src/runtime/runtime-regexp.cc +++ b/src/runtime/runtime-regexp.cc @@ -628,7 +628,8 @@ V8_WARN_UNUSED_RESULT static Object StringReplaceGlobalRegExpWithString( // Shortcut for simple non-regexp global replacements if (typeTag == JSRegExp::ATOM && simple_replace) { - if (subject->HasOnlyOneByteChars() && replacement->HasOnlyOneByteChars()) { + if (subject->IsOneByteRepresentation() && + replacement->IsOneByteRepresentation()) { return StringReplaceGlobalAtomRegExpWithString( isolate, subject, regexp, replacement, last_match_info); } else { @@ -1326,7 +1327,7 @@ V8_WARN_UNUSED_RESULT MaybeHandle RegExpReplace( String); if (replace->length() == 0) { - if (string->HasOnlyOneByteChars()) { + if (string->IsOneByteRepresentation()) { Object result = StringReplaceGlobalRegExpWithEmptyString( isolate, string, regexp, last_match_info); diff --git a/src/runtime/runtime-strings.cc b/src/runtime/runtime-strings.cc index 8675a7b9b2..aa19b103eb 100644 --- a/src/runtime/runtime-strings.cc +++ b/src/runtime/runtime-strings.cc @@ -298,7 +298,7 @@ RUNTIME_FUNCTION(Runtime_StringBuilderConcat) { } int length; - bool one_byte = special->HasOnlyOneByteChars(); + bool one_byte = special->IsOneByteRepresentation(); { DisallowHeapAllocation no_gc; diff --git a/src/string-builder.cc b/src/string-builder.cc index 04875aca66..0c48681bf7 100644 --- a/src/string-builder.cc +++ b/src/string-builder.cc @@ -88,7 +88,7 @@ int StringBuilderConcatLength(int special_length, FixedArray fixed_array, String element = String::cast(elt); int element_length = element->length(); increment = element_length; - if (*one_byte && !element->HasOnlyOneByteChars()) { + if (*one_byte && !element->IsOneByteRepresentation()) { *one_byte = false; } } else { diff --git a/test/mjsunit/string-externalize.js b/test/mjsunit/string-externalize.js index 915fba2cf7..22840c264a 100644 --- a/test/mjsunit/string-externalize.js +++ b/test/mjsunit/string-externalize.js @@ -54,12 +54,10 @@ function test() { externalizeString(realTwoByteExternalString); assertFalse(isOneByteString(realTwoByteExternalString)); - assertTrue(isOneByteString(["a", twoByteExternalWithOneByteData].join(""))); + assertFalse(isOneByteString(["a", twoByteExternalWithOneByteData].join(""))); - // Appending a two-byte string that contains only ascii chars should - // still produce an ascii cons. var str1 = str + twoByteExternalWithOneByteData; - assertTrue(isOneByteString(str1)); + assertFalse(isOneByteString(str1)); // Force flattening of the string. var old_length = str1.length - twoByteExternalWithOneByteData.length; @@ -70,11 +68,11 @@ function test() { assertEquals("A", str1[i]); } - // Flattened string should still be ascii. - assertTrue(isOneByteString(str1)); + // Flattened string should still be two-byte. + assertFalse(isOneByteString(str1)); - // Lower-casing an ascii string should produce ascii. - assertTrue(isOneByteString(str1.toLowerCase())); + // Lower-casing an ascii string should produce two-byte. + assertFalse(isOneByteString(str1.toLowerCase())); assertFalse(isOneByteString(["a", realTwoByteExternalString].join(""))); diff --git a/tools/v8heapconst.py b/tools/v8heapconst.py index 5000fc8795..eb1233ef3b 100644 --- a/tools/v8heapconst.py +++ b/tools/v8heapconst.py @@ -11,130 +11,126 @@ INSTANCE_TYPES = { 2: "EXTERNAL_INTERNALIZED_STRING_TYPE", 8: "ONE_BYTE_INTERNALIZED_STRING_TYPE", 10: "EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE", - 18: "EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE", - 34: "UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE", - 42: "UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE", - 50: "UNCACHED_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE", - 64: "STRING_TYPE", - 65: "CONS_STRING_TYPE", - 66: "EXTERNAL_STRING_TYPE", - 67: "SLICED_STRING_TYPE", - 69: "THIN_STRING_TYPE", - 72: "ONE_BYTE_STRING_TYPE", - 73: "CONS_ONE_BYTE_STRING_TYPE", - 74: "EXTERNAL_ONE_BYTE_STRING_TYPE", - 75: "SLICED_ONE_BYTE_STRING_TYPE", - 77: "THIN_ONE_BYTE_STRING_TYPE", - 82: "EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE", - 98: "UNCACHED_EXTERNAL_STRING_TYPE", - 106: "UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE", - 114: "UNCACHED_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE", - 128: "SYMBOL_TYPE", - 129: "HEAP_NUMBER_TYPE", - 130: "BIGINT_TYPE", - 131: "ODDBALL_TYPE", - 132: "MAP_TYPE", - 133: "CODE_TYPE", - 134: "MUTABLE_HEAP_NUMBER_TYPE", - 135: "FOREIGN_TYPE", - 136: "BYTE_ARRAY_TYPE", - 137: "BYTECODE_ARRAY_TYPE", - 138: "FREE_SPACE_TYPE", - 139: "FIXED_INT8_ARRAY_TYPE", - 140: "FIXED_UINT8_ARRAY_TYPE", - 141: "FIXED_INT16_ARRAY_TYPE", - 142: "FIXED_UINT16_ARRAY_TYPE", - 143: "FIXED_INT32_ARRAY_TYPE", - 144: "FIXED_UINT32_ARRAY_TYPE", - 145: "FIXED_FLOAT32_ARRAY_TYPE", - 146: "FIXED_FLOAT64_ARRAY_TYPE", - 147: "FIXED_UINT8_CLAMPED_ARRAY_TYPE", - 148: "FIXED_BIGINT64_ARRAY_TYPE", - 149: "FIXED_BIGUINT64_ARRAY_TYPE", - 150: "FIXED_DOUBLE_ARRAY_TYPE", - 151: "FEEDBACK_METADATA_TYPE", - 152: "FILLER_TYPE", - 153: "ACCESS_CHECK_INFO_TYPE", - 154: "ACCESSOR_INFO_TYPE", - 155: "ACCESSOR_PAIR_TYPE", - 156: "ALIASED_ARGUMENTS_ENTRY_TYPE", - 157: "ALLOCATION_MEMENTO_TYPE", - 158: "ASM_WASM_DATA_TYPE", - 159: "ASYNC_GENERATOR_REQUEST_TYPE", - 160: "CLASS_POSITIONS_TYPE", - 161: "DEBUG_INFO_TYPE", - 162: "FUNCTION_TEMPLATE_INFO_TYPE", - 163: "FUNCTION_TEMPLATE_RARE_DATA_TYPE", - 164: "INTERCEPTOR_INFO_TYPE", - 165: "INTERPRETER_DATA_TYPE", - 166: "MODULE_INFO_ENTRY_TYPE", - 167: "MODULE_TYPE", - 168: "OBJECT_TEMPLATE_INFO_TYPE", - 169: "PROMISE_CAPABILITY_TYPE", - 170: "PROMISE_REACTION_TYPE", - 171: "PROTOTYPE_INFO_TYPE", - 172: "SCRIPT_TYPE", - 173: "STACK_FRAME_INFO_TYPE", - 174: "STACK_TRACE_FRAME_TYPE", - 175: "TUPLE2_TYPE", - 176: "TUPLE3_TYPE", - 177: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE", - 178: "WASM_DEBUG_INFO_TYPE", - 179: "WASM_EXCEPTION_TAG_TYPE", - 180: "WASM_EXPORTED_FUNCTION_DATA_TYPE", - 181: "CALLABLE_TASK_TYPE", - 182: "CALLBACK_TASK_TYPE", - 183: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE", - 184: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE", - 185: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE", - 186: "FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE", - 187: "ALLOCATION_SITE_TYPE", - 188: "EMBEDDER_DATA_ARRAY_TYPE", - 189: "FIXED_ARRAY_TYPE", - 190: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE", - 191: "HASH_TABLE_TYPE", - 192: "ORDERED_HASH_MAP_TYPE", - 193: "ORDERED_HASH_SET_TYPE", - 194: "ORDERED_NAME_DICTIONARY_TYPE", - 195: "NAME_DICTIONARY_TYPE", - 196: "GLOBAL_DICTIONARY_TYPE", - 197: "NUMBER_DICTIONARY_TYPE", - 198: "SIMPLE_NUMBER_DICTIONARY_TYPE", - 199: "STRING_TABLE_TYPE", - 200: "EPHEMERON_HASH_TABLE_TYPE", - 201: "SCOPE_INFO_TYPE", - 202: "SCRIPT_CONTEXT_TABLE_TYPE", - 203: "AWAIT_CONTEXT_TYPE", - 204: "BLOCK_CONTEXT_TYPE", - 205: "CATCH_CONTEXT_TYPE", - 206: "DEBUG_EVALUATE_CONTEXT_TYPE", - 207: "EVAL_CONTEXT_TYPE", - 208: "FUNCTION_CONTEXT_TYPE", - 209: "MODULE_CONTEXT_TYPE", - 210: "NATIVE_CONTEXT_TYPE", - 211: "SCRIPT_CONTEXT_TYPE", - 212: "WITH_CONTEXT_TYPE", - 213: "WEAK_FIXED_ARRAY_TYPE", - 214: "TRANSITION_ARRAY_TYPE", - 215: "CALL_HANDLER_INFO_TYPE", - 216: "CELL_TYPE", - 217: "CODE_DATA_CONTAINER_TYPE", - 218: "DESCRIPTOR_ARRAY_TYPE", - 219: "FEEDBACK_CELL_TYPE", - 220: "FEEDBACK_VECTOR_TYPE", - 221: "LOAD_HANDLER_TYPE", - 222: "PREPARSE_DATA_TYPE", - 223: "PROPERTY_ARRAY_TYPE", - 224: "PROPERTY_CELL_TYPE", - 225: "SHARED_FUNCTION_INFO_TYPE", - 226: "SMALL_ORDERED_HASH_MAP_TYPE", - 227: "SMALL_ORDERED_HASH_SET_TYPE", - 228: "SMALL_ORDERED_NAME_DICTIONARY_TYPE", - 229: "STORE_HANDLER_TYPE", - 230: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE", - 231: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE", - 232: "WEAK_ARRAY_LIST_TYPE", - 233: "WEAK_CELL_TYPE", + 18: "UNCACHED_EXTERNAL_INTERNALIZED_STRING_TYPE", + 26: "UNCACHED_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE", + 32: "STRING_TYPE", + 33: "CONS_STRING_TYPE", + 34: "EXTERNAL_STRING_TYPE", + 35: "SLICED_STRING_TYPE", + 37: "THIN_STRING_TYPE", + 40: "ONE_BYTE_STRING_TYPE", + 41: "CONS_ONE_BYTE_STRING_TYPE", + 42: "EXTERNAL_ONE_BYTE_STRING_TYPE", + 43: "SLICED_ONE_BYTE_STRING_TYPE", + 45: "THIN_ONE_BYTE_STRING_TYPE", + 50: "UNCACHED_EXTERNAL_STRING_TYPE", + 58: "UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE", + 64: "SYMBOL_TYPE", + 65: "HEAP_NUMBER_TYPE", + 66: "BIGINT_TYPE", + 67: "ODDBALL_TYPE", + 68: "MAP_TYPE", + 69: "CODE_TYPE", + 70: "MUTABLE_HEAP_NUMBER_TYPE", + 71: "FOREIGN_TYPE", + 72: "BYTE_ARRAY_TYPE", + 73: "BYTECODE_ARRAY_TYPE", + 74: "FREE_SPACE_TYPE", + 75: "FIXED_INT8_ARRAY_TYPE", + 76: "FIXED_UINT8_ARRAY_TYPE", + 77: "FIXED_INT16_ARRAY_TYPE", + 78: "FIXED_UINT16_ARRAY_TYPE", + 79: "FIXED_INT32_ARRAY_TYPE", + 80: "FIXED_UINT32_ARRAY_TYPE", + 81: "FIXED_FLOAT32_ARRAY_TYPE", + 82: "FIXED_FLOAT64_ARRAY_TYPE", + 83: "FIXED_UINT8_CLAMPED_ARRAY_TYPE", + 84: "FIXED_BIGINT64_ARRAY_TYPE", + 85: "FIXED_BIGUINT64_ARRAY_TYPE", + 86: "FIXED_DOUBLE_ARRAY_TYPE", + 87: "FEEDBACK_METADATA_TYPE", + 88: "FILLER_TYPE", + 89: "ACCESS_CHECK_INFO_TYPE", + 90: "ACCESSOR_INFO_TYPE", + 91: "ACCESSOR_PAIR_TYPE", + 92: "ALIASED_ARGUMENTS_ENTRY_TYPE", + 93: "ALLOCATION_MEMENTO_TYPE", + 94: "ASM_WASM_DATA_TYPE", + 95: "ASYNC_GENERATOR_REQUEST_TYPE", + 96: "CLASS_POSITIONS_TYPE", + 97: "DEBUG_INFO_TYPE", + 98: "FUNCTION_TEMPLATE_INFO_TYPE", + 99: "FUNCTION_TEMPLATE_RARE_DATA_TYPE", + 100: "INTERCEPTOR_INFO_TYPE", + 101: "INTERPRETER_DATA_TYPE", + 102: "MODULE_INFO_ENTRY_TYPE", + 103: "MODULE_TYPE", + 104: "OBJECT_TEMPLATE_INFO_TYPE", + 105: "PROMISE_CAPABILITY_TYPE", + 106: "PROMISE_REACTION_TYPE", + 107: "PROTOTYPE_INFO_TYPE", + 108: "SCRIPT_TYPE", + 109: "STACK_FRAME_INFO_TYPE", + 110: "STACK_TRACE_FRAME_TYPE", + 111: "TUPLE2_TYPE", + 112: "TUPLE3_TYPE", + 113: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE", + 114: "WASM_DEBUG_INFO_TYPE", + 115: "WASM_EXCEPTION_TAG_TYPE", + 116: "WASM_EXPORTED_FUNCTION_DATA_TYPE", + 117: "CALLABLE_TASK_TYPE", + 118: "CALLBACK_TASK_TYPE", + 119: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE", + 120: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE", + 121: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE", + 122: "FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE", + 123: "ALLOCATION_SITE_TYPE", + 124: "EMBEDDER_DATA_ARRAY_TYPE", + 125: "FIXED_ARRAY_TYPE", + 126: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE", + 127: "HASH_TABLE_TYPE", + 128: "ORDERED_HASH_MAP_TYPE", + 129: "ORDERED_HASH_SET_TYPE", + 130: "ORDERED_NAME_DICTIONARY_TYPE", + 131: "NAME_DICTIONARY_TYPE", + 132: "GLOBAL_DICTIONARY_TYPE", + 133: "NUMBER_DICTIONARY_TYPE", + 134: "SIMPLE_NUMBER_DICTIONARY_TYPE", + 135: "STRING_TABLE_TYPE", + 136: "EPHEMERON_HASH_TABLE_TYPE", + 137: "SCOPE_INFO_TYPE", + 138: "SCRIPT_CONTEXT_TABLE_TYPE", + 139: "AWAIT_CONTEXT_TYPE", + 140: "BLOCK_CONTEXT_TYPE", + 141: "CATCH_CONTEXT_TYPE", + 142: "DEBUG_EVALUATE_CONTEXT_TYPE", + 143: "EVAL_CONTEXT_TYPE", + 144: "FUNCTION_CONTEXT_TYPE", + 145: "MODULE_CONTEXT_TYPE", + 146: "NATIVE_CONTEXT_TYPE", + 147: "SCRIPT_CONTEXT_TYPE", + 148: "WITH_CONTEXT_TYPE", + 149: "WEAK_FIXED_ARRAY_TYPE", + 150: "TRANSITION_ARRAY_TYPE", + 151: "CALL_HANDLER_INFO_TYPE", + 152: "CELL_TYPE", + 153: "CODE_DATA_CONTAINER_TYPE", + 154: "DESCRIPTOR_ARRAY_TYPE", + 155: "FEEDBACK_CELL_TYPE", + 156: "FEEDBACK_VECTOR_TYPE", + 157: "LOAD_HANDLER_TYPE", + 158: "PREPARSE_DATA_TYPE", + 159: "PROPERTY_ARRAY_TYPE", + 160: "PROPERTY_CELL_TYPE", + 161: "SHARED_FUNCTION_INFO_TYPE", + 162: "SMALL_ORDERED_HASH_MAP_TYPE", + 163: "SMALL_ORDERED_HASH_SET_TYPE", + 164: "SMALL_ORDERED_NAME_DICTIONARY_TYPE", + 165: "STORE_HANDLER_TYPE", + 166: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE", + 167: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE", + 168: "WEAK_ARRAY_LIST_TYPE", + 169: "WEAK_CELL_TYPE", 1024: "JS_PROXY_TYPE", 1025: "JS_GLOBAL_OBJECT_TYPE", 1026: "JS_GLOBAL_PROXY_TYPE", @@ -195,161 +191,157 @@ INSTANCE_TYPES = { # List of known V8 maps. KNOWN_MAPS = { - ("RO_SPACE", 0x00139): (138, "FreeSpaceMap"), - ("RO_SPACE", 0x00189): (132, "MetaMap"), - ("RO_SPACE", 0x00209): (131, "NullMap"), - ("RO_SPACE", 0x00271): (218, "DescriptorArrayMap"), - ("RO_SPACE", 0x002d1): (213, "WeakFixedArrayMap"), - ("RO_SPACE", 0x00321): (152, "OnePointerFillerMap"), - ("RO_SPACE", 0x00371): (152, "TwoPointerFillerMap"), - ("RO_SPACE", 0x003f1): (131, "UninitializedMap"), + ("RO_SPACE", 0x00139): (74, "FreeSpaceMap"), + ("RO_SPACE", 0x00189): (68, "MetaMap"), + ("RO_SPACE", 0x00209): (67, "NullMap"), + ("RO_SPACE", 0x00271): (154, "DescriptorArrayMap"), + ("RO_SPACE", 0x002d1): (149, "WeakFixedArrayMap"), + ("RO_SPACE", 0x00321): (88, "OnePointerFillerMap"), + ("RO_SPACE", 0x00371): (88, "TwoPointerFillerMap"), + ("RO_SPACE", 0x003f1): (67, "UninitializedMap"), ("RO_SPACE", 0x00461): (8, "OneByteInternalizedStringMap"), - ("RO_SPACE", 0x00501): (131, "UndefinedMap"), - ("RO_SPACE", 0x00561): (129, "HeapNumberMap"), - ("RO_SPACE", 0x005e1): (131, "TheHoleMap"), - ("RO_SPACE", 0x00689): (131, "BooleanMap"), - ("RO_SPACE", 0x00761): (136, "ByteArrayMap"), - ("RO_SPACE", 0x007b1): (189, "FixedArrayMap"), - ("RO_SPACE", 0x00801): (189, "FixedCOWArrayMap"), - ("RO_SPACE", 0x00851): (191, "HashTableMap"), - ("RO_SPACE", 0x008a1): (128, "SymbolMap"), - ("RO_SPACE", 0x008f1): (72, "OneByteStringMap"), - ("RO_SPACE", 0x00941): (201, "ScopeInfoMap"), - ("RO_SPACE", 0x00991): (225, "SharedFunctionInfoMap"), - ("RO_SPACE", 0x009e1): (133, "CodeMap"), - ("RO_SPACE", 0x00a31): (208, "FunctionContextMap"), - ("RO_SPACE", 0x00a81): (216, "CellMap"), - ("RO_SPACE", 0x00ad1): (224, "GlobalPropertyCellMap"), - ("RO_SPACE", 0x00b21): (135, "ForeignMap"), - ("RO_SPACE", 0x00b71): (214, "TransitionArrayMap"), - ("RO_SPACE", 0x00bc1): (220, "FeedbackVectorMap"), - ("RO_SPACE", 0x00c61): (131, "ArgumentsMarkerMap"), - ("RO_SPACE", 0x00d01): (131, "ExceptionMap"), - ("RO_SPACE", 0x00da1): (131, "TerminationExceptionMap"), - ("RO_SPACE", 0x00e49): (131, "OptimizedOutMap"), - ("RO_SPACE", 0x00ee9): (131, "StaleRegisterMap"), - ("RO_SPACE", 0x00f59): (210, "NativeContextMap"), - ("RO_SPACE", 0x00fa9): (209, "ModuleContextMap"), - ("RO_SPACE", 0x00ff9): (207, "EvalContextMap"), - ("RO_SPACE", 0x01049): (211, "ScriptContextMap"), - ("RO_SPACE", 0x01099): (203, "AwaitContextMap"), - ("RO_SPACE", 0x010e9): (204, "BlockContextMap"), - ("RO_SPACE", 0x01139): (205, "CatchContextMap"), - ("RO_SPACE", 0x01189): (212, "WithContextMap"), - ("RO_SPACE", 0x011d9): (206, "DebugEvaluateContextMap"), - ("RO_SPACE", 0x01229): (202, "ScriptContextTableMap"), - ("RO_SPACE", 0x01279): (151, "FeedbackMetadataArrayMap"), - ("RO_SPACE", 0x012c9): (189, "ArrayListMap"), - ("RO_SPACE", 0x01319): (130, "BigIntMap"), - ("RO_SPACE", 0x01369): (190, "ObjectBoilerplateDescriptionMap"), - ("RO_SPACE", 0x013b9): (137, "BytecodeArrayMap"), - ("RO_SPACE", 0x01409): (217, "CodeDataContainerMap"), - ("RO_SPACE", 0x01459): (150, "FixedDoubleArrayMap"), - ("RO_SPACE", 0x014a9): (196, "GlobalDictionaryMap"), - ("RO_SPACE", 0x014f9): (219, "ManyClosuresCellMap"), - ("RO_SPACE", 0x01549): (189, "ModuleInfoMap"), - ("RO_SPACE", 0x01599): (134, "MutableHeapNumberMap"), - ("RO_SPACE", 0x015e9): (195, "NameDictionaryMap"), - ("RO_SPACE", 0x01639): (219, "NoClosuresCellMap"), - ("RO_SPACE", 0x01689): (219, "NoFeedbackCellMap"), - ("RO_SPACE", 0x016d9): (197, "NumberDictionaryMap"), - ("RO_SPACE", 0x01729): (219, "OneClosureCellMap"), - ("RO_SPACE", 0x01779): (192, "OrderedHashMapMap"), - ("RO_SPACE", 0x017c9): (193, "OrderedHashSetMap"), - ("RO_SPACE", 0x01819): (194, "OrderedNameDictionaryMap"), - ("RO_SPACE", 0x01869): (222, "PreparseDataMap"), - ("RO_SPACE", 0x018b9): (223, "PropertyArrayMap"), - ("RO_SPACE", 0x01909): (215, "SideEffectCallHandlerInfoMap"), - ("RO_SPACE", 0x01959): (215, "SideEffectFreeCallHandlerInfoMap"), - ("RO_SPACE", 0x019a9): (215, "NextCallSideEffectFreeCallHandlerInfoMap"), - ("RO_SPACE", 0x019f9): (198, "SimpleNumberDictionaryMap"), - ("RO_SPACE", 0x01a49): (189, "SloppyArgumentsElementsMap"), - ("RO_SPACE", 0x01a99): (226, "SmallOrderedHashMapMap"), - ("RO_SPACE", 0x01ae9): (227, "SmallOrderedHashSetMap"), - ("RO_SPACE", 0x01b39): (228, "SmallOrderedNameDictionaryMap"), - ("RO_SPACE", 0x01b89): (199, "StringTableMap"), - ("RO_SPACE", 0x01bd9): (230, "UncompiledDataWithoutPreparseDataMap"), - ("RO_SPACE", 0x01c29): (231, "UncompiledDataWithPreparseDataMap"), - ("RO_SPACE", 0x01c79): (232, "WeakArrayListMap"), - ("RO_SPACE", 0x01cc9): (200, "EphemeronHashTableMap"), - ("RO_SPACE", 0x01d19): (188, "EmbedderDataArrayMap"), - ("RO_SPACE", 0x01d69): (233, "WeakCellMap"), - ("RO_SPACE", 0x01db9): (106, "NativeSourceStringMap"), - ("RO_SPACE", 0x01e09): (64, "StringMap"), - ("RO_SPACE", 0x01e59): (73, "ConsOneByteStringMap"), - ("RO_SPACE", 0x01ea9): (65, "ConsStringMap"), - ("RO_SPACE", 0x01ef9): (77, "ThinOneByteStringMap"), - ("RO_SPACE", 0x01f49): (69, "ThinStringMap"), - ("RO_SPACE", 0x01f99): (67, "SlicedStringMap"), - ("RO_SPACE", 0x01fe9): (75, "SlicedOneByteStringMap"), - ("RO_SPACE", 0x02039): (66, "ExternalStringMap"), - ("RO_SPACE", 0x02089): (82, "ExternalStringWithOneByteDataMap"), - ("RO_SPACE", 0x020d9): (74, "ExternalOneByteStringMap"), - ("RO_SPACE", 0x02129): (98, "UncachedExternalStringMap"), - ("RO_SPACE", 0x02179): (114, "UncachedExternalStringWithOneByteDataMap"), - ("RO_SPACE", 0x021c9): (0, "InternalizedStringMap"), - ("RO_SPACE", 0x02219): (2, "ExternalInternalizedStringMap"), - ("RO_SPACE", 0x02269): (18, "ExternalInternalizedStringWithOneByteDataMap"), - ("RO_SPACE", 0x022b9): (10, "ExternalOneByteInternalizedStringMap"), - ("RO_SPACE", 0x02309): (34, "UncachedExternalInternalizedStringMap"), - ("RO_SPACE", 0x02359): (50, "UncachedExternalInternalizedStringWithOneByteDataMap"), - ("RO_SPACE", 0x023a9): (42, "UncachedExternalOneByteInternalizedStringMap"), - ("RO_SPACE", 0x023f9): (106, "UncachedExternalOneByteStringMap"), - ("RO_SPACE", 0x02449): (140, "FixedUint8ArrayMap"), - ("RO_SPACE", 0x02499): (139, "FixedInt8ArrayMap"), - ("RO_SPACE", 0x024e9): (142, "FixedUint16ArrayMap"), - ("RO_SPACE", 0x02539): (141, "FixedInt16ArrayMap"), - ("RO_SPACE", 0x02589): (144, "FixedUint32ArrayMap"), - ("RO_SPACE", 0x025d9): (143, "FixedInt32ArrayMap"), - ("RO_SPACE", 0x02629): (145, "FixedFloat32ArrayMap"), - ("RO_SPACE", 0x02679): (146, "FixedFloat64ArrayMap"), - ("RO_SPACE", 0x026c9): (147, "FixedUint8ClampedArrayMap"), - ("RO_SPACE", 0x02719): (149, "FixedBigUint64ArrayMap"), - ("RO_SPACE", 0x02769): (148, "FixedBigInt64ArrayMap"), - ("RO_SPACE", 0x027b9): (131, "SelfReferenceMarkerMap"), - ("RO_SPACE", 0x02821): (175, "Tuple2Map"), - ("RO_SPACE", 0x028c1): (177, "ArrayBoilerplateDescriptionMap"), - ("RO_SPACE", 0x02c01): (164, "InterceptorInfoMap"), - ("RO_SPACE", 0x05129): (153, "AccessCheckInfoMap"), - ("RO_SPACE", 0x05179): (154, "AccessorInfoMap"), - ("RO_SPACE", 0x051c9): (155, "AccessorPairMap"), - ("RO_SPACE", 0x05219): (156, "AliasedArgumentsEntryMap"), - ("RO_SPACE", 0x05269): (157, "AllocationMementoMap"), - ("RO_SPACE", 0x052b9): (158, "AsmWasmDataMap"), - ("RO_SPACE", 0x05309): (159, "AsyncGeneratorRequestMap"), - ("RO_SPACE", 0x05359): (160, "ClassPositionsMap"), - ("RO_SPACE", 0x053a9): (161, "DebugInfoMap"), - ("RO_SPACE", 0x053f9): (162, "FunctionTemplateInfoMap"), - ("RO_SPACE", 0x05449): (163, "FunctionTemplateRareDataMap"), - ("RO_SPACE", 0x05499): (165, "InterpreterDataMap"), - ("RO_SPACE", 0x054e9): (166, "ModuleInfoEntryMap"), - ("RO_SPACE", 0x05539): (167, "ModuleMap"), - ("RO_SPACE", 0x05589): (168, "ObjectTemplateInfoMap"), - ("RO_SPACE", 0x055d9): (169, "PromiseCapabilityMap"), - ("RO_SPACE", 0x05629): (170, "PromiseReactionMap"), - ("RO_SPACE", 0x05679): (171, "PrototypeInfoMap"), - ("RO_SPACE", 0x056c9): (172, "ScriptMap"), - ("RO_SPACE", 0x05719): (173, "StackFrameInfoMap"), - ("RO_SPACE", 0x05769): (174, "StackTraceFrameMap"), - ("RO_SPACE", 0x057b9): (176, "Tuple3Map"), - ("RO_SPACE", 0x05809): (178, "WasmDebugInfoMap"), - ("RO_SPACE", 0x05859): (179, "WasmExceptionTagMap"), - ("RO_SPACE", 0x058a9): (180, "WasmExportedFunctionDataMap"), - ("RO_SPACE", 0x058f9): (181, "CallableTaskMap"), - ("RO_SPACE", 0x05949): (182, "CallbackTaskMap"), - ("RO_SPACE", 0x05999): (183, "PromiseFulfillReactionJobTaskMap"), - ("RO_SPACE", 0x059e9): (184, "PromiseRejectReactionJobTaskMap"), - ("RO_SPACE", 0x05a39): (185, "PromiseResolveThenableJobTaskMap"), - ("RO_SPACE", 0x05a89): (186, "FinalizationGroupCleanupJobTaskMap"), - ("RO_SPACE", 0x05ad9): (187, "AllocationSiteWithWeakNextMap"), - ("RO_SPACE", 0x05b29): (187, "AllocationSiteWithoutWeakNextMap"), - ("RO_SPACE", 0x05b79): (221, "LoadHandler1Map"), - ("RO_SPACE", 0x05bc9): (221, "LoadHandler2Map"), - ("RO_SPACE", 0x05c19): (221, "LoadHandler3Map"), - ("RO_SPACE", 0x05c69): (229, "StoreHandler0Map"), - ("RO_SPACE", 0x05cb9): (229, "StoreHandler1Map"), - ("RO_SPACE", 0x05d09): (229, "StoreHandler2Map"), - ("RO_SPACE", 0x05d59): (229, "StoreHandler3Map"), + ("RO_SPACE", 0x00501): (67, "UndefinedMap"), + ("RO_SPACE", 0x00561): (65, "HeapNumberMap"), + ("RO_SPACE", 0x005e1): (67, "TheHoleMap"), + ("RO_SPACE", 0x00689): (67, "BooleanMap"), + ("RO_SPACE", 0x00761): (72, "ByteArrayMap"), + ("RO_SPACE", 0x007b1): (125, "FixedArrayMap"), + ("RO_SPACE", 0x00801): (125, "FixedCOWArrayMap"), + ("RO_SPACE", 0x00851): (127, "HashTableMap"), + ("RO_SPACE", 0x008a1): (64, "SymbolMap"), + ("RO_SPACE", 0x008f1): (40, "OneByteStringMap"), + ("RO_SPACE", 0x00941): (137, "ScopeInfoMap"), + ("RO_SPACE", 0x00991): (161, "SharedFunctionInfoMap"), + ("RO_SPACE", 0x009e1): (69, "CodeMap"), + ("RO_SPACE", 0x00a31): (144, "FunctionContextMap"), + ("RO_SPACE", 0x00a81): (152, "CellMap"), + ("RO_SPACE", 0x00ad1): (160, "GlobalPropertyCellMap"), + ("RO_SPACE", 0x00b21): (71, "ForeignMap"), + ("RO_SPACE", 0x00b71): (150, "TransitionArrayMap"), + ("RO_SPACE", 0x00bc1): (156, "FeedbackVectorMap"), + ("RO_SPACE", 0x00c61): (67, "ArgumentsMarkerMap"), + ("RO_SPACE", 0x00d01): (67, "ExceptionMap"), + ("RO_SPACE", 0x00da1): (67, "TerminationExceptionMap"), + ("RO_SPACE", 0x00e49): (67, "OptimizedOutMap"), + ("RO_SPACE", 0x00ee9): (67, "StaleRegisterMap"), + ("RO_SPACE", 0x00f59): (146, "NativeContextMap"), + ("RO_SPACE", 0x00fa9): (145, "ModuleContextMap"), + ("RO_SPACE", 0x00ff9): (143, "EvalContextMap"), + ("RO_SPACE", 0x01049): (147, "ScriptContextMap"), + ("RO_SPACE", 0x01099): (139, "AwaitContextMap"), + ("RO_SPACE", 0x010e9): (140, "BlockContextMap"), + ("RO_SPACE", 0x01139): (141, "CatchContextMap"), + ("RO_SPACE", 0x01189): (148, "WithContextMap"), + ("RO_SPACE", 0x011d9): (142, "DebugEvaluateContextMap"), + ("RO_SPACE", 0x01229): (138, "ScriptContextTableMap"), + ("RO_SPACE", 0x01279): (87, "FeedbackMetadataArrayMap"), + ("RO_SPACE", 0x012c9): (125, "ArrayListMap"), + ("RO_SPACE", 0x01319): (66, "BigIntMap"), + ("RO_SPACE", 0x01369): (126, "ObjectBoilerplateDescriptionMap"), + ("RO_SPACE", 0x013b9): (73, "BytecodeArrayMap"), + ("RO_SPACE", 0x01409): (153, "CodeDataContainerMap"), + ("RO_SPACE", 0x01459): (86, "FixedDoubleArrayMap"), + ("RO_SPACE", 0x014a9): (132, "GlobalDictionaryMap"), + ("RO_SPACE", 0x014f9): (155, "ManyClosuresCellMap"), + ("RO_SPACE", 0x01549): (125, "ModuleInfoMap"), + ("RO_SPACE", 0x01599): (70, "MutableHeapNumberMap"), + ("RO_SPACE", 0x015e9): (131, "NameDictionaryMap"), + ("RO_SPACE", 0x01639): (155, "NoClosuresCellMap"), + ("RO_SPACE", 0x01689): (155, "NoFeedbackCellMap"), + ("RO_SPACE", 0x016d9): (133, "NumberDictionaryMap"), + ("RO_SPACE", 0x01729): (155, "OneClosureCellMap"), + ("RO_SPACE", 0x01779): (128, "OrderedHashMapMap"), + ("RO_SPACE", 0x017c9): (129, "OrderedHashSetMap"), + ("RO_SPACE", 0x01819): (130, "OrderedNameDictionaryMap"), + ("RO_SPACE", 0x01869): (158, "PreparseDataMap"), + ("RO_SPACE", 0x018b9): (159, "PropertyArrayMap"), + ("RO_SPACE", 0x01909): (151, "SideEffectCallHandlerInfoMap"), + ("RO_SPACE", 0x01959): (151, "SideEffectFreeCallHandlerInfoMap"), + ("RO_SPACE", 0x019a9): (151, "NextCallSideEffectFreeCallHandlerInfoMap"), + ("RO_SPACE", 0x019f9): (134, "SimpleNumberDictionaryMap"), + ("RO_SPACE", 0x01a49): (125, "SloppyArgumentsElementsMap"), + ("RO_SPACE", 0x01a99): (162, "SmallOrderedHashMapMap"), + ("RO_SPACE", 0x01ae9): (163, "SmallOrderedHashSetMap"), + ("RO_SPACE", 0x01b39): (164, "SmallOrderedNameDictionaryMap"), + ("RO_SPACE", 0x01b89): (135, "StringTableMap"), + ("RO_SPACE", 0x01bd9): (166, "UncompiledDataWithoutPreparseDataMap"), + ("RO_SPACE", 0x01c29): (167, "UncompiledDataWithPreparseDataMap"), + ("RO_SPACE", 0x01c79): (168, "WeakArrayListMap"), + ("RO_SPACE", 0x01cc9): (136, "EphemeronHashTableMap"), + ("RO_SPACE", 0x01d19): (124, "EmbedderDataArrayMap"), + ("RO_SPACE", 0x01d69): (169, "WeakCellMap"), + ("RO_SPACE", 0x01db9): (58, "NativeSourceStringMap"), + ("RO_SPACE", 0x01e09): (32, "StringMap"), + ("RO_SPACE", 0x01e59): (41, "ConsOneByteStringMap"), + ("RO_SPACE", 0x01ea9): (33, "ConsStringMap"), + ("RO_SPACE", 0x01ef9): (45, "ThinOneByteStringMap"), + ("RO_SPACE", 0x01f49): (37, "ThinStringMap"), + ("RO_SPACE", 0x01f99): (35, "SlicedStringMap"), + ("RO_SPACE", 0x01fe9): (43, "SlicedOneByteStringMap"), + ("RO_SPACE", 0x02039): (34, "ExternalStringMap"), + ("RO_SPACE", 0x02089): (42, "ExternalOneByteStringMap"), + ("RO_SPACE", 0x020d9): (50, "UncachedExternalStringMap"), + ("RO_SPACE", 0x02129): (0, "InternalizedStringMap"), + ("RO_SPACE", 0x02179): (2, "ExternalInternalizedStringMap"), + ("RO_SPACE", 0x021c9): (10, "ExternalOneByteInternalizedStringMap"), + ("RO_SPACE", 0x02219): (18, "UncachedExternalInternalizedStringMap"), + ("RO_SPACE", 0x02269): (26, "UncachedExternalOneByteInternalizedStringMap"), + ("RO_SPACE", 0x022b9): (58, "UncachedExternalOneByteStringMap"), + ("RO_SPACE", 0x02309): (76, "FixedUint8ArrayMap"), + ("RO_SPACE", 0x02359): (75, "FixedInt8ArrayMap"), + ("RO_SPACE", 0x023a9): (78, "FixedUint16ArrayMap"), + ("RO_SPACE", 0x023f9): (77, "FixedInt16ArrayMap"), + ("RO_SPACE", 0x02449): (80, "FixedUint32ArrayMap"), + ("RO_SPACE", 0x02499): (79, "FixedInt32ArrayMap"), + ("RO_SPACE", 0x024e9): (81, "FixedFloat32ArrayMap"), + ("RO_SPACE", 0x02539): (82, "FixedFloat64ArrayMap"), + ("RO_SPACE", 0x02589): (83, "FixedUint8ClampedArrayMap"), + ("RO_SPACE", 0x025d9): (85, "FixedBigUint64ArrayMap"), + ("RO_SPACE", 0x02629): (84, "FixedBigInt64ArrayMap"), + ("RO_SPACE", 0x02679): (67, "SelfReferenceMarkerMap"), + ("RO_SPACE", 0x026e1): (111, "Tuple2Map"), + ("RO_SPACE", 0x02781): (113, "ArrayBoilerplateDescriptionMap"), + ("RO_SPACE", 0x02ac1): (100, "InterceptorInfoMap"), + ("RO_SPACE", 0x04fe9): (89, "AccessCheckInfoMap"), + ("RO_SPACE", 0x05039): (90, "AccessorInfoMap"), + ("RO_SPACE", 0x05089): (91, "AccessorPairMap"), + ("RO_SPACE", 0x050d9): (92, "AliasedArgumentsEntryMap"), + ("RO_SPACE", 0x05129): (93, "AllocationMementoMap"), + ("RO_SPACE", 0x05179): (94, "AsmWasmDataMap"), + ("RO_SPACE", 0x051c9): (95, "AsyncGeneratorRequestMap"), + ("RO_SPACE", 0x05219): (96, "ClassPositionsMap"), + ("RO_SPACE", 0x05269): (97, "DebugInfoMap"), + ("RO_SPACE", 0x052b9): (98, "FunctionTemplateInfoMap"), + ("RO_SPACE", 0x05309): (99, "FunctionTemplateRareDataMap"), + ("RO_SPACE", 0x05359): (101, "InterpreterDataMap"), + ("RO_SPACE", 0x053a9): (102, "ModuleInfoEntryMap"), + ("RO_SPACE", 0x053f9): (103, "ModuleMap"), + ("RO_SPACE", 0x05449): (104, "ObjectTemplateInfoMap"), + ("RO_SPACE", 0x05499): (105, "PromiseCapabilityMap"), + ("RO_SPACE", 0x054e9): (106, "PromiseReactionMap"), + ("RO_SPACE", 0x05539): (107, "PrototypeInfoMap"), + ("RO_SPACE", 0x05589): (108, "ScriptMap"), + ("RO_SPACE", 0x055d9): (109, "StackFrameInfoMap"), + ("RO_SPACE", 0x05629): (110, "StackTraceFrameMap"), + ("RO_SPACE", 0x05679): (112, "Tuple3Map"), + ("RO_SPACE", 0x056c9): (114, "WasmDebugInfoMap"), + ("RO_SPACE", 0x05719): (115, "WasmExceptionTagMap"), + ("RO_SPACE", 0x05769): (116, "WasmExportedFunctionDataMap"), + ("RO_SPACE", 0x057b9): (117, "CallableTaskMap"), + ("RO_SPACE", 0x05809): (118, "CallbackTaskMap"), + ("RO_SPACE", 0x05859): (119, "PromiseFulfillReactionJobTaskMap"), + ("RO_SPACE", 0x058a9): (120, "PromiseRejectReactionJobTaskMap"), + ("RO_SPACE", 0x058f9): (121, "PromiseResolveThenableJobTaskMap"), + ("RO_SPACE", 0x05949): (122, "FinalizationGroupCleanupJobTaskMap"), + ("RO_SPACE", 0x05999): (123, "AllocationSiteWithWeakNextMap"), + ("RO_SPACE", 0x059e9): (123, "AllocationSiteWithoutWeakNextMap"), + ("RO_SPACE", 0x05a39): (157, "LoadHandler1Map"), + ("RO_SPACE", 0x05a89): (157, "LoadHandler2Map"), + ("RO_SPACE", 0x05ad9): (157, "LoadHandler3Map"), + ("RO_SPACE", 0x05b29): (165, "StoreHandler0Map"), + ("RO_SPACE", 0x05b79): (165, "StoreHandler1Map"), + ("RO_SPACE", 0x05bc9): (165, "StoreHandler2Map"), + ("RO_SPACE", 0x05c19): (165, "StoreHandler3Map"), ("MAP_SPACE", 0x00139): (1057, "ExternalMap"), ("MAP_SPACE", 0x00189): (1073, "JSMessageObjectMap"), } @@ -374,37 +366,37 @@ KNOWN_OBJECTS = { ("RO_SPACE", 0x00d71): "TerminationException", ("RO_SPACE", 0x00e19): "OptimizedOut", ("RO_SPACE", 0x00eb9): "StaleRegister", - ("RO_SPACE", 0x02809): "EmptyEnumCache", - ("RO_SPACE", 0x02871): "EmptyPropertyArray", - ("RO_SPACE", 0x02881): "EmptyByteArray", - ("RO_SPACE", 0x02891): "EmptyObjectBoilerplateDescription", - ("RO_SPACE", 0x028a9): "EmptyArrayBoilerplateDescription", - ("RO_SPACE", 0x02911): "EmptyFixedUint8Array", - ("RO_SPACE", 0x02931): "EmptyFixedInt8Array", - ("RO_SPACE", 0x02951): "EmptyFixedUint16Array", - ("RO_SPACE", 0x02971): "EmptyFixedInt16Array", - ("RO_SPACE", 0x02991): "EmptyFixedUint32Array", - ("RO_SPACE", 0x029b1): "EmptyFixedInt32Array", - ("RO_SPACE", 0x029d1): "EmptyFixedFloat32Array", - ("RO_SPACE", 0x029f1): "EmptyFixedFloat64Array", - ("RO_SPACE", 0x02a11): "EmptyFixedUint8ClampedArray", - ("RO_SPACE", 0x02a31): "EmptyFixedBigUint64Array", - ("RO_SPACE", 0x02a51): "EmptyFixedBigInt64Array", - ("RO_SPACE", 0x02a71): "EmptySloppyArgumentsElements", - ("RO_SPACE", 0x02a91): "EmptySlowElementDictionary", - ("RO_SPACE", 0x02ad9): "EmptyOrderedHashMap", - ("RO_SPACE", 0x02b01): "EmptyOrderedHashSet", - ("RO_SPACE", 0x02b29): "EmptyFeedbackMetadata", - ("RO_SPACE", 0x02b39): "EmptyPropertyCell", - ("RO_SPACE", 0x02b61): "EmptyPropertyDictionary", - ("RO_SPACE", 0x02bb1): "NoOpInterceptorInfo", - ("RO_SPACE", 0x02c51): "EmptyWeakArrayList", - ("RO_SPACE", 0x02c69): "InfinityValue", - ("RO_SPACE", 0x02c79): "MinusZeroValue", - ("RO_SPACE", 0x02c89): "MinusInfinityValue", - ("RO_SPACE", 0x02c99): "SelfReferenceMarker", - ("RO_SPACE", 0x02cf1): "OffHeapTrampolineRelocationInfo", - ("RO_SPACE", 0x02d09): "HashSeed", + ("RO_SPACE", 0x026c9): "EmptyEnumCache", + ("RO_SPACE", 0x02731): "EmptyPropertyArray", + ("RO_SPACE", 0x02741): "EmptyByteArray", + ("RO_SPACE", 0x02751): "EmptyObjectBoilerplateDescription", + ("RO_SPACE", 0x02769): "EmptyArrayBoilerplateDescription", + ("RO_SPACE", 0x027d1): "EmptyFixedUint8Array", + ("RO_SPACE", 0x027f1): "EmptyFixedInt8Array", + ("RO_SPACE", 0x02811): "EmptyFixedUint16Array", + ("RO_SPACE", 0x02831): "EmptyFixedInt16Array", + ("RO_SPACE", 0x02851): "EmptyFixedUint32Array", + ("RO_SPACE", 0x02871): "EmptyFixedInt32Array", + ("RO_SPACE", 0x02891): "EmptyFixedFloat32Array", + ("RO_SPACE", 0x028b1): "EmptyFixedFloat64Array", + ("RO_SPACE", 0x028d1): "EmptyFixedUint8ClampedArray", + ("RO_SPACE", 0x028f1): "EmptyFixedBigUint64Array", + ("RO_SPACE", 0x02911): "EmptyFixedBigInt64Array", + ("RO_SPACE", 0x02931): "EmptySloppyArgumentsElements", + ("RO_SPACE", 0x02951): "EmptySlowElementDictionary", + ("RO_SPACE", 0x02999): "EmptyOrderedHashMap", + ("RO_SPACE", 0x029c1): "EmptyOrderedHashSet", + ("RO_SPACE", 0x029e9): "EmptyFeedbackMetadata", + ("RO_SPACE", 0x029f9): "EmptyPropertyCell", + ("RO_SPACE", 0x02a21): "EmptyPropertyDictionary", + ("RO_SPACE", 0x02a71): "NoOpInterceptorInfo", + ("RO_SPACE", 0x02b11): "EmptyWeakArrayList", + ("RO_SPACE", 0x02b29): "InfinityValue", + ("RO_SPACE", 0x02b39): "MinusZeroValue", + ("RO_SPACE", 0x02b49): "MinusInfinityValue", + ("RO_SPACE", 0x02b59): "SelfReferenceMarker", + ("RO_SPACE", 0x02bb1): "OffHeapTrampolineRelocationInfo", + ("RO_SPACE", 0x02bc9): "HashSeed", ("OLD_SPACE", 0x00139): "ArgumentsIteratorAccessor", ("OLD_SPACE", 0x001a9): "ArrayLengthAccessor", ("OLD_SPACE", 0x00219): "BoundFunctionLengthAccessor",