diff options
author | Michaël Zasso <targos@protonmail.com> | 2018-12-04 08:20:37 +0100 |
---|---|---|
committer | Michaël Zasso <targos@protonmail.com> | 2018-12-06 15:23:33 +0100 |
commit | 9b4bf7de6c9a7c25f116c7a502384c20b5cfaea3 (patch) | |
tree | 2b0c843168dafb939d8df8a15b2aa72b76dee51d /deps/v8/test/mjsunit/compiler/dataview-neutered.js | |
parent | b8fbe69db1292307adb2c2b2e0d5ef48c4ab2faf (diff) | |
download | android-node-v8-9b4bf7de6c9a7c25f116c7a502384c20b5cfaea3.tar.gz android-node-v8-9b4bf7de6c9a7c25f116c7a502384c20b5cfaea3.tar.bz2 android-node-v8-9b4bf7de6c9a7c25f116c7a502384c20b5cfaea3.zip |
deps: update V8 to 7.1.302.28
PR-URL: https://github.com/nodejs/node/pull/23423
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Myles Borins <myles.borins@gmail.com>
Diffstat (limited to 'deps/v8/test/mjsunit/compiler/dataview-neutered.js')
-rw-r--r-- | deps/v8/test/mjsunit/compiler/dataview-neutered.js | 376 |
1 files changed, 376 insertions, 0 deletions
diff --git a/deps/v8/test/mjsunit/compiler/dataview-neutered.js b/deps/v8/test/mjsunit/compiler/dataview-neutered.js new file mode 100644 index 0000000000..54b35f73c8 --- /dev/null +++ b/deps/v8/test/mjsunit/compiler/dataview-neutered.js @@ -0,0 +1,376 @@ +// Copyright 2018 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax --opt --noalways-opt + +// Invalidate the neutering protector. +%ArrayBufferNeuter(new ArrayBuffer(1)); + +// Check DataView.prototype.getInt8() optimization. +(function() { + const ab = new ArrayBuffer(1); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getInt8(0); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getUint8() optimization. +(function() { + const ab = new ArrayBuffer(1); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getUint8(0); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getInt16() optimization. +(function() { + const ab = new ArrayBuffer(2); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getInt16(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getUint16() optimization. +(function() { + const ab = new ArrayBuffer(2); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getUint16(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getInt32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getInt32(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getUint32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getUint32(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getFloat32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getFloat32(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.getFloat64() optimization. +(function() { + const ab = new ArrayBuffer(8); + const dv = new DataView(ab); + + function foo(dv) { + return dv.getFloat64(0, true); + } + + assertEquals(0, foo(dv)); + assertEquals(0, foo(dv)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(0, foo(dv)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setInt8() optimization. +(function() { + const ab = new ArrayBuffer(1); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setInt8(0, x); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getInt8(0)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getInt8(0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setUint8() optimization. +(function() { + const ab = new ArrayBuffer(1); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setUint8(0, x); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getUint8(0)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getUint8(0)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setInt16() optimization. +(function() { + const ab = new ArrayBuffer(2); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setInt16(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getInt16(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getInt16(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setUint16() optimization. +(function() { + const ab = new ArrayBuffer(2); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setUint16(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getUint16(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getUint16(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setInt32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setInt32(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getInt32(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getInt32(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setUint32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setUint32(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getUint32(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getUint32(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setFloat32() optimization. +(function() { + const ab = new ArrayBuffer(4); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setFloat32(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getFloat32(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getFloat32(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); + +// Check DataView.prototype.setFloat64() optimization. +(function() { + const ab = new ArrayBuffer(8); + const dv = new DataView(ab); + + function foo(dv, x) { + return dv.setFloat64(0, x, true); + } + + assertEquals(undefined, foo(dv, 1)); + assertEquals(1, dv.getFloat64(0, true)); + assertEquals(undefined, foo(dv, 2)); + assertEquals(2, dv.getFloat64(0, true)); + %OptimizeFunctionOnNextCall(foo); + assertEquals(undefined, foo(dv, 3)); + assertOptimized(foo); + %ArrayBufferNeuter(ab); + assertThrows(() => foo(dv, 4), TypeError); + assertUnoptimized(foo); + %OptimizeFunctionOnNextCall(foo); + assertThrows(() => foo(dv, 5), TypeError); + assertOptimized(foo); +})(); |