| // Copyright 2017 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 --turbo-inline-array-builtins --opt | |
| // Flags: --no-always-opt | |
| // Early exit from some functions properly. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5]; | |
| let result = 0; | |
| function earlyExit() { | |
| return a.some(v => { | |
| result += v; | |
| return v > 2; | |
| }); | |
| } | |
| assertTrue(earlyExit()); | |
| earlyExit(); | |
| %OptimizeFunctionOnNextCall(earlyExit); | |
| assertTrue(earlyExit()); | |
| assertEquals(18, result); | |
| })(); | |
| // Soft-deopt plus early exit. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | |
| let result = 0; | |
| function softyPlusEarlyExit(deopt) { | |
| return a.some(v => { | |
| result += v; | |
| if (v === 4 && deopt) { | |
| a.abc = 25; | |
| } | |
| return v > 7; | |
| }); | |
| } | |
| assertTrue(softyPlusEarlyExit(false)); | |
| softyPlusEarlyExit(false); | |
| %OptimizeFunctionOnNextCall(softyPlusEarlyExit); | |
| assertTrue(softyPlusEarlyExit(true)); | |
| assertEquals(36*3, result); | |
| })(); | |
| // Soft-deopt synced with early exit, which forces the lazy deoptimization | |
| // continuation handler to exit. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | |
| let called_values = []; | |
| function softyPlusEarlyExit(deopt) { | |
| called_values = []; | |
| return a.some(v => { | |
| called_values.push(v); | |
| if (v === 4 && deopt) { | |
| a.abc = 25; | |
| return true; | |
| } | |
| return v > 7; | |
| }); | |
| } | |
| assertTrue(softyPlusEarlyExit(false)); | |
| assertArrayEquals([1, 2, 3, 4, 5, 6, 7, 8], called_values); | |
| softyPlusEarlyExit(false); | |
| %OptimizeFunctionOnNextCall(softyPlusEarlyExit); | |
| assertTrue(softyPlusEarlyExit(true)); | |
| assertArrayEquals([1, 2, 3, 4], called_values); | |
| })(); | |
| // Unknown field access leads to soft-deopt unrelated to some, should still | |
| // lead to correct result. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, | |
| 20, 21, 22, 23, 24, 25]; | |
| let result = 0; | |
| function eagerDeoptInCalled(deopt) { | |
| return a.some((v, i) => { | |
| if (i === 13 && deopt) { | |
| a.abc = 25; | |
| } | |
| result += v; | |
| return false; | |
| }); | |
| } | |
| eagerDeoptInCalled(); | |
| eagerDeoptInCalled(); | |
| %OptimizeFunctionOnNextCall(eagerDeoptInCalled); | |
| eagerDeoptInCalled(); | |
| assertFalse(eagerDeoptInCalled(true)); | |
| eagerDeoptInCalled(); | |
| assertEquals(1625, result); | |
| })(); | |
| // Length change detected during loop, must cause properly handled eager deopt. | |
| (() => { | |
| let called_values; | |
| function eagerDeoptInCalled(deopt) { | |
| const a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | |
| called_values = []; | |
| return a.some((v,i) => { | |
| called_values.push(v); | |
| a.length = (i === 5 && deopt) ? 8 : 10; | |
| return false; | |
| }); | |
| } | |
| assertFalse(eagerDeoptInCalled()); | |
| assertArrayEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], called_values); | |
| eagerDeoptInCalled(); | |
| %OptimizeFunctionOnNextCall(eagerDeoptInCalled); | |
| assertFalse(eagerDeoptInCalled()); | |
| assertFalse(eagerDeoptInCalled(true)); | |
| assertArrayEquals([1, 2, 3, 4, 5, 6, 7, 8], called_values); | |
| eagerDeoptInCalled(); | |
| })(); | |
| // Lazy deopt from a callback that changes the input array. Deopt in a callback | |
| // execution that returns true. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5]; | |
| function lazyChanger(deopt) { | |
| return a.some((v, i) => { | |
| if (i === 3 && deopt) { | |
| a[3] = 100; | |
| %DeoptimizeNow(); | |
| } | |
| return false; | |
| }); | |
| } | |
| assertFalse(lazyChanger()); | |
| lazyChanger(); | |
| %OptimizeFunctionOnNextCall(lazyChanger); | |
| assertFalse(lazyChanger(true)); | |
| assertFalse(lazyChanger()); | |
| })(); | |
| // Lazy deopt from a callback that will always return false and no element is | |
| // found. Verifies the lazy-after-callback continuation builtin. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5]; | |
| function lazyChanger(deopt) { | |
| return a.some((v, i) => { | |
| if (i === 3 && deopt) { | |
| %DeoptimizeNow(); | |
| } | |
| return false; | |
| }); | |
| } | |
| assertFalse(lazyChanger()); | |
| lazyChanger(); | |
| %OptimizeFunctionOnNextCall(lazyChanger); | |
| assertFalse(lazyChanger(true)); | |
| assertFalse(lazyChanger()); | |
| })(); | |
| // Lazy deopt from a callback that changes the input array. Deopt in a callback | |
| // execution that returns false. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5]; | |
| function lazyChanger(deopt) { | |
| return a.every((v, i) => { | |
| if (i === 2 && deopt) { | |
| a[3] = 100; | |
| %DeoptimizeNow(); | |
| } | |
| return false; | |
| }); | |
| } | |
| assertFalse(lazyChanger()); | |
| lazyChanger(); | |
| %OptimizeFunctionOnNextCall(lazyChanger); | |
| assertFalse(lazyChanger(true)); | |
| assertFalse(lazyChanger()); | |
| })(); | |
| // Escape analyzed array | |
| (() => { | |
| let result = 0; | |
| function eagerDeoptInCalled(deopt) { | |
| const a_noescape = [0, 1, 2, 3, 4, 5]; | |
| a_noescape.some((v, i) => { | |
| result += v | 0; | |
| if (i === 13 && deopt) { | |
| a_noescape.length = 25; | |
| } | |
| return false; | |
| }); | |
| } | |
| eagerDeoptInCalled(); | |
| eagerDeoptInCalled(); | |
| %OptimizeFunctionOnNextCall(eagerDeoptInCalled); | |
| eagerDeoptInCalled(); | |
| eagerDeoptInCalled(true); | |
| eagerDeoptInCalled(); | |
| assertEquals(75, result); | |
| })(); | |
| // Lazy deopt from runtime call from inlined callback function. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, | |
| 20, 21, 22, 23, 24, 25]; | |
| let result = 0; | |
| function lazyDeopt(deopt) { | |
| a.some((v, i) => { | |
| result += i; | |
| if (i === 13 && deopt) { | |
| %DeoptimizeNow(); | |
| } | |
| return false; | |
| }); | |
| } | |
| lazyDeopt(); | |
| lazyDeopt(); | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| lazyDeopt(); | |
| lazyDeopt(true); | |
| lazyDeopt(); | |
| assertEquals(1500, result); | |
| })(); | |
| // Lazy deopt from runtime call from non-inline callback function. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, | |
| 20, 21, 22, 23, 24, 25]; | |
| let result = 0; | |
| function lazyDeopt(deopt) { | |
| function callback(v, i) { | |
| result += i; | |
| if (i === 13 && deopt) { | |
| %DeoptimizeNow(); | |
| } | |
| return false; | |
| } | |
| %NeverOptimizeFunction(callback); | |
| a.some(callback); | |
| } | |
| lazyDeopt(); | |
| lazyDeopt(); | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| lazyDeopt(); | |
| lazyDeopt(true); | |
| lazyDeopt(); | |
| assertEquals(1500, result); | |
| })(); | |
| // Call to a.some is done inside a try-catch block and the callback function | |
| // being called actually throws. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, | |
| 20, 21, 22, 23, 24, 25]; | |
| let caught = false; | |
| function lazyDeopt(deopt) { | |
| try { | |
| a.some((v, i) => { | |
| if (i === 1 && deopt) { | |
| throw("a"); | |
| } | |
| return false; | |
| }); | |
| } catch (e) { | |
| caught = true; | |
| } | |
| } | |
| lazyDeopt(); | |
| lazyDeopt(); | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| lazyDeopt(); | |
| assertDoesNotThrow(() => lazyDeopt(true)); | |
| assertTrue(caught); | |
| lazyDeopt(); | |
| })(); | |
| // Call to a.some is done inside a try-catch block and the callback function | |
| // being called actually throws, but the callback is not inlined. | |
| (() => { | |
| let a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; | |
| let caught = false; | |
| function lazyDeopt(deopt) { | |
| function callback(v, i) { | |
| if (i === 1 && deopt) { | |
| throw("a"); | |
| } | |
| return false; | |
| } | |
| %NeverOptimizeFunction(callback); | |
| try { | |
| a.some(callback); | |
| } catch (e) { | |
| caught = true; | |
| } | |
| } | |
| lazyDeopt(); | |
| lazyDeopt(); | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| lazyDeopt(); | |
| assertDoesNotThrow(() => lazyDeopt(true)); | |
| assertTrue(caught); | |
| lazyDeopt(); | |
| })(); | |
| // Call to a.some is done inside a try-catch block and the callback function | |
| // being called throws into a deoptimized caller function. | |
| (function TestThrowIntoDeoptimizedOuter() { | |
| const a = [1, 2, 3, 4]; | |
| function lazyDeopt(deopt) { | |
| function callback(v, i) { | |
| if (i === 1 && deopt) { | |
| %DeoptimizeFunction(lazyDeopt); | |
| throw "some exception"; | |
| } | |
| return false; | |
| } | |
| %NeverOptimizeFunction(callback); | |
| let result = 0; | |
| try { | |
| result = a.some(callback); | |
| } catch (e) { | |
| assertEquals("some exception", e); | |
| result = "nope"; | |
| } | |
| return result; | |
| } | |
| assertEquals(false, lazyDeopt(false)); | |
| assertEquals(false, lazyDeopt(false)); | |
| assertEquals("nope", lazyDeopt(true)); | |
| assertEquals("nope", lazyDeopt(true)); | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| assertEquals(false, lazyDeopt(false)); | |
| assertEquals("nope", lazyDeopt(true)); | |
| })(); | |
| // An error generated inside the callback includes some in it's | |
| // stack trace. | |
| (() => { | |
| const re = /Array\.some/; | |
| function lazyDeopt(deopt) { | |
| const b = [1, 2, 3]; | |
| let result = 0; | |
| b.some((v, i) => { | |
| result += v; | |
| if (i === 1) { | |
| const e = new Error(); | |
| assertTrue(re.exec(e.stack) !== null); | |
| } | |
| return false; | |
| }); | |
| } | |
| lazyDeopt(); | |
| lazyDeopt(); | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| lazyDeopt(); | |
| })(); | |
| // An error generated inside a non-inlined callback function also | |
| // includes some in it's stack trace. | |
| (() => { | |
| const re = /Array\.some/; | |
| function lazyDeopt(deopt) { | |
| const b = [1, 2, 3]; | |
| let did_assert_error = false; | |
| let result = 0; | |
| function callback(v, i) { | |
| result += v; | |
| if (i === 1) { | |
| const e = new Error(); | |
| assertTrue(re.exec(e.stack) !== null); | |
| did_assert_error = true; | |
| } | |
| return false; | |
| } | |
| %NeverOptimizeFunction(callback); | |
| b.some(callback); | |
| return did_assert_error; | |
| } | |
| lazyDeopt(); | |
| lazyDeopt(); | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| assertTrue(lazyDeopt()); | |
| })(); | |
| // An error generated inside a recently deoptimized callback function | |
| // includes some in it's stack trace. | |
| (() => { | |
| const re = /Array\.some/; | |
| function lazyDeopt(deopt) { | |
| const b = [1, 2, 3]; | |
| let did_assert_error = false; | |
| let result = 0; | |
| b.some((v, i) => { | |
| result += v; | |
| if (i === 1) { | |
| %DeoptimizeNow(); | |
| } else if (i === 2) { | |
| const e = new Error(); | |
| assertTrue(re.exec(e.stack) !== null); | |
| did_assert_error = true; | |
| } | |
| return false; | |
| }); | |
| return did_assert_error; | |
| } | |
| lazyDeopt(); | |
| lazyDeopt(); | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| assertTrue(lazyDeopt()); | |
| })(); | |
| // Verify that various exception edges are handled appropriately. | |
| // The thrown Error object should always indicate it was created from | |
| // a some call stack. | |
| (() => { | |
| const re = /Array\.some/; | |
| const a = [1, 2, 3]; | |
| let result = 0; | |
| function lazyDeopt() { | |
| a.some((v, i) => { | |
| result += i; | |
| if (i === 1) { | |
| %DeoptimizeFunction(lazyDeopt); | |
| throw new Error(); | |
| } | |
| return false; | |
| }); | |
| } | |
| assertThrows(() => lazyDeopt()); | |
| assertThrows(() => lazyDeopt()); | |
| try { | |
| lazyDeopt(); | |
| } catch (e) { | |
| assertTrue(re.exec(e.stack) !== null); | |
| } | |
| %OptimizeFunctionOnNextCall(lazyDeopt); | |
| try { | |
| lazyDeopt(); | |
| } catch (e) { | |
| assertTrue(re.exec(e.stack) !== null); | |
| } | |
| })(); | |
| // Messing with the Array prototype causes deoptimization. | |
| (() => { | |
| const a = [1, 2, 3]; | |
| let result = 0; | |
| function prototypeChanged() { | |
| a.some((v, i) => { | |
| result += v; | |
| return false; | |
| }); | |
| } | |
| prototypeChanged(); | |
| prototypeChanged(); | |
| %OptimizeFunctionOnNextCall(prototypeChanged); | |
| prototypeChanged(); | |
| a.constructor = {}; | |
| prototypeChanged(); | |
| assertUnoptimized(prototypeChanged); | |
| assertEquals(24, result); | |
| })(); | |
| // Verify holes are skipped. | |
| (() => { | |
| const a = [1, 2, , 3, 4]; | |
| function withHoles() { | |
| const callback_values = []; | |
| a.some(v => { | |
| callback_values.push(v); | |
| return false; | |
| }); | |
| return callback_values; | |
| } | |
| withHoles(); | |
| withHoles(); | |
| %OptimizeFunctionOnNextCall(withHoles); | |
| assertArrayEquals([1, 2, 3, 4], withHoles()); | |
| })(); | |
| (() => { | |
| const a = [1.5, 2.5, , 3.5, 4.5]; | |
| function withHoles() { | |
| const callback_values = []; | |
| a.some(v => { | |
| callback_values.push(v); | |
| return false; | |
| }); | |
| return callback_values; | |
| } | |
| withHoles(); | |
| withHoles(); | |
| %OptimizeFunctionOnNextCall(withHoles); | |
| assertArrayEquals([1.5, 2.5, 3.5, 4.5], withHoles()); | |
| })(); | |
| // Handle callback is not callable. | |
| (() => { | |
| const a = [1, 2, 3, 4, 5]; | |
| function notCallable() { | |
| return a.some(undefined); | |
| } | |
| assertThrows(notCallable, TypeError); | |
| try { notCallable(); } catch(e) { } | |
| %OptimizeFunctionOnNextCall(notCallable); | |
| assertThrows(notCallable, TypeError); | |
| })(); |