From 06cd4ed7b2797a34f02df1e5cb6478c186552ed8 Mon Sep 17 00:00:00 2001 From: "srdjan@google.com" Date: Wed, 23 Jan 2013 17:43:58 +0000 Subject: [PATCH] Fix native lookup. Fix external byte arrays. Review URL: https://codereview.chromium.org//12033036 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@17478 260f80e4-7a28-3924-810f-c04153c831b5 --- runtime/lib/byte_array.cc | 35 ++++++--- runtime/lib/byte_array.dart | 121 ++++++++++++-------------------- runtime/vm/bootstrap_natives.cc | 2 +- runtime/vm/os.h | 3 +- 4 files changed, 73 insertions(+), 88 deletions(-) diff --git a/runtime/lib/byte_array.cc b/runtime/lib/byte_array.cc index f34c56bd76c..e5930ffe89b 100644 --- a/runtime/lib/byte_array.cc +++ b/runtime/lib/byte_array.cc @@ -22,7 +22,7 @@ static void RangeCheck(const ByteArray& array, 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, (array.ByteLength() / num_bytes))); + (index / num_bytes), (array.ByteLength() / num_bytes))); const Array& args = Array::Handle(Array::New(1)); args.SetAt(0, error); Exceptions::ThrowByType(Exceptions::kRange, args); @@ -86,6 +86,23 @@ static void LengthCheck(intptr_t len, intptr_t max) { 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(Mint::kMaxValue)) { \ result = BigintOperations::NewFromUint64(value); \ @@ -665,24 +682,24 @@ DEFINE_NATIVE_ENTRY(ExternalInt8Array_setIndexed, 3) { // ExternalUint8Array DEFINE_NATIVE_ENTRY(ExternalUint8Array_getIndexed, 2) { - UNALIGNED_GETTER(ExternalUint8Array, Smi, uint8_t); + SCALED_UNALIGNED_GETTER(ExternalUint8Array, Smi, uint8_t); } DEFINE_NATIVE_ENTRY(ExternalUint8Array_setIndexed, 3) { - UNALIGNED_SETTER(ExternalUint8Array, Smi, Value, uint8_t); + SCALED_UNALIGNED_SETTER(ExternalUint8Array, Smi, Value, uint8_t); } // ExternalUint8ClampedArray DEFINE_NATIVE_ENTRY(ExternalUint8ClampedArray_getIndexed, 2) { - UNALIGNED_GETTER(ExternalUint8ClampedArray, Smi, uint8_t); + SCALED_UNALIGNED_GETTER(ExternalUint8ClampedArray, Smi, uint8_t); } DEFINE_NATIVE_ENTRY(ExternalUint8ClampedArray_setIndexed, 3) { - UNALIGNED_SETTER(ExternalUint8ClampedArray, Smi, Value, uint8_t); + SCALED_UNALIGNED_SETTER(ExternalUint8ClampedArray, Smi, Value, uint8_t); } @@ -701,12 +718,12 @@ DEFINE_NATIVE_ENTRY(ExternalInt16Array_setIndexed, 3) { // ExternalUint16Array DEFINE_NATIVE_ENTRY(ExternalUint16Array_getIndexed, 2) { - UNALIGNED_GETTER(ExternalUint16Array, Smi, uint16_t); + SCALED_UNALIGNED_GETTER(ExternalUint16Array, Smi, uint16_t); } DEFINE_NATIVE_ENTRY(ExternalUint16Array_setIndexed, 3) { - UNALIGNED_SETTER(ExternalUint16Array, Smi, Value, uint16_t); + SCALED_UNALIGNED_SETTER(ExternalUint16Array, Smi, Value, uint16_t); } @@ -725,12 +742,12 @@ DEFINE_NATIVE_ENTRY(ExternalInt32Array_setIndexed, 3) { // ExternalUint32Array DEFINE_NATIVE_ENTRY(ExternalUint32Array_getIndexed, 2) { - UNALIGNED_GETTER(ExternalUint32Array, Integer, uint32_t); + SCALED_UNALIGNED_GETTER(ExternalUint32Array, Integer, uint32_t); } DEFINE_NATIVE_ENTRY(ExternalUint32Array_setIndexed, 3) { - UNALIGNED_SETTER(ExternalUint32Array, Integer, AsInt64Value, uint32_t); + SCALED_UNALIGNED_SETTER(ExternalUint32Array, Integer, AsInt64Value, uint32_t); } diff --git a/runtime/lib/byte_array.dart b/runtime/lib/byte_array.dart index 941d818d106..fca6af623ad 100644 --- a/runtime/lib/byte_array.dart +++ b/runtime/lib/byte_array.dart @@ -8,13 +8,16 @@ patch class Int8List { } /* patch */ factory Int8List.transferable(int length) { - return new _Int8Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Int8List.view(ByteArray array, [int start = 0, int length]) { return new _Int8ArrayView(array, start, length); } + + static _ExternalInt8Array _newTransferable(int length) + native "Int8Array_newTransferable"; } @@ -24,13 +27,16 @@ patch class Uint8List { } /* patch */ factory Uint8List.transferable(int length) { - return new _Uint8Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Uint8List.view(ByteArray array, [int start = 0, int length]) { return new _Uint8ArrayView(array, start, length); } + + static _ExternalUint8Array _newTransferable(int length) + native "Uint8Array_newTransferable"; } @@ -40,13 +46,16 @@ patch class Uint8ClampedList { } /* patch */ factory Uint8ClampedList.transferable(int length) { - return new _Uint8ClampedArray.transferable(length); + return _newTransferable(length); } /* patch */ factory Uint8ClampedList.view(ByteArray array, [int start = 0, int length]) { return new _Uint8ClampedArrayView(array, start, length); } + + static _ExternalUint8ClampedArray _newTransferable(int length) + native "Uint8ClampedArray_newTransferable"; } @@ -56,13 +65,16 @@ patch class Int16List { } /* patch */ factory Int16List.transferable(int length) { - return new _Int16Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Int16List.view(ByteArray array, [int start = 0, int length]) { return new _Int16ArrayView(array, start, length); } + + static _ExternalInt16Array _newTransferable(int length) + native "Int16Array_newTransferable"; } @@ -72,13 +84,16 @@ patch class Uint16List { } /* patch */ factory Uint16List.transferable(int length) { - return new _Uint16Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Uint16List.view(ByteArray array, [int start = 0, int length]) { return new _Uint16ArrayView(array, start, length); } + + static _ExternalUint16Array _newTransferable(int length) + native "Uint16Array_newTransferable"; } @@ -88,13 +103,16 @@ patch class Int32List { } /* patch */ factory Int32List.transferable(int length) { - return new _Int32Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Int32List.view(ByteArray array, [int start = 0, int length]) { return new _Int32ArrayView(array, start, length); } + + static _ExternalInt32Array _newTransferable(int length) + native "Int32Array_newTransferable"; } @@ -104,13 +122,16 @@ patch class Uint32List { } /* patch */ factory Uint32List.transferable(int length) { - return new _Uint32Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Uint32List.view(ByteArray array, [int start = 0, int length]) { return new _Uint32ArrayView(array, start, length); } + + static _ExternalUint32Array _newTransferable(int length) + native "Uint32Array_newTransferable"; } @@ -120,13 +141,16 @@ patch class Int64List { } /* patch */ factory Int64List.transferable(int length) { - return new _Int64Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Int64List.view(ByteArray array, [int start = 0, int length]) { return new _Int64ArrayView(array, start, length); } + + static _ExternalInt64Array _newTransferable(int length) + native "Int64Array_newTransferable"; } @@ -136,13 +160,16 @@ patch class Uint64List { } /* patch */ factory Uint64List.transferable(int length) { - return new _Uint64Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Uint64List.view(ByteArray array, [int start = 0, int length]) { return new _Uint64ArrayView(array, start, length); } + + static _ExternalUint64Array _newTransferable(int length) + native "Uint64Array_newTransferable"; } @@ -152,13 +179,16 @@ patch class Float32List { } /* patch */ factory Float32List.transferable(int length) { - return new _Float32Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Float32List.view(ByteArray array, [int start = 0, int length]) { return new _Float32ArrayView(array, start, length); } + + static _ExternalFloat32Array _newTransferable(int length) + native "Float32Array_newTransferable"; } @@ -168,13 +198,16 @@ patch class Float64List { } /* patch */ factory Float64List.transferable(int length) { - return new _Float64Array.transferable(length); + return _newTransferable(length); } /* patch */ factory Float64List.view(ByteArray array, [int start = 0, int length]) { return new _Float64ArrayView(array, start, length); } + + static _ExternalFloat64Array _newTransferable(int length) + native "Float64Array_newTransferable"; } @@ -497,10 +530,6 @@ class _Int8Array extends _ByteArrayBase implements Int8List { return _new(length); } - factory _Int8Array.transferable(int length) { - return _newTransferable(length); - } - factory _Int8Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = array.lengthInBytes(); @@ -553,8 +582,6 @@ class _Int8Array extends _ByteArrayBase implements Int8List { static const int _BYTES_PER_ELEMENT = 1; static _Int8Array _new(int length) native "Int8Array_new"; - static _Int8Array _newTransferable(int length) - native "Int8Array_newTransferable"; int _getIndexed(int index) native "Int8Array_getIndexed"; int _setIndexed(int index, int value) native "Int8Array_setIndexed"; @@ -566,10 +593,6 @@ class _Uint8Array extends _ByteArrayBase implements Uint8List { return _new(length); } - factory _Uint8Array.transferable(int length) { - return _newTransferable(length); - } - factory _Uint8Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = array.lengthInBytes(); @@ -623,8 +646,6 @@ class _Uint8Array extends _ByteArrayBase implements Uint8List { static const int _BYTES_PER_ELEMENT = 1; static _Uint8Array _new(int length) native "Uint8Array_new"; - static _Uint8Array _newTransferable(int length) - native "Uint8Array_newTransferable"; int _getIndexed(int index) native "Uint8Array_getIndexed"; int _setIndexed(int index, int value) native "Uint8Array_setIndexed"; @@ -636,10 +657,6 @@ class _Uint8ClampedArray extends _ByteArrayBase implements Uint8ClampedList { return _new(length); } - factory _Uint8ClampedArray.transferable(int length) { - return _newTransferable(length); - } - factory _Uint8ClampedArray.view(ByteArray array, [int start = 0, int length]) { if (length == null) { @@ -694,8 +711,6 @@ class _Uint8ClampedArray extends _ByteArrayBase implements Uint8ClampedList { static const int _BYTES_PER_ELEMENT = 1; static _Uint8ClampedArray _new(int length) native "Uint8ClampedArray_new"; - static _Uint8ClampedArray _newTransferable(int length) - native "Uint8ClampedArray_newTransferable"; int _getIndexed(int index) native "Uint8ClampedArray_getIndexed"; int _setIndexed(int index, int value) native "Uint8ClampedArray_setIndexed"; @@ -707,10 +722,6 @@ class _Int16Array extends _ByteArrayBase implements Int16List { return _new(length); } - factory _Int16Array.transferable(int length) { - return _newTransferable(length); - } - factory _Int16Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; @@ -763,8 +774,6 @@ class _Int16Array extends _ByteArrayBase implements Int16List { static const int _BYTES_PER_ELEMENT = 2; static _Int16Array _new(int length) native "Int16Array_new"; - static _Int16Array _newTransferable(int length) - native "Int16Array_newTransferable"; int _getIndexed(int index) native "Int16Array_getIndexed"; int _setIndexed(int index, int value) native "Int16Array_setIndexed"; @@ -776,10 +785,6 @@ class _Uint16Array extends _ByteArrayBase implements Uint16List { return _new(length); } - factory _Uint16Array.transferable(int length) { - return _newTransferable(length); - } - factory _Uint16Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; @@ -832,8 +837,6 @@ class _Uint16Array extends _ByteArrayBase implements Uint16List { static const int _BYTES_PER_ELEMENT = 2; static _Uint16Array _new(int length) native "Uint16Array_new"; - static _Uint16Array _newTransferable(int length) - native "Uint16Array_newTransferable"; int _getIndexed(int index) native "Uint16Array_getIndexed"; int _setIndexed(int index, int value) native "Uint16Array_setIndexed"; @@ -845,10 +848,6 @@ class _Int32Array extends _ByteArrayBase implements Int32List { return _new(length); } - factory _Int32Array.transferable(int length) { - return _newTransferable(length); - } - factory _Int32Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; @@ -901,8 +900,6 @@ class _Int32Array extends _ByteArrayBase implements Int32List { static const int _BYTES_PER_ELEMENT = 4; static _Int32Array _new(int length) native "Int32Array_new"; - static _Int32Array _newTransferable(int length) - native "Int32Array_newTransferable"; int _getIndexed(int index) native "Int32Array_getIndexed"; @@ -915,10 +912,6 @@ class _Uint32Array extends _ByteArrayBase implements Uint32List { return _new(length); } - factory _Uint32Array.transferable(int length) { - return _newTransferable(length); - } - factory _Uint32Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; @@ -971,8 +964,6 @@ class _Uint32Array extends _ByteArrayBase implements Uint32List { static const int _BYTES_PER_ELEMENT = 4; static _Uint32Array _new(int length) native "Uint32Array_new"; - static _Uint32Array _newTransferable(int length) - native "Uint32Array_newTransferable"; int _getIndexed(int index) native "Uint32Array_getIndexed"; int _setIndexed(int index, int value) native "Uint32Array_setIndexed"; @@ -984,10 +975,6 @@ class _Int64Array extends _ByteArrayBase implements Int64List { return _new(length); } - factory _Int64Array.transferable(int length) { - return _newTransferable(length); - } - factory _Int64Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; @@ -1040,8 +1027,6 @@ class _Int64Array extends _ByteArrayBase implements Int64List { static const int _BYTES_PER_ELEMENT = 8; static _Int64Array _new(int length) native "Int64Array_new"; - static _Int64Array _newTransferable(int length) - native "Int64Array_newTransferable"; int _getIndexed(int index) native "Int64Array_getIndexed"; int _setIndexed(int index, int value) native "Int64Array_setIndexed"; @@ -1053,10 +1038,6 @@ class _Uint64Array extends _ByteArrayBase implements Uint64List { return _new(length); } - factory _Uint64Array.transferable(int length) { - return _newTransferable(length); - } - factory _Uint64Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; @@ -1109,8 +1090,6 @@ class _Uint64Array extends _ByteArrayBase implements Uint64List { static const int _BYTES_PER_ELEMENT = 8; static _Uint64Array _new(int length) native "Uint64Array_new"; - static _Uint64Array _newTransferable(int length) - native "Uint64Array_newTransferable"; int _getIndexed(int index) native "Uint64Array_getIndexed"; int _setIndexed(int index, int value) native "Uint64Array_setIndexed"; @@ -1122,10 +1101,6 @@ class _Float32Array extends _ByteArrayBase implements Float32List { return _new(length); } - factory _Float32Array.transferable(int length) { - return _newTransferable(length); - } - factory _Float32Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; @@ -1178,8 +1153,6 @@ class _Float32Array extends _ByteArrayBase implements Float32List { static const int _BYTES_PER_ELEMENT = 4; static _Float32Array _new(int length) native "Float32Array_new"; - static _Float32Array _newTransferable(int length) - native "Float32Array_newTransferable"; double _getIndexed(int index) native "Float32Array_getIndexed"; int _setIndexed(int index, double value) native "Float32Array_setIndexed"; @@ -1191,10 +1164,6 @@ class _Float64Array extends _ByteArrayBase implements Float64List { return _new(length); } - factory _Float64Array.transferable(int length) { - return _newTransferable(length); - } - factory _Float64Array.view(ByteArray array, [int start = 0, int length]) { if (length == null) { length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT; @@ -1247,8 +1216,6 @@ class _Float64Array extends _ByteArrayBase implements Float64List { static const int _BYTES_PER_ELEMENT = 8; static _Float64Array _new(int length) native "Float64Array_new"; - static _Float64Array _newTransferable(int length) - native "Float64Array_newTransferable"; double _getIndexed(int index) native "Float64Array_getIndexed"; int _setIndexed(int index, double value) native "Float64Array_setIndexed"; diff --git a/runtime/vm/bootstrap_natives.cc b/runtime/vm/bootstrap_natives.cc index 164b33d9a02..3b65e03ecaf 100644 --- a/runtime/vm/bootstrap_natives.cc +++ b/runtime/vm/bootstrap_natives.cc @@ -41,7 +41,7 @@ Dart_NativeFunction BootstrapNatives::Lookup(Dart_Handle name, int num_entries = sizeof(BootStrapEntries) / sizeof(struct NativeEntries); for (int i = 0; i < num_entries; i++) { struct NativeEntries* entry = &(BootStrapEntries[i]); - if (!strncmp(function_name, entry->name_, strlen(entry->name_)) && + if ((strcmp(function_name, entry->name_) == 0) && (entry->argument_count_ == argument_count)) { return reinterpret_cast(entry->function_); } diff --git a/runtime/vm/os.h b/runtime/vm/os.h index 8829b463099..cde6268cc55 100644 --- a/runtime/vm/os.h +++ b/runtime/vm/os.h @@ -40,12 +40,13 @@ class OS { // from midnight January 1, 1970 UTC. static int64_t GetCurrentTimeMicros(); - // Returns an aligned array of type T with n entries. + // Returns a cleared aligned array of type T with n entries. // Alignment must be >= 16 and a power of two. template static T* AllocateAlignedArray(intptr_t n, intptr_t alignment) { T* result = reinterpret_cast(OS::AlignedAllocate(n * sizeof(*result), alignment)); + memset(result, 0, n * sizeof(*result)); return result; }