[cleanup] Remove obsolete "one byte data hint" for strings.
In the early days of Chrome when we used WebKit there was no support for ASCII strings on the C++ side, so we put a hint onto these two-byte strings that said "string only contains one byte data", such that internally in V8 when these were involved in string operations, we could instead create the *cheaper* one byte strings. Nowadays Blink properly supports one-byte string representations and this additional hint only comes with overhead, since we check it in quite a few places (i.e. on the hot path for string concatenation), plus we end up consuming more memory due to the additional string maps. Removing the hint also frees one bit in the InstanceType zoo for strings. This alone improves performance on the `bench-dom-serialize.js` test case by around **3%**. Tbr: mstarzinger@chromium.org Bug: v8:6622, v8:8834, v8:8939 Cq-Include-Trybots: luci.chromium.try:linux-blink-rel Change-Id: I0753f2859cee7b5a37b6f0da64d8ec39fcb044ff Doc: https://bit.ly/fast-string-concatenation-in-javascript Reviewed-on: https://chromium-review.googlesource.com/c/1498478 Commit-Queue: Benedikt Meurer <bmeurer@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#60006}
This commit is contained in:
Benedikt Meurer
Commit Bot
parent
4633c78207
commit
683cf6f43b
@ -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;
|
||||
|
||||
@ -5153,7 +5153,7 @@ int String::Length() const {
|
||||
|
||||
bool String::IsOneByte() const {
|
||||
i::Handle<i::String> str = Utils::OpenHandle(this);
|
||||
return str->HasOnlyOneByteChars();
|
||||
return str->IsOneByteRepresentation();
|
||||
}
|
||||
|
||||
|
||||
@ -5266,7 +5266,7 @@ class ContainsOnlyOneByteHelper {
|
||||
|
||||
bool String::ContainsOnlyOneByte() const {
|
||||
i::Handle<i::String> str = Utils::OpenHandle(this);
|
||||
if (str->HasOnlyOneByteChars()) return true;
|
||||
if (str->IsOneByteRepresentation()) return true;
|
||||
ContainsOnlyOneByteHelper helper;
|
||||
return helper.Check(*str);
|
||||
}
|
||||
|
||||
@ -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)
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@ -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):
|
||||
|
||||
@ -3315,53 +3315,18 @@ TNode<String> CodeStubAssembler::AllocateConsString(TNode<Uint32T> 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<Map> result_map = CAST(Select<Object>(
|
||||
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<BoolT> CodeStubAssembler::IsOneByteStringInstanceType(
|
||||
Int32Constant(kOneByteStringTag));
|
||||
}
|
||||
|
||||
TNode<BoolT> CodeStubAssembler::HasOnlyOneByteChars(
|
||||
TNode<Int32T> instance_type) {
|
||||
CSA_ASSERT(this, IsStringInstanceType(instance_type));
|
||||
return IsSetWord32(instance_type, kStringEncodingMask | kOneByteDataHintMask);
|
||||
}
|
||||
|
||||
TNode<BoolT> CodeStubAssembler::IsSequentialStringInstanceType(
|
||||
SloppyTNode<Int32T> instance_type) {
|
||||
CSA_ASSERT(this, IsStringInstanceType(instance_type));
|
||||
|
||||
@ -2141,7 +2141,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
|
||||
TNode<BoolT> IsNullOrUndefined(SloppyTNode<Object> object);
|
||||
TNode<BoolT> IsNumberDictionary(SloppyTNode<HeapObject> object);
|
||||
TNode<BoolT> IsOneByteStringInstanceType(SloppyTNode<Int32T> instance_type);
|
||||
TNode<BoolT> HasOnlyOneByteChars(TNode<Int32T> instance_type);
|
||||
TNode<BoolT> IsPrimitiveInstanceType(SloppyTNode<Int32T> instance_type);
|
||||
TNode<BoolT> IsPrivateSymbol(SloppyTNode<HeapObject> object);
|
||||
TNode<BoolT> IsPromiseCapability(SloppyTNode<HeapObject> object);
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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) \
|
||||
|
||||
@ -991,14 +991,10 @@ MaybeHandle<Map> GetInternalizedStringMap(Factory* f, Handle<String> 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<Map>(); // No match found.
|
||||
}
|
||||
@ -1176,17 +1172,6 @@ MaybeHandle<String> Factory::NewConsString(Handle<String> 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<String> Factory::NewConsString(Handle<String> left,
|
||||
return result;
|
||||
}
|
||||
|
||||
return (is_one_byte_data_in_two_byte_string)
|
||||
? ConcatStringContent<uint8_t>(
|
||||
NewRawOneByteString(length).ToHandleChecked(), left, right)
|
||||
: ConcatStringContent<uc16>(
|
||||
NewRawTwoByteString(length).ToHandleChecked(), left,
|
||||
right);
|
||||
return ConcatStringContent<uc16>(
|
||||
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<String> Factory::NewConsString(Handle<String> left, Handle<String> right,
|
||||
@ -1339,12 +1319,9 @@ MaybeHandle<String> Factory::NewExternalStringFromOneByte(
|
||||
}
|
||||
if (length == 0) return empty_string();
|
||||
|
||||
Handle<Map> map;
|
||||
if (!resource->IsCacheable()) {
|
||||
map = uncached_external_one_byte_string_map();
|
||||
} else {
|
||||
map = external_one_byte_string_map();
|
||||
}
|
||||
Handle<Map> map = resource->IsCacheable()
|
||||
? external_one_byte_string_map()
|
||||
: uncached_external_one_byte_string_map();
|
||||
Handle<ExternalOneByteString> external_string(
|
||||
ExternalOneByteString::cast(New(map, TENURED)), isolate());
|
||||
external_string->set_length(static_cast<int>(length));
|
||||
@ -1363,20 +1340,8 @@ MaybeHandle<String> 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<int>(length));
|
||||
Handle<Map> 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> map = resource->IsCacheable() ? external_string_map()
|
||||
: uncached_external_string_map();
|
||||
Handle<ExternalTwoByteString> external_string(
|
||||
ExternalTwoByteString::cast(New(map, TENURED)), isolate());
|
||||
external_string->set_length(static_cast<int>(length));
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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()) {
|
||||
|
||||
@ -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();
|
||||
|
||||
@ -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).
|
||||
|
||||
@ -255,7 +255,7 @@ MaybeHandle<String> LocaleConvertCase(Isolate* isolate, Handle<String> 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<String> Intl::ConvertToLower(Isolate* isolate, Handle<String> 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<String> Intl::ConvertToLower(Isolate* isolate, Handle<String> s) {
|
||||
|
||||
MaybeHandle<String> Intl::ConvertToUpper(Isolate* isolate, Handle<String> s) {
|
||||
int32_t length = s->length();
|
||||
if (s->HasOnlyOneByteChars() && length > 0) {
|
||||
if (s->IsOneByteRepresentation() && length > 0) {
|
||||
Handle<SeqOneByteString> result =
|
||||
isolate->factory()->NewRawOneByteString(length).ToHandleChecked();
|
||||
|
||||
|
||||
@ -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<uint8_t>(index);
|
||||
|
||||
@ -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.
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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, \
|
||||
|
||||
@ -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<SeqOneByteString>(
|
||||
isolate, subject, regexp, replacement, last_match_info);
|
||||
} else {
|
||||
@ -1326,7 +1327,7 @@ V8_WARN_UNUSED_RESULT MaybeHandle<String> RegExpReplace(
|
||||
String);
|
||||
|
||||
if (replace->length() == 0) {
|
||||
if (string->HasOnlyOneByteChars()) {
|
||||
if (string->IsOneByteRepresentation()) {
|
||||
Object result =
|
||||
StringReplaceGlobalRegExpWithEmptyString<SeqOneByteString>(
|
||||
isolate, string, regexp, last_match_info);
|
||||
|
||||
@ -298,7 +298,7 @@ RUNTIME_FUNCTION(Runtime_StringBuilderConcat) {
|
||||
}
|
||||
|
||||
int length;
|
||||
bool one_byte = special->HasOnlyOneByteChars();
|
||||
bool one_byte = special->IsOneByteRepresentation();
|
||||
|
||||
{
|
||||
DisallowHeapAllocation no_gc;
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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("")));
|
||||
|
||||
|
||||
@ -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",
|
||||
|
||||
Loading…
Reference in New Issue
Block a user