Expose transferable constructor to Int8List

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"
@@ skipping 24 matching lines @@
 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));
     GrowableArray<const Object*> args;
     args.Add(&error);
     Exceptions::ThrowByType(Exceptions::kArgument, args);
   }
 }
 
+// Allocates an aligned region of len bytes from the C heap.
+static void* AllocateExternalBytes(intptr_t len, intptr_t alignment = 16) {

[cshapiro, 2012/11/28 22:28:01]

Maybe stick this constant into the base class of the external byte arrays.

+  intptr_t pointersize = sizeof(len);
+  intptr_t slop = alignment+pointersize;

[srdjan, 2012/11/28 23:30:26]

please add spaces around +, - and everywhere else in new code.

+  void* bytes = malloc(len+slop);

[srdjan, 2012/11/28 23:30:26]

why not intptr_t* ptr = reinterpret_cast<intptr_t*>(malloc(...)), getting rid of
"bytes* void"? Why is ptr intptr_t instead of intptr_t* ?

+  intptr_t ptr = reinterpret_cast<intptr_t>(bytes);
+  // Move forward and then round down to the alignment boundary.
+  ptr += slop;
+  ptr &= (alignment-1);
+  // Store the original address immediately before the address we return.
+  intptr_t* address_slot = reinterpret_cast<intptr_t*>(ptr-pointersize);
+  *address_slot = reinterpret_cast<intptr_t>(bytes);
+  return reinterpret_cast<void*>(ptr);
+}
+
+// Free an aligned region of memory
+// that was allocated by AllocateExternalBytes.
+// Called as a Dart_PeerFinalizer callback.
+static void FinalizeExternalBytes(void* bytes) {
+  intptr_t pointersize = sizeof(bytes);
+  intptr_t ptr = reinterpret_cast<intptr_t>(bytes);

[srdjan, 2012/11/28 23:30:26]

ditto

+  intptr_t* address_slot = reinterpret_cast<intptr_t*>(ptr-pointersize);
+  void* bytes = reinterpret_cast<void*>(*address_slot);
+  free(bytes);
+}
+
 
 #define GETTER_ARGUMENTS(ArrayT, ValueT)                                \
   GET_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0));        \
   GET_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));
 
 
 #define SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT)                       \
   GET_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0));        \
   GET_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));           \
   GET_NATIVE_ARGUMENT(ObjectT, value_object, arguments->NativeArgAt(2));
@@ skipping 223 matching lines @@
 // Int8Array
 
 DEFINE_NATIVE_ENTRY(Int8Array_new, 1) {
   GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
   intptr_t len = length.Value();
   LengthCheck(len, Int8Array::kMaxElements);
   return Int8Array::New(len);
 }
 
 
+DEFINE_NATIVE_ENTRY(Int8Array_newTransferrable, 1) {
+  GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
+  intptr_t len = length.Value();
+  LengthCheck(len, Int8Array::kMaxElements);
+  void* bytes = AllocateExternalBytes(len);
+  return ExternalInt8Array::New(reinterpret_cast<int8_t*>(bytes),
+                                len,
+                                bytes,
+                                FinalizeExternalBytes);
+}
+
+
 DEFINE_NATIVE_ENTRY(Int8Array_getIndexed, 2) {
   GETTER(Int8Array, Smi, int8_t);
 }
 
 
 DEFINE_NATIVE_ENTRY(Int8Array_setIndexed, 3) {
   SETTER(Int8Array, Smi, Value, int8_t);
 }
 
 
@@ skipping 290 matching lines @@
 DEFINE_NATIVE_ENTRY(ExternalFloat64Array_getIndexed, 2) {
   GETTER(ExternalFloat64Array, Double, double);
 }
 
 
 DEFINE_NATIVE_ENTRY(ExternalFloat64Array_setIndexed, 3) {
   SETTER(ExternalFloat64Array, Double, value, double);
 }
 
 }  // namespace dart