From 90b1077e31b19e2a5b15d6a027133dc5562e2ec3 Mon Sep 17 00:00:00 2001 From: "ishell@chromium.org" Date: Fri, 21 Mar 2014 12:23:39 +0000 Subject: [PATCH] Reland of r20146 "JSObject::NormalizeElements() handlified." R=verwaest@chromium.org Review URL: https://codereview.chromium.org/208003002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20161 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/objects.cc | 109 +++++++++++++++++++++------------------------------------ src/objects.h | 2 -- 2 files changed, 40 insertions(+), 71 deletions(-) diff --git a/src/objects.cc b/src/objects.cc index 88e7234..54ffcb6 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -4661,120 +4661,91 @@ void JSObject::TransformToFastProperties(Handle object, } -static MUST_USE_RESULT MaybeObject* CopyFastElementsToDictionary( - Isolate* isolate, - FixedArrayBase* array, +static Handle CopyFastElementsToDictionary( + Handle array, int length, - SeededNumberDictionary* dictionary) { - Heap* heap = isolate->heap(); + Handle dictionary) { + Isolate* isolate = array->GetIsolate(); + Factory* factory = isolate->factory(); bool has_double_elements = array->IsFixedDoubleArray(); for (int i = 0; i < length; i++) { - Object* value = NULL; + Handle value; if (has_double_elements) { - FixedDoubleArray* double_array = FixedDoubleArray::cast(array); + Handle double_array = + Handle::cast(array); if (double_array->is_the_hole(i)) { - value = isolate->heap()->the_hole_value(); + value = factory->the_hole_value(); } else { - // Objects must be allocated in the old object space, since the - // overall number of HeapNumbers needed for the conversion might - // exceed the capacity of new space, and we would fail repeatedly - // trying to convert the FixedDoubleArray. - MaybeObject* maybe_value_object = - heap->AllocateHeapNumber(double_array->get_scalar(i), TENURED); - if (!maybe_value_object->ToObject(&value)) return maybe_value_object; + value = factory->NewHeapNumber(double_array->get_scalar(i)); } } else { - value = FixedArray::cast(array)->get(i); + value = handle(Handle::cast(array)->get(i), isolate); } if (!value->IsTheHole()) { PropertyDetails details = PropertyDetails(NONE, NORMAL, 0); - MaybeObject* maybe_result = - dictionary->AddNumberEntry(i, value, details); - if (!maybe_result->To(&dictionary)) return maybe_result; + dictionary = + SeededNumberDictionary::AddNumberEntry(dictionary, i, value, details); } } return dictionary; } -static Handle CopyFastElementsToDictionary( - Handle array, - int length, - Handle dict) { - Isolate* isolate = array->GetIsolate(); - CALL_HEAP_FUNCTION(isolate, - CopyFastElementsToDictionary( - isolate, *array, length, *dict), - SeededNumberDictionary); -} - - Handle JSObject::NormalizeElements( Handle object) { - CALL_HEAP_FUNCTION(object->GetIsolate(), - object->NormalizeElements(), - SeededNumberDictionary); -} - - -MaybeObject* JSObject::NormalizeElements() { - ASSERT(!HasExternalArrayElements()); + ASSERT(!object->HasExternalArrayElements()); + Isolate* isolate = object->GetIsolate(); + Factory* factory = isolate->factory(); // Find the backing store. - FixedArrayBase* array = FixedArrayBase::cast(elements()); - Map* old_map = array->map(); + Handle array(FixedArrayBase::cast(object->elements())); bool is_arguments = - (old_map == old_map->GetHeap()->sloppy_arguments_elements_map()); + (array->map() == isolate->heap()->sloppy_arguments_elements_map()); if (is_arguments) { - array = FixedArrayBase::cast(FixedArray::cast(array)->get(1)); + array = handle(FixedArrayBase::cast( + Handle::cast(array)->get(1))); } - if (array->IsDictionary()) return array; + if (array->IsDictionary()) return Handle::cast(array); - ASSERT(HasFastSmiOrObjectElements() || - HasFastDoubleElements() || - HasFastArgumentsElements()); + ASSERT(object->HasFastSmiOrObjectElements() || + object->HasFastDoubleElements() || + object->HasFastArgumentsElements()); // Compute the effective length and allocate a new backing store. - int length = IsJSArray() - ? Smi::cast(JSArray::cast(this)->length())->value() + int length = object->IsJSArray() + ? Smi::cast(Handle::cast(object)->length())->value() : array->length(); int old_capacity = 0; int used_elements = 0; - GetElementsCapacityAndUsage(&old_capacity, &used_elements); - SeededNumberDictionary* dictionary; - MaybeObject* maybe_dictionary = - SeededNumberDictionary::Allocate(GetHeap(), used_elements); - if (!maybe_dictionary->To(&dictionary)) return maybe_dictionary; + object->GetElementsCapacityAndUsage(&old_capacity, &used_elements); + Handle dictionary = + factory->NewSeededNumberDictionary(used_elements); - maybe_dictionary = CopyFastElementsToDictionary( - GetIsolate(), array, length, dictionary); - if (!maybe_dictionary->To(&dictionary)) return maybe_dictionary; + dictionary = CopyFastElementsToDictionary(array, length, dictionary); // Switch to using the dictionary as the backing storage for elements. if (is_arguments) { - FixedArray::cast(elements())->set(1, dictionary); + FixedArray::cast(object->elements())->set(1, *dictionary); } else { // Set the new map first to satify the elements type assert in // set_elements(). - Map* new_map; - MaybeObject* maybe = GetElementsTransitionMap(GetIsolate(), - DICTIONARY_ELEMENTS); - if (!maybe->To(&new_map)) return maybe; - // TODO(verwaest): Replace by MigrateToMap. - set_map(new_map); - set_elements(dictionary); + Handle new_map = + JSObject::GetElementsTransitionMap(object, DICTIONARY_ELEMENTS); + + JSObject::MigrateToMap(object, new_map); + object->set_elements(*dictionary); } - old_map->GetHeap()->isolate()->counters()->elements_to_dictionary()-> - Increment(); + isolate->counters()->elements_to_dictionary()->Increment(); #ifdef DEBUG if (FLAG_trace_normalization) { PrintF("Object elements have been normalized:\n"); - Print(); + object->Print(); } #endif - ASSERT(HasDictionaryElements() || HasDictionaryArgumentsElements()); + ASSERT(object->HasDictionaryElements() || + object->HasDictionaryArgumentsElements()); return dictionary; } diff --git a/src/objects.h b/src/objects.h index 134ef04..f730d2f 100644 --- a/src/objects.h +++ b/src/objects.h @@ -2608,8 +2608,6 @@ class JSObject: public JSReceiver { static Handle NormalizeElements( Handle object); - MUST_USE_RESULT MaybeObject* NormalizeElements(); - // Transform slow named properties to fast variants. static void TransformToFastProperties(Handle object, int unused_property_fields); -- 2.7.4