[typedarrays] Implement %TypedArray%.prototype.reverse in C++

src/elements.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/elements.h"
 
 #include "src/arguments.h"
 #include "src/conversions.h"
 #include "src/factory.h"
 #include "src/isolate-inl.h"
@@ skipping 1215 matching lines @@
     UNREACHABLE();
     return Just<int64_t>(-1);
   }
 
   Maybe<int64_t> LastIndexOfValue(Isolate* isolate, Handle<JSObject> receiver,
                                   Handle<Object> value,
                                   uint32_t start_from) final {
     return Subclass::LastIndexOfValueImpl(isolate, receiver, value, start_from);
   }
 
+  static void ReverseImpl(Handle<JSObject> receiver) { UNREACHABLE(); }
+
+  void Reverse(Handle<JSObject> receiver) final {
+    Subclass::ReverseImpl(receiver);
+  }
+
   static uint32_t GetIndexForEntryImpl(FixedArrayBase* backing_store,
                                        uint32_t entry) {
     return entry;
   }
 
   static uint32_t GetEntryForIndexImpl(Isolate* isolate, JSObject* holder,
                                        FixedArrayBase* backing_store,
                                        uint32_t index, PropertyFilter filter) {
     uint32_t length = Subclass::GetMaxIndex(holder, backing_store);
     if (IsHoleyElementsKind(kind())) {
@@ skipping 1717 matching lines @@
 
     DCHECK_LT(start_from, elements->length());
 
     uint32_t k = start_from;
     do {
       ctype element_k = elements->get_scalar(k);
       if (element_k == typed_search_value) return Just<int64_t>(k);
     } while (k-- != 0);
     return Just<int64_t>(-1);
   }
+
+  static void ReverseImpl(Handle<JSObject> receiver) {
+    DisallowHeapAllocation no_gc;
+    DCHECK(!WasNeutered(*receiver));
+
+    BackingStore* elements = BackingStore::cast(receiver->elements());
+
+    uint32_t len = elements->length();
+    if (len == 0) return;
+
+    for (uint32_t i = 0, j = len - 1; i < j; i++, j--) {
+      ctype element_i = elements->get_scalar(i);
+      ctype element_j = elements->get_scalar(j);
+      elements->set(i, element_j);
+      elements->set(j, element_i);
+    }

[rongjie, 2017/03/19 06:47:52]

Why not try to use std::reverse on elements->DataPtr() instead? A win for both
correctness and performance.

[Choongwoo Han, 2017/03/19 09:30:31]

Done.

+  }
 };
 
 #define FIXED_ELEMENTS_ACCESSOR(Type, type, TYPE, ctype, size) \
   typedef TypedElementsAccessor<TYPE##_ELEMENTS, ctype>        \
       Fixed##Type##ElementsAccessor;
 
 TYPED_ARRAYS(FIXED_ELEMENTS_ACCESSOR)
 #undef FIXED_ELEMENTS_ACCESSOR
 
 template <typename Subclass, typename ArgumentsAccessor, typename KindTraits>
@@ skipping 935 matching lines @@
     insertion_index += len;
   }
 
   DCHECK_EQ(insertion_index, result_len);
   return result_array;
 }
 
 ElementsAccessor** ElementsAccessor::elements_accessors_ = NULL;
 }  // namespace internal
 }  // namespace v8