Revision: 20113
Author: [email protected]
Date: Thu Mar 20 10:52:22 2014 UTC
Log: ElementsAccessor::Delete() handlified.
[email protected]
Review URL: https://codereview.chromium.org/200923006
http://code.google.com/p/v8/source/detail?r=20113
Modified:
/branches/bleeding_edge/src/elements.cc
/branches/bleeding_edge/src/elements.h
/branches/bleeding_edge/src/objects.cc
=======================================
--- /branches/bleeding_edge/src/elements.cc Wed Mar 19 16:29:19 2014 UTC
+++ /branches/bleeding_edge/src/elements.cc Thu Mar 20 10:52:22 2014 UTC
@@ -768,9 +768,10 @@
return obj;
}
- MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* obj,
- uint32_t key,
- JSReceiver::DeleteMode mode)
= 0;
+ MUST_USE_RESULT virtual Handle<Object> Delete(
+ Handle<JSObject> obj,
+ uint32_t key,
+ JSReceiver::DeleteMode mode) = 0;
MUST_USE_RESULT static MaybeObject* CopyElementsImpl(FixedArrayBase*
from,
uint32_t from_start,
@@ -999,42 +1000,38 @@
Object);
}
- static MaybeObject* DeleteCommon(JSObject* obj,
- uint32_t key,
- JSReceiver::DeleteMode mode) {
+ static Handle<Object> DeleteCommon(Handle<JSObject> obj,
+ uint32_t key,
+ JSReceiver::DeleteMode mode) {
ASSERT(obj->HasFastSmiOrObjectElements() ||
obj->HasFastDoubleElements() ||
obj->HasFastArgumentsElements());
+ Isolate* isolate = obj->GetIsolate();
Heap* heap = obj->GetHeap();
- Object* elements = obj->elements();
- if (elements == heap->empty_fixed_array()) {
- return heap->true_value();
+ Handle<Object> elements = handle(obj->elements(), isolate);
+ if (*elements == heap->empty_fixed_array()) {
+ return isolate->factory()->true_value();
}
- typename KindTraits::BackingStore* backing_store =
- KindTraits::BackingStore::cast(elements);
+ Handle<BackingStore> backing_store =
Handle<BackingStore>::cast(elements);
bool is_sloppy_arguments_elements_map =
backing_store->map() == heap->sloppy_arguments_elements_map();
if (is_sloppy_arguments_elements_map) {
- backing_store = KindTraits::BackingStore::cast(
- FixedArray::cast(backing_store)->get(1));
+ backing_store = Handle<BackingStore>::cast(
+ handle(Handle<FixedArray>::cast(backing_store)->get(1),
isolate));
}
uint32_t length = static_cast<uint32_t>(
obj->IsJSArray()
- ? Smi::cast(JSArray::cast(obj)->length())->value()
+ ? Smi::cast(Handle<JSArray>::cast(obj)->length())->value()
: backing_store->length());
if (key < length) {
if (!is_sloppy_arguments_elements_map) {
ElementsKind kind = KindTraits::Kind;
if (IsFastPackedElementsKind(kind)) {
- MaybeObject* transitioned =
- obj->TransitionElementsKind(GetHoleyElementsKind(kind));
- if (transitioned->IsFailure()) return transitioned;
+ JSObject::TransitionElementsKind(obj,
GetHoleyElementsKind(kind));
}
if (IsFastSmiOrObjectElementsKind(KindTraits::Kind)) {
- Object* writable;
- MaybeObject* maybe = obj->EnsureWritableFastElements();
- if (!maybe->ToObject(&writable)) return maybe;
- backing_store = KindTraits::BackingStore::cast(writable);
+ Handle<Object> writable =
JSObject::EnsureWritableFastElements(obj);
+ backing_store = Handle<BackingStore>::cast(writable);
}
}
backing_store->set_the_hole(key);
@@ -1044,7 +1041,7 @@
// one adjacent hole to the value being deleted.
const int kMinLengthForSparsenessCheck = 64;
if (backing_store->length() >= kMinLengthForSparsenessCheck &&
- !heap->InNewSpace(backing_store) &&
+ !heap->InNewSpace(*backing_store) &&
((key > 0 && backing_store->is_the_hole(key - 1)) ||
(key + 1 < length && backing_store->is_the_hole(key + 1)))) {
int num_used = 0;
@@ -1054,17 +1051,16 @@
if (4 * num_used > backing_store->length()) break;
}
if (4 * num_used <= backing_store->length()) {
- MaybeObject* result = obj->NormalizeElements();
- if (result->IsFailure()) return result;
+ JSObject::NormalizeElements(obj);
}
}
}
- return heap->true_value();
+ return isolate->factory()->true_value();
}
- virtual MaybeObject* Delete(JSObject* obj,
- uint32_t key,
- JSReceiver::DeleteMode mode) {
+ virtual Handle<Object> Delete(Handle<JSObject> obj,
+ uint32_t key,
+ JSReceiver::DeleteMode mode) {
return DeleteCommon(obj, key, mode);
}
@@ -1396,11 +1392,11 @@
return obj;
}
- MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* obj,
- uint32_t key,
- JSReceiver::DeleteMode mode)
{
+ MUST_USE_RESULT virtual Handle<Object> Delete(Handle<JSObject> obj,
+ uint32_t key,
+ JSReceiver::DeleteMode
mode) {
// External arrays always ignore deletes.
- return obj->GetHeap()->true_value();
+ return obj->GetIsolate()->factory()->true_value();
}
static bool HasElementImpl(Object* receiver,
@@ -1554,6 +1550,16 @@
}
return heap->true_value();
}
+
+ // TODO(ishell): Temporary wrapper until handlified.
+ MUST_USE_RESULT static Handle<Object> DeleteCommon(
+ Handle<JSObject> obj,
+ uint32_t key,
+ JSReceiver::DeleteMode mode) {
+ CALL_HEAP_FUNCTION(obj->GetIsolate(),
+ DeleteCommon(*obj, key, mode),
+ Object);
+ }
MUST_USE_RESULT static MaybeObject* CopyElementsImpl(FixedArrayBase*
from,
uint32_t from_start,
@@ -1571,9 +1577,9 @@
friend class ElementsAccessorBase<DictionaryElementsAccessor,
ElementsKindTraits<DICTIONARY_ELEMENTS> >;
- MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* obj,
- uint32_t key,
- JSReceiver::DeleteMode mode)
{
+ MUST_USE_RESULT virtual Handle<Object> Delete(Handle<JSObject> obj,
+ uint32_t key,
+ JSReceiver::DeleteMode
mode) {
return DeleteCommon(obj, key, mode);
}
@@ -1763,18 +1769,21 @@
return obj;
}
- MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* obj,
- uint32_t key,
- JSReceiver::DeleteMode mode)
{
- FixedArray* parameter_map = FixedArray::cast(obj->elements());
- Object* probe = GetParameterMapArg(obj, parameter_map, key);
+ MUST_USE_RESULT virtual Handle<Object> Delete(Handle<JSObject> obj,
+ uint32_t key,
+ JSReceiver::DeleteMode
mode) {
+ Isolate* isolate = obj->GetIsolate();
+ Handle<FixedArray> parameter_map =
+ handle(FixedArray::cast(obj->elements()), isolate);
+ Handle<Object> probe = GetParameterMapArg(obj, parameter_map, key);
if (!probe->IsTheHole()) {
// TODO(kmillikin): We could check if this was the last aliased
// parameter, and revert to normal elements in that case. That
// would enable GC of the context.
parameter_map->set_the_hole(key + 2);
} else {
- FixedArray* arguments = FixedArray::cast(parameter_map->get(1));
+ Handle<FixedArray> arguments =
+ handle(FixedArray::cast(parameter_map->get(1)), isolate);
if (arguments->IsDictionary()) {
return DictionaryElementsAccessor::DeleteCommon(obj, key, mode);
} else {
@@ -1784,7 +1793,7 @@
return FastHoleyObjectElementsAccessor::DeleteCommon(obj, key,
mode);
}
}
- return obj->GetHeap()->true_value();
+ return isolate->factory()->true_value();
}
MUST_USE_RESULT static MaybeObject* CopyElementsImpl(FixedArrayBase*
from,
@@ -1827,6 +1836,7 @@
}
private:
+ // TODO(ishell): remove when all usages are handlified.
static Object* GetParameterMapArg(JSObject* holder,
FixedArray* parameter_map,
uint32_t key) {
@@ -1837,6 +1847,18 @@
? parameter_map->get(key + 2)
: parameter_map->GetHeap()->the_hole_value();
}
+
+ static Handle<Object> GetParameterMapArg(Handle<JSObject> holder,
+ Handle<FixedArray>
parameter_map,
+ uint32_t key) {
+ Isolate* isolate = holder->GetIsolate();
+ uint32_t length = holder->IsJSArray()
+ ? Smi::cast(Handle<JSArray>::cast(holder)->length())->value()
+ : parameter_map->length();
+ return key < (length - 2)
+ ? handle(parameter_map->get(key + 2), isolate)
+ : Handle<Object>::cast(isolate->factory()->the_hole_value());
+ }
};
=======================================
--- /branches/bleeding_edge/src/elements.h Wed Mar 19 16:29:19 2014 UTC
+++ /branches/bleeding_edge/src/elements.h Thu Mar 20 10:52:22 2014 UTC
@@ -124,9 +124,10 @@
int length) =
0;
// Deletes an element in an object, returning a new elements backing
store.
- MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* holder,
- uint32_t key,
- JSReceiver::DeleteMode mode)
= 0;
+ MUST_USE_RESULT virtual Handle<Object> Delete(
+ Handle<JSObject> holder,
+ uint32_t key,
+ JSReceiver::DeleteMode mode) = 0;
// If kCopyToEnd is specified as the copy_size to CopyElements, it
copies all
// of elements from source after source_start to the destination array.
=======================================
--- /branches/bleeding_edge/src/objects.cc Wed Mar 19 14:09:50 2014 UTC
+++ /branches/bleeding_edge/src/objects.cc Thu Mar 20 10:52:22 2014 UTC
@@ -5101,18 +5101,6 @@
RETURN_HANDLE_IF_SCHEDULED_EXCEPTION(isolate, Object);
return result;
}
-
-
-// TODO(mstarzinger): Temporary wrapper until handlified.
-static Handle<Object> AccessorDelete(Handle<JSObject> object,
- uint32_t index,
- JSObject::DeleteMode mode) {
- CALL_HEAP_FUNCTION(object->GetIsolate(),
- object->GetElementsAccessor()->Delete(*object,
- index,
- mode),
- Object);
-}
Handle<Object> JSObject::DeleteElementWithInterceptor(Handle<JSObject>
object,
@@ -5141,7 +5129,8 @@
// Rebox CustomArguments::kReturnValueOffset before returning.
return handle(*result_internal, isolate);
}
- Handle<Object> delete_result = AccessorDelete(object, index,
NORMAL_DELETION);
+ Handle<Object> delete_result = object->GetElementsAccessor()->Delete(
+ object, index, NORMAL_DELETION);
RETURN_HANDLE_IF_SCHEDULED_EXCEPTION(isolate, Object);
return delete_result;
}
@@ -5201,7 +5190,7 @@
if (object->HasIndexedInterceptor() && mode != FORCE_DELETION) {
result = DeleteElementWithInterceptor(object, index);
} else {
- result = AccessorDelete(object, index, mode);
+ result = object->GetElementsAccessor()->Delete(object, index, mode);
}
if (should_enqueue_change_record && !HasLocalElement(object, index)) {
--
--
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.
