From 107ea152a40b3540867f9ffa9618091f54d09265 Mon Sep 17 00:00:00 2001 From: "ishell@chromium.org" Date: Thu, 20 Mar 2014 10:52:22 +0000 Subject: [PATCH] ElementsAccessor::Delete() handlified. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/200923006 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20113 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/elements.cc | 106 ++++++++++++++++++++++++++++++++++---------------------- src/elements.h | 7 ++-- src/objects.cc | 17 ++------- 3 files changed, 71 insertions(+), 59 deletions(-) diff --git a/src/elements.cc b/src/elements.cc index d935fb1..087b625 100644 --- a/src/elements.cc +++ b/src/elements.cc @@ -768,9 +768,10 @@ class ElementsAccessorBase : public ElementsAccessor { return obj; } - MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* obj, - uint32_t key, - JSReceiver::DeleteMode mode) = 0; + MUST_USE_RESULT virtual Handle Delete( + Handle obj, + uint32_t key, + JSReceiver::DeleteMode mode) = 0; MUST_USE_RESULT static MaybeObject* CopyElementsImpl(FixedArrayBase* from, uint32_t from_start, @@ -999,42 +1000,38 @@ class FastElementsAccessor Object); } - static MaybeObject* DeleteCommon(JSObject* obj, - uint32_t key, - JSReceiver::DeleteMode mode) { + static Handle DeleteCommon(Handle 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 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 backing_store = Handle::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::cast( + handle(Handle::cast(backing_store)->get(1), isolate)); } uint32_t length = static_cast( obj->IsJSArray() - ? Smi::cast(JSArray::cast(obj)->length())->value() + ? Smi::cast(Handle::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 writable = JSObject::EnsureWritableFastElements(obj); + backing_store = Handle::cast(writable); } } backing_store->set_the_hole(key); @@ -1044,7 +1041,7 @@ class FastElementsAccessor // 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 @@ class FastElementsAccessor 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 Delete(Handle obj, + uint32_t key, + JSReceiver::DeleteMode mode) { return DeleteCommon(obj, key, mode); } @@ -1396,11 +1392,11 @@ class TypedElementsAccessor return obj; } - MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* obj, - uint32_t key, - JSReceiver::DeleteMode mode) { + MUST_USE_RESULT virtual Handle Delete(Handle 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, @@ -1555,6 +1551,16 @@ class DictionaryElementsAccessor return heap->true_value(); } + // TODO(ishell): Temporary wrapper until handlified. + MUST_USE_RESULT static Handle DeleteCommon( + Handle 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, FixedArrayBase* to, @@ -1571,9 +1577,9 @@ class DictionaryElementsAccessor friend class ElementsAccessorBase >; - MUST_USE_RESULT virtual MaybeObject* Delete(JSObject* obj, - uint32_t key, - JSReceiver::DeleteMode mode) { + MUST_USE_RESULT virtual Handle Delete(Handle obj, + uint32_t key, + JSReceiver::DeleteMode mode) { return DeleteCommon(obj, key, mode); } @@ -1763,18 +1769,21 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< 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 Delete(Handle obj, + uint32_t key, + JSReceiver::DeleteMode mode) { + Isolate* isolate = obj->GetIsolate(); + Handle parameter_map = + handle(FixedArray::cast(obj->elements()), isolate); + Handle 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 arguments = + handle(FixedArray::cast(parameter_map->get(1)), isolate); if (arguments->IsDictionary()) { return DictionaryElementsAccessor::DeleteCommon(obj, key, mode); } else { @@ -1784,7 +1793,7 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< 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 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< } private: + // TODO(ishell): remove when all usages are handlified. static Object* GetParameterMapArg(JSObject* holder, FixedArray* parameter_map, uint32_t key) { @@ -1837,6 +1847,18 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< ? parameter_map->get(key + 2) : parameter_map->GetHeap()->the_hole_value(); } + + static Handle GetParameterMapArg(Handle holder, + Handle parameter_map, + uint32_t key) { + Isolate* isolate = holder->GetIsolate(); + uint32_t length = holder->IsJSArray() + ? Smi::cast(Handle::cast(holder)->length())->value() + : parameter_map->length(); + return key < (length - 2) + ? handle(parameter_map->get(key + 2), isolate) + : Handle::cast(isolate->factory()->the_hole_value()); + } }; diff --git a/src/elements.h b/src/elements.h index 1353869..50a75eb 100644 --- a/src/elements.h +++ b/src/elements.h @@ -124,9 +124,10 @@ class ElementsAccessor { 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 Delete( + Handle 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. diff --git a/src/objects.cc b/src/objects.cc index 897c52a..5d36a63 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -5103,18 +5103,6 @@ Handle JSObject::DeletePropertyWithInterceptor(Handle object, } -// TODO(mstarzinger): Temporary wrapper until handlified. -static Handle AccessorDelete(Handle object, - uint32_t index, - JSObject::DeleteMode mode) { - CALL_HEAP_FUNCTION(object->GetIsolate(), - object->GetElementsAccessor()->Delete(*object, - index, - mode), - Object); -} - - Handle JSObject::DeleteElementWithInterceptor(Handle object, uint32_t index) { Isolate* isolate = object->GetIsolate(); @@ -5141,7 +5129,8 @@ Handle JSObject::DeleteElementWithInterceptor(Handle object, // Rebox CustomArguments::kReturnValueOffset before returning. return handle(*result_internal, isolate); } - Handle delete_result = AccessorDelete(object, index, NORMAL_DELETION); + Handle delete_result = object->GetElementsAccessor()->Delete( + object, index, NORMAL_DELETION); RETURN_HANDLE_IF_SCHEDULED_EXCEPTION(isolate, Object); return delete_result; } @@ -5201,7 +5190,7 @@ Handle JSObject::DeleteElement(Handle object, 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)) { -- 2.7.4