[v8-dev] [v8] r20180 committed - Builtin helper function EnsureJSArrayWithWritableFastElements() handli...

codesite-noreply Mon, 24 Mar 2014 01:50:25 -0700

Revision: 20180
Author:   [email protected]
Date:     Mon Mar 24 08:48:36 2014 UTC

Log: Builtin helper function EnsureJSArrayWithWritableFastElements()handlified.


[email protected]

Review URL: https://codereview.chromium.org/208033002
http://code.google.com/p/v8/source/detail?r=20180

Modified:
 /branches/bleeding_edge/src/builtins.cc

=======================================
--- /branches/bleeding_edge/src/builtins.cc     Fri Mar 21 11:22:16 2014 UTC
+++ /branches/bleeding_edge/src/builtins.cc     Mon Mar 24 08:48:36 2014 UTC
@@ -300,33 +300,35 @@
 }


+// Returns empty handle if not applicable.
 MUST_USE_RESULT
-static inline MaybeObject* EnsureJSArrayWithWritableFastElements(
-    Heap* heap, Object* receiver, Arguments* args, int first_added_arg) {
-  if (!receiver->IsJSArray()) return NULL;
-  JSArray* array = JSArray::cast(receiver);
-  if (array->map()->is_observed()) return NULL;
-  if (!array->map()->is_extensible()) return NULL;
-  HeapObject* elms = array->elements();
+static inline Handle<FixedArrayBase> EnsureJSArrayWithWritableFastElements(
+    Isolate* isolate,
+    Handle<Object> receiver,
+    Arguments* args,
+    int first_added_arg) {
+  if (!receiver->IsJSArray()) return Handle<FixedArrayBase>::null();
+  Handle<JSArray> array = Handle<JSArray>::cast(receiver);
+  if (array->map()->is_observed()) return Handle<FixedArrayBase>::null();

+ if (!array->map()->is_extensible()) returnHandle<FixedArrayBase>::null();

+  Handle<FixedArrayBase> elms(array->elements());
+  Heap* heap = isolate->heap();
   Map* map = elms->map();
   if (map == heap->fixed_array_map()) {
     if (args == NULL || array->HasFastObjectElements()) return elms;
   } else if (map == heap->fixed_cow_array_map()) {

- MaybeObject* maybe_writable_result =array->EnsureWritableFastElements();

-    if (args == NULL || array->HasFastObjectElements() ||
-        !maybe_writable_result->To(&elms)) {
-      return maybe_writable_result;
-    }
+    elms = JSObject::EnsureWritableFastElements(array);
+    if (args == NULL || array->HasFastObjectElements()) return elms;
   } else if (map == heap->fixed_double_array_map()) {
     if (args == NULL) return elms;
   } else {
-    return NULL;
+    return Handle<FixedArrayBase>::null();
   }

   // Need to ensure that the arguments passed in args can be contained in
   // the array.
   int args_length = args->length();
-  if (first_added_arg >= args_length) return array->elements();
+  if (first_added_arg >= args_length) return handle(array->elements());

   ElementsKind origin_kind = array->map()->elements_kind();
   ASSERT(!IsFastObjectElementsKind(origin_kind));
@@ -345,26 +347,11 @@
     }
   }
   if (target_kind != origin_kind) {

- MaybeObject* maybe_failure =array->TransitionElementsKind(target_kind);

-    if (maybe_failure->IsFailure()) return maybe_failure;
-    return array->elements();
+    JSObject::TransitionElementsKind(array, target_kind);
+    return handle(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);
-}


 // TODO(ishell): Handlify when all Array* builtins are handlified.
@@ -409,12 +396,10 @@
 BUILTIN(ArrayPush) {
   HandleScope scope(isolate);
   Handle<Object> receiver = args.receiver();
-  Handle<Object> elms_or_null =

- EnsureJSArrayWithWritableFastElementsWrapper(isolate, receiver,&args, 1);

-  RETURN_IF_EMPTY_HANDLE(isolate, elms_or_null);

- if (*elms_or_null == NULL) return CallJsBuiltin(isolate, "ArrayPush",args);

+  Handle<FixedArrayBase> elms_obj =
+      EnsureJSArrayWithWritableFastElements(isolate, receiver, &args, 1);
+  if (elms_obj.is_null()) return CallJsBuiltin(isolate, "ArrayPush", args);