216bcf9fb3
This introduces optimized number operations based on type feedback.
Summary of changes:
1. Typed lowering produces SpeculativeNumberAdd/Subtract for JSAdd/Subtract if
there is suitable feedback. The speculative nodes are connected to both the
effect chain and the control chain and they retain the eager frame state.
2. Simplified lowering now executes in three phases:
a. Propagation phase computes truncations by traversing the graph from uses to
definitions until checkpoint is reached. It also records type-check decisions
for later typing phase, and computes representation.
b. The typing phase computes more precise types base on the speculative types (and recomputes
representation for affected nodes).
c. The lowering phase performs lowering and inserts representation changes and/or checks.
3. Effect-control linearization lowers the checks to machine graphs.
Notes:
- SimplifiedLowering will be refactored to have handling of each operation one place and
with clearer input/output protocol for each sub-phase. I would prefer to do this once
we have more operations implemented, and the pattern is clearer.
- The check operations (Checked<A>To<B>) should have some flags that would affect
the kind of truncations that they can handle. E.g., if we know that a node produces
a number, we can omit the oddball check in the CheckedTaggedToFloat64 lowering.
- In future, we want the typer to reuse the logic from OperationTyper.
BUG=v8:4583
LOG=n
Review-Url: https://codereview.chromium.org/1921563002
Cr-Commit-Position: refs/heads/master@{#36674}
59 lines
1.3 KiB
JavaScript
59 lines
1.3 KiB
JavaScript
// Copyright 2016 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-type-feedback
|
|
|
|
(function AddSubtractSmis() {
|
|
function f0(a, b, c) {
|
|
return a + b - c;
|
|
}
|
|
|
|
assertEquals(4, f0(3, 2, 1));
|
|
assertEquals(4, f0(3, 2, 1));
|
|
%OptimizeFunctionOnNextCall(f0);
|
|
assertEquals(4, f0(3, 2, 1));
|
|
})();
|
|
|
|
(function AddSubtractDoubles() {
|
|
function f1(a, b, c) {
|
|
return a + b - c;
|
|
}
|
|
|
|
assertEquals(4.5, f1(3.5, 2.5, 1.5));
|
|
assertEquals(4.5, f1(3.5, 2.5, 1.5));
|
|
%OptimizeFunctionOnNextCall(f1);
|
|
assertEquals(4.5, f1(3.5, 2.5, 1.5));
|
|
assertEquals(4, f1(3, 2, 1));
|
|
assertTrue(isNaN(f1(3, 2, undefined)));
|
|
assertTrue(isNaN(f1(3, undefined, 1)));
|
|
})();
|
|
|
|
(function CheckUint32ToInt32Conv() {
|
|
function f2(a) {
|
|
return (a >>> 0) + 1;
|
|
}
|
|
|
|
assertEquals(1, f2(0));
|
|
assertEquals(1, f2(0));
|
|
%OptimizeFunctionOnNextCall(f2);
|
|
assertEquals(1, f2(0));
|
|
assertEquals(4294967295, f2(-2));
|
|
})();
|
|
|
|
(function CheckFloat64ToInt32Conv() {
|
|
function f3(a, b) {
|
|
var x = 0;
|
|
if (a) {
|
|
x = 0.5;
|
|
}
|
|
return x + b;
|
|
}
|
|
|
|
assertEquals(1, f3(0, 1));
|
|
assertEquals(1, f3(0, 1));
|
|
%OptimizeFunctionOnNextCall(f3);
|
|
assertEquals(1, f3(0, 1));
|
|
assertEquals(1.5, f3(1, 1));
|
|
})();
|