Issue #2026 - Part 1 - Implement BigInt64 and BigUint64Array.

https://bugzilla.mozilla.org/show_bug.cgi?id=1456569

1 files changed, 334 insertions, 120 deletions

diff --git a/js/src/vm/TypedArrayObject.cpp b/js/src/vm/TypedArrayObject.cpp
index ac93ec9b14..28e4090eb8 100644
--- a/js/src/vm/TypedArrayObject.cpp
+++ b/js/src/vm/TypedArrayObject.cpp
@@ -65,6 +65,33 @@ using JS::ToUint32;
  * the subclasses.
  */
 
+bool TypedArrayObject::convertForSideEffect(JSContext* cx, HandleValue v) const
+{
+    switch (type()) {
+        case Scalar::BigInt64:
+        case Scalar::BigUint64: {
+            return ToBigInt(cx, v) != nullptr;
+        }
+        case Scalar::Int8:
+        case Scalar::Uint8:
+        case Scalar::Int16:
+        case Scalar::Uint16:
+        case Scalar::Int32:
+        case Scalar::Uint32:
+        case Scalar::Float32:
+        case Scalar::Float64:
+        case Scalar::Uint8Clamped: {
+            double ignore;
+            return ToNumber(cx, v, &ignore);
+        }
+        case Scalar::MaxTypedArrayViewType:
+        case Scalar::Int64:
+            MOZ_CRASH("Unsupported TypedArray type");
+    }
+    MOZ_ASSERT_UNREACHABLE("Invalid scalar type");
+    return false;
+}
+
 /* static */ int
 TypedArrayObject::lengthOffset()
 {
@@ -414,30 +441,7 @@ class TypedArrayObjectTemplate : public TypedArrayObject
         return v.isObject() && v.toObject().hasClass(instanceClass());
     }
 
-    static void
-    setIndexValue(TypedArrayObject& tarray, uint32_t index, double d)
-    {
-        // If the array is an integer array, we only handle up to
-        // 32-bit ints from this point on.  if we want to handle
-        // 64-bit ints, we'll need some changes.
-
-        // Assign based on characteristics of the destination type
-        if (ArrayTypeIsFloatingPoint()) {
-            setIndex(tarray, index, NativeType(d));
-        } else if (ArrayTypeIsUnsigned()) {
-            MOZ_ASSERT(sizeof(NativeType) <= 4);
-            uint32_t n = ToUint32(d);
-            setIndex(tarray, index, NativeType(n));
-        } else if (ArrayTypeID() == Scalar::Uint8Clamped) {
-            // The uint8_clamped type has a special rounding converter
-            // for doubles.
-            setIndex(tarray, index, NativeType(d));
-        } else {
-            MOZ_ASSERT(sizeof(NativeType) <= 4);
-            int32_t n = ToInt32(d);
-            setIndex(tarray, index, NativeType(n));
-        }
-    }
+    static bool convertValue(JSContext* cx, HandleValue v, NativeType* result);
 
     static TypedArrayObject*
     makeProtoInstance(JSContext* cx, HandleObject proto, AllocKind allocKind)
@@ -1001,9 +1005,128 @@ class TypedArrayObjectTemplate : public TypedArrayObject
         jit::AtomicOperations::storeSafeWhenRacy(tarray.viewDataEither().cast<NativeType*>() + index, val);
     }
 
-    static Value getIndexValue(JSObject* tarray, uint32_t index);
+    static bool getElement(ExclusiveContext* cx, TypedArrayObject* tarray, uint32_t index, MutableHandleValue val);
+    static bool getElementPure(TypedArrayObject* tarray, uint32_t index, Value* vp);
+
+    static bool setElement(JSContext* cx, Handle<TypedArrayObject*> obj, uint64_t index, HandleValue v, 
+                           ObjectOpResult& result);
+    static bool defineElement(JSContext* cx, HandleObject obj, uint64_t index, HandleValue v, 
+                              ObjectOpResult& result);
 };
 
+template <typename NativeType>
+bool TypedArrayObjectTemplate<NativeType>::convertValue(JSContext* cx, HandleValue v, NativeType* result)
+{
+    double d;
+    if (!ToNumber(cx, v, &d)) {
+        return false;
+    }
+
+#ifdef JS_MORE_DETERMINISTIC
+    // See the comment in ElementSpecific::doubleToNative.
+    d = JS::CanonicalizeNaN(d);
+#endif
+
+    // Assign based on characteristics of the destination type
+    if (ArrayTypeIsFloatingPoint()) {
+        *result = NativeType(d);
+    } else if (ArrayTypeIsUnsigned()) {
+        MOZ_ASSERT(sizeof(NativeType) <= 4);
+        uint32_t n = ToUint32(d);
+        *result = NativeType(n);
+    } else if (ArrayTypeID() == Scalar::Uint8Clamped) {
+        // The uint8_clamped type has a special rounding converter
+        // for doubles.
+        *result = NativeType(d);
+    } else {
+        MOZ_ASSERT(sizeof(NativeType) <= 4);
+        int32_t n = ToInt32(d);
+        *result = NativeType(n);
+    }
+    return true;
+}
+
+template <>
+bool TypedArrayObjectTemplate<int64_t>::convertValue(JSContext* cx, HandleValue v, int64_t* result)
+{
+    JS_TRY_VAR_OR_RETURN_FALSE(cx, *result, ToBigInt64(cx, v));
+    return true;
+}
+
+template <>
+bool TypedArrayObjectTemplate<uint64_t>::convertValue(JSContext* cx, HandleValue v, uint64_t* result)
+{
+    JS_TRY_VAR_OR_RETURN_FALSE(cx, *result, ToBigUint64(cx, v));
+    return true;
+}
+
+// https://tc39.github.io/proposal-bigint/#sec-integerindexedelementset
+// 7.8 IntegerIndexedElementSet ( O, index, value )
+template <typename NativeType>
+/* static */ bool TypedArrayObjectTemplate<NativeType>::setElement(
+    JSContext* cx, Handle<TypedArrayObject*> obj, uint64_t index, HandleValue v,
+    ObjectOpResult& result)
+{
+    // Steps 1-2 are enforced by the caller.
+
+    // Steps 3-6.
+    NativeType nativeValue;
+    if (!convertValue(cx, v, &nativeValue)) {
+        return false;
+    }
+
+    // Step 8.
+    if (obj->hasDetachedBuffer()) {
+        return result.failSoft(JSMSG_TYPED_ARRAY_DETACHED);
+    }
+
+    // Steps 9-10 are enforced by the caller.
+
+    // Step 11.
+    uint32_t length = obj->length();
+
+    // Step 12.
+    if (index >= length) {
+        return result.failSoft(JSMSG_BAD_INDEX);
+    }
+
+    // Steps 7, 13-16.
+    TypedArrayObjectTemplate<NativeType>::setIndex(*obj, index, nativeValue);
+
+    // Step 17.
+    return result.succeed();
+}
+
+// Version of IntegerIndexedElementSet with no length check, used in
+// [[DefineOwnProperty]]
+template <typename NativeType>
+/* static */ bool TypedArrayObjectTemplate<NativeType>::defineElement(
+    JSContext* cx, HandleObject obj, uint64_t index, HandleValue v,
+    ObjectOpResult& result)
+{
+    // Steps 1-2 are enforced by the caller.
+
+    // Steps 3-6.
+    NativeType nativeValue;
+    if (!convertValue(cx, v, &nativeValue)) {
+        return false;
+    }
+
+    // Step 8.
+    if (obj->as<TypedArrayObject>().hasDetachedBuffer()) {
+        return result.fail(JSMSG_TYPED_ARRAY_DETACHED);
+    }
+
+    // Steps 9-12 are enforced by the caller.
+
+    // Steps 7, 13-16.
+    TypedArrayObjectTemplate<NativeType>::setIndex(obj->as<TypedArrayObject>(),
+                                                   index, nativeValue);
+
+    // Step 17.
+    return result.succeed();
+}
+
 #define CREATE_TYPE_FOR_TYPED_ARRAY(T, N) \
     typedef TypedArrayObjectTemplate<T> N##Array;
 JS_FOR_EACH_TYPED_ARRAY(CREATE_TYPE_FOR_TYPED_ARRAY)
@@ -1240,6 +1363,13 @@ TypedArrayObjectTemplate<T>::fromTypedArray(JSContext* cx, HandleObject other, b
         }
     }
 
+    // BigInt proposal 7.24, step 19.c.
+    if (Scalar::isBigIntType(ArrayTypeID()) !=
+        Scalar::isBigIntType(srcArray->type())) {
+        JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_BIGINT);
+        return nullptr;
+    }
+
     // Steps 3-4 (remaining part), 18-21.
     Rooted<TypedArrayObject*> obj(cx, makeInstance(cx, buffer, 0, elementLength, proto));
     if (!obj)
@@ -1584,40 +1714,43 @@ ArrayBufferObject::createTypedArrayFromBuffer(JSContext* cx, unsigned argc, Valu
     return CallNonGenericMethod<IsAnyArrayBuffer, createTypedArrayFromBufferImpl<T> >(cx, args);
 }
 
-// this default implementation is only valid for integer types
-// less than 32-bits in size.
+// This default implementation is only valid for integer types less
+// than 32-bits in size.
 template<typename NativeType>
-Value
-TypedArrayObjectTemplate<NativeType>::getIndexValue(JSObject* tarray, uint32_t index)
+bool
+TypedArrayObjectTemplate<NativeType>::getElementPure(TypedArrayObject* tarray, uint32_t index, Value* vp)
 {
     static_assert(sizeof(NativeType) < 4,
                   "this method must only handle NativeType values that are "
                   "always exact int32_t values");
 
-    return Int32Value(getIndex(tarray, index));
+    *vp = Int32Value(getIndex(tarray, index));
+    return true;
 }
 
 namespace {
 
-// and we need to specialize for 32-bit integers and floats
+// We need to specialize for floats and other integer types.
 template<>
-Value
-TypedArrayObjectTemplate<int32_t>::getIndexValue(JSObject* tarray, uint32_t index)
+bool
+TypedArrayObjectTemplate<int32_t>::getElementPure(TypedArrayObject* tarray, uint32_t index, Value* vp)
 {
-    return Int32Value(getIndex(tarray, index));
+    *vp = Int32Value(getIndex(tarray, index));
+    return true;
 }
 
 template<>
-Value
-TypedArrayObjectTemplate<uint32_t>::getIndexValue(JSObject* tarray, uint32_t index)
+bool
+TypedArrayObjectTemplate<uint32_t>::getElementPure(TypedArrayObject* tarray, uint32_t index, Value* vp)
 {
     uint32_t val = getIndex(tarray, index);
-    return NumberValue(val);
+    *vp = NumberValue(val);
+    return true;
 }
 
 template<>
-Value
-TypedArrayObjectTemplate<float>::getIndexValue(JSObject* tarray, uint32_t index)
+bool
+TypedArrayObjectTemplate<float>::getElementPure(TypedArrayObject* tarray, uint32_t index, Value* vp)
 {
     float val = getIndex(tarray, index);
     double dval = val;
@@ -1632,12 +1765,13 @@ TypedArrayObjectTemplate<float>::getIndexValue(JSObject* tarray, uint32_t index)
      * This could be removed for platforms/compilers known to convert a 32-bit
      * non-canonical nan to a 64-bit canonical nan.
      */
-    return DoubleValue(CanonicalizeNaN(dval));
+    *vp = DoubleValue(CanonicalizeNaN(dval));
+    return true;
 }
 
 template<>
-Value
-TypedArrayObjectTemplate<double>::getIndexValue(JSObject* tarray, uint32_t index)
+bool
+TypedArrayObjectTemplate<double>::getElementPure(TypedArrayObject* tarray, uint32_t index, Value* vp)
 {
     double val = getIndex(tarray, index);
 
@@ -1648,9 +1782,60 @@ TypedArrayObjectTemplate<double>::getIndexValue(JSObject* tarray, uint32_t index
      * confuse the engine into interpreting a double-typed jsval as an
      * object-typed jsval.
      */
-    return DoubleValue(CanonicalizeNaN(val));
+    *vp = DoubleValue(CanonicalizeNaN(val));
+    return true;
+}
+
+template <>
+bool
+TypedArrayObjectTemplate<int64_t>::getElementPure(TypedArrayObject* tarray, uint32_t index, Value* vp)
+{
+    return false;
 }
 
+template <>
+bool
+TypedArrayObjectTemplate<uint64_t>::getElementPure(TypedArrayObject* tarray, uint32_t index, Value* vp)
+{
+    return false;
+}
+} /* anonymous namespace */
+
+namespace {
+
+template <typename NativeType>
+bool TypedArrayObjectTemplate<NativeType>::getElement(ExclusiveContext* cx, TypedArrayObject* tarray, uint32_t index,
+                                                      MutableHandleValue val)
+{
+    MOZ_ALWAYS_TRUE(getElementPure(tarray, index, val.address()));
+    return true;
+}
+ 
+template <>
+bool TypedArrayObjectTemplate<int64_t>::getElement(ExclusiveContext* cx, TypedArrayObject* tarray, uint32_t index,
+                                                   MutableHandleValue val)
+{
+    int64_t n = getIndex(tarray, index);
+    BigInt* res = BigInt::createFromInt64(cx, n);
+    if (!res) {
+        return false;
+    }
+    val.setBigInt(res);
+    return true;
+}
+
+template <>
+bool TypedArrayObjectTemplate<uint64_t>::getElement(ExclusiveContext* cx, TypedArrayObject* tarray, uint32_t index,
+                                                    MutableHandleValue val)
+{
+    uint64_t n = getIndex(tarray, index);
+    BigInt* res = BigInt::createFromUint64(cx, n);
+    if (!res) {
+        return false;
+    }
+    val.setBigInt(res);
+    return true;
+}
 } /* anonymous namespace */
 
 static NewObjectKind
@@ -2544,28 +2729,17 @@ DataViewObject::fun_setFloat64(JSContext* cx, unsigned argc, Value* vp)
     return CallNonGenericMethod<is, setFloat64Impl>(cx, args);
 }
 
-Value
-TypedArrayObject::getElement(uint32_t index)
+namespace js {
+
+template <>
+bool TypedArrayObject::getElement<CanGC>(ExclusiveContext* cx, uint32_t index, MutableHandleValue val)
 {
     switch (type()) {
-      case Scalar::Int8:
-        return Int8Array::getIndexValue(this, index);
-      case Scalar::Uint8:
-        return Uint8Array::getIndexValue(this, index);
-      case Scalar::Int16:
-        return Int16Array::getIndexValue(this, index);
-      case Scalar::Uint16:
-        return Uint16Array::getIndexValue(this, index);
-      case Scalar::Int32:
-        return Int32Array::getIndexValue(this, index);
-      case Scalar::Uint32:
-        return Uint32Array::getIndexValue(this, index);
-      case Scalar::Float32:
-        return Float32Array::getIndexValue(this, index);
-      case Scalar::Float64:
-        return Float64Array::getIndexValue(this, index);
-      case Scalar::Uint8Clamped:
-        return Uint8ClampedArray::getIndexValue(this, index);
+#define GET_ELEMENT(T, N) \
+  case Scalar::N:         \
+    return N##Array::getElement(cx, this, index, val);
+    JS_FOR_EACH_TYPED_ARRAY(GET_ELEMENT)
+#undef GET_ELEMENT
       case Scalar::Int64:
       case Scalar::Float32x4:
       case Scalar::Int8x16:
@@ -2578,44 +2752,23 @@ TypedArrayObject::getElement(uint32_t index)
     MOZ_CRASH("Unknown TypedArray type");
 }
 
-void
-TypedArrayObject::setElement(TypedArrayObject& obj, uint32_t index, double d)
-{
-    MOZ_ASSERT(index < obj.length());
+template <>
+bool TypedArrayObject::getElement<NoGC>(
+    ExclusiveContext* cx, uint32_t index,
+    typename MaybeRooted<Value, NoGC>::MutableHandleType vp) {
+  return getElementPure(index, vp.address());
+}
 
-#ifdef JS_MORE_DETERMINISTIC
-    // See the comment in ElementSpecific::doubleToNative.
-    d = JS::CanonicalizeNaN(d);
-#endif
+}  // namespace js
 
-    switch (obj.type()) {
-      case Scalar::Int8:
-        Int8Array::setIndexValue(obj, index, d);
-        return;
-      case Scalar::Uint8:
-        Uint8Array::setIndexValue(obj, index, d);
-        return;
-      case Scalar::Uint8Clamped:
-        Uint8ClampedArray::setIndexValue(obj, index, d);
-        return;
-      case Scalar::Int16:
-        Int16Array::setIndexValue(obj, index, d);
-        return;
-      case Scalar::Uint16:
-        Uint16Array::setIndexValue(obj, index, d);
-        return;
-      case Scalar::Int32:
-        Int32Array::setIndexValue(obj, index, d);
-        return;
-      case Scalar::Uint32:
-        Uint32Array::setIndexValue(obj, index, d);
-        return;
-      case Scalar::Float32:
-        Float32Array::setIndexValue(obj, index, d);
-        return;
-      case Scalar::Float64:
-        Float64Array::setIndexValue(obj, index, d);
-        return;
+bool TypedArrayObject::getElementPure(uint32_t index, Value* vp)
+{
+  switch (type()) {
+#define GET_ELEMENT_PURE(T, N) \
+  case Scalar::N:              \
+    return N##Array::getElementPure(this, index, vp);
+    JS_FOR_EACH_TYPED_ARRAY(GET_ELEMENT_PURE)
+#undef GET_ELEMENT
       case Scalar::Int64:
       case Scalar::Float32x4:
       case Scalar::Int8x16:
@@ -2628,6 +2781,38 @@ TypedArrayObject::setElement(TypedArrayObject& obj, uint32_t index, double d)
     MOZ_CRASH("Unknown TypedArray type");
 }
 
+/* static */
+bool TypedArrayObject::getElements(JSContext* cx, Handle<TypedArrayObject*> tarray, Value* vp)
+{
+  uint32_t length = tarray->length();
+  MOZ_ASSERT_IF(length > 0, !tarray->hasDetachedBuffer());
+
+  switch (tarray->type()) {
+#define GET_ELEMENTS(T, N)                                                     \
+  case Scalar::N:                                                              \
+    for (uint32_t i = 0; i < length; ++i, ++vp) {                              \
+      if (!N##Array::getElement(cx, tarray, i,                                 \
+                                MutableHandleValue::fromMarkedLocation(vp))) { \
+        return false;                                                          \
+      }                                                                        \
+    }                                                                          \
+    return true;
+    JS_FOR_EACH_TYPED_ARRAY(GET_ELEMENTS)
+#undef GET_ELEMENTS
+    default:
+      MOZ_CRASH("Unknown TypedArray type");
+    case Scalar::MaxTypedArrayViewType:
+    case Scalar::Int64:
+    case Scalar::Float32x4:
+    case Scalar::Int8x16:
+    case Scalar::Int16x8:
+    case Scalar::Int32x4:
+      break;
+  }
+
+  MOZ_CRASH("Unknown TypedArray type");
+}
+
 /***
  *** JS impl
  ***/
@@ -2680,6 +2865,8 @@ IMPL_TYPED_ARRAY_JSAPI_CONSTRUCTORS(Int32, int32_t)
 IMPL_TYPED_ARRAY_JSAPI_CONSTRUCTORS(Uint32, uint32_t)
 IMPL_TYPED_ARRAY_JSAPI_CONSTRUCTORS(Float32, float)
 IMPL_TYPED_ARRAY_JSAPI_CONSTRUCTORS(Float64, double)
+IMPL_TYPED_ARRAY_JSAPI_CONSTRUCTORS(BigInt64, int64_t)
+IMPL_TYPED_ARRAY_JSAPI_CONSTRUCTORS(BigUint64, uint64_t)
 
 #define IMPL_TYPED_ARRAY_COMBINED_UNWRAPPERS(Name, ExternalType, InternalType)              \
   JS_FRIEND_API(JSObject*) JS_GetObjectAs ## Name ## Array(JSObject* obj,                  \
@@ -2711,6 +2898,8 @@ IMPL_TYPED_ARRAY_COMBINED_UNWRAPPERS(Int32, int32_t, int32_t)
 IMPL_TYPED_ARRAY_COMBINED_UNWRAPPERS(Uint32, uint32_t, uint32_t)
 IMPL_TYPED_ARRAY_COMBINED_UNWRAPPERS(Float32, float, float)
 IMPL_TYPED_ARRAY_COMBINED_UNWRAPPERS(Float64, double, double)
+IMPL_TYPED_ARRAY_COMBINED_UNWRAPPERS(BigInt64, int64_t, int64_t)
+IMPL_TYPED_ARRAY_COMBINED_UNWRAPPERS(BigUint64, uint32_t, uint64_t)
 
 static const ClassOps TypedArrayClassOps = {
     nullptr,                 /* addProperty */
@@ -2748,7 +2937,9 @@ static const JSPropertySpec static_prototype_properties[Scalar::MaxTypedArrayVie
     IMPL_TYPED_ARRAY_PROPERTIES(Uint32),
     IMPL_TYPED_ARRAY_PROPERTIES(Float32),
     IMPL_TYPED_ARRAY_PROPERTIES(Float64),
-    IMPL_TYPED_ARRAY_PROPERTIES(Uint8Clamped)
+    IMPL_TYPED_ARRAY_PROPERTIES(Uint8Clamped),
+    IMPL_TYPED_ARRAY_PROPERTIES(BigInt64),
+    IMPL_TYPED_ARRAY_PROPERTIES(BigUint64)
 };
 
 #define IMPL_TYPED_ARRAY_CLASS_SPEC(_type)                                     \
@@ -2772,7 +2963,9 @@ static const ClassSpec TypedArrayObjectClassSpecs[Scalar::MaxTypedArrayViewType]
     IMPL_TYPED_ARRAY_CLASS_SPEC(Uint32),
     IMPL_TYPED_ARRAY_CLASS_SPEC(Float32),
     IMPL_TYPED_ARRAY_CLASS_SPEC(Float64),
-    IMPL_TYPED_ARRAY_CLASS_SPEC(Uint8Clamped)
+    IMPL_TYPED_ARRAY_CLASS_SPEC(Uint8Clamped),
+    IMPL_TYPED_ARRAY_CLASS_SPEC(BigInt64),
+    IMPL_TYPED_ARRAY_CLASS_SPEC(BigUint64)
 };
 
 #define IMPL_TYPED_ARRAY_CLASS(_type)                                          \
@@ -2798,7 +2991,9 @@ const Class TypedArrayObject::classes[Scalar::MaxTypedArrayViewType] = {
     IMPL_TYPED_ARRAY_CLASS(Uint32),
     IMPL_TYPED_ARRAY_CLASS(Float32),
     IMPL_TYPED_ARRAY_CLASS(Float64),
-    IMPL_TYPED_ARRAY_CLASS(Uint8Clamped)
+    IMPL_TYPED_ARRAY_CLASS(Uint8Clamped),
+    IMPL_TYPED_ARRAY_CLASS(BigInt64),
+    IMPL_TYPED_ARRAY_CLASS(BigUint64)
 };
 
 #define IMPL_TYPED_ARRAY_PROTO_CLASS_SPEC(_type) \
@@ -2822,7 +3017,9 @@ static const ClassSpec TypedArrayObjectProtoClassSpecs[Scalar::MaxTypedArrayView
     IMPL_TYPED_ARRAY_PROTO_CLASS_SPEC(Uint32),
     IMPL_TYPED_ARRAY_PROTO_CLASS_SPEC(Float32),
     IMPL_TYPED_ARRAY_PROTO_CLASS_SPEC(Float64),
-    IMPL_TYPED_ARRAY_PROTO_CLASS_SPEC(Uint8Clamped)
+    IMPL_TYPED_ARRAY_PROTO_CLASS_SPEC(Uint8Clamped),
+    IMPL_TYPED_ARRAY_PROTO_CLASS_SPEC(BigInt64),
+    IMPL_TYPED_ARRAY_PROTO_CLASS_SPEC(BigUint64)
 };
 
 // The various typed array prototypes are supposed to 1) be normal objects,
@@ -2856,7 +3053,9 @@ const Class TypedArrayObject::protoClasses[Scalar::MaxTypedArrayViewType] = {
     IMPL_TYPED_ARRAY_PROTO_CLASS(Uint32),
     IMPL_TYPED_ARRAY_PROTO_CLASS(Float32),
     IMPL_TYPED_ARRAY_PROTO_CLASS(Float64),
-    IMPL_TYPED_ARRAY_PROTO_CLASS(Uint8Clamped)
+    IMPL_TYPED_ARRAY_PROTO_CLASS(Uint8Clamped),
+    IMPL_TYPED_ARRAY_PROTO_CLASS(BigInt64),
+    IMPL_TYPED_ARRAY_PROTO_CLASS(BigUint64)
 };
 
 /* static */ bool
@@ -3112,6 +3311,25 @@ js::StringIsTypedArrayIndex(const char16_t* s, size_t length, uint64_t* indexp);
 template bool
 js::StringIsTypedArrayIndex(const Latin1Char* s, size_t length, uint64_t* indexp);
 
+bool js::SetTypedArrayElement(JSContext* cx, Handle<TypedArrayObject*> obj,
+                              uint64_t index, HandleValue v, ObjectOpResult& result)
+{
+    TypedArrayObject* tobj = &obj->as<TypedArrayObject>();
+
+    switch (tobj->type()) {
+#define SET_TYPED_ARRAY_ELEMENT(T, N) \
+    case Scalar::N:                     \
+        return TypedArrayObjectTemplate<T>::setElement(cx, obj, index, v, result);
+        JS_FOR_EACH_TYPED_ARRAY(SET_TYPED_ARRAY_ELEMENT)
+#undef SET_TYPED_ARRAY_ELEMENT
+        case Scalar::MaxTypedArrayViewType:
+        case Scalar::Int64:
+        break;
+    }
+
+    MOZ_CRASH("Unsupported TypedArray type");
+}
+
 /* ES6 draft rev 34 (2015 Feb 20) 9.4.5.3 [[DefineOwnProperty]] step 3.c. */
 bool
 js::DefineTypedArrayElement(JSContext* cx, HandleObject obj, uint64_t index,
@@ -3147,22 +3365,18 @@ js::DefineTypedArrayElement(JSContext* cx, HandleObject obj, uint64_t index,
 
     // Step x.
     if (desc.hasValue()) {
-        // The following step numbers refer to 9.4.5.9
-        // IntegerIndexedElementSet.
-
-        // Steps 1-2 are enforced by the caller.
-
-        // Step 3.
-        double numValue;
-        if (!ToNumber(cx, desc.value(), &numValue))
-            return false;
-
-        // Steps 4-5, 8-9.
-        if (obj->as<TypedArrayObject>().hasDetachedBuffer())
-            return result.fail(JSMSG_TYPED_ARRAY_DETACHED);
-
-        // Steps 10-16.
-        TypedArrayObject::setElement(obj->as<TypedArrayObject>(), index, numValue);
+        TypedArrayObject* tobj = &obj->as<TypedArrayObject>();
+        switch (tobj->type()) {
+#define DEFINE_TYPED_ARRAY_ELEMENT(T, N)                                                 \
+            case Scalar::N:                                                              \
+                return TypedArrayObjectTemplate<T>::defineElement(cx, obj, index,        \
+                                                                  desc.value(), result);
+            JS_FOR_EACH_TYPED_ARRAY(DEFINE_TYPED_ARRAY_ELEMENT)
+#undef DEFINE_TYPED_ARRAY_ELEMENT
+            case Scalar::MaxTypedArrayViewType:
+            case Scalar::Int64:
+                break;
+        }
     }
 
     // Step xii.