From d42146c8b88be221e9a6253b558f8784e3033418 Mon Sep 17 00:00:00 2001 From: "yangguo@chromium.org" Date: Mon, 14 Apr 2014 14:34:37 +0000 Subject: [PATCH] Revert "Handlify DebugLookupResultValue." This reverts r20729. TBR=jarin@chromium.org Review URL: https://codereview.chromium.org/237093003 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20732 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/objects.cc | 4 +-- src/runtime.cc | 109 ++++++++++++++++++++++++++++++++++----------------------- 2 files changed, 68 insertions(+), 45 deletions(-) diff --git a/src/objects.cc b/src/objects.cc index 736854b..73b8c23 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -811,8 +811,8 @@ MaybeHandle Object::GetProperty(Handle object, Handle value; switch (result->type()) { case NORMAL: { - value = JSObject::GetNormalizedProperty( - handle(result->holder(), isolate), result); + DisallowHeapAllocation no_gc; + value = handle(result->holder()->GetNormalizedProperty(result), isolate); break; } case FIELD: diff --git a/src/runtime.cc b/src/runtime.cc index 54cd3a0..2975ebe 100644 --- a/src/runtime.cc +++ b/src/runtime.cc @@ -10714,49 +10714,63 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_Break) { } -static Handle DebugLookupResultValue(Isolate* isolate, - Handle receiver, - Handle name, - LookupResult* result, - bool* has_caught = NULL) { - Handle value = isolate->factory()->undefined_value(); - if (!result->IsFound()) return value; +static MaybeObject* DebugLookupResultValue(Heap* heap, + Object* receiver, + Name* name, + LookupResult* result, + bool* caught_exception) { + Object* value; + if (result->IsTransition()) return heap->undefined_value(); switch (result->type()) { case NORMAL: - value = JSObject::GetNormalizedProperty( - handle(result->holder(), isolate), result); - break; - case FIELD: - value = JSObject::FastPropertyAt(handle(result->holder(), isolate), - result->representation(), - result->GetFieldIndex().field_index()); - break; + value = result->holder()->GetNormalizedProperty(result); + if (value->IsTheHole()) { + return heap->undefined_value(); + } + return value; + case FIELD: { + Object* value; + MaybeObject* maybe_value = + JSObject::cast(result->holder())->FastPropertyAt( + result->representation(), + result->GetFieldIndex().field_index()); + if (!maybe_value->To(&value)) return maybe_value; + if (value->IsTheHole()) { + return heap->undefined_value(); + } + return value; + } case CONSTANT: - return handle(result->GetConstant(), isolate); + return result->GetConstant(); case CALLBACKS: { - Handle structure(result->GetCallbackObject(), isolate); + Object* structure = result->GetCallbackObject(); if (structure->IsForeign() || structure->IsAccessorInfo()) { - MaybeHandle obj = JSObject::GetPropertyWithCallback( - handle(result->holder(), isolate), receiver, structure, name); - if (!obj.ToHandle(&value)) { - value = handle(isolate->pending_exception(), isolate); - isolate->clear_pending_exception(); - if (has_caught != NULL) *has_caught = true; - return value; - } + Isolate* isolate = heap->isolate(); + HandleScope scope(isolate); + MaybeHandle maybe_value = JSObject::GetPropertyWithCallback( + handle(result->holder(), isolate), + handle(receiver, isolate), + handle(structure, isolate), + handle(name, isolate)); + Handle value; + if (maybe_value.ToHandle(&value)) return *value; + Object* exception = heap->isolate()->pending_exception(); + heap->isolate()->clear_pending_exception(); + if (caught_exception != NULL) *caught_exception = true; + return exception; + } else { + return heap->undefined_value(); } - break; } case INTERCEPTOR: - break; + return heap->undefined_value(); case HANDLER: case NONEXISTENT: UNREACHABLE(); - break; + return heap->undefined_value(); } - ASSERT(!value->IsTheHole() || result->IsReadOnly()); - return value->IsTheHole() - ? Handle::cast(isolate->factory()->undefined_value()) : value; + UNREACHABLE(); // keep the compiler happy + return heap->undefined_value(); } @@ -10830,23 +10844,29 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugGetPropertyDetails) { result_callback_obj = Handle(result.GetCallbackObject(), isolate); } - - - bool has_caught; - Handle value = DebugLookupResultValue( - isolate, obj, name, &result, &has_caught); + Smi* property_details = result.GetPropertyDetails().AsSmi(); + // DebugLookupResultValue can cause GC so details from LookupResult needs + // to be copied to handles before this. + bool caught_exception = false; + Object* raw_value; + { MaybeObject* maybe_raw_value = + DebugLookupResultValue(isolate->heap(), *obj, *name, + &result, &caught_exception); + if (!maybe_raw_value->ToObject(&raw_value)) return maybe_raw_value; + } + Handle value(raw_value, isolate); // If the callback object is a fixed array then it contains JavaScript // getter and/or setter. - bool has_js_accessors = result.IsPropertyCallbacks() && - result_callback_obj->IsAccessorPair(); + bool hasJavaScriptAccessors = result.IsPropertyCallbacks() && + result_callback_obj->IsAccessorPair(); Handle details = - isolate->factory()->NewFixedArray(has_js_accessors ? 5 : 2); + isolate->factory()->NewFixedArray(hasJavaScriptAccessors ? 5 : 2); details->set(0, *value); - details->set(1, result.GetPropertyDetails().AsSmi()); - if (has_js_accessors) { + details->set(1, property_details); + if (hasJavaScriptAccessors) { AccessorPair* accessors = AccessorPair::cast(*result_callback_obj); - details->set(2, isolate->heap()->ToBoolean(has_caught)); + details->set(2, isolate->heap()->ToBoolean(caught_exception)); details->set(3, accessors->GetComponent(ACCESSOR_GETTER)); details->set(4, accessors->GetComponent(ACCESSOR_SETTER)); } @@ -10872,7 +10892,10 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugGetProperty) { LookupResult result(isolate); obj->Lookup(*name, &result); - return *DebugLookupResultValue(isolate, obj, name, &result); + if (result.IsFound()) { + return DebugLookupResultValue(isolate->heap(), *obj, *name, &result, NULL); + } + return isolate->heap()->undefined_value(); } -- 2.7.4