From cca6ffff7e1db2581f6ef49fda70dc7e0759d2ec Mon Sep 17 00:00:00 2001 From: verwaest Date: Thu, 19 Feb 2015 01:04:49 -0800 Subject: [PATCH] Revert of Remove handle wrappers from basic elements accessors (patchset #2 id:20001 of https://codereview.chromium.org/934173004/) Reason for revert: Breakage Original issue's description: > Remove handle wrappers from basic elements accessors > > BUG= > R=yangguo@chromium.org > > Committed: https://crrev.com/40b7c513c696f405af0ae3e74e844d3c341bc3f2 > Cr-Commit-Position: refs/heads/master@{#26736} TBR=yangguo@chromium.org NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG= Review URL: https://codereview.chromium.org/932693003 Cr-Commit-Position: refs/heads/master@{#26737} --- src/builtins.cc | 2 +- src/elements.cc | 119 ++++++++++++++++++++--------------- src/elements.h | 27 +++++--- src/objects.cc | 8 +-- src/runtime/runtime-array.cc | 6 +- 5 files changed, 93 insertions(+), 69 deletions(-) diff --git a/src/builtins.cc b/src/builtins.cc index f2b55c294cc..21c246ca42d 100644 --- a/src/builtins.cc +++ b/src/builtins.cc @@ -666,7 +666,7 @@ BUILTIN(ArraySlice) { bool packed = true; ElementsAccessor* accessor = ElementsAccessor::ForKind(kind); for (int i = k; i < final; i++) { - if (!accessor->HasElement(*object, i, *elms)) { + if (!accessor->HasElement(object, i, elms)) { packed = false; break; } diff --git a/src/elements.cc b/src/elements.cc index e58deb6105c..cd7ba984af0 100644 --- a/src/elements.cc +++ b/src/elements.cc @@ -587,14 +587,14 @@ class ElementsAccessorBase : public ElementsAccessor { ElementsAccessorSubclass::ValidateImpl(holder); } - static bool HasElementImpl(JSObject* holder, uint32_t key, - FixedArrayBase* backing_store) { + static bool HasElementImpl(Handle holder, uint32_t key, + Handle backing_store) { return ElementsAccessorSubclass::GetAttributesImpl(holder, key, backing_store) != ABSENT; } - virtual bool HasElement(JSObject* holder, uint32_t key, - FixedArrayBase* backing_store) FINAL { + virtual bool HasElement(Handle holder, uint32_t key, + Handle backing_store) FINAL { return ElementsAccessorSubclass::HasElementImpl(holder, key, backing_store); } @@ -620,7 +620,7 @@ class ElementsAccessorBase : public ElementsAccessor { Handle obj, uint32_t key, Handle backing_store) { - if (key < ElementsAccessorSubclass::GetCapacityImpl(*backing_store)) { + if (key < ElementsAccessorSubclass::GetCapacityImpl(backing_store)) { return BackingStore::get(Handle::cast(backing_store), key); } else { return backing_store->GetIsolate()->factory()->the_hole_value(); @@ -628,17 +628,22 @@ class ElementsAccessorBase : public ElementsAccessor { } MUST_USE_RESULT virtual PropertyAttributes GetAttributes( - JSObject* holder, uint32_t key, FixedArrayBase* backing_store) FINAL { + Handle holder, uint32_t key, + Handle backing_store) FINAL { return ElementsAccessorSubclass::GetAttributesImpl(holder, key, backing_store); } MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( - JSObject* obj, uint32_t key, FixedArrayBase* backing_store) { + Handle obj, + uint32_t key, + Handle backing_store) { if (key >= ElementsAccessorSubclass::GetCapacityImpl(backing_store)) { return ABSENT; } - return BackingStore::cast(backing_store)->is_the_hole(key) ? ABSENT : NONE; + return + Handle::cast(backing_store)->is_the_hole(key) + ? ABSENT : NONE; } MUST_USE_RESULT virtual MaybeHandle GetAccessorPair( @@ -746,7 +751,7 @@ class ElementsAccessorBase : public ElementsAccessor { // Optimize if 'other' is empty. // 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; Isolate* isolate = from->GetIsolate(); @@ -755,7 +760,7 @@ class ElementsAccessorBase : public ElementsAccessor { uint32_t extra = 0; for (uint32_t y = 0; y < len1; y++) { uint32_t key = ElementsAccessorSubclass::GetKeyForIndexImpl(from, y); - if (ElementsAccessorSubclass::HasElementImpl(*holder, key, *from)) { + if (ElementsAccessorSubclass::HasElementImpl(holder, key, from)) { Handle value; ASSIGN_RETURN_ON_EXCEPTION( isolate, value, @@ -792,7 +797,7 @@ class ElementsAccessorBase : public ElementsAccessor { for (uint32_t y = 0; y < len1; y++) { uint32_t key = ElementsAccessorSubclass::GetKeyForIndexImpl(from, y); - if (ElementsAccessorSubclass::HasElementImpl(*holder, key, *from)) { + if (ElementsAccessorSubclass::HasElementImpl(holder, key, from)) { Handle value; ASSIGN_RETURN_ON_EXCEPTION( isolate, value, @@ -812,11 +817,11 @@ class ElementsAccessorBase : public ElementsAccessor { } protected: - static uint32_t GetCapacityImpl(FixedArrayBase* backing_store) { + static uint32_t GetCapacityImpl(Handle backing_store) { return backing_store->length(); } - uint32_t GetCapacity(FixedArrayBase* backing_store) FINAL { + uint32_t GetCapacity(Handle backing_store) FINAL { return ElementsAccessorSubclass::GetCapacityImpl(backing_store); } @@ -964,12 +969,14 @@ class FastElementsAccessor return DeleteCommon(obj, key, language_mode); } - static bool HasElementImpl(JSObject* holder, uint32_t key, - FixedArrayBase* backing_store) { + static bool HasElementImpl( + Handle holder, + uint32_t key, + Handle backing_store) { if (key >= static_cast(backing_store->length())) { return false; } - return !BackingStore::cast(backing_store)->is_the_hole(key); + return !Handle::cast(backing_store)->is_the_hole(key); } static void ValidateContents(Handle holder, int length) { @@ -1253,7 +1260,7 @@ class TypedElementsAccessor Handle obj, uint32_t key, Handle backing_store) { - if (key < AccessorClass::GetCapacityImpl(*backing_store)) { + if (key < AccessorClass::GetCapacityImpl(backing_store)) { return BackingStore::get(Handle::cast(backing_store), key); } else { return backing_store->GetIsolate()->factory()->undefined_value(); @@ -1261,7 +1268,9 @@ class TypedElementsAccessor } MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( - JSObject* obj, uint32_t key, FixedArrayBase* backing_store) { + Handle obj, + uint32_t key, + Handle backing_store) { return key < AccessorClass::GetCapacityImpl(backing_store) ? NONE : ABSENT; @@ -1282,8 +1291,8 @@ class TypedElementsAccessor return obj->GetIsolate()->factory()->true_value(); } - static bool HasElementImpl(JSObject* holder, uint32_t key, - FixedArrayBase* backing_store) { + static bool HasElementImpl(Handle holder, uint32_t key, + Handle backing_store) { uint32_t capacity = AccessorClass::GetCapacityImpl(backing_store); return key < capacity; @@ -1452,9 +1461,11 @@ class DictionaryElementsAccessor } MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( - JSObject* obj, uint32_t key, FixedArrayBase* backing_store) { - SeededNumberDictionary* dictionary = - SeededNumberDictionary::cast(backing_store); + Handle obj, + uint32_t key, + Handle backing_store) { + Handle dictionary = + Handle::cast(backing_store); int entry = dictionary->FindEntry(key); if (entry != SeededNumberDictionary::kNotFound) { return dictionary->DetailsAt(entry).attributes(); @@ -1477,9 +1488,10 @@ class DictionaryElementsAccessor return MaybeHandle(); } - static bool HasElementImpl(JSObject* holder, uint32_t key, - FixedArrayBase* store) { - SeededNumberDictionary* backing_store = SeededNumberDictionary::cast(store); + static bool HasElementImpl(Handle holder, uint32_t key, + Handle store) { + Handle backing_store = + Handle::cast(store); return backing_store->FindEntry(key) != SeededNumberDictionary::kNotFound; } @@ -1514,11 +1526,11 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< Handle parameters) { Isolate* isolate = obj->GetIsolate(); Handle parameter_map = Handle::cast(parameters); - Object* probe = GetParameterMapArg(*obj, *parameter_map, key); + Handle probe = GetParameterMapArg(obj, parameter_map, key); if (!probe->IsTheHole()) { DisallowHeapAllocation no_gc; Context* context = Context::cast(parameter_map->get(0)); - int context_index = Smi::cast(probe)->value(); + int context_index = Handle::cast(probe)->value(); DCHECK(!context->get(context_index)->IsTheHole()); return handle(context->get(context_index), isolate); } else { @@ -1526,10 +1538,11 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< Handle arguments(FixedArray::cast(parameter_map->get(1)), isolate); Handle result; - ASSIGN_RETURN_ON_EXCEPTION(isolate, result, - ElementsAccessor::ForArray(*arguments) - ->Get(receiver, obj, key, arguments), - Object); + ASSIGN_RETURN_ON_EXCEPTION( + isolate, result, + ElementsAccessor::ForArray(arguments)->Get( + receiver, obj, key, arguments), + Object); // Elements of the arguments object in slow mode might be slow aliases. if (result->IsAliasedArgumentsEntry()) { DisallowHeapAllocation no_gc; @@ -1545,14 +1558,16 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< } MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( - JSObject* obj, uint32_t key, FixedArrayBase* backing_store) { - FixedArray* parameter_map = FixedArray::cast(backing_store); - Object* probe = GetParameterMapArg(obj, parameter_map, key); + Handle obj, + uint32_t key, + Handle backing_store) { + Handle parameter_map = Handle::cast(backing_store); + Handle probe = GetParameterMapArg(obj, parameter_map, key); if (!probe->IsTheHole()) { return NONE; } else { // If not aliased, check the arguments. - FixedArray* arguments = FixedArray::cast(parameter_map->get(1)); + Handle arguments(FixedArray::cast(parameter_map->get(1))); return ElementsAccessor::ForArray(arguments) ->GetAttributes(obj, key, arguments); } @@ -1563,13 +1578,13 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< uint32_t key, Handle parameters) { Handle parameter_map = Handle::cast(parameters); - Object* probe = GetParameterMapArg(*obj, *parameter_map, key); + Handle probe = GetParameterMapArg(obj, parameter_map, key); if (!probe->IsTheHole()) { return MaybeHandle(); } else { // If not aliased, check the arguments. Handle arguments(FixedArray::cast(parameter_map->get(1))); - return ElementsAccessor::ForArray(*arguments) + return ElementsAccessor::ForArray(arguments) ->GetAccessorPair(obj, key, arguments); } } @@ -1588,8 +1603,7 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< Handle obj, uint32_t key, LanguageMode language_mode) FINAL { Isolate* isolate = obj->GetIsolate(); Handle parameter_map(FixedArray::cast(obj->elements())); - Handle probe(GetParameterMapArg(*obj, *parameter_map, key), - 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 @@ -1618,9 +1632,10 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< UNREACHABLE(); } - static uint32_t GetCapacityImpl(FixedArrayBase* backing_store) { - FixedArray* parameter_map = FixedArray::cast(backing_store); - FixedArrayBase* arguments = FixedArrayBase::cast(parameter_map->get(1)); + static uint32_t GetCapacityImpl(Handle backing_store) { + Handle parameter_map = Handle::cast(backing_store); + Handle arguments( + FixedArrayBase::cast(parameter_map->get(1))); return Max(static_cast(parameter_map->length() - 2), ForArray(arguments)->GetCapacity(arguments)); } @@ -1631,20 +1646,22 @@ class SloppyArgumentsElementsAccessor : public ElementsAccessorBase< } private: - static Object* GetParameterMapArg(JSObject* holder, FixedArray* parameter_map, - uint32_t key) { + static Handle GetParameterMapArg(Handle holder, + Handle parameter_map, + uint32_t key) { Isolate* isolate = holder->GetIsolate(); uint32_t length = holder->IsJSArray() - ? Smi::cast(JSArray::cast(holder)->length())->value() - : parameter_map->length(); - return key < (length - 2) ? parameter_map->get(key + 2) - : isolate->heap()->the_hole_value(); + ? 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()); } }; -ElementsAccessor* ElementsAccessor::ForArray(FixedArrayBase* array) { - return elements_accessors_[ElementsKindForArray(array)]; +ElementsAccessor* ElementsAccessor::ForArray(Handle array) { + return elements_accessors_[ElementsKindForArray(*array)]; } diff --git a/src/elements.h b/src/elements.h index 1c299a1f67d..1d80b258910 100644 --- a/src/elements.h +++ b/src/elements.h @@ -32,11 +32,15 @@ class ElementsAccessor { // 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(JSObject* holder, uint32_t key, - FixedArrayBase* backing_store) = 0; + virtual bool HasElement( + Handle holder, + uint32_t key, + Handle backing_store) = 0; - inline bool HasElement(JSObject* holder, uint32_t key) { - return HasElement(holder, key, holder->elements()); + inline bool HasElement( + Handle holder, + uint32_t key) { + return HasElement(holder, key, handle(holder->elements())); } // Returns the element with the specified key or undefined if there is no such @@ -63,11 +67,14 @@ class ElementsAccessor { // be compatible with the ElementsKind of the ElementsAccessor. If // backing_store is NULL, the holder->elements() is used as the backing store. MUST_USE_RESULT virtual PropertyAttributes GetAttributes( - JSObject* holder, uint32_t key, FixedArrayBase* backing_store) = 0; + Handle holder, + uint32_t key, + Handle backing_store) = 0; - MUST_USE_RESULT inline PropertyAttributes GetAttributes(JSObject* holder, - uint32_t key) { - return GetAttributes(holder, key, holder->elements()); + MUST_USE_RESULT inline PropertyAttributes GetAttributes( + Handle holder, + uint32_t key) { + return GetAttributes(holder, key, handle(holder->elements())); } // Returns an element's accessors, or NULL if the element does not exist or @@ -168,7 +175,7 @@ class ElementsAccessor { return elements_accessors_[elements_kind]; } - static ElementsAccessor* ForArray(FixedArrayBase* array); + static ElementsAccessor* ForArray(Handle array); static void InitializeOncePerProcess(); static void TearDown(); @@ -176,7 +183,7 @@ class ElementsAccessor { protected: friend class SloppyArgumentsElementsAccessor; - virtual uint32_t GetCapacity(FixedArrayBase* backing_store) = 0; + virtual uint32_t GetCapacity(Handle backing_store) = 0; // Element handlers distinguish between indexes and keys when they manipulate // elements. Indexes refer to elements in terms of their location in the diff --git a/src/objects.cc b/src/objects.cc index 716694bdfe9..49097c66809 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -731,7 +731,7 @@ MaybeHandle Object::SetElementWithReceiver( if (!done && js_object->elements() != isolate->heap()->empty_fixed_array()) { ElementsAccessor* accessor = js_object->GetElementsAccessor(); - PropertyAttributes attrs = accessor->GetAttributes(*js_object, index); + PropertyAttributes attrs = accessor->GetAttributes(js_object, index); if ((attrs & READ_ONLY) != 0) { return WriteToReadOnlyElement(isolate, receiver, index, value, language_mode); @@ -752,7 +752,7 @@ MaybeHandle Object::SetElementWithReceiver( } Handle target = Handle::cast(receiver); ElementsAccessor* accessor = target->GetElementsAccessor(); - PropertyAttributes attrs = accessor->GetAttributes(*target, index); + PropertyAttributes attrs = accessor->GetAttributes(target, index); if ((attrs & READ_ONLY) != 0) { return WriteToReadOnlyElement(isolate, receiver, index, value, language_mode); @@ -4371,7 +4371,7 @@ Maybe JSObject::GetElementAttributeWithoutInterceptor( Handle object, Handle receiver, uint32_t index, bool check_prototype) { PropertyAttributes attr = - object->GetElementsAccessor()->GetAttributes(*object, index); + object->GetElementsAccessor()->GetAttributes(object, index); if (attr != ABSENT) return maybe(attr); // Handle [] on String objects. @@ -8254,7 +8254,7 @@ MaybeHandle FixedArray::AddKeysFromArrayLike( MaybeHandle FixedArray::UnionOfKeys(Handle first, Handle second) { - ElementsAccessor* accessor = ElementsAccessor::ForArray(*second); + ElementsAccessor* accessor = ElementsAccessor::ForArray(second); Handle result; ASSIGN_RETURN_ON_EXCEPTION( first->GetIsolate(), result, diff --git a/src/runtime/runtime-array.cc b/src/runtime/runtime-array.cc index fe6c2ade6fd..84d0953afea 100644 --- a/src/runtime/runtime-array.cc +++ b/src/runtime/runtime-array.cc @@ -420,7 +420,7 @@ static void CollectElementIndices(Handle object, uint32_t range, uint32_t length = static_cast(DoubleToInt32(length_num)); ElementsAccessor* accessor = object->GetElementsAccessor(); for (uint32_t i = 0; i < length; i++) { - if (accessor->HasElement(*object, i)) { + if (accessor->HasElement(object, i)) { indices->Add(i); } } @@ -687,7 +687,7 @@ static bool IterateElements(Isolate* isolate, Handle receiver, ElementsAccessor* accessor = receiver->GetElementsAccessor(); for (uint32_t index = 0; index < length; index++) { HandleScope loop_scope(isolate); - if (accessor->HasElement(*receiver, index)) { + if (accessor->HasElement(receiver, index)) { Handle element; ASSIGN_RETURN_ON_EXCEPTION_VALUE( isolate, element, accessor->Get(receiver, receiver, index), @@ -979,7 +979,7 @@ RUNTIME_FUNCTION(Runtime_EstimateNumberOfElements) { ElementsAccessor* accessor = array->GetElementsAccessor(); int holes = 0; for (int i = 0; i < length; i += increment) { - if (!accessor->HasElement(*array, i, *elements)) { + if (!accessor->HasElement(array, i, elements)) { ++holes; } }