AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Further ElementsAccessor handlification (GetKeyForIndex(), GetCapacity(), GetType() and GetAttributes()).

Browse Source 
R=verwaest@chromium.org

Review URL: https://codereview.chromium.org/228643003

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20606 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
ishell@chromium.org 2014-04-09 09:58:26 +00:00
parent d426cd1012
commit 773738d4d1
2 changed files with 71 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
src/elements.cc
View File

@ -146,7 +146,9 @@ ELEMENTS_LIST(ELEMENTS_TRAITS)
ElementsAccessor** ElementsAccessor::elements_accessors_; ElementsAccessor** ElementsAccessor::elements_accessors_;
static bool HasKey(FixedArray* array, Object* key) { static bool HasKey(Handle<FixedArray> array, Handle<Object> key_handle) {
DisallowHeapAllocation no_gc;
Object* key = *key_handle;
int len0 = array->length(); int len0 = array->length();
for (int i = 0; i < len0; i++) { for (int i = 0; i < len0; i++) {
Object* element = array->get(i); Object* element = array->get(i);
@ -621,7 +623,7 @@ class ElementsAccessorBase : public ElementsAccessor {
uint32_t key, uint32_t key,
Handle<FixedArrayBase> backing_store) { Handle<FixedArrayBase> backing_store) {
return ElementsAccessorSubclass::GetAttributesImpl( return ElementsAccessorSubclass::GetAttributesImpl(
*receiver, *holder, key, *backing_store) != ABSENT; receiver, holder, key, backing_store) != ABSENT;
} }
virtual bool HasElement( virtual bool HasElement(
@ -657,7 +659,7 @@ class ElementsAccessorBase : public ElementsAccessor {
Handle<JSObject> obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
Handle<FixedArrayBase> backing_store) { Handle<FixedArrayBase> backing_store) {
if (key < ElementsAccessorSubclass::GetCapacityImpl(*backing_store)) { if (key < ElementsAccessorSubclass::GetCapacityImpl(backing_store)) {
return BackingStore::get(Handle<BackingStore>::cast(backing_store), key); return BackingStore::get(Handle<BackingStore>::cast(backing_store), key);
} else { } else {
return backing_store->GetIsolate()->factory()->the_hole_value(); return backing_store->GetIsolate()->factory()->the_hole_value();
@ -669,29 +671,21 @@ class ElementsAccessorBase : public ElementsAccessor {
Handle<JSObject> holder, Handle<JSObject> holder,
uint32_t key, uint32_t key,
Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE { Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE {
return ElementsAccessorSubclass::GetAttributesImpl(
*receiver, *holder, key, *backing_store);
}
// TODO(ishell): To be removed once elements.cc is handlified.
MUST_USE_RESULT virtual PropertyAttributes GetAttributes(
Object* receiver,
JSObject* holder,
uint32_t key,
FixedArrayBase* backing_store) V8_FINAL V8_OVERRIDE {
return ElementsAccessorSubclass::GetAttributesImpl( return ElementsAccessorSubclass::GetAttributesImpl(
receiver, holder, key, backing_store); receiver, holder, key, backing_store);
} }
MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( MUST_USE_RESULT static PropertyAttributes GetAttributesImpl(
Object* receiver, Handle<Object> receiver,
JSObject* obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
FixedArrayBase* backing_store) { Handle<FixedArrayBase> backing_store) {
if (key >= ElementsAccessorSubclass::GetCapacityImpl(backing_store)) { if (key >= ElementsAccessorSubclass::GetCapacityImpl(backing_store)) {
return ABSENT; return ABSENT;
} }
return BackingStore::cast(backing_store)->is_the_hole(key) ? ABSENT : NONE; return
Handle<BackingStore>::cast(backing_store)->is_the_hole(key)
? ABSENT : NONE;
} }
MUST_USE_RESULT virtual PropertyType GetType( MUST_USE_RESULT virtual PropertyType GetType(
@ -699,30 +693,21 @@ class ElementsAccessorBase : public ElementsAccessor {
Handle<JSObject> holder, Handle<JSObject> holder,
uint32_t key, uint32_t key,
Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE { Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE {
return ElementsAccessorSubclass::GetTypeImpl(
*receiver, *holder, key, *backing_store);
}
// TODO(ishell): To be removed once elements.cc is handlified.
MUST_USE_RESULT virtual PropertyType GetType(
Object* receiver,
JSObject* holder,
uint32_t key,
FixedArrayBase* backing_store) V8_FINAL V8_OVERRIDE {
return ElementsAccessorSubclass::GetTypeImpl( return ElementsAccessorSubclass::GetTypeImpl(
receiver, holder, key, backing_store); receiver, holder, key, backing_store);
} }
MUST_USE_RESULT static PropertyType GetTypeImpl( MUST_USE_RESULT static PropertyType GetTypeImpl(
Object* receiver, Handle<Object> receiver,
JSObject* obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
FixedArrayBase* backing_store) { Handle<FixedArrayBase> backing_store) {
if (key >= ElementsAccessorSubclass::GetCapacityImpl(backing_store)) { if (key >= ElementsAccessorSubclass::GetCapacityImpl(backing_store)) {
return NONEXISTENT; return NONEXISTENT;
} }
return BackingStore::cast(backing_store)->is_the_hole(key) return
? NONEXISTENT : FIELD; Handle<BackingStore>::cast(backing_store)->is_the_hole(key)
? NONEXISTENT : FIELD;
} }
MUST_USE_RESULT virtual MaybeHandle<AccessorPair> GetAccessorPair( MUST_USE_RESULT virtual MaybeHandle<AccessorPair> GetAccessorPair(
@ -835,20 +820,20 @@ class ElementsAccessorBase : public ElementsAccessor {
// Optimize if 'other' is empty. // Optimize if 'other' is empty.
// We cannot optimize if 'this' is empty, as other may have holes. // We cannot optimize if 'this' is empty, as other may have holes.
uint32_t len1 = ElementsAccessorSubclass::GetCapacityImpl(*from); uint32_t len1 = ElementsAccessorSubclass::GetCapacityImpl(from);
if (len1 == 0) return to; if (len1 == 0) return to;
// Compute how many elements are not in other. // Compute how many elements are not in other.
uint32_t extra = 0; uint32_t extra = 0;
for (uint32_t y = 0; y < len1; y++) { for (uint32_t y = 0; y < len1; y++) {
uint32_t key = ElementsAccessorSubclass::GetKeyForIndexImpl(*from, y); uint32_t key = ElementsAccessorSubclass::GetKeyForIndexImpl(from, y);
if (ElementsAccessorSubclass::HasElementImpl( if (ElementsAccessorSubclass::HasElementImpl(
receiver, holder, key, from)) { receiver, holder, key, from)) {
Handle<Object> value = Handle<Object> value =
ElementsAccessorSubclass::GetImpl(receiver, holder, key, from); ElementsAccessorSubclass::GetImpl(receiver, holder, key, from);
ASSERT(!value->IsTheHole()); ASSERT(!value->IsTheHole());
if (!HasKey(*to, *value)) { if (!HasKey(to, value)) {
extra++; extra++;
} }
} }
@ -874,12 +859,12 @@ class ElementsAccessorBase : public ElementsAccessor {
uint32_t index = 0; uint32_t index = 0;
for (uint32_t y = 0; y < len1; y++) { for (uint32_t y = 0; y < len1; y++) {
uint32_t key = uint32_t key =
ElementsAccessorSubclass::GetKeyForIndexImpl(*from, y); ElementsAccessorSubclass::GetKeyForIndexImpl(from, y);
if (ElementsAccessorSubclass::HasElementImpl( if (ElementsAccessorSubclass::HasElementImpl(
receiver, holder, key, from)) { receiver, holder, key, from)) {
Handle<Object> value = Handle<Object> value =
ElementsAccessorSubclass::GetImpl(receiver, holder, key, from); ElementsAccessorSubclass::GetImpl(receiver, holder, key, from);
if (!value->IsTheHole() && !HasKey(*to, *value)) { if (!value->IsTheHole() && !HasKey(to, value)) {
result->set(len0 + index, *value); result->set(len0 + index, *value);
index++; index++;
} }
@ -890,23 +875,23 @@ class ElementsAccessorBase : public ElementsAccessor {
} }
protected: protected:
static uint32_t GetCapacityImpl(FixedArrayBase* backing_store) { static uint32_t GetCapacityImpl(Handle<FixedArrayBase> backing_store) {
return backing_store->length(); return backing_store->length();
} }
virtual uint32_t GetCapacity(FixedArrayBase* backing_store) virtual uint32_t GetCapacity(Handle<FixedArrayBase> backing_store)
V8_FINAL V8_OVERRIDE { V8_FINAL V8_OVERRIDE {
return ElementsAccessorSubclass::GetCapacityImpl(backing_store); return ElementsAccessorSubclass::GetCapacityImpl(backing_store);
} }
static uint32_t GetKeyForIndexImpl(FixedArrayBase* backing_store, static uint32_t GetKeyForIndexImpl(Handle<FixedArrayBase> backing_store,
uint32_t index) { uint32_t index) {
return index; return index;
} }
virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store, virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store,
uint32_t index) V8_FINAL V8_OVERRIDE { uint32_t index) V8_FINAL V8_OVERRIDE {
return ElementsAccessorSubclass::GetKeyForIndexImpl(*backing_store, index); return ElementsAccessorSubclass::GetKeyForIndexImpl(backing_store, index);
} }
private: private:
@ -1094,7 +1079,7 @@ class FastElementsAccessor
}; };
static inline ElementsKind ElementsKindForArray(FixedArrayBase* array) { static inline ElementsKind ElementsKindForArray(Handle<FixedArrayBase> array) {
switch (array->map()->instance_type()) { switch (array->map()->instance_type()) {
case FIXED_ARRAY_TYPE: case FIXED_ARRAY_TYPE:
if (array->IsDictionary()) { if (array->IsDictionary()) {
@ -1165,7 +1150,7 @@ class FastSmiOrObjectElementsAccessor
Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(from); Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(from);
Handle<FixedArrayBase> arguments( Handle<FixedArrayBase> arguments(
FixedArrayBase::cast(parameter_map->get(1))); FixedArrayBase::cast(parameter_map->get(1)));
ElementsKind from_kind = ElementsKindForArray(*arguments); ElementsKind from_kind = ElementsKindForArray(arguments);
CopyElementsImpl(arguments, from_start, to, from_kind, CopyElementsImpl(arguments, from_start, to, from_kind,
to_start, packed_size, copy_size); to_start, packed_size, copy_size);
break; break;
@ -1352,7 +1337,7 @@ class TypedElementsAccessor
Handle<JSObject> obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
Handle<FixedArrayBase> backing_store) { Handle<FixedArrayBase> backing_store) {
if (key < AccessorClass::GetCapacityImpl(*backing_store)) { if (key < AccessorClass::GetCapacityImpl(backing_store)) {
return BackingStore::get(Handle<BackingStore>::cast(backing_store), key); return BackingStore::get(Handle<BackingStore>::cast(backing_store), key);
} else { } else {
return backing_store->GetIsolate()->factory()->undefined_value(); return backing_store->GetIsolate()->factory()->undefined_value();
@ -1360,20 +1345,20 @@ class TypedElementsAccessor
} }
MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( MUST_USE_RESULT static PropertyAttributes GetAttributesImpl(
Object* receiver, Handle<Object> receiver,
JSObject* obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
FixedArrayBase* backing_store) { Handle<FixedArrayBase> backing_store) {
return return
key < AccessorClass::GetCapacityImpl(backing_store) key < AccessorClass::GetCapacityImpl(backing_store)
? NONE : ABSENT; ? NONE : ABSENT;
} }
MUST_USE_RESULT static PropertyType GetTypeImpl( MUST_USE_RESULT static PropertyType GetTypeImpl(
Object* receiver, Handle<Object> receiver,
JSObject* obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
FixedArrayBase* backing_store) { Handle<FixedArrayBase> backing_store) {
return return
key < AccessorClass::GetCapacityImpl(backing_store) key < AccessorClass::GetCapacityImpl(backing_store)
? FIELD : NONEXISTENT; ? FIELD : NONEXISTENT;
@ -1401,7 +1386,7 @@ class TypedElementsAccessor
uint32_t key, uint32_t key,
Handle<FixedArrayBase> backing_store) { Handle<FixedArrayBase> backing_store) {
uint32_t capacity = uint32_t capacity =
AccessorClass::GetCapacityImpl(*backing_store); AccessorClass::GetCapacityImpl(backing_store);
return key < capacity; return key < capacity;
} }
}; };
@ -1603,12 +1588,12 @@ class DictionaryElementsAccessor
} }
MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( MUST_USE_RESULT static PropertyAttributes GetAttributesImpl(
Object* receiver, Handle<Object> receiver,
JSObject* obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
FixedArrayBase* backing_store) { Handle<FixedArrayBase> backing_store) {
SeededNumberDictionary* dictionary = Handle<SeededNumberDictionary> dictionary =
SeededNumberDictionary::cast(backing_store); Handle<SeededNumberDictionary>::cast(backing_store);
int entry = dictionary->FindEntry(key); int entry = dictionary->FindEntry(key);
if (entry != SeededNumberDictionary::kNotFound) { if (entry != SeededNumberDictionary::kNotFound) {
return dictionary->DetailsAt(entry).attributes(); return dictionary->DetailsAt(entry).attributes();
@ -1617,11 +1602,12 @@ class DictionaryElementsAccessor
} }
MUST_USE_RESULT static PropertyType GetTypeImpl( MUST_USE_RESULT static PropertyType GetTypeImpl(
Object* receiver, Handle<Object> receiver,
JSObject* obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
FixedArrayBase* store) { Handle<FixedArrayBase> store) {
SeededNumberDictionary* backing_store = SeededNumberDictionary::cast(store); Handle<SeededNumberDictionary> backing_store =
Handle<SeededNumberDictionary>::cast(store);
int entry = backing_store->FindEntry(key); int entry = backing_store->FindEntry(key);
if (entry != SeededNumberDictionary::kNotFound) { if (entry != SeededNumberDictionary::kNotFound) {
return backing_store->DetailsAt(entry).type(); return backing_store->DetailsAt(entry).type();
@ -1654,10 +1640,11 @@ class DictionaryElementsAccessor
return backing_store->FindEntry(key) != SeededNumberDictionary::kNotFound; return backing_store->FindEntry(key) != SeededNumberDictionary::kNotFound;
} }
// TODO(ishell): Handlify when all callers are handlified. static uint32_t GetKeyForIndexImpl(Handle<FixedArrayBase> store,
static uint32_t GetKeyForIndexImpl(FixedArrayBase* store,
uint32_t index) { uint32_t index) {
SeededNumberDictionary* dict = SeededNumberDictionary::cast(store); DisallowHeapAllocation no_gc;
Handle<SeededNumberDictionary> dict =
Handle<SeededNumberDictionary>::cast(store);
Object* key = dict->KeyAt(index); Object* key = dict->KeyAt(index);
return Smi::cast(key)->value(); return Smi::cast(key)->value();
} }
@ -1712,34 +1699,34 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase<
} }
MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( MUST_USE_RESULT static PropertyAttributes GetAttributesImpl(
Object* receiver, Handle<Object> receiver,
JSObject* obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
FixedArrayBase* backing_store) { Handle<FixedArrayBase> backing_store) {
FixedArray* parameter_map = FixedArray::cast(backing_store); Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(backing_store);
Object* probe = GetParameterMapArg(obj, parameter_map, key); Handle<Object> probe = GetParameterMapArg(obj, parameter_map, key);
if (!probe->IsTheHole()) { if (!probe->IsTheHole()) {
return NONE; return NONE;
} else { } else {
// If not aliased, check the arguments. // If not aliased, check the arguments.
FixedArray* arguments = FixedArray::cast(parameter_map->get(1)); Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
return ElementsAccessor::ForArray(arguments)->GetAttributes( return ElementsAccessor::ForArray(arguments)->GetAttributes(
receiver, obj, key, arguments); receiver, obj, key, arguments);
} }
} }
MUST_USE_RESULT static PropertyType GetTypeImpl( MUST_USE_RESULT static PropertyType GetTypeImpl(
Object* receiver, Handle<Object> receiver,
JSObject* obj, Handle<JSObject> obj,
uint32_t key, uint32_t key,
FixedArrayBase* parameters) { Handle<FixedArrayBase> parameters) {
FixedArray* parameter_map = FixedArray::cast(parameters); Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(parameters);
Object* probe = GetParameterMapArg(obj, parameter_map, key); Handle<Object> probe = GetParameterMapArg(obj, parameter_map, key);
if (!probe->IsTheHole()) { if (!probe->IsTheHole()) {
return FIELD; return FIELD;
} else { } else {
// If not aliased, check the arguments. // If not aliased, check the arguments.
FixedArray* arguments = FixedArray::cast(parameter_map->get(1)); Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
return ElementsAccessor::ForArray(arguments)->GetType( return ElementsAccessor::ForArray(arguments)->GetType(
receiver, obj, key, arguments); receiver, obj, key, arguments);
} }
@ -1808,15 +1795,15 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase<
UNREACHABLE(); UNREACHABLE();
} }
static uint32_t GetCapacityImpl(FixedArrayBase* backing_store) { static uint32_t GetCapacityImpl(Handle<FixedArrayBase> backing_store) {
FixedArray* parameter_map = FixedArray::cast(backing_store); Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(backing_store);
FixedArrayBase* arguments = FixedArrayBase::cast(parameter_map->get(1)); Handle<FixedArrayBase> arguments(
FixedArrayBase::cast(parameter_map->get(1)));
return Max(static_cast<uint32_t>(parameter_map->length() - 2), return Max(static_cast<uint32_t>(parameter_map->length() - 2),
ForArray(arguments)->GetCapacity(arguments)); ForArray(arguments)->GetCapacity(arguments));
} }
// TODO(ishell): Handlify when all callers are handlified. static uint32_t GetKeyForIndexImpl(Handle<FixedArrayBase> dict,
static uint32_t GetKeyForIndexImpl(FixedArrayBase* dict,
uint32_t index) { uint32_t index) {
return index; return index;
} }
@ -1838,18 +1825,6 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase<
} }
private: private:
// TODO(ishell): remove when all usages are handlified.
static Object* GetParameterMapArg(JSObject* holder,
FixedArray* parameter_map,
uint32_t key) {
uint32_t length = holder->IsJSArray()
? Smi::cast(JSArray::cast(holder)->length())->value()
: parameter_map->length();
return key < (length - 2)
? parameter_map->get(key + 2)
: parameter_map->GetHeap()->the_hole_value();
}
static Handle<Object> GetParameterMapArg(Handle<JSObject> holder, static Handle<Object> GetParameterMapArg(Handle<JSObject> holder,
Handle<FixedArray> parameter_map, Handle<FixedArray> parameter_map,
uint32_t key) { uint32_t key) {
@ -1864,7 +1839,7 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase<
}; };
ElementsAccessor* ElementsAccessor::ForArray(FixedArrayBase* array) { ElementsAccessor* ElementsAccessor::ForArray(Handle<FixedArrayBase> array) {
return elements_accessors_[ElementsKindForArray(array)]; return elements_accessors_[ElementsKindForArray(array)];
} }

22
src/elements.h
View File

@ -226,11 +226,7 @@ class ElementsAccessor {
return elements_accessors_[elements_kind]; return elements_accessors_[elements_kind];
} }
// TODO(ishell): Temporary wrapper until handlified. static ElementsAccessor* ForArray(Handle<FixedArrayBase> array);
inline static ElementsAccessor* ForArray(Handle<FixedArrayBase> array) {
return ForArray(*array);
}
static ElementsAccessor* ForArray(FixedArrayBase* array);
static void InitializeOncePerProcess(); static void InitializeOncePerProcess();
static void TearDown(); static void TearDown();
@ -238,7 +234,7 @@ class ElementsAccessor {
protected: protected:
friend class SloppyArgumentsElementsAccessor; friend class SloppyArgumentsElementsAccessor;
virtual uint32_t GetCapacity(FixedArrayBase* backing_store) = 0; virtual uint32_t GetCapacity(Handle<FixedArrayBase> backing_store) = 0;
// Element handlers distinguish between indexes and keys when they manipulate // Element handlers distinguish between indexes and keys when they manipulate
// elements. Indexes refer to elements in terms of their location in the // elements. Indexes refer to elements in terms of their location in the
@ -251,20 +247,6 @@ class ElementsAccessor {
virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store, virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store,
uint32_t index) = 0; uint32_t index) = 0;
// TODO(ishell): Non-handlified versions, used only by accessors'
// implementations. To be removed once elements.cc is handlified.
MUST_USE_RESULT virtual PropertyAttributes GetAttributes(
Object* receiver,
JSObject* holder,
uint32_t key,
FixedArrayBase* backing_store) = 0;
MUST_USE_RESULT virtual PropertyType GetType(
Object* receiver,
JSObject* holder,
uint32_t key,
FixedArrayBase* backing_store) = 0;
private: private:
static ElementsAccessor** elements_accessors_; static ElementsAccessor** elements_accessors_;
const char* name_; const char* name_;