blob: f41c9333b7ed82884c3b00894ebfaaef44c690e2 (
plain)
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
// Copyright 2021 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-optimize-apply --opt
// These tests do not work well if this script is run more than once (e.g.
// --stress-opt); after a few runs the whole function is immediately compiled
// and assertions would fail. We prevent re-runs.
// Flags: --nostress-opt --no-always-opt
// These tests do not work well if we flush the feedback vector, which causes
// deoptimization.
// Flags: --no-stress-flush-code --no-flush-bytecode
// Some of the tests rely on optimizing/deoptimizing at predictable moments, so
// this is not suitable for deoptimization fuzzing.
// Flags: --deopt-every-n-times=0
// Test for optimization of CallWithSpread when the array iterator is replaced
// with a generator function after a function is compiled.
//
// Note: this test must be in a separate file because the test invalidates a
// protector, which then remains invalidated.
(function () {
"use strict";
var log_got_interpreted = true;
function log(a) {
assertEquals(1, arguments.length);
log_got_interpreted = %IsBeingInterpreted();
return a;
}
function foo() {
return log(...[1]);
}
%PrepareFunctionForOptimization(log);
%PrepareFunctionForOptimization(foo);
assertEquals(1, foo());
assertTrue(log_got_interpreted);
// Compile foo.
%OptimizeFunctionForTopTier(log);
%OptimizeFunctionForTopTier(foo);
assertEquals(1, foo());
// The call with spread should have been inlined.
assertFalse(log_got_interpreted);
assertOptimized(foo);
%PrepareFunctionForOptimization(foo);
// This invalidates the DependOnArrayIteratorProtector and causes deopt.
Object.defineProperty(Array.prototype, Symbol.iterator, {
value: function* () {
yield 42;
},
});
// Now we expect the value yielded by the generator.
assertEquals(42, foo());
assertFalse(log_got_interpreted);
assertUnoptimized(foo);
// Recompile 'foo'.
%PrepareFunctionForOptimization(foo);
%OptimizeFunctionForTopTier(foo);
assertEquals(42, foo());
// The call with spread will not be inlined because we have redefined the
// array iterator.
assertFalse(log_got_interpreted);
assertOptimized(foo);
})();
|
