[typedarrays] sort in C++ for undefined comparefn

src/runtime/runtime-typedarray.cc

 // Copyright 2014 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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/factory.h"
 #include "src/messages.h"
 #include "src/objects-inl.h"
@@ skipping 349 matching lines @@
        target_base + target_byte_length > source_base)) {
     // We do not support overlapping ArrayBuffers
     DCHECK(target->GetBuffer()->backing_store() ==
            source->GetBuffer()->backing_store());
     return Smi::FromInt(TYPED_ARRAY_SET_TYPED_ARRAY_OVERLAPPING);
   } else {  // Non-overlapping typed arrays
     return Smi::FromInt(TYPED_ARRAY_SET_TYPED_ARRAY_NONOVERLAPPING);
   }
 }
 
+namespace {
+
+#define TYPED_ARRAY_SORT_COMPAREFN(Type, type, TYPE, ctype, size) \
+  bool compare##Type(ctype x, ctype y) {                          \
+    if (x < y) {                                                  \
+      return true;                                                \
+    } else if (x > y) {                                           \
+      return false;                                               \
+    } else if (x == 0 && x == y) {                                \
+      return std::signbit(static_cast<double>(x)) ? true : false; \
+    } else if (std::isnan(static_cast<double>(x))) {              \
+      return false;                                               \
+    }                                                             \
+    return true;                                                  \
+  }
+
+TYPED_ARRAYS(TYPED_ARRAY_SORT_COMPAREFN)
+#undef TYPED_ARRAY_SORT_COMPAREFN
+
+}  // namespace
+
+RUNTIME_FUNCTION(Runtime_TypedArraySortFast) {
+  HandleScope scope(isolate);
+  DCHECK_EQ(1, args.length());
+
+  CONVERT_ARG_HANDLE_CHECKED(Object, target_obj, 0);
+
+  Handle<JSTypedArray> array;
+  const char* method = "%TypedArray%.prototype.sort";
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+      isolate, array, JSTypedArray::Validate(isolate, target_obj, method));
+
+  // This line can be remove when JSTypedArray::Validate throws
+  // if array.[[ViewedArrayBuffer]] is neutered(v8:4648)
+  if (V8_UNLIKELY(array->WasNeutered())) return *array;
+
+  size_t length = array->length_value();
+  if (length == 0) return *array;
+
+  switch (array->type()) {
+#define TYPED_ARRAY_SORT(Type, type, TYPE, ctype, size)              \
+  case kExternal##Type##Array: {                                     \
+    ctype* backing_store =                                           \
+        static_cast<ctype*>(array->GetBuffer()->backing_store());    \
+    std::sort(backing_store, backing_store + length, compare##Type); \
+    break;                                                           \
+  }
+
+    TYPED_ARRAYS(TYPED_ARRAY_SORT)
+#undef TYPED_ARRAY_SORT
+  }
+
+  return *array;
+}
 
 RUNTIME_FUNCTION(Runtime_TypedArrayMaxSizeInHeap) {
   DCHECK_EQ(0, args.length());
   DCHECK_OBJECT_SIZE(FLAG_typed_array_max_size_in_heap +
                      FixedTypedArrayBase::kDataOffset);
   return Smi::FromInt(FLAG_typed_array_max_size_in_heap);
 }
 
 
 RUNTIME_FUNCTION(Runtime_IsTypedArray) {
@@ skipping 34 matching lines @@
     return isolate->heap()->false_value();
   }
 
   Handle<JSTypedArray> obj(JSTypedArray::cast(args[0]));
   return isolate->heap()->ToBoolean(obj->GetBuffer()->is_shared() &&
                                     obj->type() == kExternalInt32Array);
 }
 
 }  // namespace internal
 }  // namespace v8