[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(x) ? true : false;                      \
+    } else if (std::isnan(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());
+
+  if (!args[0]->IsJSTypedArray()) {
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kNotTypedArray));
+  }
+
+  CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, target_obj, 0);
+
+  Handle<JSTypedArray> array = Handle<JSTypedArray>::cast(target_obj);
+
+  if (array->WasNeutered()) {
+    THROW_NEW_ERROR_RETURN_FAILURE(

[caitp, 2017/02/15 12:24:20]

So, as Dan was saying, we probably want to jist early return if neutered, and
make all cases throw simultaneously in the same CL.

[caitp, 2017/02/15 13:27:22]

To add to this, maybe move ValidateTypedArray() in builtins-typedarray to a
static inline JSTypedArray method (`MaybeHandle<JSTypedArray>
JSTypedArray::Validate(isolate, Handle<Object>) ...` or something like that?)
and use that instead of duplicating the logic here. That will make it easier to
do the "throw in all algorithms simultaneously" later

[Choongwoo Han, 2017/02/16 08:06:34]

Done. I've moved it to static inline method of JSTypedArray.

+        isolate, NewTypeError(MessageTemplate::kNotTypedArray));
+  }
+
+  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