class CpuProfiler;
class Data;
class Date;
-class DeclaredAccessorDescriptor;
class External;
class Function;
class FunctionTemplate;
class StackTrace;
class StackFrame;
class Isolate;
-class DeclaredAccessorDescriptor;
-class ObjectOperationDescriptor;
-class RawOperationDescriptor;
class CallHandlerHelper;
class EscapableHandleScope;
template<typename T> class ReturnValue;
AccessControl settings = DEFAULT,
PropertyAttribute attribute = None);
- // This function is not yet stable and should not be used at this time.
- bool SetDeclaredAccessor(Local<Name> name,
- Local<DeclaredAccessorDescriptor> descriptor,
- PropertyAttribute attribute = None,
- AccessControl settings = DEFAULT);
-
void SetAccessorProperty(Local<Name> name,
Local<Function> getter,
Handle<Function> setter = Handle<Function>(),
Local<AccessorSignature>(),
AccessControl settings = DEFAULT);
- // This function is not yet stable and should not be used at this time.
- bool SetDeclaredAccessor(Local<Name> name,
- Local<DeclaredAccessorDescriptor> descriptor,
- PropertyAttribute attribute = None,
- Local<AccessorSignature> signature =
- Local<AccessorSignature>(),
- AccessControl settings = DEFAULT);
-
private:
Template();
};
-class V8_EXPORT DeclaredAccessorDescriptor : public Data {
- private:
- DeclaredAccessorDescriptor();
-};
-
-
-class V8_EXPORT ObjectOperationDescriptor : public Data {
- public:
- // This function is not yet stable and should not be used at this time.
- static Local<RawOperationDescriptor> NewInternalFieldDereference(
- Isolate* isolate,
- int internal_field);
- private:
- ObjectOperationDescriptor();
-};
-
-
-enum DeclaredAccessorDescriptorDataType {
- kDescriptorBoolType,
- kDescriptorInt8Type, kDescriptorUint8Type,
- kDescriptorInt16Type, kDescriptorUint16Type,
- kDescriptorInt32Type, kDescriptorUint32Type,
- kDescriptorFloatType, kDescriptorDoubleType
-};
-
-
-class V8_EXPORT RawOperationDescriptor : public Data {
- public:
- Local<DeclaredAccessorDescriptor> NewHandleDereference(Isolate* isolate);
- Local<RawOperationDescriptor> NewRawDereference(Isolate* isolate);
- Local<RawOperationDescriptor> NewRawShift(Isolate* isolate,
- int16_t byte_offset);
- Local<DeclaredAccessorDescriptor> NewPointerCompare(Isolate* isolate,
- void* compare_value);
- Local<DeclaredAccessorDescriptor> NewPrimitiveValue(
- Isolate* isolate,
- DeclaredAccessorDescriptorDataType data_type,
- uint8_t bool_offset = 0);
- Local<DeclaredAccessorDescriptor> NewBitmaskCompare8(Isolate* isolate,
- uint8_t bitmask,
- uint8_t compare_value);
- Local<DeclaredAccessorDescriptor> NewBitmaskCompare16(
- Isolate* isolate,
- uint16_t bitmask,
- uint16_t compare_value);
- Local<DeclaredAccessorDescriptor> NewBitmaskCompare32(
- Isolate* isolate,
- uint32_t bitmask,
- uint32_t compare_value);
-
- private:
- RawOperationDescriptor();
-};
-
-
/**
* A utility for determining the type of objects based on the template
* they were constructed from.
}
-template<typename Operation>
-static Local<Operation> NewDescriptor(
- Isolate* isolate,
- const i::DeclaredAccessorDescriptorData& data,
- Data* previous_descriptor) {
- i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
- i::Handle<i::DeclaredAccessorDescriptor> previous =
- i::Handle<i::DeclaredAccessorDescriptor>();
- if (previous_descriptor != NULL) {
- previous = Utils::OpenHandle(
- static_cast<DeclaredAccessorDescriptor*>(previous_descriptor));
- }
- i::Handle<i::DeclaredAccessorDescriptor> descriptor =
- i::DeclaredAccessorDescriptor::Create(internal_isolate, data, previous);
- return Utils::Convert<i::DeclaredAccessorDescriptor, Operation>(descriptor);
-}
-
-
-Local<RawOperationDescriptor>
-ObjectOperationDescriptor::NewInternalFieldDereference(
- Isolate* isolate,
- int internal_field) {
- i::DeclaredAccessorDescriptorData data;
- data.type = i::kDescriptorObjectDereference;
- data.object_dereference_descriptor.internal_field = internal_field;
- return NewDescriptor<RawOperationDescriptor>(isolate, data, NULL);
-}
-
-
-Local<RawOperationDescriptor> RawOperationDescriptor::NewRawShift(
- Isolate* isolate,
- int16_t byte_offset) {
- i::DeclaredAccessorDescriptorData data;
- data.type = i::kDescriptorPointerShift;
- data.pointer_shift_descriptor.byte_offset = byte_offset;
- return NewDescriptor<RawOperationDescriptor>(isolate, data, this);
-}
-
-
-Local<DeclaredAccessorDescriptor> RawOperationDescriptor::NewHandleDereference(
- Isolate* isolate) {
- i::DeclaredAccessorDescriptorData data;
- data.type = i::kDescriptorReturnObject;
- return NewDescriptor<DeclaredAccessorDescriptor>(isolate, data, this);
-}
-
-
-Local<RawOperationDescriptor> RawOperationDescriptor::NewRawDereference(
- Isolate* isolate) {
- i::DeclaredAccessorDescriptorData data;
- data.type = i::kDescriptorPointerDereference;
- return NewDescriptor<RawOperationDescriptor>(isolate, data, this);
-}
-
-
-Local<DeclaredAccessorDescriptor> RawOperationDescriptor::NewPointerCompare(
- Isolate* isolate,
- void* compare_value) {
- i::DeclaredAccessorDescriptorData data;
- data.type = i::kDescriptorPointerCompare;
- data.pointer_compare_descriptor.compare_value = compare_value;
- return NewDescriptor<DeclaredAccessorDescriptor>(isolate, data, this);
-}
-
-
-Local<DeclaredAccessorDescriptor> RawOperationDescriptor::NewPrimitiveValue(
- Isolate* isolate,
- DeclaredAccessorDescriptorDataType data_type,
- uint8_t bool_offset) {
- i::DeclaredAccessorDescriptorData data;
- data.type = i::kDescriptorPrimitiveValue;
- data.primitive_value_descriptor.data_type = data_type;
- data.primitive_value_descriptor.bool_offset = bool_offset;
- return NewDescriptor<DeclaredAccessorDescriptor>(isolate, data, this);
-}
-
-
-template<typename T>
-static Local<DeclaredAccessorDescriptor> NewBitmaskCompare(
- Isolate* isolate,
- T bitmask,
- T compare_value,
- RawOperationDescriptor* operation) {
- i::DeclaredAccessorDescriptorData data;
- data.type = i::kDescriptorBitmaskCompare;
- data.bitmask_compare_descriptor.bitmask = bitmask;
- data.bitmask_compare_descriptor.compare_value = compare_value;
- data.bitmask_compare_descriptor.size = sizeof(T);
- return NewDescriptor<DeclaredAccessorDescriptor>(isolate, data, operation);
-}
-
-
-Local<DeclaredAccessorDescriptor> RawOperationDescriptor::NewBitmaskCompare8(
- Isolate* isolate,
- uint8_t bitmask,
- uint8_t compare_value) {
- return NewBitmaskCompare(isolate, bitmask, compare_value, this);
-}
-
-
-Local<DeclaredAccessorDescriptor> RawOperationDescriptor::NewBitmaskCompare16(
- Isolate* isolate,
- uint16_t bitmask,
- uint16_t compare_value) {
- return NewBitmaskCompare(isolate, bitmask, compare_value, this);
-}
-
-
-Local<DeclaredAccessorDescriptor> RawOperationDescriptor::NewBitmaskCompare32(
- Isolate* isolate,
- uint32_t bitmask,
- uint32_t compare_value) {
- return NewBitmaskCompare(isolate, bitmask, compare_value, this);
-}
-
-
Local<TypeSwitch> TypeSwitch::New(Handle<FunctionTemplate> type) {
Handle<FunctionTemplate> types[1] = { type };
return TypeSwitch::New(1, types);
}
-static i::Handle<i::AccessorInfo> MakeAccessorInfo(
- v8::Handle<Name> name,
- v8::Handle<v8::DeclaredAccessorDescriptor> descriptor,
- void* setter_ignored,
- void* data_ignored,
- v8::AccessControl settings,
- v8::PropertyAttribute attributes,
- v8::Handle<AccessorSignature> signature) {
- i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate();
- if (descriptor.IsEmpty()) return i::Handle<i::DeclaredAccessorInfo>();
- i::Handle<i::DeclaredAccessorInfo> obj =
- isolate->factory()->NewDeclaredAccessorInfo();
- obj->set_descriptor(*Utils::OpenHandle(*descriptor));
- return SetAccessorInfoProperties(obj, name, settings, attributes, signature);
-}
-
-
Local<ObjectTemplate> FunctionTemplate::InstanceTemplate() {
i::Handle<i::FunctionTemplateInfo> handle = Utils::OpenHandle(this, true);
if (!Utils::ApiCheck(!handle.is_null(),
}
-bool Template::SetDeclaredAccessor(
- Local<Name> name,
- Local<DeclaredAccessorDescriptor> descriptor,
- PropertyAttribute attribute,
- Local<AccessorSignature> signature,
- AccessControl settings) {
- void* null = NULL;
- return TemplateSetAccessor(
- this, name, descriptor, null, null, settings, attribute, signature);
-}
-
-
void Template::SetNativeDataProperty(v8::Local<String> name,
AccessorGetterCallback getter,
AccessorSetterCallback setter,
}
-bool Object::SetDeclaredAccessor(Local<Name> name,
- Local<DeclaredAccessorDescriptor> descriptor,
- PropertyAttribute attributes,
- AccessControl settings) {
- void* null = NULL;
- return ObjectSetAccessor(
- this, name, descriptor, null, null, settings, attributes);
-}
-
-
void Object::SetAccessorProperty(Local<Name> name,
Local<Function> getter,
Handle<Function> setter,
};
-#define OPEN_HANDLE_LIST(V) \
- V(Template, TemplateInfo) \
- V(FunctionTemplate, FunctionTemplateInfo) \
- V(ObjectTemplate, ObjectTemplateInfo) \
- V(Signature, SignatureInfo) \
- V(AccessorSignature, FunctionTemplateInfo) \
- V(TypeSwitch, TypeSwitchInfo) \
- V(Data, Object) \
- V(RegExp, JSRegExp) \
- V(Object, JSObject) \
- V(Array, JSArray) \
- V(ArrayBuffer, JSArrayBuffer) \
- V(ArrayBufferView, JSArrayBufferView) \
- V(TypedArray, JSTypedArray) \
- V(Uint8Array, JSTypedArray) \
- V(Uint8ClampedArray, JSTypedArray) \
- V(Int8Array, JSTypedArray) \
- V(Uint16Array, JSTypedArray) \
- V(Int16Array, JSTypedArray) \
- V(Uint32Array, JSTypedArray) \
- V(Int32Array, JSTypedArray) \
- V(Float32Array, JSTypedArray) \
- V(Float64Array, JSTypedArray) \
- V(DataView, JSDataView) \
- V(Name, Name) \
- V(String, String) \
- V(Symbol, Symbol) \
- V(Script, JSFunction) \
- V(UnboundScript, SharedFunctionInfo) \
- V(Function, JSFunction) \
- V(Message, JSMessageObject) \
- V(Context, Context) \
- V(External, Object) \
- V(StackTrace, JSArray) \
- V(StackFrame, JSObject) \
- V(DeclaredAccessorDescriptor, DeclaredAccessorDescriptor)
-
+#define OPEN_HANDLE_LIST(V) \
+ V(Template, TemplateInfo) \
+ V(FunctionTemplate, FunctionTemplateInfo) \
+ V(ObjectTemplate, ObjectTemplateInfo) \
+ V(Signature, SignatureInfo) \
+ V(AccessorSignature, FunctionTemplateInfo) \
+ V(TypeSwitch, TypeSwitchInfo) \
+ V(Data, Object) \
+ V(RegExp, JSRegExp) \
+ V(Object, JSObject) \
+ V(Array, JSArray) \
+ V(ArrayBuffer, JSArrayBuffer) \
+ V(ArrayBufferView, JSArrayBufferView) \
+ V(TypedArray, JSTypedArray) \
+ V(Uint8Array, JSTypedArray) \
+ V(Uint8ClampedArray, JSTypedArray) \
+ V(Int8Array, JSTypedArray) \
+ V(Uint16Array, JSTypedArray) \
+ V(Int16Array, JSTypedArray) \
+ V(Uint32Array, JSTypedArray) \
+ V(Int32Array, JSTypedArray) \
+ V(Float32Array, JSTypedArray) \
+ V(Float64Array, JSTypedArray) \
+ V(DataView, JSDataView) \
+ V(Name, Name) \
+ V(String, String) \
+ V(Symbol, Symbol) \
+ V(Script, JSFunction) \
+ V(UnboundScript, SharedFunctionInfo) \
+ V(Function, JSFunction) \
+ V(Message, JSMessageObject) \
+ V(Context, Context) \
+ V(External, Object) \
+ V(StackTrace, JSArray) \
+ V(StackFrame, JSObject)
class Utils {
public:
v8::internal::Handle<v8::internal::TypeSwitchInfo> obj);
static inline Local<External> ExternalToLocal(
v8::internal::Handle<v8::internal::JSObject> obj);
- static inline Local<DeclaredAccessorDescriptor> ToLocal(
- v8::internal::Handle<v8::internal::DeclaredAccessorDescriptor> obj);
#define DECLARE_OPEN_HANDLE(From, To) \
static inline v8::internal::Handle<v8::internal::To> \
MAKE_TO_LOCAL(IntegerToLocal, Object, Integer)
MAKE_TO_LOCAL(Uint32ToLocal, Object, Uint32)
MAKE_TO_LOCAL(ExternalToLocal, JSObject, External)
-MAKE_TO_LOCAL(ToLocal, DeclaredAccessorDescriptor, DeclaredAccessorDescriptor)
#undef MAKE_TO_LOCAL_TYPED_ARRAY
#undef MAKE_TO_LOCAL
}
-Handle<DeclaredAccessorDescriptor> Factory::NewDeclaredAccessorDescriptor() {
- return Handle<DeclaredAccessorDescriptor>::cast(
- NewStruct(DECLARED_ACCESSOR_DESCRIPTOR_TYPE));
-}
-
-
-Handle<DeclaredAccessorInfo> Factory::NewDeclaredAccessorInfo() {
- Handle<DeclaredAccessorInfo> info =
- Handle<DeclaredAccessorInfo>::cast(
- NewStruct(DECLARED_ACCESSOR_INFO_TYPE));
- info->set_flag(0); // Must clear the flag, it was initialized as undefined.
- return info;
-}
-
-
Handle<ExecutableAccessorInfo> Factory::NewExecutableAccessorInfo() {
Handle<ExecutableAccessorInfo> info =
Handle<ExecutableAccessorInfo>::cast(
Handle<AliasedArgumentsEntry> NewAliasedArgumentsEntry(
int aliased_context_slot);
- Handle<DeclaredAccessorDescriptor> NewDeclaredAccessorDescriptor();
-
- Handle<DeclaredAccessorInfo> NewDeclaredAccessorInfo();
-
Handle<ExecutableAccessorInfo> NewExecutableAccessorInfo();
Handle<Script> NewScript(Handle<String> source);
SetInternalReference(accessor_info, entry, "expected_receiver_type",
accessor_info->expected_receiver_type(),
AccessorInfo::kExpectedReceiverTypeOffset);
- if (accessor_info->IsDeclaredAccessorInfo()) {
- DeclaredAccessorInfo* declared_accessor_info =
- DeclaredAccessorInfo::cast(accessor_info);
- SetInternalReference(declared_accessor_info, entry, "descriptor",
- declared_accessor_info->descriptor(),
- DeclaredAccessorInfo::kDescriptorOffset);
- } else if (accessor_info->IsExecutableAccessorInfo()) {
+ if (accessor_info->IsExecutableAccessorInfo()) {
ExecutableAccessorInfo* executable_accessor_info =
ExecutableAccessorInfo::cast(accessor_info);
SetInternalReference(executable_accessor_info, entry, "getter",
}
return compiler.CompileLoadViaGetter(lookup->name(), function);
}
- // TODO(dcarney): Handle correctly.
- DCHECK(accessors->IsDeclaredAccessorInfo());
break;
}
return compiler.CompileStoreViaSetter(receiver, lookup->name(),
Handle<JSFunction>::cast(setter));
}
- // TODO(dcarney): Handle correctly.
- DCHECK(accessors->IsDeclaredAccessorInfo());
- TRACE_GENERIC_IC(isolate(), "StoreIC", "declared accessor info");
break;
}
Handle<Object> value, PropertyAttributes attributes,
Object::StoreFromKeyed store_mode) {
if (state_ == TRANSITION) return;
- DCHECK(state_ != LookupIterator::ACCESSOR ||
- GetAccessors()->IsDeclaredAccessorInfo());
+ DCHECK(state_ != LookupIterator::ACCESSOR);
DCHECK(state_ == NOT_FOUND || !HolderIsReceiverOrHiddenPrototype());
// Can only be called when the receiver is a JSObject. JSProxy has to be
}
-void DeclaredAccessorDescriptor::DeclaredAccessorDescriptorVerify() {
- CHECK(IsDeclaredAccessorDescriptor());
- VerifyPointer(serialized_data());
-}
-
-
-void DeclaredAccessorInfo::DeclaredAccessorInfoVerify() {
- CHECK(IsDeclaredAccessorInfo());
- AccessorInfoVerify();
- VerifyPointer(descriptor());
-}
-
-
void AccessorPair::AccessorPairVerify() {
CHECK(IsAccessorPair());
VerifyPointer(getter());
}
-bool Object::IsAccessorInfo() const {
- return IsExecutableAccessorInfo() || IsDeclaredAccessorInfo();
-}
+bool Object::IsAccessorInfo() const { return IsExecutableAccessorInfo(); }
bool Object::IsSmi() const {
ACCESSORS(AccessorInfo, expected_receiver_type, Object,
kExpectedReceiverTypeOffset)
-ACCESSORS(DeclaredAccessorDescriptor, serialized_data, ByteArray,
- kSerializedDataOffset)
-
-ACCESSORS(DeclaredAccessorInfo, descriptor, DeclaredAccessorDescriptor,
- kDescriptorOffset)
-
ACCESSORS(ExecutableAccessorInfo, getter, Object, kGetterOffset)
ACCESSORS(ExecutableAccessorInfo, setter, Object, kSetterOffset)
ACCESSORS(ExecutableAccessorInfo, data, Object, kDataOffset)
}
-void DeclaredAccessorInfo::DeclaredAccessorInfoPrint(
- std::ostream& os) { // NOLINT
- HeapObject::PrintHeader(os, "DeclaredAccessorInfo");
- os << "\n - name: " << Brief(name());
- os << "\n - flag: " << Brief(flag());
- os << "\n - descriptor: " << Brief(descriptor());
- os << "\n";
-}
-
-
-void DeclaredAccessorDescriptor::DeclaredAccessorDescriptorPrint(
- std::ostream& os) { // NOLINT
- HeapObject::PrintHeader(os, "DeclaredAccessorDescriptor");
- os << "\n - internal field: " << Brief(serialized_data());
- os << "\n";
-}
-
-
void Box::BoxPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "Box");
os << "\n - value: " << Brief(value());
}
-template<typename To>
-static inline To* CheckedCast(void *from) {
- uintptr_t temp = reinterpret_cast<uintptr_t>(from);
- DCHECK(temp % sizeof(To) == 0);
- return reinterpret_cast<To*>(temp);
-}
-
-
-static Handle<Object> PerformCompare(const BitmaskCompareDescriptor& descriptor,
- char* ptr,
- Isolate* isolate) {
- uint32_t bitmask = descriptor.bitmask;
- uint32_t compare_value = descriptor.compare_value;
- uint32_t value;
- switch (descriptor.size) {
- case 1:
- value = static_cast<uint32_t>(*CheckedCast<uint8_t>(ptr));
- compare_value &= 0xff;
- bitmask &= 0xff;
- break;
- case 2:
- value = static_cast<uint32_t>(*CheckedCast<uint16_t>(ptr));
- compare_value &= 0xffff;
- bitmask &= 0xffff;
- break;
- case 4:
- value = *CheckedCast<uint32_t>(ptr);
- break;
- default:
- UNREACHABLE();
- return isolate->factory()->undefined_value();
- }
- return isolate->factory()->ToBoolean(
- (bitmask & value) == (bitmask & compare_value));
-}
-
-
-static Handle<Object> PerformCompare(const PointerCompareDescriptor& descriptor,
- char* ptr,
- Isolate* isolate) {
- uintptr_t compare_value =
- reinterpret_cast<uintptr_t>(descriptor.compare_value);
- uintptr_t value = *CheckedCast<uintptr_t>(ptr);
- return isolate->factory()->ToBoolean(compare_value == value);
-}
-
-
-static Handle<Object> GetPrimitiveValue(
- const PrimitiveValueDescriptor& descriptor,
- char* ptr,
- Isolate* isolate) {
- int32_t int32_value = 0;
- switch (descriptor.data_type) {
- case kDescriptorInt8Type:
- int32_value = *CheckedCast<int8_t>(ptr);
- break;
- case kDescriptorUint8Type:
- int32_value = *CheckedCast<uint8_t>(ptr);
- break;
- case kDescriptorInt16Type:
- int32_value = *CheckedCast<int16_t>(ptr);
- break;
- case kDescriptorUint16Type:
- int32_value = *CheckedCast<uint16_t>(ptr);
- break;
- case kDescriptorInt32Type:
- int32_value = *CheckedCast<int32_t>(ptr);
- break;
- case kDescriptorUint32Type: {
- uint32_t value = *CheckedCast<uint32_t>(ptr);
- AllowHeapAllocation allow_gc;
- return isolate->factory()->NewNumberFromUint(value);
- }
- case kDescriptorBoolType: {
- uint8_t byte = *CheckedCast<uint8_t>(ptr);
- return isolate->factory()->ToBoolean(
- byte & (0x1 << descriptor.bool_offset));
- }
- case kDescriptorFloatType: {
- float value = *CheckedCast<float>(ptr);
- AllowHeapAllocation allow_gc;
- return isolate->factory()->NewNumber(value);
- }
- case kDescriptorDoubleType: {
- double value = *CheckedCast<double>(ptr);
- AllowHeapAllocation allow_gc;
- return isolate->factory()->NewNumber(value);
- }
- }
- AllowHeapAllocation allow_gc;
- return isolate->factory()->NewNumberFromInt(int32_value);
-}
-
-
-static Handle<Object> GetDeclaredAccessorProperty(
- Handle<Object> receiver,
- Handle<DeclaredAccessorInfo> info,
- Isolate* isolate) {
- DisallowHeapAllocation no_gc;
- char* current = reinterpret_cast<char*>(*receiver);
- DeclaredAccessorDescriptorIterator iterator(info->descriptor());
- while (true) {
- const DeclaredAccessorDescriptorData* data = iterator.Next();
- switch (data->type) {
- case kDescriptorReturnObject: {
- DCHECK(iterator.Complete());
- current = *CheckedCast<char*>(current);
- return handle(*CheckedCast<Object*>(current), isolate);
- }
- case kDescriptorPointerDereference:
- DCHECK(!iterator.Complete());
- current = *reinterpret_cast<char**>(current);
- break;
- case kDescriptorPointerShift:
- DCHECK(!iterator.Complete());
- current += data->pointer_shift_descriptor.byte_offset;
- break;
- case kDescriptorObjectDereference: {
- DCHECK(!iterator.Complete());
- Object* object = CheckedCast<Object>(current);
- int field = data->object_dereference_descriptor.internal_field;
- Object* smi = JSObject::cast(object)->GetInternalField(field);
- DCHECK(smi->IsSmi());
- current = reinterpret_cast<char*>(smi);
- break;
- }
- case kDescriptorBitmaskCompare:
- DCHECK(iterator.Complete());
- return PerformCompare(data->bitmask_compare_descriptor,
- current,
- isolate);
- case kDescriptorPointerCompare:
- DCHECK(iterator.Complete());
- return PerformCompare(data->pointer_compare_descriptor,
- current,
- isolate);
- case kDescriptorPrimitiveValue:
- DCHECK(iterator.Complete());
- return GetPrimitiveValue(data->primitive_value_descriptor,
- current,
- isolate);
- }
- }
- UNREACHABLE();
- return isolate->factory()->undefined_value();
-}
-
-
Handle<FixedArray> JSObject::EnsureWritableFastElements(
Handle<JSObject> object) {
DCHECK(object->HasFastSmiOrObjectElements());
HandleVector(args, arraysize(args))),
Object);
}
- if (structure->IsDeclaredAccessorInfo()) {
- return GetDeclaredAccessorProperty(
- receiver,
- Handle<DeclaredAccessorInfo>::cast(structure),
- isolate);
- }
Handle<ExecutableAccessorInfo> data =
Handle<ExecutableAccessorInfo>::cast(structure);
}
}
- // TODO(dcarney): Handle correctly.
- if (structure->IsDeclaredAccessorInfo()) {
- return value;
- }
-
UNREACHABLE();
return MaybeHandle<Object>();
}
if (it->property_details().IsReadOnly()) {
return WriteToReadOnlyProperty(it, value, strict_mode);
}
- if (it->HolderIsReceiverOrHiddenPrototype() ||
- !it->GetAccessors()->IsDeclaredAccessorInfo()) {
- return SetPropertyWithAccessor(it->GetReceiver(), it->name(), value,
- it->GetHolder<JSObject>(),
- it->GetAccessors(), strict_mode);
- }
- done = true;
- break;
+ return SetPropertyWithAccessor(it->GetReceiver(), it->name(), value,
+ it->GetHolder<JSObject>(),
+ it->GetAccessors(), strict_mode);
case LookupIterator::DATA:
if (it->property_details().IsReadOnly()) {
return isolate->factory()->undefined_value();
}
- if (structure->IsDeclaredAccessorInfo()) {
- return GetDeclaredAccessorProperty(
- receiver, Handle<DeclaredAccessorInfo>::cast(structure), isolate);
- }
-
UNREACHABLE();
return MaybeHandle<Object>();
}
}
}
- // TODO(dcarney): Handle correctly.
- if (structure->IsDeclaredAccessorInfo()) return value;
-
UNREACHABLE();
return MaybeHandle<Object>();
}
OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Transition();
-DeclaredAccessorDescriptorIterator::DeclaredAccessorDescriptorIterator(
- DeclaredAccessorDescriptor* descriptor)
- : array_(descriptor->serialized_data()->GetDataStartAddress()),
- length_(descriptor->serialized_data()->length()),
- offset_(0) {
-}
-
-
-const DeclaredAccessorDescriptorData*
- DeclaredAccessorDescriptorIterator::Next() {
- DCHECK(offset_ < length_);
- uint8_t* ptr = &array_[offset_];
- DCHECK(reinterpret_cast<uintptr_t>(ptr) % sizeof(uintptr_t) == 0);
- const DeclaredAccessorDescriptorData* data =
- reinterpret_cast<const DeclaredAccessorDescriptorData*>(ptr);
- offset_ += sizeof(*data);
- DCHECK(offset_ <= length_);
- return data;
-}
-
-
-Handle<DeclaredAccessorDescriptor> DeclaredAccessorDescriptor::Create(
- Isolate* isolate,
- const DeclaredAccessorDescriptorData& descriptor,
- Handle<DeclaredAccessorDescriptor> previous) {
- int previous_length =
- previous.is_null() ? 0 : previous->serialized_data()->length();
- int length = sizeof(descriptor) + previous_length;
- Handle<ByteArray> serialized_descriptor =
- isolate->factory()->NewByteArray(length);
- Handle<DeclaredAccessorDescriptor> value =
- isolate->factory()->NewDeclaredAccessorDescriptor();
- value->set_serialized_data(*serialized_descriptor);
- // Copy in the data.
- {
- DisallowHeapAllocation no_allocation;
- uint8_t* array = serialized_descriptor->GetDataStartAddress();
- if (previous_length != 0) {
- uint8_t* previous_array =
- previous->serialized_data()->GetDataStartAddress();
- MemCopy(array, previous_array, previous_length);
- array += previous_length;
- }
- DCHECK(reinterpret_cast<uintptr_t>(array) % sizeof(uintptr_t) == 0);
- DeclaredAccessorDescriptorData* data =
- reinterpret_cast<DeclaredAccessorDescriptorData*>(array);
- *data = descriptor;
- }
- return value;
-}
-
-
// Check if there is a break point at this code position.
bool DebugInfo::HasBreakPoint(int code_position) {
// Get the break point info object for this code position.
// - SharedFunctionInfo
// - Struct
// - Box
-// - DeclaredAccessorDescriptor
// - AccessorInfo
-// - DeclaredAccessorInfo
// - ExecutableAccessorInfo
// - AccessorPair
// - AccessCheckInfo
// manually.
#define STRUCT_LIST(V) \
V(BOX, Box, box) \
- V(DECLARED_ACCESSOR_DESCRIPTOR, \
- DeclaredAccessorDescriptor, \
- declared_accessor_descriptor) \
- V(DECLARED_ACCESSOR_INFO, DeclaredAccessorInfo, declared_accessor_info) \
V(EXECUTABLE_ACCESSOR_INFO, ExecutableAccessorInfo, executable_accessor_info)\
V(ACCESSOR_PAIR, AccessorPair, accessor_pair) \
V(ACCESS_CHECK_INFO, AccessCheckInfo, access_check_info) \
};
-enum AccessorDescriptorType {
- kDescriptorBitmaskCompare,
- kDescriptorPointerCompare,
- kDescriptorPrimitiveValue,
- kDescriptorObjectDereference,
- kDescriptorPointerDereference,
- kDescriptorPointerShift,
- kDescriptorReturnObject
-};
-
-
-struct BitmaskCompareDescriptor {
- uint32_t bitmask;
- uint32_t compare_value;
- uint8_t size; // Must be in {1,2,4}.
-};
-
-
-struct PointerCompareDescriptor {
- void* compare_value;
-};
-
-
-struct PrimitiveValueDescriptor {
- v8::DeclaredAccessorDescriptorDataType data_type;
- uint8_t bool_offset; // Must be in [0,7], used for kDescriptorBoolType.
-};
-
-
-struct ObjectDerefenceDescriptor {
- uint8_t internal_field;
-};
-
-
-struct PointerShiftDescriptor {
- int16_t byte_offset;
-};
-
-
-struct DeclaredAccessorDescriptorData {
- AccessorDescriptorType type;
- union {
- struct BitmaskCompareDescriptor bitmask_compare_descriptor;
- struct PointerCompareDescriptor pointer_compare_descriptor;
- struct PrimitiveValueDescriptor primitive_value_descriptor;
- struct ObjectDerefenceDescriptor object_dereference_descriptor;
- struct PointerShiftDescriptor pointer_shift_descriptor;
- };
-};
-
-
-class DeclaredAccessorDescriptor;
-
-
-class DeclaredAccessorDescriptorIterator {
- public:
- explicit DeclaredAccessorDescriptorIterator(
- DeclaredAccessorDescriptor* descriptor);
- const DeclaredAccessorDescriptorData* Next();
- bool Complete() const { return length_ == offset_; }
- private:
- uint8_t* array_;
- const int length_;
- int offset_;
- DISALLOW_IMPLICIT_CONSTRUCTORS(DeclaredAccessorDescriptorIterator);
-};
-
-
-class DeclaredAccessorDescriptor: public Struct {
- public:
- DECL_ACCESSORS(serialized_data, ByteArray)
-
- DECLARE_CAST(DeclaredAccessorDescriptor)
-
- static Handle<DeclaredAccessorDescriptor> Create(
- Isolate* isolate,
- const DeclaredAccessorDescriptorData& data,
- Handle<DeclaredAccessorDescriptor> previous);
-
- // Dispatched behavior.
- DECLARE_PRINTER(DeclaredAccessorDescriptor)
- DECLARE_VERIFIER(DeclaredAccessorDescriptor)
-
- static const int kSerializedDataOffset = HeapObject::kHeaderSize;
- static const int kSize = kSerializedDataOffset + kPointerSize;
-
- private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(DeclaredAccessorDescriptor);
-};
-
-
-class DeclaredAccessorInfo: public AccessorInfo {
- public:
- DECL_ACCESSORS(descriptor, DeclaredAccessorDescriptor)
-
- DECLARE_CAST(DeclaredAccessorInfo)
-
- // Dispatched behavior.
- DECLARE_PRINTER(DeclaredAccessorInfo)
- DECLARE_VERIFIER(DeclaredAccessorInfo)
-
- static const int kDescriptorOffset = AccessorInfo::kSize;
- static const int kSize = kDescriptorOffset + kPointerSize;
-
- private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(DeclaredAccessorInfo);
-};
-
-
// An accessor must have a getter, but can have no setter.
//
// When setting a property, V8 searches accessors in prototypes.
'test-cpu-profiler.cc',
'test-date.cc',
'test-debug.cc',
- 'test-declarative-accessors.cc',
'test-decls.cc',
'test-deoptimization.cc',
'test-dictionary.cc',
+++ /dev/null
-// Copyright 2013 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following
-// disclaimer in the documentation and/or other materials provided
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include <stdlib.h>
-
-#include "src/v8.h"
-
-#include "test/cctest/cctest.h"
-
-using namespace v8::internal;
-
-
-class HandleArray : public Malloced {
- public:
- static const unsigned kArraySize = 200;
- HandleArray() {}
- ~HandleArray() { Reset(); }
- void Reset() {
- for (unsigned i = 0; i < kArraySize; i++) {
- if (handles_[i].IsEmpty()) continue;
- handles_[i].Reset();
- }
- }
- v8::Persistent<v8::Value> handles_[kArraySize];
- private:
- DISALLOW_COPY_AND_ASSIGN(HandleArray);
-};
-
-
-// An aligned character array of size 1024.
-class AlignedArray : public Malloced {
- public:
- static const unsigned kArraySize = 1024/sizeof(uint64_t);
- AlignedArray() { Reset(); }
-
- void Reset() {
- for (unsigned i = 0; i < kArraySize; i++) {
- data_[i] = 0;
- }
- }
-
- template<typename T>
- T As() { return reinterpret_cast<T>(data_); }
-
- private:
- uint64_t data_[kArraySize];
- DISALLOW_COPY_AND_ASSIGN(AlignedArray);
-};
-
-
-class DescriptorTestHelper {
- public:
- DescriptorTestHelper() :
- isolate_(NULL), array_(new AlignedArray), handle_array_(new HandleArray) {
- v8::V8::Initialize();
- isolate_ = CcTest::isolate();
- }
- v8::Isolate* isolate_;
- // Data objects.
- SmartPointer<AlignedArray> array_;
- SmartPointer<HandleArray> handle_array_;
- private:
- DISALLOW_COPY_AND_ASSIGN(DescriptorTestHelper);
-};
-
-
-static v8::Local<v8::ObjectTemplate> CreateConstructor(
- v8::Handle<v8::Context> context,
- const char* class_name,
- int internal_field,
- const char* descriptor_name = NULL,
- v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
- v8::Handle<v8::DeclaredAccessorDescriptor>()) {
- v8::Local<v8::FunctionTemplate> constructor =
- v8::FunctionTemplate::New(context->GetIsolate());
- v8::Local<v8::ObjectTemplate> obj_template = constructor->InstanceTemplate();
- // Setup object template.
- if (descriptor_name != NULL && !descriptor.IsEmpty()) {
- bool added_accessor =
- obj_template->SetDeclaredAccessor(v8_str(descriptor_name), descriptor);
- CHECK(added_accessor);
- }
- obj_template->SetInternalFieldCount((internal_field+1)*2 + 7);
- context->Global()->Set(v8_str(class_name), constructor->GetFunction());
- return obj_template;
-}
-
-
-static void VerifyRead(v8::Handle<v8::DeclaredAccessorDescriptor> descriptor,
- int internal_field,
- void* internal_object,
- v8::Handle<v8::Value> expected_value) {
- LocalContext local_context;
- v8::HandleScope scope(local_context->GetIsolate());
- v8::Handle<v8::Context> context = local_context.local();
- CreateConstructor(context, "Accessible", internal_field, "x", descriptor);
- // Setup object.
- CompileRun("var accessible = new Accessible();");
- v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(
- context->Global()->Get(v8_str("accessible")));
- obj->SetAlignedPointerInInternalField(internal_field, internal_object);
- bool added_accessor;
- added_accessor = obj->SetDeclaredAccessor(v8_str("y"), descriptor);
- CHECK(added_accessor);
- added_accessor = obj->SetDeclaredAccessor(v8_str("13"), descriptor);
- CHECK(added_accessor);
- // Test access from template getter.
- v8::Local<v8::Value> value;
- value = CompileRun("accessible.x;");
- CHECK_EQ(expected_value, value);
- value = CompileRun("accessible['x'];");
- CHECK_EQ(expected_value, value);
- // Test access from object getter.
- value = CompileRun("accessible.y;");
- CHECK_EQ(expected_value, value);
- value = CompileRun("accessible['y'];");
- CHECK_EQ(expected_value, value);
- value = CompileRun("accessible[13];");
- CHECK_EQ(expected_value, value);
- value = CompileRun("accessible['13'];");
- CHECK_EQ(expected_value, value);
-}
-
-
-static v8::Handle<v8::Value> Convert(int32_t value, v8::Isolate* isolate) {
- return v8::Integer::New(isolate, value);
-}
-
-
-static v8::Handle<v8::Value> Convert(float value, v8::Isolate* isolate) {
- return v8::Number::New(isolate, value);
-}
-
-
-static v8::Handle<v8::Value> Convert(double value, v8::Isolate* isolate) {
- return v8::Number::New(isolate, value);
-}
-
-
-typedef v8::ObjectOperationDescriptor OOD;
-
-template<typename T>
-static void TestPrimitiveValue(
- T value,
- v8::DeclaredAccessorDescriptorDataType data_type,
- DescriptorTestHelper* helper) {
- v8::HandleScope handle_scope(helper->isolate_);
- int index = 17;
- int internal_field = 6;
- v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
- OOD::NewInternalFieldDereference(helper->isolate_, internal_field)
- ->NewRawShift(helper->isolate_, static_cast<uint16_t>(index*sizeof(T)))
- ->NewPrimitiveValue(helper->isolate_, data_type, 0);
- v8::Handle<v8::Value> expected = Convert(value, helper->isolate_);
- helper->array_->Reset();
- helper->array_->As<T*>()[index] = value;
- VerifyRead(descriptor, internal_field, helper->array_.get(), expected);
-}
-
-
-TEST(PrimitiveValueRead) {
- DescriptorTestHelper helper;
- TestPrimitiveValue<int32_t>(203, v8::kDescriptorInt32Type, &helper);
- TestPrimitiveValue<float>(23.7f, v8::kDescriptorFloatType, &helper);
- TestPrimitiveValue<double>(23.7, v8::kDescriptorDoubleType, &helper);
-}
-
-
-template<typename T>
-static void TestBitmaskCompare(T bitmask,
- T compare_value,
- DescriptorTestHelper* helper) {
- v8::HandleScope handle_scope(helper->isolate_);
- int index = 13;
- int internal_field = 4;
- v8::Handle<v8::RawOperationDescriptor> raw_descriptor =
- OOD::NewInternalFieldDereference(helper->isolate_, internal_field)
- ->NewRawShift(helper->isolate_, static_cast<uint16_t>(index*sizeof(T)));
- v8::Handle<v8::DeclaredAccessorDescriptor> descriptor;
- switch (sizeof(T)) {
- case 1:
- descriptor = raw_descriptor->NewBitmaskCompare8(
- helper->isolate_,
- static_cast<uint8_t>(bitmask),
- static_cast<uint8_t>(compare_value));
- break;
- case 2:
- descriptor = raw_descriptor->NewBitmaskCompare16(
- helper->isolate_,
- static_cast<uint16_t>(bitmask),
- static_cast<uint16_t>(compare_value));
- break;
- case 4:
- descriptor = raw_descriptor->NewBitmaskCompare32(
- helper->isolate_,
- static_cast<uint32_t>(bitmask),
- static_cast<uint32_t>(compare_value));
- break;
- default:
- CHECK(false);
- break;
- }
- AlignedArray* array = helper->array_.get();
- array->Reset();
- VerifyRead(descriptor, internal_field, array, v8::False(helper->isolate_));
- array->As<T*>()[index] = compare_value;
- VerifyRead(descriptor, internal_field, array, v8::True(helper->isolate_));
- helper->array_->As<T*>()[index] = compare_value & bitmask;
- VerifyRead(descriptor, internal_field, array, v8::True(helper->isolate_));
-}
-
-
-TEST(BitmaskCompareRead) {
- DescriptorTestHelper helper;
- TestBitmaskCompare<uint8_t>(0xf3, 0xa8, &helper);
- TestBitmaskCompare<uint16_t>(0xfefe, 0x7d42, &helper);
- TestBitmaskCompare<uint32_t>(0xfefeab18, 0x1234fdec, &helper);
-}
-
-
-TEST(PointerCompareRead) {
- DescriptorTestHelper helper;
- v8::HandleScope handle_scope(helper.isolate_);
- int index = 35;
- int internal_field = 3;
- void* ptr = helper.isolate_;
- v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
- OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
- ->NewRawShift(helper.isolate_, static_cast<uint16_t>(index*sizeof(ptr)))
- ->NewPointerCompare(helper.isolate_, ptr);
- AlignedArray* array = helper.array_.get();
- VerifyRead(descriptor, internal_field, array, v8::False(helper.isolate_));
- array->As<uintptr_t*>()[index] = reinterpret_cast<uintptr_t>(ptr);
- VerifyRead(descriptor, internal_field, array, v8::True(helper.isolate_));
-}
-
-
-TEST(PointerDereferenceRead) {
- DescriptorTestHelper helper;
- v8::HandleScope handle_scope(helper.isolate_);
- int first_index = 13;
- int internal_field = 7;
- int second_index = 11;
- int pointed_to_index = 75;
- uint16_t expected = 0x1425;
- v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
- OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
- ->NewRawShift(helper.isolate_, first_index*kPointerSize)
- ->NewRawDereference(helper.isolate_)
- ->NewRawShift(helper.isolate_,
- static_cast<uint16_t>(second_index*sizeof(int16_t)))
- ->NewPrimitiveValue(helper.isolate_, v8::kDescriptorInt16Type, 0);
- AlignedArray* array = helper.array_.get();
- array->As<uintptr_t**>()[first_index] =
- &array->As<uintptr_t*>()[pointed_to_index];
- VerifyRead(descriptor, internal_field, array,
- v8::Integer::New(helper.isolate_, 0));
- second_index += pointed_to_index*sizeof(uintptr_t)/sizeof(uint16_t);
- array->As<uint16_t*>()[second_index] = expected;
- VerifyRead(descriptor, internal_field, array,
- v8::Integer::New(helper.isolate_, expected));
-}
-
-
-TEST(HandleDereferenceRead) {
- DescriptorTestHelper helper;
- v8::HandleScope handle_scope(helper.isolate_);
- int index = 13;
- int internal_field = 0;
- v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
- OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
- ->NewRawShift(helper.isolate_, index*kPointerSize)
- ->NewHandleDereference(helper.isolate_);
- HandleArray* array = helper.handle_array_.get();
- v8::Handle<v8::String> expected = v8_str("whatever");
- array->handles_[index].Reset(helper.isolate_, expected);
- VerifyRead(descriptor, internal_field, array, expected);
-}
90: "SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE",
0: "INTERNALIZED_STRING_TYPE",
4: "ONE_BYTE_INTERNALIZED_STRING_TYPE",
- 1: "CONS_INTERNALIZED_STRING_TYPE",
- 5: "CONS_ONE_BYTE_INTERNALIZED_STRING_TYPE",
2: "EXTERNAL_INTERNALIZED_STRING_TYPE",
6: "EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE",
10: "EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE",
132: "CELL_TYPE",
133: "PROPERTY_CELL_TYPE",
134: "HEAP_NUMBER_TYPE",
- 135: "FOREIGN_TYPE",
- 136: "BYTE_ARRAY_TYPE",
- 137: "FREE_SPACE_TYPE",
- 138: "EXTERNAL_INT8_ARRAY_TYPE",
- 139: "EXTERNAL_UINT8_ARRAY_TYPE",
- 140: "EXTERNAL_INT16_ARRAY_TYPE",
- 141: "EXTERNAL_UINT16_ARRAY_TYPE",
- 142: "EXTERNAL_INT32_ARRAY_TYPE",
- 143: "EXTERNAL_UINT32_ARRAY_TYPE",
- 144: "EXTERNAL_FLOAT32_ARRAY_TYPE",
- 145: "EXTERNAL_FLOAT64_ARRAY_TYPE",
- 146: "EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE",
- 147: "FIXED_INT8_ARRAY_TYPE",
- 148: "FIXED_UINT8_ARRAY_TYPE",
- 149: "FIXED_INT16_ARRAY_TYPE",
- 150: "FIXED_UINT16_ARRAY_TYPE",
- 151: "FIXED_INT32_ARRAY_TYPE",
- 152: "FIXED_UINT32_ARRAY_TYPE",
- 153: "FIXED_FLOAT32_ARRAY_TYPE",
- 154: "FIXED_FLOAT64_ARRAY_TYPE",
- 155: "FIXED_UINT8_CLAMPED_ARRAY_TYPE",
- 157: "FILLER_TYPE",
- 158: "DECLARED_ACCESSOR_DESCRIPTOR_TYPE",
- 159: "DECLARED_ACCESSOR_INFO_TYPE",
- 160: "EXECUTABLE_ACCESSOR_INFO_TYPE",
- 161: "ACCESSOR_PAIR_TYPE",
- 162: "ACCESS_CHECK_INFO_TYPE",
- 163: "INTERCEPTOR_INFO_TYPE",
- 164: "CALL_HANDLER_INFO_TYPE",
- 165: "FUNCTION_TEMPLATE_INFO_TYPE",
- 166: "OBJECT_TEMPLATE_INFO_TYPE",
- 167: "SIGNATURE_INFO_TYPE",
- 168: "TYPE_SWITCH_INFO_TYPE",
- 170: "ALLOCATION_MEMENTO_TYPE",
- 169: "ALLOCATION_SITE_TYPE",
- 171: "SCRIPT_TYPE",
- 172: "CODE_CACHE_TYPE",
- 173: "POLYMORPHIC_CODE_CACHE_TYPE",
- 174: "TYPE_FEEDBACK_INFO_TYPE",
- 175: "ALIASED_ARGUMENTS_ENTRY_TYPE",
- 176: "BOX_TYPE",
- 179: "FIXED_ARRAY_TYPE",
- 156: "FIXED_DOUBLE_ARRAY_TYPE",
- 180: "CONSTANT_POOL_ARRAY_TYPE",
- 181: "SHARED_FUNCTION_INFO_TYPE",
- 182: "JS_MESSAGE_OBJECT_TYPE",
- 185: "JS_VALUE_TYPE",
- 186: "JS_DATE_TYPE",
- 187: "JS_OBJECT_TYPE",
- 188: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
- 189: "JS_GENERATOR_OBJECT_TYPE",
- 190: "JS_MODULE_TYPE",
- 191: "JS_GLOBAL_OBJECT_TYPE",
- 192: "JS_BUILTINS_OBJECT_TYPE",
- 193: "JS_GLOBAL_PROXY_TYPE",
- 194: "JS_ARRAY_TYPE",
- 195: "JS_ARRAY_BUFFER_TYPE",
- 196: "JS_TYPED_ARRAY_TYPE",
- 197: "JS_DATA_VIEW_TYPE",
- 184: "JS_PROXY_TYPE",
- 198: "JS_SET_TYPE",
- 199: "JS_MAP_TYPE",
- 200: "JS_WEAK_MAP_TYPE",
- 201: "JS_WEAK_SET_TYPE",
- 202: "JS_REGEXP_TYPE",
- 203: "JS_FUNCTION_TYPE",
- 183: "JS_FUNCTION_PROXY_TYPE",
- 177: "DEBUG_INFO_TYPE",
- 178: "BREAK_POINT_INFO_TYPE",
+ 135: "MUTABLE_HEAP_NUMBER_TYPE",
+ 136: "FOREIGN_TYPE",
+ 137: "BYTE_ARRAY_TYPE",
+ 138: "FREE_SPACE_TYPE",
+ 139: "EXTERNAL_INT8_ARRAY_TYPE",
+ 140: "EXTERNAL_UINT8_ARRAY_TYPE",
+ 141: "EXTERNAL_INT16_ARRAY_TYPE",
+ 142: "EXTERNAL_UINT16_ARRAY_TYPE",
+ 143: "EXTERNAL_INT32_ARRAY_TYPE",
+ 144: "EXTERNAL_UINT32_ARRAY_TYPE",
+ 145: "EXTERNAL_FLOAT32_ARRAY_TYPE",
+ 146: "EXTERNAL_FLOAT64_ARRAY_TYPE",
+ 147: "EXTERNAL_UINT8_CLAMPED_ARRAY_TYPE",
+ 148: "FIXED_INT8_ARRAY_TYPE",
+ 149: "FIXED_UINT8_ARRAY_TYPE",
+ 150: "FIXED_INT16_ARRAY_TYPE",
+ 151: "FIXED_UINT16_ARRAY_TYPE",
+ 152: "FIXED_INT32_ARRAY_TYPE",
+ 153: "FIXED_UINT32_ARRAY_TYPE",
+ 154: "FIXED_FLOAT32_ARRAY_TYPE",
+ 155: "FIXED_FLOAT64_ARRAY_TYPE",
+ 156: "FIXED_UINT8_CLAMPED_ARRAY_TYPE",
+ 158: "FILLER_TYPE",
+ 159: "DECLARED_ACCESSOR_DESCRIPTOR_TYPE",
+ 160: "DECLARED_ACCESSOR_INFO_TYPE",
+ 161: "EXECUTABLE_ACCESSOR_INFO_TYPE",
+ 162: "ACCESSOR_PAIR_TYPE",
+ 163: "ACCESS_CHECK_INFO_TYPE",
+ 164: "INTERCEPTOR_INFO_TYPE",
+ 165: "CALL_HANDLER_INFO_TYPE",
+ 166: "FUNCTION_TEMPLATE_INFO_TYPE",
+ 167: "OBJECT_TEMPLATE_INFO_TYPE",
+ 168: "SIGNATURE_INFO_TYPE",
+ 169: "TYPE_SWITCH_INFO_TYPE",
+ 171: "ALLOCATION_MEMENTO_TYPE",
+ 170: "ALLOCATION_SITE_TYPE",
+ 172: "SCRIPT_TYPE",
+ 173: "CODE_CACHE_TYPE",
+ 174: "POLYMORPHIC_CODE_CACHE_TYPE",
+ 175: "TYPE_FEEDBACK_INFO_TYPE",
+ 176: "ALIASED_ARGUMENTS_ENTRY_TYPE",
+ 177: "BOX_TYPE",
+ 180: "FIXED_ARRAY_TYPE",
+ 157: "FIXED_DOUBLE_ARRAY_TYPE",
+ 181: "CONSTANT_POOL_ARRAY_TYPE",
+ 182: "SHARED_FUNCTION_INFO_TYPE",
+ 183: "WEAK_CELL_TYPE",
+ 187: "JS_MESSAGE_OBJECT_TYPE",
+ 186: "JS_VALUE_TYPE",
+ 188: "JS_DATE_TYPE",
+ 189: "JS_OBJECT_TYPE",
+ 190: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
+ 191: "JS_GENERATOR_OBJECT_TYPE",
+ 192: "JS_MODULE_TYPE",
+ 193: "JS_GLOBAL_OBJECT_TYPE",
+ 194: "JS_BUILTINS_OBJECT_TYPE",
+ 195: "JS_GLOBAL_PROXY_TYPE",
+ 196: "JS_ARRAY_TYPE",
+ 197: "JS_ARRAY_BUFFER_TYPE",
+ 198: "JS_TYPED_ARRAY_TYPE",
+ 199: "JS_DATA_VIEW_TYPE",
+ 185: "JS_PROXY_TYPE",
+ 200: "JS_SET_TYPE",
+ 201: "JS_MAP_TYPE",
+ 202: "JS_SET_ITERATOR_TYPE",
+ 203: "JS_MAP_ITERATOR_TYPE",
+ 204: "JS_WEAK_MAP_TYPE",
+ 205: "JS_WEAK_SET_TYPE",
+ 206: "JS_REGEXP_TYPE",
+ 207: "JS_FUNCTION_TYPE",
+ 184: "JS_FUNCTION_PROXY_TYPE",
+ 178: "DEBUG_INFO_TYPE",
+ 179: "BREAK_POINT_INFO_TYPE",
}
# List of known V8 maps.
KNOWN_MAPS = {
- 0x08081: (136, "ByteArrayMap"),
+ 0x08081: (137, "ByteArrayMap"),
0x080a9: (129, "MetaMap"),
- 0x080d1: (131, "OddballMap"),
- 0x080f9: (4, "OneByteInternalizedStringMap"),
- 0x08121: (179, "FixedArrayMap"),
- 0x08149: (134, "HeapNumberMap"),
- 0x08171: (137, "FreeSpaceMap"),
- 0x08199: (157, "OnePointerFillerMap"),
- 0x081c1: (157, "TwoPointerFillerMap"),
- 0x081e9: (132, "CellMap"),
- 0x08211: (133, "GlobalPropertyCellMap"),
- 0x08239: (181, "SharedFunctionInfoMap"),
- 0x08261: (179, "NativeContextMap"),
- 0x08289: (130, "CodeMap"),
- 0x082b1: (179, "ScopeInfoMap"),
- 0x082d9: (179, "FixedCOWArrayMap"),
- 0x08301: (156, "FixedDoubleArrayMap"),
- 0x08329: (180, "ConstantPoolArrayMap"),
- 0x08351: (179, "HashTableMap"),
- 0x08379: (128, "SymbolMap"),
- 0x083a1: (64, "StringMap"),
- 0x083c9: (68, "OneByteStringMap"),
- 0x083f1: (65, "ConsStringMap"),
- 0x08419: (69, "ConsOneByteStringMap"),
- 0x08441: (67, "SlicedStringMap"),
- 0x08469: (71, "SlicedOneByteStringMap"),
- 0x08491: (66, "ExternalStringMap"),
- 0x084b9: (74, "ExternalStringWithOneByteDataMap"),
- 0x084e1: (70, "ExternalOneByteStringMap"),
- 0x08509: (82, "ShortExternalStringMap"),
- 0x08531: (90, "ShortExternalStringWithOneByteDataMap"),
- 0x08559: (0, "InternalizedStringMap"),
- 0x08581: (1, "ConsInternalizedStringMap"),
- 0x085a9: (5, "ConsOneByteInternalizedStringMap"),
- 0x085d1: (2, "ExternalInternalizedStringMap"),
- 0x085f9: (10, "ExternalInternalizedStringWithOneByteDataMap"),
- 0x08621: (6, "ExternalOneByteInternalizedStringMap"),
- 0x08649: (18, "ShortExternalInternalizedStringMap"),
- 0x08671: (26, "ShortExternalInternalizedStringWithOneByteDataMap"),
- 0x08699: (22, "ShortExternalOneByteInternalizedStringMap"),
- 0x086c1: (86, "ShortExternalOneByteStringMap"),
- 0x086e9: (64, "UndetectableStringMap"),
- 0x08711: (68, "UndetectableOneByteStringMap"),
- 0x08739: (138, "ExternalInt8ArrayMap"),
- 0x08761: (139, "ExternalUint8ArrayMap"),
- 0x08789: (140, "ExternalInt16ArrayMap"),
- 0x087b1: (141, "ExternalUint16ArrayMap"),
- 0x087d9: (142, "ExternalInt32ArrayMap"),
- 0x08801: (143, "ExternalUint32ArrayMap"),
- 0x08829: (144, "ExternalFloat32ArrayMap"),
- 0x08851: (145, "ExternalFloat64ArrayMap"),
- 0x08879: (146, "ExternalUint8ClampedArrayMap"),
- 0x088a1: (148, "FixedUint8ArrayMap"),
- 0x088c9: (147, "FixedInt8ArrayMap"),
- 0x088f1: (150, "FixedUint16ArrayMap"),
- 0x08919: (149, "FixedInt16ArrayMap"),
- 0x08941: (152, "FixedUint32ArrayMap"),
- 0x08969: (151, "FixedInt32ArrayMap"),
- 0x08991: (153, "FixedFloat32ArrayMap"),
- 0x089b9: (154, "FixedFloat64ArrayMap"),
- 0x089e1: (155, "FixedUint8ClampedArrayMap"),
- 0x08a09: (179, "NonStrictArgumentsElementsMap"),
- 0x08a31: (179, "FunctionContextMap"),
- 0x08a59: (179, "CatchContextMap"),
- 0x08a81: (179, "WithContextMap"),
- 0x08aa9: (179, "BlockContextMap"),
- 0x08ad1: (179, "ModuleContextMap"),
- 0x08af9: (179, "GlobalContextMap"),
- 0x08b21: (182, "JSMessageObjectMap"),
- 0x08b49: (135, "ForeignMap"),
- 0x08b71: (187, "NeanderMap"),
- 0x08b99: (170, "AllocationMementoMap"),
- 0x08bc1: (169, "AllocationSiteMap"),
- 0x08be9: (173, "PolymorphicCodeCacheMap"),
- 0x08c11: (171, "ScriptMap"),
- 0x08c61: (187, "ExternalMap"),
- 0x08cb1: (176, "BoxMap"),
- 0x08cd9: (158, "DeclaredAccessorDescriptorMap"),
- 0x08d01: (159, "DeclaredAccessorInfoMap"),
- 0x08d29: (160, "ExecutableAccessorInfoMap"),
- 0x08d51: (161, "AccessorPairMap"),
- 0x08d79: (162, "AccessCheckInfoMap"),
- 0x08da1: (163, "InterceptorInfoMap"),
- 0x08dc9: (164, "CallHandlerInfoMap"),
- 0x08df1: (165, "FunctionTemplateInfoMap"),
- 0x08e19: (166, "ObjectTemplateInfoMap"),
- 0x08e41: (167, "SignatureInfoMap"),
- 0x08e69: (168, "TypeSwitchInfoMap"),
- 0x08e91: (172, "CodeCacheMap"),
- 0x08eb9: (174, "TypeFeedbackInfoMap"),
- 0x08ee1: (175, "AliasedArgumentsEntryMap"),
- 0x08f09: (177, "DebugInfoMap"),
- 0x08f31: (178, "BreakPointInfoMap"),
+ 0x080d1: (131, "NullMap"),
+ 0x080f9: (131, "UndefinedMap"),
+ 0x08121: (180, "FixedArrayMap"),
+ 0x08149: (4, "OneByteInternalizedStringMap"),
+ 0x08171: (134, "HeapNumberMap"),
+ 0x08199: (138, "FreeSpaceMap"),
+ 0x081c1: (158, "OnePointerFillerMap"),
+ 0x081e9: (158, "TwoPointerFillerMap"),
+ 0x08211: (131, "TheHoleMap"),
+ 0x08239: (131, "BooleanMap"),
+ 0x08261: (131, "UninitializedMap"),
+ 0x08289: (131, "ExceptionMap"),
+ 0x082b1: (132, "CellMap"),
+ 0x082d9: (133, "GlobalPropertyCellMap"),
+ 0x08301: (182, "SharedFunctionInfoMap"),
+ 0x08329: (135, "MutableHeapNumberMap"),
+ 0x08351: (180, "NativeContextMap"),
+ 0x08379: (130, "CodeMap"),
+ 0x083a1: (180, "ScopeInfoMap"),
+ 0x083c9: (180, "FixedCOWArrayMap"),
+ 0x083f1: (157, "FixedDoubleArrayMap"),
+ 0x08419: (181, "ConstantPoolArrayMap"),
+ 0x08441: (183, "WeakCellMap"),
+ 0x08469: (131, "NoInterceptorResultSentinelMap"),
+ 0x08491: (180, "HashTableMap"),
+ 0x084b9: (180, "OrderedHashTableMap"),
+ 0x084e1: (131, "ArgumentsMarkerMap"),
+ 0x08509: (131, "TerminationExceptionMap"),
+ 0x08531: (128, "SymbolMap"),
+ 0x08559: (64, "StringMap"),
+ 0x08581: (68, "OneByteStringMap"),
+ 0x085a9: (65, "ConsStringMap"),
+ 0x085d1: (69, "ConsOneByteStringMap"),
+ 0x085f9: (67, "SlicedStringMap"),
+ 0x08621: (71, "SlicedOneByteStringMap"),
+ 0x08649: (66, "ExternalStringMap"),
+ 0x08671: (74, "ExternalStringWithOneByteDataMap"),
+ 0x08699: (70, "ExternalOneByteStringMap"),
+ 0x086c1: (70, "NativeSourceStringMap"),
+ 0x086e9: (82, "ShortExternalStringMap"),
+ 0x08711: (90, "ShortExternalStringWithOneByteDataMap"),
+ 0x08739: (0, "InternalizedStringMap"),
+ 0x08761: (2, "ExternalInternalizedStringMap"),
+ 0x08789: (10, "ExternalInternalizedStringWithOneByteDataMap"),
+ 0x087b1: (6, "ExternalOneByteInternalizedStringMap"),
+ 0x087d9: (18, "ShortExternalInternalizedStringMap"),
+ 0x08801: (26, "ShortExternalInternalizedStringWithOneByteDataMap"),
+ 0x08829: (22, "ShortExternalOneByteInternalizedStringMap"),
+ 0x08851: (86, "ShortExternalOneByteStringMap"),
+ 0x08879: (64, "UndetectableStringMap"),
+ 0x088a1: (68, "UndetectableOneByteStringMap"),
+ 0x088c9: (139, "ExternalInt8ArrayMap"),
+ 0x088f1: (140, "ExternalUint8ArrayMap"),
+ 0x08919: (141, "ExternalInt16ArrayMap"),
+ 0x08941: (142, "ExternalUint16ArrayMap"),
+ 0x08969: (143, "ExternalInt32ArrayMap"),
+ 0x08991: (144, "ExternalUint32ArrayMap"),
+ 0x089b9: (145, "ExternalFloat32ArrayMap"),
+ 0x089e1: (146, "ExternalFloat64ArrayMap"),
+ 0x08a09: (147, "ExternalUint8ClampedArrayMap"),
+ 0x08a31: (149, "FixedUint8ArrayMap"),
+ 0x08a59: (148, "FixedInt8ArrayMap"),
+ 0x08a81: (151, "FixedUint16ArrayMap"),
+ 0x08aa9: (150, "FixedInt16ArrayMap"),
+ 0x08ad1: (153, "FixedUint32ArrayMap"),
+ 0x08af9: (152, "FixedInt32ArrayMap"),
+ 0x08b21: (154, "FixedFloat32ArrayMap"),
+ 0x08b49: (155, "FixedFloat64ArrayMap"),
+ 0x08b71: (156, "FixedUint8ClampedArrayMap"),
+ 0x08b99: (180, "SloppyArgumentsElementsMap"),
+ 0x08bc1: (180, "FunctionContextMap"),
+ 0x08be9: (180, "CatchContextMap"),
+ 0x08c11: (180, "WithContextMap"),
+ 0x08c39: (180, "BlockContextMap"),
+ 0x08c61: (180, "ModuleContextMap"),
+ 0x08c89: (180, "ScriptContextMap"),
+ 0x08cb1: (180, "ScriptContextTableMap"),
+ 0x08cd9: (187, "JSMessageObjectMap"),
+ 0x08d01: (136, "ForeignMap"),
+ 0x08d29: (189, "NeanderMap"),
+ 0x08d51: (170, "AllocationSiteMap"),
+ 0x08d79: (171, "AllocationMementoMap"),
+ 0x08da1: (174, "PolymorphicCodeCacheMap"),
+ 0x08dc9: (172, "ScriptMap"),
+ 0x08e19: (189, "ExternalMap"),
+ 0x08f59: (177, "BoxMap"),
+ 0x08f81: (161, "ExecutableAccessorInfoMap"),
+ 0x08fa9: (162, "AccessorPairMap"),
+ 0x08fd1: (163, "AccessCheckInfoMap"),
+ 0x08ff9: (164, "InterceptorInfoMap"),
+ 0x09021: (165, "CallHandlerInfoMap"),
+ 0x09049: (166, "FunctionTemplateInfoMap"),
+ 0x09071: (167, "ObjectTemplateInfoMap"),
+ 0x09099: (168, "SignatureInfoMap"),
+ 0x090c1: (169, "TypeSwitchInfoMap"),
+ 0x090e9: (173, "CodeCacheMap"),
+ 0x09111: (175, "TypeFeedbackInfoMap"),
+ 0x09139: (176, "AliasedArgumentsEntryMap"),
+ 0x09161: (178, "DebugInfoMap"),
+ 0x09189: (179, "BreakPointInfoMap"),
}
# List of known V8 objects.
("OLD_POINTER_SPACE", 0x080b1): "TrueValue",
("OLD_POINTER_SPACE", 0x080c1): "FalseValue",
("OLD_POINTER_SPACE", 0x080d1): "UninitializedValue",
- ("OLD_POINTER_SPACE", 0x080e1): "NoInterceptorResultSentinel",
- ("OLD_POINTER_SPACE", 0x080f1): "ArgumentsMarker",
- ("OLD_POINTER_SPACE", 0x08101): "NumberStringCache",
- ("OLD_POINTER_SPACE", 0x08909): "SingleCharacterStringCache",
- ("OLD_POINTER_SPACE", 0x08d11): "StringSplitCache",
- ("OLD_POINTER_SPACE", 0x09119): "RegExpMultipleCache",
- ("OLD_POINTER_SPACE", 0x09521): "TerminationException",
- ("OLD_POINTER_SPACE", 0x09531): "MessageListeners",
- ("OLD_POINTER_SPACE", 0x0954d): "CodeStubs",
- ("OLD_POINTER_SPACE", 0x0ca65): "MegamorphicSymbol",
- ("OLD_POINTER_SPACE", 0x0ca75): "UninitializedSymbol",
- ("OLD_POINTER_SPACE", 0x10ae9): "NonMonomorphicCache",
- ("OLD_POINTER_SPACE", 0x110fd): "PolymorphicCodeCache",
- ("OLD_POINTER_SPACE", 0x11105): "NativesSourceCache",
- ("OLD_POINTER_SPACE", 0x11155): "EmptyScript",
- ("OLD_POINTER_SPACE", 0x11189): "IntrinsicFunctionNames",
- ("OLD_POINTER_SPACE", 0x141a5): "ObservationState",
- ("OLD_POINTER_SPACE", 0x141b1): "FrozenSymbol",
- ("OLD_POINTER_SPACE", 0x141c1): "NonExistentSymbol",
- ("OLD_POINTER_SPACE", 0x141d1): "ElementsTransitionSymbol",
- ("OLD_POINTER_SPACE", 0x141e1): "EmptySlowElementDictionary",
- ("OLD_POINTER_SPACE", 0x1437d): "ObservedSymbol",
- ("OLD_POINTER_SPACE", 0x1438d): "AllocationSitesScratchpad",
- ("OLD_POINTER_SPACE", 0x14795): "MicrotaskState",
- ("OLD_POINTER_SPACE", 0x36241): "StringTable",
- ("OLD_DATA_SPACE", 0x08099): "EmptyDescriptorArray",
- ("OLD_DATA_SPACE", 0x080a1): "EmptyFixedArray",
+ ("OLD_POINTER_SPACE", 0x080e1): "Exception",
+ ("OLD_POINTER_SPACE", 0x080f1): "NoInterceptorResultSentinel",
+ ("OLD_POINTER_SPACE", 0x08101): "ArgumentsMarker",
+ ("OLD_POINTER_SPACE", 0x08111): "NumberStringCache",
+ ("OLD_POINTER_SPACE", 0x08919): "SingleCharacterStringCache",
+ ("OLD_POINTER_SPACE", 0x08d21): "StringSplitCache",
+ ("OLD_POINTER_SPACE", 0x09129): "RegExpMultipleCache",
+ ("OLD_POINTER_SPACE", 0x09531): "TerminationException",
+ ("OLD_POINTER_SPACE", 0x09541): "MessageListeners",
+ ("OLD_POINTER_SPACE", 0x0955d): "CodeStubs",
+ ("OLD_POINTER_SPACE", 0x10f91): "NonMonomorphicCache",
+ ("OLD_POINTER_SPACE", 0x115a5): "PolymorphicCodeCache",
+ ("OLD_POINTER_SPACE", 0x115ad): "NativesSourceCache",
+ ("OLD_POINTER_SPACE", 0x11621): "EmptyScript",
+ ("OLD_POINTER_SPACE", 0x1165d): "IntrinsicFunctionNames",
+ ("OLD_POINTER_SPACE", 0x17679): "ObservationState",
+ ("OLD_POINTER_SPACE", 0x17685): "SymbolRegistry",
+ ("OLD_POINTER_SPACE", 0x18041): "EmptySlowElementDictionary",
+ ("OLD_POINTER_SPACE", 0x181dd): "AllocationSitesScratchpad",
+ ("OLD_POINTER_SPACE", 0x4559d): "StringTable",
+ ("OLD_DATA_SPACE", 0x08081): "EmptyDescriptorArray",
+ ("OLD_DATA_SPACE", 0x08089): "EmptyFixedArray",
("OLD_DATA_SPACE", 0x080a9): "NanValue",
- ("OLD_DATA_SPACE", 0x08141): "EmptyByteArray",
- ("OLD_DATA_SPACE", 0x08149): "EmptyConstantPoolArray",
- ("OLD_DATA_SPACE", 0x0828d): "EmptyExternalInt8Array",
- ("OLD_DATA_SPACE", 0x08299): "EmptyExternalUint8Array",
- ("OLD_DATA_SPACE", 0x082a5): "EmptyExternalInt16Array",
- ("OLD_DATA_SPACE", 0x082b1): "EmptyExternalUint16Array",
- ("OLD_DATA_SPACE", 0x082bd): "EmptyExternalInt32Array",
- ("OLD_DATA_SPACE", 0x082c9): "EmptyExternalUint32Array",
- ("OLD_DATA_SPACE", 0x082d5): "EmptyExternalFloat32Array",
- ("OLD_DATA_SPACE", 0x082e1): "EmptyExternalFloat64Array",
- ("OLD_DATA_SPACE", 0x082ed): "EmptyExternalUint8ClampedArray",
- ("OLD_DATA_SPACE", 0x082f9): "InfinityValue",
- ("OLD_DATA_SPACE", 0x08305): "MinusZeroValue",
- ("CODE_SPACE", 0x138e1): "JsConstructEntryCode",
- ("CODE_SPACE", 0x21361): "JsEntryCode",
+ ("OLD_DATA_SPACE", 0x08159): "EmptyByteArray",
+ ("OLD_DATA_SPACE", 0x08161): "EmptyConstantPoolArray",
+ ("OLD_DATA_SPACE", 0x08241): "EmptyExternalInt8Array",
+ ("OLD_DATA_SPACE", 0x0824d): "EmptyExternalUint8Array",
+ ("OLD_DATA_SPACE", 0x08259): "EmptyExternalInt16Array",
+ ("OLD_DATA_SPACE", 0x08265): "EmptyExternalUint16Array",
+ ("OLD_DATA_SPACE", 0x08271): "EmptyExternalInt32Array",
+ ("OLD_DATA_SPACE", 0x0827d): "EmptyExternalUint32Array",
+ ("OLD_DATA_SPACE", 0x08289): "EmptyExternalFloat32Array",
+ ("OLD_DATA_SPACE", 0x08295): "EmptyExternalFloat64Array",
+ ("OLD_DATA_SPACE", 0x082a1): "EmptyExternalUint8ClampedArray",
+ ("OLD_DATA_SPACE", 0x082ad): "EmptyFixedUint8Array",
+ ("OLD_DATA_SPACE", 0x082b5): "EmptyFixedInt8Array",
+ ("OLD_DATA_SPACE", 0x082bd): "EmptyFixedUint16Array",
+ ("OLD_DATA_SPACE", 0x082c5): "EmptyFixedInt16Array",
+ ("OLD_DATA_SPACE", 0x082cd): "EmptyFixedUint32Array",
+ ("OLD_DATA_SPACE", 0x082d5): "EmptyFixedInt32Array",
+ ("OLD_DATA_SPACE", 0x082dd): "EmptyFixedFloat32Array",
+ ("OLD_DATA_SPACE", 0x082e5): "EmptyFixedFloat64Array",
+ ("OLD_DATA_SPACE", 0x082ed): "EmptyFixedUint8ClampedArray",
+ ("OLD_DATA_SPACE", 0x082f5): "InfinityValue",
+ ("OLD_DATA_SPACE", 0x08301): "MinusZeroValue",
+ ("CODE_SPACE", 0x136a1): "JsConstructEntryCode",
+ ("CODE_SPACE", 0x2c421): "JsEntryCode",
}
projects / platform / upstream / v8.git / commitdiff