ArrayPop builtin handlified.

src/builtins.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 335 matching lines @@
   }
   if (target_kind != origin_kind) {
     MaybeObject* maybe_failure = array->TransitionElementsKind(target_kind);
     if (maybe_failure->IsFailure()) return maybe_failure;
     return array->elements();
   }
   return elms;
 }
 
 
+// TODO(ishell): Temporary wrapper until handlified.
+MUST_USE_RESULT
+static inline Handle<Object> EnsureJSArrayWithWritableFastElementsWrapper(
+    Isolate* isolate,
+    Handle<Object> receiver,
+    Arguments* args,
+    int first_added_arg) {
+  CALL_HEAP_FUNCTION(isolate,
+                     EnsureJSArrayWithWritableFastElements(
+                         isolate->heap(), *receiver, args, first_added_arg),
+                     Object);
+}
+
+
 static inline bool IsJSArrayFastElementMovingAllowed(Heap* heap,
                                                      JSArray* receiver) {
   if (!FLAG_clever_optimizations) return false;
   Context* native_context = heap->isolate()->context()->native_context();
   JSObject* array_proto =
       JSObject::cast(native_context->array_function()->prototype());
   return receiver->GetPrototype() == array_proto &&
          ArrayPrototypeHasNoElements(heap, native_context, array_proto);
 }
 
@@ skipping 133 matching lines @@
       array->set_elements(new_elms);
     }
 
     // Set the length.
     array->set_length(Smi::FromInt(new_length));
     return Smi::FromInt(new_length);
   }
 }
 
 
+// TODO(ishell): Temporary wrapper until handlified.
+static bool ElementsAccessorHasElementWrapper(
+    ElementsAccessor* accessor,
+    Handle<Object> receiver,
+    Handle<JSObject> holder,
+    uint32_t key,
+    Handle<FixedArrayBase> backing_store = Handle<FixedArrayBase>::null()) {
+  return accessor->HasElement(*receiver, *holder, key,
+                              backing_store.is_null() ? *backing_store : NULL);
+}
+
+
+// TODO(ishell): Temporary wrapper until handlified.
+static Handle<Object> ElementsAccessorGetWrapper(
+    Isolate* isolate,
+    ElementsAccessor* accessor,
+    Handle<Object> receiver,
+    Handle<JSObject> holder,
+    uint32_t key,
+    Handle<FixedArrayBase> backing_store = Handle<FixedArrayBase>::null()) {
+  CALL_HEAP_FUNCTION(isolate,
+                     accessor->Get(*receiver, *holder, key,
+                                   backing_store.is_null()
+                                   ? *backing_store : NULL),
+                     Object);
+}
+
+
+// TODO(ishell): Temporary wrapper until handlified.
 static Handle<Object> ElementsAccessorSetLengthWrapper(
     Isolate* isolate,
     ElementsAccessor* accessor,
     Handle<JSArray> array,
     int new_length) {
   CALL_HEAP_FUNCTION(isolate,
                      accessor->SetLength(*array, Smi::FromInt(new_length)),
                      Object);
 }
 
 
 BUILTIN(ArrayPop) {
-  Heap* heap = isolate->heap();
-  Object* receiver = *args.receiver();
-  FixedArrayBase* elms_obj;
-  MaybeObject* maybe_elms =
-      EnsureJSArrayWithWritableFastElements(heap, receiver, NULL, 0);
-  if (maybe_elms == NULL) return CallJsBuiltin(isolate, "ArrayPop", args);
-  if (!maybe_elms->To(&elms_obj)) return maybe_elms;
+  HandleScope scope(isolate);
+  Handle<Object> receiver = args.receiver();
+  Handle<Object> maybe_elms =

[Yang, 2014/03/19 15:06:30]

name is confusing. It's not a MaybeObject.

+      EnsureJSArrayWithWritableFastElementsWrapper(isolate, receiver, NULL, 0);
+  RETURN_IF_EMPTY_HANDLE(isolate, maybe_elms);
+  if (*maybe_elms == NULL) return CallJsBuiltin(isolate, "ArrayPop", args);
 
-  JSArray* array = JSArray::cast(receiver);
+  Handle<FixedArrayBase> elms_obj = Handle<FixedArrayBase>::cast(maybe_elms);
+  Handle<JSArray> array = Handle<JSArray>::cast(receiver);
   ASSERT(!array->map()->is_observed());
 
   int len = Smi::cast(array->length())->value();
-  if (len == 0) return heap->undefined_value();
+  if (len == 0) return isolate->heap()->undefined_value();
 
   ElementsAccessor* accessor = array->GetElementsAccessor();
   int new_length = len - 1;
-  if (accessor->HasElement(array, array, new_length, elms_obj)) {
-    MaybeObject* maybe_result =
-        accessor->Get(array, array, new_length, elms_obj);
-    if (maybe_result->IsFailure()) return maybe_result;
-    MaybeObject* maybe_failure =
-        accessor->SetLength(array, Smi::FromInt(new_length));
-    if (maybe_failure->IsFailure()) return maybe_failure;
-    return maybe_result;
+  Handle<Object> element;
+  if (ElementsAccessorHasElementWrapper(
+      accessor, array, array, new_length, elms_obj)) {
+    element = ElementsAccessorGetWrapper(
+        isolate, accessor, array, array, new_length, elms_obj);
   } else {
-    // TODO(yangguo): handlify all once ElementsAccessors are handlified.
-    HandleScope scope(isolate);
     Handle<Object> proto(array->GetPrototype(), isolate);
-    Handle<Object> element = Object::GetElement(isolate, proto, len - 1);
-    RETURN_IF_EMPTY_HANDLE(isolate, element);
-    Handle<JSArray> array_handle(array, isolate);
-    RETURN_IF_EMPTY_HANDLE(isolate,
-                           ElementsAccessorSetLengthWrapper(
-                               isolate, accessor, array_handle, new_length));
-    return *element;
+    element = Object::GetElement(isolate, proto, len - 1);
   }
+  RETURN_IF_EMPTY_HANDLE(isolate, element);
+  RETURN_IF_EMPTY_HANDLE(isolate,
+                         ElementsAccessorSetLengthWrapper(
+                             isolate, accessor, array, new_length));
+  return *element;
 }
 
 
 BUILTIN(ArrayShift) {
   Heap* heap = isolate->heap();
   Object* receiver = *args.receiver();
   FixedArrayBase* elms_obj;
   MaybeObject* maybe_elms_obj =
       EnsureJSArrayWithWritableFastElements(heap, receiver, NULL, 0);
   if (maybe_elms_obj == NULL)
@@ skipping 1190 matching lines @@
 }
 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C)
 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A)
 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 
 
 } }  // namespace v8::internal