remove declarative accessors
R=jochen@chromium.org BUG= Review URL: https://codereview.chromium.org/834443004 Cr-Commit-Position: refs/heads/master@{#25981}
This commit is contained in:
dcarney
Commit bot
parent
cedc11ba59
commit
a5aa01beec
73
include/v8.h
73
include/v8.h
@ -72,7 +72,6 @@ class Context;
|
||||
class CpuProfiler;
|
||||
class Data;
|
||||
class Date;
|
||||
class DeclaredAccessorDescriptor;
|
||||
class External;
|
||||
class Function;
|
||||
class FunctionTemplate;
|
||||
@ -122,9 +121,6 @@ template<typename T> class PropertyCallbackInfo;
|
||||
class StackTrace;
|
||||
class StackFrame;
|
||||
class Isolate;
|
||||
class DeclaredAccessorDescriptor;
|
||||
class ObjectOperationDescriptor;
|
||||
class RawOperationDescriptor;
|
||||
class CallHandlerHelper;
|
||||
class EscapableHandleScope;
|
||||
template<typename T> class ReturnValue;
|
||||
@ -2465,12 +2461,6 @@ class V8_EXPORT Object : public Value {
|
||||
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>(),
|
||||
@ -3539,14 +3529,6 @@ class V8_EXPORT Template : public Data {
|
||||
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();
|
||||
|
||||
@ -4156,61 +4138,6 @@ class V8_EXPORT AccessorSignature : public Data {
|
||||
};
|
||||
|
||||
|
||||
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.
|
||||
|
||||
155
src/api.cc
155
src/api.cc
@ -854,122 +854,6 @@ Local<AccessorSignature> AccessorSignature::New(
|
||||
}
|
||||
|
||||
|
||||
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);
|
||||
@ -1068,23 +952,6 @@ static i::Handle<i::AccessorInfo> MakeAccessorInfo(
|
||||
}
|
||||
|
||||
|
||||
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(),
|
||||
@ -1244,18 +1111,6 @@ static bool TemplateSetAccessor(
|
||||
}
|
||||
|
||||
|
||||
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,
|
||||
@ -3631,16 +3486,6 @@ bool Object::SetAccessor(Handle<Name> name,
|
||||
}
|
||||
|
||||
|
||||
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,
|
||||
|
||||
@ -169,9 +169,7 @@ class RegisteredExtension {
|
||||
V(Context, Context) \
|
||||
V(External, Object) \
|
||||
V(StackTrace, JSArray) \
|
||||
V(StackFrame, JSObject) \
|
||||
V(DeclaredAccessorDescriptor, DeclaredAccessorDescriptor)
|
||||
|
||||
V(StackFrame, JSObject)
|
||||
|
||||
class Utils {
|
||||
public:
|
||||
@ -257,8 +255,6 @@ class Utils {
|
||||
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> \
|
||||
@ -365,7 +361,6 @@ MAKE_TO_LOCAL(NumberToLocal, Object, Number)
|
||||
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
|
||||
|
||||
@ -816,21 +816,6 @@ Handle<AliasedArgumentsEntry> Factory::NewAliasedArgumentsEntry(
|
||||
}
|
||||
|
||||
|
||||
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(
|
||||
|
||||
@ -264,10 +264,6 @@ class Factory FINAL {
|
||||
Handle<AliasedArgumentsEntry> NewAliasedArgumentsEntry(
|
||||
int aliased_context_slot);
|
||||
|
||||
Handle<DeclaredAccessorDescriptor> NewDeclaredAccessorDescriptor();
|
||||
|
||||
Handle<DeclaredAccessorInfo> NewDeclaredAccessorInfo();
|
||||
|
||||
Handle<ExecutableAccessorInfo> NewExecutableAccessorInfo();
|
||||
|
||||
Handle<Script> NewScript(Handle<String> source);
|
||||
|
||||
@ -1422,13 +1422,7 @@ void V8HeapExplorer::ExtractAccessorInfoReferences(
|
||||
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",
|
||||
|
||||
@ -1223,8 +1223,6 @@ Handle<Code> LoadIC::CompileHandler(LookupIterator* lookup,
|
||||
}
|
||||
return compiler.CompileLoadViaGetter(lookup->name(), function);
|
||||
}
|
||||
// TODO(dcarney): Handle correctly.
|
||||
DCHECK(accessors->IsDeclaredAccessorInfo());
|
||||
break;
|
||||
}
|
||||
|
||||
@ -1732,9 +1730,6 @@ Handle<Code> StoreIC::CompileHandler(LookupIterator* lookup,
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
@ -118,8 +118,7 @@ void LookupIterator::PrepareTransitionToDataProperty(
|
||||
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
|
||||
|
||||
@ -894,19 +894,6 @@ void ExecutableAccessorInfo::ExecutableAccessorInfoVerify() {
|
||||
}
|
||||
|
||||
|
||||
void DeclaredAccessorDescriptor::DeclaredAccessorDescriptorVerify() {
|
||||
CHECK(IsDeclaredAccessorDescriptor());
|
||||
VerifyPointer(serialized_data());
|
||||
}
|
||||
|
||||
|
||||
void DeclaredAccessorInfo::DeclaredAccessorInfoVerify() {
|
||||
CHECK(IsDeclaredAccessorInfo());
|
||||
AccessorInfoVerify();
|
||||
VerifyPointer(descriptor());
|
||||
}
|
||||
|
||||
|
||||
void AccessorPair::AccessorPairVerify() {
|
||||
CHECK(IsAccessorPair());
|
||||
VerifyPointer(getter());
|
||||
|
||||
@ -161,9 +161,7 @@ bool Object::IsExternal() const {
|
||||
}
|
||||
|
||||
|
||||
bool Object::IsAccessorInfo() const {
|
||||
return IsExecutableAccessorInfo() || IsDeclaredAccessorInfo();
|
||||
}
|
||||
bool Object::IsAccessorInfo() const { return IsExecutableAccessorInfo(); }
|
||||
|
||||
|
||||
bool Object::IsSmi() const {
|
||||
@ -5489,12 +5487,6 @@ ACCESSORS_TO_SMI(AccessorInfo, flag, kFlagOffset)
|
||||
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)
|
||||
|
||||
@ -863,24 +863,6 @@ void ExecutableAccessorInfo::ExecutableAccessorInfoPrint(
|
||||
}
|
||||
|
||||
|
||||
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());
|
||||
|
||||
224
src/objects.cc
224
src/objects.cc
@ -234,154 +234,6 @@ bool FunctionTemplateInfo::IsTemplateFor(Map* map) {
|
||||
}
|
||||
|
||||
|
||||
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());
|
||||
@ -426,12 +278,6 @@ MaybeHandle<Object> Object::GetPropertyWithAccessor(Handle<Object> receiver,
|
||||
HandleVector(args, arraysize(args))),
|
||||
Object);
|
||||
}
|
||||
if (structure->IsDeclaredAccessorInfo()) {
|
||||
return GetDeclaredAccessorProperty(
|
||||
receiver,
|
||||
Handle<DeclaredAccessorInfo>::cast(structure),
|
||||
isolate);
|
||||
}
|
||||
|
||||
Handle<ExecutableAccessorInfo> data =
|
||||
Handle<ExecutableAccessorInfo>::cast(structure);
|
||||
@ -525,11 +371,6 @@ MaybeHandle<Object> Object::SetPropertyWithAccessor(
|
||||
}
|
||||
}
|
||||
|
||||
// TODO(dcarney): Handle correctly.
|
||||
if (structure->IsDeclaredAccessorInfo()) {
|
||||
return value;
|
||||
}
|
||||
|
||||
UNREACHABLE();
|
||||
return MaybeHandle<Object>();
|
||||
}
|
||||
@ -3002,14 +2843,9 @@ MaybeHandle<Object> Object::SetProperty(LookupIterator* it,
|
||||
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;
|
||||
|
||||
case LookupIterator::DATA:
|
||||
if (it->property_details().IsReadOnly()) {
|
||||
@ -12362,11 +12198,6 @@ MaybeHandle<Object> JSObject::GetElementWithCallback(
|
||||
return isolate->factory()->undefined_value();
|
||||
}
|
||||
|
||||
if (structure->IsDeclaredAccessorInfo()) {
|
||||
return GetDeclaredAccessorProperty(
|
||||
receiver, Handle<DeclaredAccessorInfo>::cast(structure), isolate);
|
||||
}
|
||||
|
||||
UNREACHABLE();
|
||||
return MaybeHandle<Object>();
|
||||
}
|
||||
@ -12417,9 +12248,6 @@ MaybeHandle<Object> JSObject::SetElementWithCallback(
|
||||
}
|
||||
}
|
||||
|
||||
// TODO(dcarney): Handle correctly.
|
||||
if (structure->IsDeclaredAccessorInfo()) return value;
|
||||
|
||||
UNREACHABLE();
|
||||
return MaybeHandle<Object>();
|
||||
}
|
||||
@ -16476,58 +16304,6 @@ template void
|
||||
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.
|
||||
|
||||
115
src/objects.h
115
src/objects.h
@ -128,9 +128,7 @@
|
||||
// - SharedFunctionInfo
|
||||
// - Struct
|
||||
// - Box
|
||||
// - DeclaredAccessorDescriptor
|
||||
// - AccessorInfo
|
||||
// - DeclaredAccessorInfo
|
||||
// - ExecutableAccessorInfo
|
||||
// - AccessorPair
|
||||
// - AccessCheckInfo
|
||||
@ -520,10 +518,6 @@ const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
|
||||
// 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) \
|
||||
@ -10405,115 +10399,6 @@ class AccessorInfo: public Struct {
|
||||
};
|
||||
|
||||
|
||||
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.
|
||||
|
||||
@ -113,7 +113,6 @@
|
||||
'test-cpu-profiler.cc',
|
||||
'test-date.cc',
|
||||
'test-debug.cc',
|
||||
'test-declarative-accessors.cc',
|
||||
'test-decls.cc',
|
||||
'test-deoptimization.cc',
|
||||
'test-dictionary.cc',
|
||||
|
||||
@ -1,302 +0,0 @@
|
||||
// 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);
|
||||
}
|
||||
@ -44,8 +44,6 @@ INSTANCE_TYPES = {
|
||||
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",
|
||||
@ -59,172 +57,185 @@ INSTANCE_TYPES = {
|
||||
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.
|
||||
@ -235,47 +246,51 @@ KNOWN_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",
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user