Narrow when storing to a byte array and implement uint64 get and set.

runtime/lib/byte_array.cc

 // 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 "vm/bigint_operations.h"
 #include "vm/exceptions.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 
 namespace dart {
 
 DEFINE_NATIVE_ENTRY(ByteArray_getLength, 1) {
   const ByteArray& byte_array = ByteArray::CheckedHandle(arguments->At(0));
   const Smi& length = Smi::Handle(Smi::New(byte_array.Length()));
   arguments->SetReturn(length);
@@ skipping 36 matching lines @@
   intptr_t dst_start_value = dst_start.Value();
   if (length_value < 0) {
     GrowableArray<const Object*> args;
     Exceptions::ThrowByType(Exceptions::kIllegalArgument, 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);
 }
 
+#define GETTER_ARGUMENTS(ArrayT, ValueT)                                \
+  GET_NATIVE_ARGUMENT(ArrayT, array, arguments->At(0));                 \
+  GET_NATIVE_ARGUMENT(Smi, index, arguments->At(1));                    \
+  RangeCheck(array, index.Value(), sizeof(ValueT));
 
-#define GETTER(ArrayT, ObjectT, ValueT)                                 \
+
+#define SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT)                       \
   GET_NATIVE_ARGUMENT(ArrayT, array, arguments->At(0));                 \
   GET_NATIVE_ARGUMENT(Smi, index, arguments->At(1));                    \
   RangeCheck(array, index.Value(), sizeof(ValueT));                     \
+  GET_NATIVE_ARGUMENT(ObjectT, integer_value, arguments->At(2));
+
+
+#define GETTER(ArrayT, ObjectT, ValueT)                                 \
+  GETTER_ARGUMENTS(ArrayT, ValueT);                                     \
   ValueT result = array.UnalignedAt<ValueT>(index.Value());             \
   arguments->SetReturn(ObjectT::Handle(ObjectT::New(result)));
 
 
 #define SETTER(ArrayT, ObjectT, Getter, ValueT)                         \
-  GET_NATIVE_ARGUMENT(ArrayT, array, arguments->At(0));                 \
-  GET_NATIVE_ARGUMENT(Smi, index, arguments->At(1));                    \
-  RangeCheck(array, index.Value(), sizeof(ValueT));                     \
-  GET_NATIVE_ARGUMENT(ObjectT, value, arguments->At(2));                \
-  array.SetUnalignedAt<ValueT>(index.Value(), value.Getter());
+  SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT);                            \
+  array.SetUnalignedAt<ValueT>(index.Value(), integer_value.Getter());
+
+
+#define GETTER_UINT64(ArrayT)                                           \
+  GETTER_ARGUMENTS(ArrayT, uint64_t);                                   \
+  uint64_t value = array.UnalignedAt<uint64_t>(index.Value());          \
+  Integer& result = Integer::Handle();                                  \
+  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);                                           \
+  }                                                                     \
+  arguments->SetReturn(result);
+
+
+#define SETTER_UINT64(ArrayT)                                           \
+  SETTER_ARGUMENTS(ArrayT, Integer, uint64_t);                          \
+  uint64_t value;                                                       \
+  if (integer_value.IsBigint()) {                                       \
+    Bigint& bigint_value = Bigint::Handle();                            \
+    bigint_value ^= integer_value.raw();                                \
+    ASSERT(BigintOperations::FitsIntoUint64(bigint_value));             \
+    value = BigintOperations::AbsToUint64(bigint_value);                \
+  } else {                                                              \
+    ASSERT(integer_value.IsMint() || integer_value.IsSmi());            \
+    value = integer_value.AsInt64Value();                               \
+  }                                                                     \
+  array.SetUnalignedAt<uint64_t>(index.Value(), value);
 
 
 DEFINE_NATIVE_ENTRY(InternalByteArray_getInt8, 2) {
   GETTER(InternalByteArray, Smi, int8_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(InternalByteArray_setInt8, 3) {
   SETTER(InternalByteArray, Smi, Value, int8_t);
 }
@@ skipping 53 matching lines @@
   GETTER(InternalByteArray, Integer, int64_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(InternalByteArray_setInt64, 3) {
   SETTER(InternalByteArray, Integer, AsInt64Value, int64_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(InternalByteArray_getUint64, 2) {
-  UNIMPLEMENTED();  // TODO(cshapiro): need getter implementation.
+  GETTER_UINT64(InternalByteArray);
 }
 
 
 DEFINE_NATIVE_ENTRY(InternalByteArray_setUint64, 3) {
-  UNIMPLEMENTED();  // TODO(cshapiro): need setter implementation.
+  SETTER_UINT64(InternalByteArray);
 }
 
 
 DEFINE_NATIVE_ENTRY(InternalByteArray_getFloat32, 2) {
   GETTER(InternalByteArray, Double, float);
 }
 
 
 DEFINE_NATIVE_ENTRY(InternalByteArray_setFloat32, 3) {
   SETTER(InternalByteArray, Double, value, float);
@@ skipping 74 matching lines @@
   GETTER(ExternalByteArray, Integer, int64_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalByteArray_setInt64, 3) {
   SETTER(ExternalByteArray, Integer, AsInt64Value, int64_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalByteArray_getUint64, 2) {
-  UNIMPLEMENTED();  // TODO(cshapiro): need getter implementation.
+  GETTER_UINT64(ExternalByteArray);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalByteArray_setUint64, 3) {
-  UNIMPLEMENTED();  // TODO(cshapiro): need setter implementation.
+  SETTER_UINT64(ExternalByteArray);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalByteArray_getFloat32, 2) {
   GETTER(ExternalByteArray, Double, float);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalByteArray_setFloat32, 3) {
   SETTER(ExternalByteArray, Double, value, float);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalByteArray_getFloat64, 2) {
   GETTER(ExternalByteArray, Double, double);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalByteArray_setFloat64, 3) {
   SETTER(ExternalByteArray, Double, value, double);
 }
 
 }  // namespace dart