Revision: 20513
Author: [email protected]
Date: Fri Apr 4 13:05:37 2014 UTC
Log: Callers of ElementsAccessor::AddElementsToFixedArray(),
ElementsAccessor::HasElement() and ElementsAccessor::GetKeyForIndex()
handlified.
[email protected]
Review URL: https://codereview.chromium.org/225623004
http://code.google.com/p/v8/source/detail?r=20513
Modified:
/branches/bleeding_edge/src/builtins.cc
/branches/bleeding_edge/src/elements.cc
/branches/bleeding_edge/src/elements.h
/branches/bleeding_edge/src/handles.cc
/branches/bleeding_edge/src/handles.h
/branches/bleeding_edge/src/objects.cc
/branches/bleeding_edge/src/objects.h
/branches/bleeding_edge/src/runtime.cc
=======================================
--- /branches/bleeding_edge/src/builtins.cc Fri Apr 4 08:17:23 2014 UTC
+++ /branches/bleeding_edge/src/builtins.cc Fri Apr 4 13:05:37 2014 UTC
@@ -515,7 +515,7 @@
ElementsAccessor* accessor = array->GetElementsAccessor();
int new_length = len - 1;
Handle<Object> element;
- if (accessor->HasElement(*array, *array, new_length, *elms_obj)) {
+ if (accessor->HasElement(array, array, new_length, elms_obj)) {
element = accessor->Get(
array, array, new_length, elms_obj);
} else {
@@ -756,7 +756,7 @@
bool packed = true;
ElementsAccessor* accessor = ElementsAccessor::ForKind(kind);
for (int i = k; i < final; i++) {
- if (!accessor->HasElement(*object, *object, i, *elms)) {
+ if (!accessor->HasElement(object, object, i, elms)) {
packed = false;
break;
}
=======================================
--- /branches/bleeding_edge/src/elements.cc Thu Apr 3 09:12:59 2014 UTC
+++ /branches/bleeding_edge/src/elements.cc Fri Apr 4 13:05:37 2014 UTC
@@ -622,15 +622,14 @@
receiver, holder, key, backing_store) != ABSENT;
}
- virtual bool HasElement(Object* receiver,
- JSObject* holder,
- uint32_t key,
- FixedArrayBase* backing_store) V8_FINAL
V8_OVERRIDE {
- if (backing_store == NULL) {
- backing_store = holder->elements();
- }
+ virtual bool HasElement(
+ Handle<Object> receiver,
+ Handle<JSObject> holder,
+ uint32_t key,
+ Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE {
+ // TODO(ishell): Handlify HasElementImpl().
return ElementsAccessorSubclass::HasElementImpl(
- receiver, holder, key, backing_store);
+ *receiver, *holder, key, *backing_store);
}
// TODO(ishell): Temporary wrapper until handlified.
@@ -830,11 +829,25 @@
from, from_start, to, from_kind, to_start, packed_size, copy_size);
}
- MUST_USE_RESULT virtual MaybeObject* AddElementsToFixedArray(
+ virtual Handle<FixedArray> AddElementsToFixedArray(
+ Handle<Object> receiver,
+ Handle<JSObject> holder,
+ Handle<FixedArray> to,
+ Handle<FixedArrayBase> from) V8_FINAL V8_OVERRIDE {
+ CALL_HEAP_FUNCTION(to->GetIsolate(),
+ AddElementsToFixedArray(
+ receiver.is_null() ? NULL : *receiver,
+ holder.is_null() ? NULL : *holder,
+ *to,
+ *from),
+ FixedArray);
+ }
+
+ static MUST_USE_RESULT MaybeObject* AddElementsToFixedArray(
Object* receiver,
JSObject* holder,
FixedArray* to,
- FixedArrayBase* from) V8_FINAL V8_OVERRIDE {
+ FixedArrayBase* from) {
int len0 = to->length();
#ifdef ENABLE_SLOW_ASSERTS
if (FLAG_enable_slow_asserts) {
@@ -843,9 +856,6 @@
}
}
#endif
- if (from == NULL) {
- from = holder->elements();
- }
// Optimize if 'other' is empty.
// We cannot optimize if 'this' is empty, as other may have holes.
@@ -922,9 +932,9 @@
return index;
}
- virtual uint32_t GetKeyForIndex(FixedArrayBase* backing_store,
+ virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store,
uint32_t index) V8_FINAL V8_OVERRIDE {
- return ElementsAccessorSubclass::GetKeyForIndexImpl(backing_store,
index);
+ return ElementsAccessorSubclass::GetKeyForIndexImpl(*backing_store,
index);
}
private:
@@ -1668,6 +1678,7 @@
SeededNumberDictionary::kNotFound;
}
+ // TODO(ishell): Handlify when all callers are handlified.
static uint32_t GetKeyForIndexImpl(FixedArrayBase* store,
uint32_t index) {
SeededNumberDictionary* dict = SeededNumberDictionary::cast(store);
@@ -1825,6 +1836,7 @@
ForArray(arguments)->GetCapacity(arguments));
}
+ // TODO(ishell): Handlify when all callers are handlified.
static uint32_t GetKeyForIndexImpl(FixedArrayBase* dict,
uint32_t index) {
return index;
=======================================
--- /branches/bleeding_edge/src/elements.h Thu Apr 3 09:12:59 2014 UTC
+++ /branches/bleeding_edge/src/elements.h Fri Apr 4 13:05:37 2014 UTC
@@ -55,10 +55,18 @@
// in the backing store to use for the check, which must be compatible
with
// the ElementsKind of the ElementsAccessor. If backing_store is NULL,
the
// holder->elements() is used as the backing store.
- virtual bool HasElement(Object* receiver,
- JSObject* holder,
- uint32_t key,
- FixedArrayBase* backing_store = NULL) = 0;
+ virtual bool HasElement(
+ Handle<Object> receiver,
+ Handle<JSObject> holder,
+ uint32_t key,
+ Handle<FixedArrayBase> backing_store) = 0;
+
+ inline bool HasElement(
+ Handle<Object> receiver,
+ Handle<JSObject> holder,
+ uint32_t key) {
+ return HasElement(receiver, holder, key, handle(holder->elements()));
+ }
// Returns the element with the specified key or undefined if there is
no such
// element. This method doesn't iterate up the prototype chain. The
caller
@@ -181,11 +189,19 @@
*from_holder, 0, from_kind, to, 0, kCopyToEndAndInitializeToHole);
}
- MUST_USE_RESULT virtual MaybeObject* AddElementsToFixedArray(
- Object* receiver,
- JSObject* holder,
- FixedArray* to,
- FixedArrayBase* from = NULL) = 0;
+ virtual Handle<FixedArray> AddElementsToFixedArray(
+ Handle<Object> receiver,
+ Handle<JSObject> holder,
+ Handle<FixedArray> to,
+ Handle<FixedArrayBase> from) = 0;
+
+ inline Handle<FixedArray> AddElementsToFixedArray(
+ Handle<Object> receiver,
+ Handle<JSObject> holder,
+ Handle<FixedArray> to) {
+ return AddElementsToFixedArray(
+ receiver, holder, to, handle(holder->elements()));
+ }
// Returns a shared ElementsAccessor for the specified ElementsKind.
static ElementsAccessor* ForKind(ElementsKind elements_kind) {
@@ -193,6 +209,10 @@
return elements_accessors_[elements_kind];
}
+ // TODO(ishell): Temporary wrapper until handlified.
+ inline static ElementsAccessor* ForArray(Handle<FixedArrayBase> array) {
+ return ForArray(*array);
+ }
static ElementsAccessor* ForArray(FixedArrayBase* array);
static void InitializeOncePerProcess();
@@ -211,7 +231,7 @@
// keys are equivalent to indexes, and GetKeyForIndex returns the same
value
// it is passed. In the NumberDictionary ElementsAccessor,
GetKeyForIndex maps
// the index to a key using the KeyAt method on the NumberDictionary.
- virtual uint32_t GetKeyForIndex(FixedArrayBase* backing_store,
+ virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store,
uint32_t index) = 0;
private:
=======================================
--- /branches/bleeding_edge/src/handles.cc Fri Apr 4 12:06:11 2014 UTC
+++ /branches/bleeding_edge/src/handles.cc Fri Apr 4 13:05:37 2014 UTC
@@ -122,20 +122,6 @@
Address HandleScope::current_limit_address(Isolate* isolate) {
return reinterpret_cast<Address>(&isolate->handle_scope_data()->limit);
}
-
-
-Handle<FixedArray> AddKeysFromJSArray(Handle<FixedArray> content,
- Handle<JSArray> array) {
- CALL_HEAP_FUNCTION(content->GetIsolate(),
- content->AddKeysFromJSArray(*array), FixedArray);
-}
-
-
-Handle<FixedArray> UnionOfKeys(Handle<FixedArray> first,
- Handle<FixedArray> second) {
- CALL_HEAP_FUNCTION(first->GetIsolate(),
- first->UnionOfKeys(*second), FixedArray);
-}
Handle<JSGlobalProxy> ReinitializeJSGlobalProxy(
@@ -512,7 +498,8 @@
args,
threw);
if (*threw) return content;
- content = AddKeysFromJSArray(content, Handle<JSArray>::cast(names));
+ content = FixedArray::AddKeysFromJSArray(content,
+
Handle<JSArray>::cast(names));
break;
}
@@ -535,7 +522,7 @@
Handle<FixedArray> element_keys =
isolate->factory()->NewFixedArray(current->NumberOfEnumElements());
current->GetEnumElementKeys(*element_keys);
- content = UnionOfKeys(content, element_keys);
+ content = FixedArray::UnionOfKeys(content, element_keys);
ASSERT(ContainsOnlyValidKeys(content));
// Add the element keys from the interceptor.
@@ -543,7 +530,8 @@
v8::Handle<v8::Array> result =
GetKeysForIndexedInterceptor(object, current);
if (!result.IsEmpty())
- content = AddKeysFromJSArray(content,
v8::Utils::OpenHandle(*result));
+ content = FixedArray::AddKeysFromJSArray(
+ content, v8::Utils::OpenHandle(*result));
ASSERT(ContainsOnlyValidKeys(content));
}
@@ -564,8 +552,8 @@
!current->HasNamedInterceptor() &&
!current->HasIndexedInterceptor());
// Compute the property keys and cache them if possible.
- content =
- UnionOfKeys(content, GetEnumPropertyKeys(current,
cache_enum_keys));
+ content = FixedArray::UnionOfKeys(
+ content, GetEnumPropertyKeys(current, cache_enum_keys));
ASSERT(ContainsOnlyValidKeys(content));
// Add the property keys from the interceptor.
@@ -573,7 +561,8 @@
v8::Handle<v8::Array> result =
GetKeysForNamedInterceptor(object, current);
if (!result.IsEmpty())
- content = AddKeysFromJSArray(content,
v8::Utils::OpenHandle(*result));
+ content = FixedArray::AddKeysFromJSArray(
+ content, v8::Utils::OpenHandle(*result));
ASSERT(ContainsOnlyValidKeys(content));
}
=======================================
--- /branches/bleeding_edge/src/handles.h Fri Apr 4 12:06:11 2014 UTC
+++ /branches/bleeding_edge/src/handles.h Fri Apr 4 13:05:37 2014 UTC
@@ -305,9 +305,6 @@
Handle<String> LookupSingleCharacterStringFromCode(Isolate* isolate,
uint32_t index);
-Handle<FixedArray> AddKeysFromJSArray(Handle<FixedArray>,
- Handle<JSArray> array);
-
// Get the JS object corresponding to the given script; create it
// if none exists.
Handle<JSValue> GetScriptWrapper(Handle<Script> script);
@@ -344,11 +341,6 @@
Handle<FixedArray> GetEnumPropertyKeys(Handle<JSObject> object,
bool cache_result);
-// Computes the union of keys and return the result.
-// Used for implementing "for (n in object) { }"
-Handle<FixedArray> UnionOfKeys(Handle<FixedArray> first,
- Handle<FixedArray> second);
-
Handle<JSGlobalProxy> ReinitializeJSGlobalProxy(
Handle<JSFunction> constructor,
Handle<JSGlobalProxy> global);
=======================================
--- /branches/bleeding_edge/src/objects.cc Fri Apr 4 12:25:45 2014 UTC
+++ /branches/bleeding_edge/src/objects.cc Fri Apr 4 13:05:37 2014 UTC
@@ -7906,14 +7906,15 @@
}
-MaybeObject* FixedArray::AddKeysFromJSArray(JSArray* array) {
+Handle<FixedArray> FixedArray::AddKeysFromJSArray(Handle<FixedArray>
content,
+ Handle<JSArray> array) {
ElementsAccessor* accessor = array->GetElementsAccessor();
- MaybeObject* maybe_result =
- accessor->AddElementsToFixedArray(array, array, this);
- FixedArray* result;
- if (!maybe_result->To<FixedArray>(&result)) return maybe_result;
+ Handle<FixedArray> result =
+ accessor->AddElementsToFixedArray(array, array, content);
+
#ifdef ENABLE_SLOW_ASSERTS
if (FLAG_enable_slow_asserts) {
+ DisallowHeapAllocation no_allocation;
for (int i = 0; i < result->length(); i++) {
Object* current = result->get(i);
ASSERT(current->IsNumber() || current->IsName());
@@ -7924,14 +7925,19 @@
}
-MaybeObject* FixedArray::UnionOfKeys(FixedArray* other) {
- ElementsAccessor* accessor = ElementsAccessor::ForArray(other);
- MaybeObject* maybe_result =
- accessor->AddElementsToFixedArray(NULL, NULL, this, other);
- FixedArray* result;
- if (!maybe_result->To(&result)) return maybe_result;
+Handle<FixedArray> FixedArray::UnionOfKeys(Handle<FixedArray> first,
+ Handle<FixedArray> second) {
+ ElementsAccessor* accessor = ElementsAccessor::ForArray(second);
+ Handle<FixedArray> result =
+ accessor->AddElementsToFixedArray(
+ Handle<Object>::null(), // receiver
+ Handle<JSObject>::null(), // holder
+ first,
+ Handle<FixedArrayBase>::cast(second));
+
#ifdef ENABLE_SLOW_ASSERTS
if (FLAG_enable_slow_asserts) {
+ DisallowHeapAllocation no_allocation;
for (int i = 0; i < result->length(); i++) {
Object* current = result->get(i);
ASSERT(current->IsNumber() || current->IsName());
=======================================
--- /branches/bleeding_edge/src/objects.h Fri Apr 4 12:25:45 2014 UTC
+++ /branches/bleeding_edge/src/objects.h Fri Apr 4 13:05:37 2014 UTC
@@ -3060,10 +3060,13 @@
PretenureFlag pretenure =
NOT_TENURED);
// Add the elements of a JSArray to this FixedArray.
- MUST_USE_RESULT MaybeObject* AddKeysFromJSArray(JSArray* array);
+ static Handle<FixedArray> AddKeysFromJSArray(Handle<FixedArray> content,
+ Handle<JSArray> array);
- // Compute the union of this and other.
- MUST_USE_RESULT MaybeObject* UnionOfKeys(FixedArray* other);
+ // Computes the union of keys and return the result.
+ // Used for implementing "for (n in object) { }"
+ static Handle<FixedArray> UnionOfKeys(Handle<FixedArray> first,
+ Handle<FixedArray> second);
// Copy a sub array from the receiver to dest.
void CopyTo(int pos, FixedArray* dest, int dest_pos, int len);
=======================================
--- /branches/bleeding_edge/src/runtime.cc Fri Apr 4 12:25:45 2014 UTC
+++ /branches/bleeding_edge/src/runtime.cc Fri Apr 4 13:05:37 2014 UTC
@@ -10716,7 +10716,7 @@
isolate->factory()->NewFixedArray(
current->NumberOfLocalElements(NONE));
current->GetLocalElementKeys(*current_keys, NONE);
- keys = UnionOfKeys(keys, current_keys);
+ keys = FixedArray::UnionOfKeys(keys, current_keys);
}
// Erase any keys >= length.
// TODO(adamk): Remove this step when the contract of %GetArrayKeys
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
