// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

#include "vm/bootstrap_natives.h"

#include "include/dart_api.h"

#include "vm/bigint_operations.h"
#include "vm/exceptions.h"
#include "vm/native_entry.h"
#include "vm/object.h"

namespace dart {

// ByteArray

// Checks to see if (index * num_bytes) is in the range
// [0..array.ByteLength()).  without the risk of integer overflow.  If
// the index is out of range, then a RangeError is thrown.
static void RangeCheck(const ByteArray& array,
                       intptr_t index,
                       intptr_t num_bytes) {
  if (!Utils::RangeCheck(index, num_bytes, array.ByteLength())) {
    const String& error = String::Handle(String::NewFormatted(
        "index (%"Pd") must be in the range [0..%"Pd")",
        (index / num_bytes), (array.ByteLength() / num_bytes)));
    const Array& args = Array::Handle(Array::New(1));
    args.SetAt(0, error);
    Exceptions::ThrowByType(Exceptions::kRange, args);
  }
}


// Checks to see if a length is in the range [0..max].  If the length
// is out of range, then an ArgumentError is thrown.
static void LengthCheck(intptr_t len, intptr_t max) {
  if (len < 0 || len > max) {
    const String& error = String::Handle(String::NewFormatted(
        "length (%"Pd") must be in the range [0..%"Pd"]", len, max));
    const Array& args = Array::Handle(Array::New(1));
    args.SetAt(0, error);
    Exceptions::ThrowByType(Exceptions::kArgument, args);
  }
}


#define GETTER_ARGUMENTS(ArrayT, ValueT)                                       \
  GET_NON_NULL_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0));      \
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));


#define SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT)                              \
  GET_NON_NULL_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0));      \
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));         \
  GET_NON_NULL_NATIVE_ARGUMENT(                                                \
      ObjectT, value_object, arguments->NativeArgAt(2));


#define GETTER(ArrayT, ObjectT, ValueT)                                        \
  GETTER_ARGUMENTS(ArrayT, ValueT);                                            \
  RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT));           \
  ValueT result = array.At(index.Value());                                     \
  return ObjectT::New(result);


#define SETTER(ArrayT, ObjectT, Getter, ValueT)                                \
  SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT);                                   \
  RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT));           \
  ValueT value = value_object.Getter();                                        \
  array.SetAt(index.Value(), value);                                           \
  return Object::null();


#define UNALIGNED_GETTER(ArrayT, ObjectT, ValueT)                              \
  GETTER_ARGUMENTS(ArrayT, ValueT);                                            \
  RangeCheck(array, index.Value(), sizeof(ValueT));                            \
  ValueT result;                                                               \
  ByteArray::Copy(&result, array, index.Value(), sizeof(ValueT));              \
  return ObjectT::New(result);


#define UNALIGNED_SETTER(ArrayT, ObjectT, Getter, ValueT)                      \
  SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT);                                   \
  RangeCheck(array, index.Value(), sizeof(ValueT));                            \
  ValueT src = value_object.Getter();                                          \
  ByteArray::Copy(array, index.Value(), &src, sizeof(ValueT));                 \
  return Integer::New(index.Value() + sizeof(ValueT));


#define SCALED_UNALIGNED_GETTER(ArrayT, ObjectT, ValueT)                       \
  GETTER_ARGUMENTS(ArrayT, ValueT);                                            \
  RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT));           \
  ValueT result;                                                               \
  ByteArray::Copy(&result, array,                                              \
      index.Value() * sizeof(ValueT), sizeof(ValueT));                         \
  return ObjectT::New(result);


#define SCALED_UNALIGNED_SETTER(ArrayT, ObjectT, Getter, ValueT)               \
  SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT);                                   \
  RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT));           \
  ValueT src = value_object.Getter();                                          \
  ByteArray::Copy(array, index.Value() * sizeof(ValueT), &src, sizeof(ValueT));\
  return Integer::New(index.Value() + sizeof(ValueT));


#define UINT64_TO_INTEGER(value, integer)                                      \
  if (value > static_cast<uint64_t>(Mint::kMaxValue)) {                        \
    result = BigintOperations::NewFromUint64(value);                           \
  } else if (value > static_cast<uint64_t>(Smi::kMaxValue)) {                  \
    result = Mint::New(value);                                                 \
  } else {                                                                     \
    result = Smi::New(value);                                                  \
  }


#define GETTER_UINT64(ArrayT)                                                  \
  GETTER_ARGUMENTS(ArrayT, uint64_t);                                          \
  intptr_t size = sizeof(uint64_t);                                            \
  RangeCheck(array, index.Value() * size, size);                               \
  uint64_t value = array.At(index.Value());                                    \
  Integer& result = Integer::Handle();                                         \
  UINT64_TO_INTEGER(value, result);                                            \
  return result.raw();


#define UNALIGNED_GETTER_UINT64(ArrayT)                                        \
  GETTER_ARGUMENTS(ArrayT, uint64_t);                                          \
  RangeCheck(array, index.Value(), sizeof(uint64_t));                          \
  uint64_t value;                                                              \
  ByteArray::Copy(&value, array, index.Value(), sizeof(uint64_t));             \
  Integer& result = Integer::Handle();                                         \
  UINT64_TO_INTEGER(value, result);                                            \
  return result.raw();


#define INTEGER_TO_UINT64(integer, uint64)                                     \
  if (integer.IsBigint()) {                                                    \
    const Bigint& bigint = Bigint::Cast(integer);                              \
    ASSERT(BigintOperations::FitsIntoUint64(bigint));                          \
    value = BigintOperations::AbsToUint64(bigint);                             \
  } else {                                                                     \
    ASSERT(integer.IsMint() || integer.IsSmi());                               \
    value = integer.AsInt64Value();                                            \
  }                                                                            \


#define SETTER_UINT64(ArrayT)                                                  \
  SETTER_ARGUMENTS(ArrayT, Integer, uint64_t);                                 \
  intptr_t size = sizeof(uint64_t);                                            \
  RangeCheck(array, index.Value() * size, size);                               \
  uint64_t value;                                                              \
  INTEGER_TO_UINT64(value_object, value);                                      \
  array.SetAt(index.Value(), value);                                           \
  return Object::null();


#define UNALIGNED_SETTER_UINT64(ArrayT)                                        \
  SETTER_ARGUMENTS(ArrayT, Integer, uint64_t);                                 \
  RangeCheck(array, index.Value(), sizeof(uint64_t));                          \
  uint64_t value;                                                              \
  INTEGER_TO_UINT64(value_object, value);                                      \
  ByteArray::Copy(array, index.Value(), &value, sizeof(uint64_t));             \
  return Integer::New(index.Value() + sizeof(uint64_t));


DEFINE_NATIVE_ENTRY(ByteArray_getLength, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(ByteArray, array, arguments->NativeArgAt(0));
  return Smi::New(array.Length());
}


DEFINE_NATIVE_ENTRY(ByteArray_getInt8, 2) {
  UNALIGNED_GETTER(ByteArray, Smi, int8_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_setInt8, 3) {
  UNALIGNED_SETTER(ByteArray, Smi, Value, int8_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_getUint8, 2) {
  UNALIGNED_GETTER(ByteArray, Smi, uint8_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_setUint8, 3) {
  UNALIGNED_SETTER(ByteArray, Smi, Value, uint8_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_getInt16, 2) {
  UNALIGNED_GETTER(ByteArray, Smi, int16_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_setInt16, 3) {
  UNALIGNED_SETTER(ByteArray, Smi, Value, int16_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_getUint16, 2) {
  UNALIGNED_GETTER(ByteArray, Smi, uint16_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_setUint16, 3) {
  UNALIGNED_SETTER(ByteArray, Smi, Value, uint16_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_getInt32, 2) {
  UNALIGNED_GETTER(ByteArray, Integer, int32_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_setInt32, 3) {
  UNALIGNED_SETTER(ByteArray, Integer, AsInt64Value, int32_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_getUint32, 2) {
  UNALIGNED_GETTER(ByteArray, Integer, uint32_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_setUint32, 3) {
  UNALIGNED_SETTER(ByteArray, Integer, AsInt64Value, uint32_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_getInt64, 2) {
  UNALIGNED_GETTER(ByteArray, Integer, int64_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_setInt64, 3) {
  UNALIGNED_SETTER(ByteArray, Integer, AsInt64Value, int64_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_getUint64, 2) {
  UNALIGNED_GETTER_UINT64(ByteArray);
}


DEFINE_NATIVE_ENTRY(ByteArray_setUint64, 3) {
  UNALIGNED_SETTER_UINT64(ByteArray);
}


DEFINE_NATIVE_ENTRY(ByteArray_getFloat32x4, 2) {
  UNALIGNED_GETTER(ByteArray, Float32x4, simd_value_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_setFloat32x4, 3) {
  UNALIGNED_SETTER(ByteArray, Float32x4, value, simd_value_t);
}


DEFINE_NATIVE_ENTRY(ByteArray_getFloat32, 2) {
  UNALIGNED_GETTER(ByteArray, Double, float);
}


DEFINE_NATIVE_ENTRY(ByteArray_setFloat32, 3) {
  UNALIGNED_SETTER(ByteArray, Double, value, float);
}


DEFINE_NATIVE_ENTRY(ByteArray_getFloat64, 2) {
  UNALIGNED_GETTER(ByteArray, Double, double);
}


DEFINE_NATIVE_ENTRY(ByteArray_setFloat64, 3) {
  UNALIGNED_SETTER(ByteArray, Double, value, double);
}


DEFINE_NATIVE_ENTRY(ByteArray_setRange, 5) {
  ByteArray& dst = ByteArray::CheckedHandle(arguments->NativeArgAt(0));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, dst_start, arguments->NativeArgAt(1));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(2));
  GET_NON_NULL_NATIVE_ARGUMENT(ByteArray, src, arguments->NativeArgAt(3));
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, src_start, arguments->NativeArgAt(4));
  intptr_t length_value = length.Value();
  intptr_t src_start_value = src_start.Value();
  intptr_t dst_start_value = dst_start.Value();
  if (length_value < 0) {
    const String& error = String::Handle(String::NewFormatted(
        "length (%"Pd") must be non-negative", length_value));
    const Array& args = Array::Handle(Array::New(1));
    args.SetAt(0, error);
    Exceptions::ThrowByType(Exceptions::kArgument, args);
  }
  RangeCheck(src, src_start_value, length_value);
  RangeCheck(dst, dst_start_value, length_value);
  ByteArray::Copy(dst, dst_start_value, src, src_start_value, length_value);
  return Object::null();
}


static void PeerFinalizer(Dart_Handle handle, void* peer) {
  Dart_DeletePersistentHandle(handle);
  OS::AlignedFree(peer);
}


// Int8Array

DEFINE_NATIVE_ENTRY(Int8Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Int8Array::kMaxElements);
  return Int8Array::New(len);
}


DEFINE_NATIVE_ENTRY(Int8List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Int8Array::kMaxElements);
  int8_t* bytes = OS::AllocateAlignedArray<int8_t>(len, kAlignment);
  const ExternalInt8Array& obj =
      ExternalInt8Array::Handle(ExternalInt8Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Int8Array_getIndexed, 2) {
  GETTER(Int8Array, Smi, int8_t);
}


DEFINE_NATIVE_ENTRY(Int8Array_setIndexed, 3) {
  SETTER(Int8Array, Smi, Value, int8_t);
}


// Uint8Array

DEFINE_NATIVE_ENTRY(Uint8Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint8Array::kMaxElements);
  return Uint8Array::New(len);
}


DEFINE_NATIVE_ENTRY(Uint8List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint8Array::kMaxElements);
  uint8_t* bytes = OS::AllocateAlignedArray<uint8_t>(len, kAlignment);
  const ExternalUint8Array& obj =
      ExternalUint8Array::Handle(ExternalUint8Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Uint8Array_getIndexed, 2) {
  GETTER(Uint8Array, Smi, uint8_t);
}


DEFINE_NATIVE_ENTRY(Uint8Array_setIndexed, 3) {
  SETTER(Uint8Array, Smi, Value, uint8_t);
}


// Uint8ClampedArray

DEFINE_NATIVE_ENTRY(Uint8ClampedArray_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint8ClampedArray::kMaxElements);
  return Uint8ClampedArray::New(len);
}


DEFINE_NATIVE_ENTRY(Uint8ClampedList_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint8ClampedArray::kMaxElements);
  uint8_t* bytes = OS::AllocateAlignedArray<uint8_t>(len, kAlignment);
  const ExternalUint8ClampedArray& obj = ExternalUint8ClampedArray::Handle(
      ExternalUint8ClampedArray::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Uint8ClampedArray_getIndexed, 2) {
  GETTER(Uint8ClampedArray, Smi, uint8_t);
}


DEFINE_NATIVE_ENTRY(Uint8ClampedArray_setIndexed, 3) {
  SETTER(Uint8ClampedArray, Smi, Value, uint8_t);
}


// Int16Array

DEFINE_NATIVE_ENTRY(Int16Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Int16Array::kMaxElements);
  return Int16Array::New(len);
}


DEFINE_NATIVE_ENTRY(Int16List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Int16Array::kMaxElements);
  int16_t* bytes = OS::AllocateAlignedArray<int16_t>(len, kAlignment);
  const ExternalInt16Array& obj =
      ExternalInt16Array::Handle(ExternalInt16Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Int16Array_getIndexed, 2) {
  GETTER(Int16Array, Smi, int16_t);
}


DEFINE_NATIVE_ENTRY(Int16Array_setIndexed, 3) {
  SETTER(Int16Array, Smi, Value, int16_t);
}


// Uint16Array

DEFINE_NATIVE_ENTRY(Uint16Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint16Array::kMaxElements);
  return Uint16Array::New(len);
}


DEFINE_NATIVE_ENTRY(Uint16List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint16Array::kMaxElements);
  uint16_t* bytes = OS::AllocateAlignedArray<uint16_t>(len, kAlignment);
  const ExternalUint16Array& obj =
      ExternalUint16Array::Handle(ExternalUint16Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Uint16Array_getIndexed, 2) {
  GETTER(Uint16Array, Smi, uint16_t);
}


DEFINE_NATIVE_ENTRY(Uint16Array_setIndexed, 3) {
  SETTER(Uint16Array, Smi, Value, uint16_t);
}


// Int32Array

DEFINE_NATIVE_ENTRY(Int32Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Int32Array::kMaxElements);
  return Int32Array::New(len);
}


DEFINE_NATIVE_ENTRY(Int32List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Int32Array::kMaxElements);
  int32_t* bytes = OS::AllocateAlignedArray<int32_t>(len, kAlignment);
  const ExternalInt32Array& obj =
      ExternalInt32Array::Handle(ExternalInt32Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Int32Array_getIndexed, 2) {
  GETTER(Int32Array, Integer, int32_t);
}


DEFINE_NATIVE_ENTRY(Int32Array_setIndexed, 3) {
  SETTER(Int32Array, Integer, AsInt64Value, int32_t);
}


// Uint32Array

DEFINE_NATIVE_ENTRY(Uint32Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint32Array::kMaxElements);
  return Uint32Array::New(len);
}


DEFINE_NATIVE_ENTRY(Uint32List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint32Array::kMaxElements);
  uint32_t* bytes = OS::AllocateAlignedArray<uint32_t>(len, kAlignment);
  const ExternalUint32Array& obj =
      ExternalUint32Array::Handle(ExternalUint32Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Uint32Array_getIndexed, 2) {
  GETTER(Uint32Array, Integer, uint32_t);
}


DEFINE_NATIVE_ENTRY(Uint32Array_setIndexed, 3) {
  SETTER(Uint32Array, Integer, AsInt64Value, uint32_t);
}


// Int64Array

DEFINE_NATIVE_ENTRY(Int64Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Int64Array::kMaxElements);
  return Int64Array::New(len);
}


DEFINE_NATIVE_ENTRY(Int64List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Int64Array::kMaxElements);
  int64_t* bytes = OS::AllocateAlignedArray<int64_t>(len, kAlignment);
  const ExternalInt64Array& obj =
      ExternalInt64Array::Handle(ExternalInt64Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Int64Array_getIndexed, 2) {
  GETTER(Int64Array, Integer, int64_t);
}


DEFINE_NATIVE_ENTRY(Int64Array_setIndexed, 3) {
  SETTER(Int64Array, Integer, AsInt64Value, int64_t);
}


// Uint64Array

DEFINE_NATIVE_ENTRY(Uint64Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint64Array::kMaxElements);
  return Uint64Array::New(len);
}


DEFINE_NATIVE_ENTRY(Uint64List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Uint64Array::kMaxElements);
  uint64_t* bytes = OS::AllocateAlignedArray<uint64_t>(len, kAlignment);
  const ExternalUint64Array& obj =
      ExternalUint64Array::Handle(ExternalUint64Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Uint64Array_getIndexed, 2) {
  GETTER_UINT64(Uint64Array);
}


DEFINE_NATIVE_ENTRY(Uint64Array_setIndexed, 3) {
  SETTER_UINT64(Uint64Array);
}

// Float32x4Array

DEFINE_NATIVE_ENTRY(Float32x4Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Float32x4Array::kMaxElements);
  return Float32x4Array::New(len);
}


DEFINE_NATIVE_ENTRY(Float32x4List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Float32x4Array::kMaxElements);
  simd_value_t* bytes = OS::AllocateAlignedArray<simd_value_t>(len, kAlignment);
  const ExternalFloat32x4Array& obj =
      ExternalFloat32x4Array::Handle(ExternalFloat32x4Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Float32x4Array_getIndexed, 2) {
  GETTER(Float32x4Array, Float32x4, simd_value_t);
}


DEFINE_NATIVE_ENTRY(Float32x4Array_setIndexed, 3) {
  SETTER(Float32x4Array, Float32x4, value, simd_value_t);
}


// Float32Array

DEFINE_NATIVE_ENTRY(Float32Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Float32Array::kMaxElements);
  return Float32Array::New(len);
}


DEFINE_NATIVE_ENTRY(Float32List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Float32Array::kMaxElements);
  float* bytes = OS::AllocateAlignedArray<float>(len, kAlignment);
  const ExternalFloat32Array& obj =
      ExternalFloat32Array::Handle(ExternalFloat32Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Float32Array_getIndexed, 2) {
  GETTER(Float32Array, Double, float);
}


DEFINE_NATIVE_ENTRY(Float32Array_setIndexed, 3) {
  SETTER(Float32Array, Double, value, float);
}


// Float64Array

DEFINE_NATIVE_ENTRY(Float64Array_new, 1) {
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Float64Array::kMaxElements);
  return Float64Array::New(len);
}


DEFINE_NATIVE_ENTRY(Float64List_newTransferable, 1) {
  const int kAlignment = 16;
  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
  intptr_t len = length.Value();
  LengthCheck(len, Float64Array::kMaxElements);
  double* bytes = OS::AllocateAlignedArray<double>(len, kAlignment);
  const ExternalFloat64Array& obj =
      ExternalFloat64Array::Handle(ExternalFloat64Array::New(bytes, len));
  obj.AddFinalizer(bytes, PeerFinalizer);
  return obj.raw();
}


DEFINE_NATIVE_ENTRY(Float64Array_getIndexed, 2) {
  GETTER(Float64Array, Double, double);
}


DEFINE_NATIVE_ENTRY(Float64Array_setIndexed, 3) {
  SETTER(Float64Array, Double, value, double);
}


// ExternalInt8Array

DEFINE_NATIVE_ENTRY(ExternalInt8Array_getIndexed, 2) {
  GETTER(ExternalInt8Array, Smi, int8_t);
}


DEFINE_NATIVE_ENTRY(ExternalInt8Array_setIndexed, 3) {
  SETTER(ExternalInt8Array, Smi, Value, int8_t);
}


// ExternalUint8Array

DEFINE_NATIVE_ENTRY(ExternalUint8Array_getIndexed, 2) {
  SCALED_UNALIGNED_GETTER(ExternalUint8Array, Smi, uint8_t);
}


DEFINE_NATIVE_ENTRY(ExternalUint8Array_setIndexed, 3) {
  SCALED_UNALIGNED_SETTER(ExternalUint8Array, Smi, Value, uint8_t);
}


// ExternalUint8ClampedArray

DEFINE_NATIVE_ENTRY(ExternalUint8ClampedArray_getIndexed, 2) {
  SCALED_UNALIGNED_GETTER(ExternalUint8ClampedArray, Smi, uint8_t);
}


DEFINE_NATIVE_ENTRY(ExternalUint8ClampedArray_setIndexed, 3) {
  SCALED_UNALIGNED_SETTER(ExternalUint8ClampedArray, Smi, Value, uint8_t);
}


// ExternalInt16Array

DEFINE_NATIVE_ENTRY(ExternalInt16Array_getIndexed, 2) {
  GETTER(ExternalInt16Array, Smi, int16_t);
}


DEFINE_NATIVE_ENTRY(ExternalInt16Array_setIndexed, 3) {
  SETTER(ExternalInt16Array, Smi, Value, int16_t);
}


// ExternalUint16Array

DEFINE_NATIVE_ENTRY(ExternalUint16Array_getIndexed, 2) {
  SCALED_UNALIGNED_GETTER(ExternalUint16Array, Smi, uint16_t);
}


DEFINE_NATIVE_ENTRY(ExternalUint16Array_setIndexed, 3) {
  SCALED_UNALIGNED_SETTER(ExternalUint16Array, Smi, Value, uint16_t);
}


// ExternalInt32Array

DEFINE_NATIVE_ENTRY(ExternalInt32Array_getIndexed, 2) {
  GETTER(ExternalInt32Array, Integer, int32_t);
}


DEFINE_NATIVE_ENTRY(ExternalInt32Array_setIndexed, 3) {
  SETTER(ExternalInt32Array, Integer, AsInt64Value, int32_t);
}


// ExternalUint32Array

DEFINE_NATIVE_ENTRY(ExternalUint32Array_getIndexed, 2) {
  SCALED_UNALIGNED_GETTER(ExternalUint32Array, Integer, uint32_t);
}


DEFINE_NATIVE_ENTRY(ExternalUint32Array_setIndexed, 3) {
  SCALED_UNALIGNED_SETTER(ExternalUint32Array, Integer, AsInt64Value, uint32_t);
}


// ExternalInt64Array

DEFINE_NATIVE_ENTRY(ExternalInt64Array_getIndexed, 2) {
  GETTER(ExternalInt64Array, Integer, int64_t);
}


DEFINE_NATIVE_ENTRY(ExternalInt64Array_setIndexed, 3) {
  SETTER(ExternalInt64Array, Integer, AsInt64Value, int64_t);
}


// ExternalUint64Array

DEFINE_NATIVE_ENTRY(ExternalUint64Array_getIndexed, 2) {
  GETTER_UINT64(ExternalUint64Array);
}


DEFINE_NATIVE_ENTRY(ExternalUint64Array_setIndexed, 3) {
  SETTER_UINT64(ExternalUint64Array);
}


// ExternalFloat32x4Array

DEFINE_NATIVE_ENTRY(ExternalFloat32x4Array_getIndexed, 2) {
  GETTER(ExternalFloat32x4Array, Float32x4, simd_value_t);
}


DEFINE_NATIVE_ENTRY(ExternalFloat32x4Array_setIndexed, 3) {
  SETTER(ExternalFloat32x4Array, Float32x4, value, simd_value_t);
}


// ExternalFloat32Array

DEFINE_NATIVE_ENTRY(ExternalFloat32Array_getIndexed, 2) {
  GETTER(ExternalFloat32Array, Double, float);
}


DEFINE_NATIVE_ENTRY(ExternalFloat32Array_setIndexed, 3) {
  SETTER(ExternalFloat32Array, Double, value, float);
}


// ExternalFloat64Array

DEFINE_NATIVE_ENTRY(ExternalFloat64Array_getIndexed, 2) {
  GETTER(ExternalFloat64Array, Double, double);
}


DEFINE_NATIVE_ENTRY(ExternalFloat64Array_setIndexed, 3) {
  SETTER(ExternalFloat64Array, Double, value, double);
}

}  // namespace dart