From: mstarzinger@chromium.org Date: Mon, 9 Sep 2013 14:29:47 +0000 (+0000) Subject: Handlify JSObject::EnsureCanContainHeapObjectElements method. X-Git-Tag: upstream/4.7.83~12609 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=1a26455d22e2f4893a042978fce2e7247be6c007;p=platform%2Fupstream%2Fv8.git Handlify JSObject::EnsureCanContainHeapObjectElements method. R=verwaest@chromium.org Review URL: https://codereview.chromium.org/23818005 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16595 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/factory.cc b/src/factory.cc index c7f7806..be85a73 100644 --- a/src/factory.cc +++ b/src/factory.cc @@ -1081,13 +1081,6 @@ void Factory::SetContent(Handle array, } -void Factory::EnsureCanContainHeapObjectElements(Handle array) { - CALL_HEAP_FUNCTION_VOID( - isolate(), - array->EnsureCanContainHeapObjectElements()); -} - - void Factory::EnsureCanContainElements(Handle array, Handle elements, uint32_t length, diff --git a/src/factory.h b/src/factory.h index e592020..fc48b32 100644 --- a/src/factory.h +++ b/src/factory.h @@ -328,7 +328,6 @@ class Factory { void SetContent(Handle array, Handle elements); - void EnsureCanContainHeapObjectElements(Handle array); void EnsureCanContainElements(Handle array, Handle elements, uint32_t length, diff --git a/src/objects-inl.h b/src/objects-inl.h index 8a3cbec..9f68c4f 100644 --- a/src/objects-inl.h +++ b/src/objects-inl.h @@ -1353,17 +1353,16 @@ inline bool AllocationSite::CanTrack(InstanceType type) { } -MaybeObject* JSObject::EnsureCanContainHeapObjectElements() { - ValidateElements(); - ElementsKind elements_kind = map()->elements_kind(); +void JSObject::EnsureCanContainHeapObjectElements(Handle object) { + object->ValidateElements(); + ElementsKind elements_kind = object->map()->elements_kind(); if (!IsFastObjectElementsKind(elements_kind)) { if (IsFastHoleyElementsKind(elements_kind)) { - return TransitionElementsKind(FAST_HOLEY_ELEMENTS); + TransitionElementsKind(object, FAST_HOLEY_ELEMENTS); } else { - return TransitionElementsKind(FAST_ELEMENTS); + TransitionElementsKind(object, FAST_ELEMENTS); } } - return this; } diff --git a/src/objects.cc b/src/objects.cc index ca10394..253405a 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -4458,27 +4458,17 @@ void NormalizedMapCache::Clear() { void JSObject::UpdateMapCodeCache(Handle object, Handle name, Handle code) { - Isolate* isolate = object->GetIsolate(); - CALL_HEAP_FUNCTION_VOID(isolate, - object->UpdateMapCodeCache(*name, *code)); -} - - -MaybeObject* JSObject::UpdateMapCodeCache(Name* name, Code* code) { - if (map()->is_shared()) { + Handle map(object->map()); + if (map->is_shared()) { // Fast case maps are never marked as shared. - ASSERT(!HasFastProperties()); + ASSERT(!object->HasFastProperties()); // Replace the map with an identical copy that can be safely modified. - Object* obj; - { MaybeObject* maybe_obj = map()->CopyNormalized(KEEP_INOBJECT_PROPERTIES, - UNIQUE_NORMALIZED_MAP); - if (!maybe_obj->ToObject(&obj)) return maybe_obj; - } - GetIsolate()->counters()->normalized_maps()->Increment(); - - set_map(Map::cast(obj)); + map = Map::CopyNormalized(map, KEEP_INOBJECT_PROPERTIES, + UNIQUE_NORMALIZED_MAP); + object->GetIsolate()->counters()->normalized_maps()->Increment(); + object->set_map(*map); } - return map()->UpdateCodeCache(name, code); + Map::UpdateCodeCache(map, name, code); } @@ -6510,6 +6500,15 @@ MaybeObject* Map::RawCopy(int instance_size) { } +Handle Map::CopyNormalized(Handle map, + PropertyNormalizationMode mode, + NormalizedMapSharingMode sharing) { + CALL_HEAP_FUNCTION(map->GetIsolate(), + map->CopyNormalized(mode, sharing), + Map); +} + + MaybeObject* Map::CopyNormalized(PropertyNormalizationMode mode, NormalizedMapSharingMode sharing) { int new_instance_size = instance_size(); @@ -9523,21 +9522,13 @@ bool JSFunction::IsInlineable() { void JSObject::OptimizeAsPrototype(Handle object) { - CALL_HEAP_FUNCTION_VOID(object->GetIsolate(), object->OptimizeAsPrototype()); -} - - -MaybeObject* JSObject::OptimizeAsPrototype() { - if (IsGlobalObject()) return this; + if (object->IsGlobalObject()) return; // Make sure prototypes are fast objects and their maps have the bit set // so they remain fast. - if (!HasFastProperties()) { - MaybeObject* new_proto = TransformToFastProperties(0); - if (new_proto->IsFailure()) return new_proto; - ASSERT(new_proto == this); + if (!object->HasFastProperties()) { + TransformToFastProperties(object, 0); } - return this; } diff --git a/src/objects.h b/src/objects.h index 97d1e5d..82c4bf1 100644 --- a/src/objects.h +++ b/src/objects.h @@ -2220,7 +2220,6 @@ class JSObject: public JSReceiver { PropertyDetails details); static void OptimizeAsPrototype(Handle object); - MUST_USE_RESULT MaybeObject* OptimizeAsPrototype(); // Retrieve interceptors. InterceptorInfo* GetNamedInterceptor(); @@ -2314,7 +2313,7 @@ class JSObject: public JSReceiver { inline void ValidateElements(); // Makes sure that this object can contain HeapObject as elements. - MUST_USE_RESULT inline MaybeObject* EnsureCanContainHeapObjectElements(); + static inline void EnsureCanContainHeapObjectElements(Handle obj); // Makes sure that this object can contain the specified elements. MUST_USE_RESULT inline MaybeObject* EnsureCanContainElements( @@ -2569,8 +2568,6 @@ class JSObject: public JSReceiver { Handle name, Handle code); - MUST_USE_RESULT MaybeObject* UpdateMapCodeCache(Name* name, Code* code); - // Transform slow named properties to fast variants. // Returns failure if allocation failed. static void TransformToFastProperties(Handle object, @@ -5794,6 +5791,9 @@ class Map: public HeapObject { TransitionFlag flag); MUST_USE_RESULT MaybeObject* CopyForObserved(); + static Handle CopyNormalized(Handle map, + PropertyNormalizationMode mode, + NormalizedMapSharingMode sharing); MUST_USE_RESULT MaybeObject* CopyNormalized(PropertyNormalizationMode mode, NormalizedMapSharingMode sharing); diff --git a/src/runtime.cc b/src/runtime.cc index 56558e0..1eff289 100644 --- a/src/runtime.cc +++ b/src/runtime.cc @@ -6551,8 +6551,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StringSplit) { int part_count = indices.length(); Handle result = isolate->factory()->NewJSArray(part_count); - MaybeObject* maybe_result = result->EnsureCanContainHeapObjectElements(); - if (maybe_result->IsFailure()) return maybe_result; + JSObject::EnsureCanContainHeapObjectElements(result); result->set_length(Smi::FromInt(part_count)); ASSERT(result->HasFastObjectElements()); @@ -6945,21 +6944,20 @@ static inline void StringBuilderConcatHelper(String* special, RUNTIME_FUNCTION(MaybeObject*, Runtime_StringBuilderConcat) { - SealHandleScope shs(isolate); + HandleScope scope(isolate); ASSERT(args.length() == 3); - CONVERT_ARG_CHECKED(JSArray, array, 0); + CONVERT_ARG_HANDLE_CHECKED(JSArray, array, 0); if (!args[1]->IsSmi()) { isolate->context()->mark_out_of_memory(); return Failure::OutOfMemoryException(0x14); } int array_length = args.smi_at(1); - CONVERT_ARG_CHECKED(String, special, 2); + CONVERT_ARG_HANDLE_CHECKED(String, special, 2); // This assumption is used by the slice encoding in one or two smis. ASSERT(Smi::kMaxValue >= String::kMaxLength); - MaybeObject* maybe_result = array->EnsureCanContainHeapObjectElements(); - if (maybe_result->IsFailure()) return maybe_result; + JSObject::EnsureCanContainHeapObjectElements(array); int special_length = special->length(); if (!array->HasFastObjectElements()) { @@ -7041,7 +7039,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StringBuilderConcat) { if (!maybe_object->ToObject(&object)) return maybe_object; } SeqOneByteString* answer = SeqOneByteString::cast(object); - StringBuilderConcatHelper(special, + StringBuilderConcatHelper(*special, answer->GetChars(), fixed_array, array_length); @@ -7052,7 +7050,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StringBuilderConcat) { if (!maybe_object->ToObject(&object)) return maybe_object; } SeqTwoByteString* answer = SeqTwoByteString::cast(object); - StringBuilderConcatHelper(special, + StringBuilderConcatHelper(*special, answer->GetChars(), fixed_array, array_length); @@ -9411,9 +9409,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DateParseString) { CONVERT_ARG_HANDLE_CHECKED(JSArray, output, 1); - MaybeObject* maybe_result_array = - output->EnsureCanContainHeapObjectElements(); - if (maybe_result_array->IsFailure()) return maybe_result_array; + JSObject::EnsureCanContainHeapObjectElements(output); RUNTIME_ASSERT(output->HasFastObjectElements()); DisallowHeapAllocation no_gc;