Version 1.1.0-dev.5.7

runtime/lib/typed_data.cc

 // Copyright (c) 2013, 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"
@@ skipping 47 matching lines @@
   if (instance.IsExternalTypedData()) {
     const ExternalTypedData& array = ExternalTypedData::Cast(instance);
     return Smi::New(array.Length());
   }
   const String& error = String::Handle(String::NewFormatted(
       "Expected a TypedData object but found %s", instance.ToCString()));
   Exceptions::ThrowArgumentError(error);
   return Integer::null();
 }
 
+
 template <typename DstType, typename SrcType>
 static RawBool* CopyData(const Instance& dst, const Instance& src,
                          const Smi& dst_start, const Smi& src_start,
                          const Smi& length) {
   const DstType& dst_array = DstType::Cast(dst);
   const SrcType& src_array = SrcType::Cast(src);
-  intptr_t element_size_in_bytes = dst_array.ElementSizeInBytes();
-  intptr_t dst_offset_in_bytes = dst_start.Value() * element_size_in_bytes;
-  intptr_t src_offset_in_bytes = src_start.Value() * element_size_in_bytes;
-  intptr_t length_in_bytes = length.Value() * element_size_in_bytes;
+  const intptr_t dst_offset_in_bytes = dst_start.Value();
+  const intptr_t src_offset_in_bytes = src_start.Value();
+  const intptr_t length_in_bytes = length.Value();
   if (dst_array.ElementType() != src_array.ElementType()) {
     return Bool::False().raw();
   }
-  RangeCheck(src_offset_in_bytes,
-             length_in_bytes,
-             src_array.LengthInBytes(),
-             element_size_in_bytes);
-  RangeCheck(dst_offset_in_bytes,
-             length_in_bytes,
-             dst_array.LengthInBytes(),
-             element_size_in_bytes);
+  ASSERT(Utils::RangeCheck(
+      src_offset_in_bytes, length_in_bytes, src_array.LengthInBytes()));
+  ASSERT(Utils::RangeCheck(
+      dst_offset_in_bytes, length_in_bytes, dst_array.LengthInBytes()));
   TypedData::Copy<DstType, SrcType>(dst_array, dst_offset_in_bytes,
                                     src_array, src_offset_in_bytes,
                                     length_in_bytes);
   return Bool::True().raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(TypedData_setRange, 5) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, dst, 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(Instance, src, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, src_start, arguments->NativeArgAt(4));
 
   if (length.Value() < 0) {
     const String& error = String::Handle(String::NewFormatted(
         "length (%" Pd ") must be non-negative", length.Value()));
     Exceptions::ThrowArgumentError(error);
   }
   if (dst.IsTypedData()) {
     if (src.IsTypedData()) {
       return CopyData<TypedData, TypedData>(
           dst, src, dst_start, src_start, length);
     } else if (src.IsExternalTypedData()) {
       return CopyData<TypedData, ExternalTypedData>(
           dst, src, dst_start, src_start, length);
     }
   } else if (dst.IsExternalTypedData()) {
     if (src.IsTypedData()) {
       return CopyData<ExternalTypedData, TypedData>(
           dst, src, dst_start, src_start, length);
     } else if (src.IsExternalTypedData()) {
       return CopyData<ExternalTypedData, ExternalTypedData>(
           dst, src, dst_start, src_start, length);
     }
   }
+  UNREACHABLE();
   return Bool::False().raw();
 }
 
-
 // We check the length parameter against a possible maximum length for the
 // array based on available physical addressable memory on the system. The
 // maximum possible length is a scaled value of kSmiMax which is set up based
 // on whether the underlying architecture is 32-bit or 64-bit.
 #define TYPED_DATA_NEW(name)                                                   \
 DEFINE_NATIVE_ENTRY(TypedData_##name##_new, 1) {                               \
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));        \
   intptr_t cid = kTypedData##name##Cid;                                        \
   intptr_t len = length.Value();                                               \
   intptr_t max = TypedData::MaxElements(cid);                                  \
@@ skipping 269 matching lines @@
     value = bit_cast<double>(
         Utils::HostToLittleEndian64(bit_cast<uint64_t>(value)));
   } else {
     value = bit_cast<double>(
         Utils::HostToBigEndian64(bit_cast<uint64_t>(value)));
   }
   return Double::New(value);
 }
 
 }  // namespace dart