Further extend TypedArray support in d8:

test/mjsunit/external-array.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Flags: --allow-natives-syntax --expose-gc
 
+// Helper
+function assertInstance(o, f) {
+  assertSame(o.constructor, f);
+  assertInstanceof(o, f);
+}
+
 // This is a regression test for overlapping key and value registers.
 function f(a) {
   a[0] = 0;
   a[1] = 0;
 }
 
 var a = new Int32Array(2);
 for (var i = 0; i < 5; i++) {
   f(a);
 }
 %OptimizeFunctionOnNextCall(f);
 f(a);
 
 assertEquals(0, a[0]);
 assertEquals(0, a[1]);
 
 // No-parameter constructor should fail right now.
 function abfunc1() {
   return new ArrayBuffer();
 }
 assertThrows(abfunc1);
 
 // Test derivation from an ArrayBuffer
 var ab = new ArrayBuffer(12);
+assertInstance(ab, ArrayBuffer);
 var derived_uint8 = new Uint8Array(ab);
+assertInstance(derived_uint8, Uint8Array);
 assertSame(ab, derived_uint8.buffer);
 assertEquals(12, derived_uint8.length);
 assertEquals(12, derived_uint8.byteLength);
 assertEquals(0, derived_uint8.byteOffset);
 assertEquals(1, derived_uint8.BYTES_PER_ELEMENT);
 var derived_uint8_2 = new Uint8Array(ab,7);
+assertInstance(derived_uint8_2, Uint8Array);
 assertSame(ab, derived_uint8_2.buffer);
 assertEquals(5, derived_uint8_2.length);
 assertEquals(5, derived_uint8_2.byteLength);
 assertEquals(7, derived_uint8_2.byteOffset);
 assertEquals(1, derived_uint8_2.BYTES_PER_ELEMENT);
 var derived_int16 = new Int16Array(ab);
+assertInstance(derived_int16, Int16Array);
 assertSame(ab, derived_int16.buffer);
 assertEquals(6, derived_int16.length);
 assertEquals(12, derived_int16.byteLength);
 assertEquals(0, derived_int16.byteOffset);
 assertEquals(2, derived_int16.BYTES_PER_ELEMENT);
 var derived_int16_2 = new Int16Array(ab,6);
+assertInstance(derived_int16_2, Int16Array);
 assertSame(ab, derived_int16_2.buffer);
 assertEquals(3, derived_int16_2.length);
 assertEquals(6, derived_int16_2.byteLength);
 assertEquals(6, derived_int16_2.byteOffset);
 assertEquals(2, derived_int16_2.BYTES_PER_ELEMENT);
 var derived_uint32 = new Uint32Array(ab);
+assertInstance(derived_uint32, Uint32Array);
 assertSame(ab, derived_uint32.buffer);
 assertEquals(3, derived_uint32.length);
 assertEquals(12, derived_uint32.byteLength);
 assertEquals(0, derived_uint32.byteOffset);
 assertEquals(4, derived_uint32.BYTES_PER_ELEMENT);
 var derived_uint32_2 = new Uint32Array(ab,4);
+assertInstance(derived_uint32_2, Uint32Array);
 assertSame(ab, derived_uint32_2.buffer);
 assertEquals(2, derived_uint32_2.length);
 assertEquals(8, derived_uint32_2.byteLength);
 assertEquals(4, derived_uint32_2.byteOffset);
 assertEquals(4, derived_uint32_2.BYTES_PER_ELEMENT);
 var derived_uint32_3 = new Uint32Array(ab,4,1);
+assertInstance(derived_uint32_3, Uint32Array);
 assertSame(ab, derived_uint32_3.buffer);
 assertEquals(1, derived_uint32_3.length);
 assertEquals(4, derived_uint32_3.byteLength);
 assertEquals(4, derived_uint32_3.byteOffset);
 assertEquals(4, derived_uint32_3.BYTES_PER_ELEMENT);
 var derived_float64 = new Float64Array(ab,0,1);
+assertInstance(derived_float64, Float64Array);
 assertSame(ab, derived_float64.buffer);
 assertEquals(1, derived_float64.length);
 assertEquals(8, derived_float64.byteLength);
 assertEquals(0, derived_float64.byteOffset);
 assertEquals(8, derived_float64.BYTES_PER_ELEMENT);
 
 // If a given byteOffset and length references an area beyond the end of the
 // ArrayBuffer an exception is raised.
 function abfunc3() {
   new Uint32Array(ab,4,3);
@@ skipping 84 matching lines @@
 var foo = { valueOf: function() { return 3; } };
 array_with_length_from_non_number = new Int32Array(foo);
 assertEquals(3, array_with_length_from_non_number.length);
 foo = { toString: function() { return "4"; } };
 array_with_length_from_non_number = new Int32Array(foo);
 assertEquals(4, array_with_length_from_non_number.length);
 
 
 // Test loads and stores.
 types = [Array, Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array,
-         Uint32Array, PixelArray, Float32Array, Float64Array];
+         Uint32Array, Uint8ClampedArray, Float32Array, Float64Array];
 
 test_result_nan = [NaN, 0, 0, 0, 0, 0, 0, 0, NaN, NaN];
 test_result_low_int = [-1, -1, 255, -1, 65535, -1, 0xFFFFFFFF, 0, -1, -1];
 test_result_low_double = [-1.25, -1, 255, -1, 65535, -1, 0xFFFFFFFF, 0, -1.25, -1.25];
 test_result_middle = [253.75, -3, 253, 253, 253, 253, 253, 254, 253.75, 253.75];
 test_result_high_int = [256, 0, 0, 256, 256, 256, 256, 255, 256, 256];
 test_result_high_double = [256.25, 0, 0, 256, 256, 256, 256, 255, 256.25, 256.25];
 
 const kElementCount = 40;
 
@@ skipping 193 matching lines @@
 // Make sure the ICs do it right
 store_float64_undefined(float64_array);
 assertTrue(isNaN(float64_array[0]));
 // Make sure that Cranskshft does it right.
 %OptimizeFunctionOnNextCall(store_float64_undefined);
 store_float64_undefined(float64_array);
 assertTrue(isNaN(float64_array[0]));
 
 
 // Check handling of 0-sized buffers and arrays.
-
 ab = new ArrayBuffer(0);
+assertInstance(ab, ArrayBuffer);
 assertEquals(0, ab.byteLength);
 a = new Int8Array(ab);
+assertInstance(a, Int8Array);
 assertEquals(0, a.byteLength);
 assertEquals(0, a.length);
 a[0] = 1;
-assertEquals(undefined, a[0])
+assertEquals(undefined, a[0]);
 ab = new ArrayBuffer(16);
+assertInstance(ab, ArrayBuffer);
 a = new Float32Array(ab,4,0);
+assertInstance(a, Float32Array);
 assertEquals(0, a.byteLength);
 assertEquals(0, a.length);
 a[0] = 1;
-assertEquals(undefined, a[0])
+assertEquals(undefined, a[0]);
 a = new Uint16Array(0);
+assertInstance(a, Uint16Array);
 assertEquals(0, a.byteLength);
 assertEquals(0, a.length);
 a[0] = 1;
-assertEquals(undefined, a[0])
+assertEquals(undefined, a[0]);
+
+
+// Check construction from arrays.
+a = new Uint32Array([]);
+assertInstance(a, Uint32Array);
+assertEquals(0, a.length);
+assertEquals(0, a.byteLength);
+assertEquals(0, a.buffer.byteLength);
+assertEquals(4, a.BYTES_PER_ELEMENT);
+a = new Uint16Array([1,2,3]);
+assertInstance(a, Uint16Array);
+assertEquals(3, a.length);
+assertEquals(6, a.byteLength);
+assertEquals(6, a.buffer.byteLength);
+assertEquals(2, a.BYTES_PER_ELEMENT);
+assertEquals(1, a[0]);
+assertEquals(3, a[2]);
+a = new Uint32Array(a);
+assertInstance(a, Uint32Array);
+assertEquals(3, a.length);
+assertEquals(12, a.byteLength);
+assertEquals(12, a.buffer.byteLength);
+assertEquals(4, a.BYTES_PER_ELEMENT);
+assertEquals(1, a[0]);
+assertEquals(3, a[2]);
+
+
+// Check subarrays.
+a = new Uint16Array([1,2,3,4,5,6]);
+aa = a.subarray(3);
+assertInstance(aa, Uint16Array);
+assertEquals(3, aa.length);
+assertEquals(6, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(3,5);
+assertInstance(aa, Uint16Array);
+assertEquals(2, aa.length);
+assertEquals(4, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(4,8);
+assertInstance(aa, Uint16Array);
+assertEquals(2, aa.length);
+assertEquals(4, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(9);
+assertInstance(aa, Uint16Array);
+assertEquals(0, aa.length);
+assertEquals(0, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(-4);
+assertInstance(aa, Uint16Array);
+assertEquals(4, aa.length);
+assertEquals(8, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(-3,-1);
+assertInstance(aa, Uint16Array);
+assertEquals(2, aa.length);
+assertEquals(4, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(3,2);
+assertInstance(aa, Uint16Array);
+assertEquals(0, aa.length);
+assertEquals(0, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(-3,-4);
+assertInstance(aa, Uint16Array);
+assertEquals(0, aa.length);
+assertEquals(0, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+aa = a.subarray(0,-8);
+assertInstance(aa, Uint16Array);
+assertEquals(0, aa.length);
+assertEquals(0, aa.byteLength);
+assertEquals(2, aa.BYTES_PER_ELEMENT);
+assertSame(a.buffer, aa.buffer);
+
+assertThrows(function(){ a.subarray.call({}, 0) });
+assertThrows(function(){ a.subarray.call([], 0) });
+assertThrows(function(){ a.subarray.call(a) });