[typedarrays] No callbacks for fast sorting of integer typed arrays

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 318 matching lines @@
     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 {                                                      \
-      double _x = x, _y = y;                                      \
-      if (x == 0 && x == y) {                                     \
-        /* -0.0 is less than +0.0 */                              \
-        return std::signbit(_x) && !std::signbit(_y);             \
-      } else if (!std::isnan(_x) && std::isnan(_y)) {             \
-        /* number is less than NaN */                             \
-        return true;                                              \
-      }                                                           \
-    }                                                             \
-    return false;                                                 \
+template <typename T>
+bool CompareNum(T x, T y) {
+  if (x < y) {
+    return true;
+  } else if (x > y) {
+    return false;
+  } else if (!std::is_integral<T>::value) {
+    double _x = x, _y = y;
+    if (x == 0 && x == y) {
+      /* -0.0 is less than +0.0 */
+      return std::signbit(_x) && !std::signbit(_y);
+    } else if (!std::isnan(_x) && std::isnan(_y)) {
+      /* number is less than NaN */
+      return true;
+    }
   }
-
-TYPED_ARRAYS(TYPED_ARRAY_SORT_COMPAREFN)
-#undef TYPED_ARRAY_SORT_COMPAREFN
+  return false;
+}
 
 }  // 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 removed 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;
+  if (length <= 1) 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;                                                           \
+#define TYPED_ARRAY_SORT(Type, type, TYPE, ctype, size)                    \
+  case kExternal##Type##Array: {                                           \
+    ctype* backing_store =                                                 \
+        static_cast<ctype*>(array->GetBuffer()->backing_store());          \
+    if (kExternal##Type##Array == kExternalFloat64Array ||                 \
+        kExternal##Type##Array == kExternalFloat32Array)                   \
+      std::sort(backing_store, backing_store + length, CompareNum<ctype>); \
+    else                                                                   \
+      std::sort(backing_store, backing_store + length);                    \
+    break;                                                                 \
   }
 
     TYPED_ARRAYS(TYPED_ARRAY_SORT)
 #undef TYPED_ARRAY_SORT
   }
 
   return *array;
 }
 
 RUNTIME_FUNCTION(Runtime_TypedArrayMaxSizeInHeap) {
@@ skipping 42 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