f19c4a594f
This changes the ReceiverOrOddball feedback on JSStrictEqual to
ReceiverOrNullOrUndefined feedback, which can also safely be
consumed by JSEqual (we cannot generally accept any oddball here
since booleans trigger implicit conversions, unfortunately).
Thus we replace the previously introduced CheckReceiverOrOddball
with CheckReceiverOrNullOrUndefined, and drop CheckOddball, since
we will no longer collect Oddball feedback separately.
TurboFan will then turn a JSEqual[ReceiverOrNullOrUndefined] into
a sequence like this:
```
left = CheckReceiverOrNullOrUndefined(left);
right = CheckReceiverOrNullOrUndefined(right);
result = if ObjectIsUndetectable(left) then
ObjectIsUndetectable(right)
else
ReferenceEqual(left, right);
```
This significantly improves the peak performance of abstract equality
with Receiver, Null or Undefined inputs. On the test case outlined in
http://crbug.com/v8/8356 we go from
naive: 2946 ms.
tenary: 2134 ms.
to
naive: 2230 ms.
tenary: 2250 ms.
which corresponds to a 25% improvement on the abstract equality case.
For regular code this will probably yield more performance, since we
get rid of the JSEqual operator, which might have arbitrary side
effects and thus blocks all kinds of TurboFan optimizations. The
JSStrictEqual case is slightly slower now, since it has to rule out
booleans as well (even though that's not strictly necessary, but
consistency is key here).
This way developers can safely use `a == b` instead of doing a dance
like `a == null ? b == null : a === b` (which is what dart2js does
right now) when both `a` and `b` are known to be Receiver, Null or
Undefined. The abstract equality is not only faster to parse than
the tenary, but also generates a shorter bytecode sequence. In the
test case referenced in http://crbug.com/v8/8356 the bytecode for
`naive` is
```
StackCheck
Ldar a1
TestEqual a0, [0]
JumpIfFalse [5]
LdaSmi [1]
Return
LdaSmi [2]
Return
```
which is 14 bytes, whereas the `tenary` function generates
```
StackCheck
Ldar a0
TestUndetectable
JumpIfFalse [7]
Ldar a1
TestUndetectable
Jump [7]
Ldar a1
TestEqualStrict a0, [0]
JumpIfToBooleanFalse [5]
LdaSmi [1]
Return
LdaSmi [2]
Return
```
which is 24 bytes. So the `naive` version is 40% smaller and requires
fewer bytecode dispatches.
Bug: chromium:898455, v8:8356
Change-Id: If3961b2518b4438700706b3bd6071d546305e233
Reviewed-on: https://chromium-review.googlesource.com/c/1297315
Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#56948}
178 lines
3.7 KiB
JavaScript
178 lines
3.7 KiB
JavaScript
// 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
|
|
|
|
// Known receivers abstract equality.
|
|
(function() {
|
|
const a = {};
|
|
const b = {};
|
|
|
|
function foo() { return a == b; }
|
|
|
|
assertFalse(foo());
|
|
assertFalse(foo());
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertFalse(foo());
|
|
})();
|
|
|
|
// Known receiver/null abstract equality.
|
|
(function() {
|
|
const a = {};
|
|
const b = null;
|
|
|
|
function foo() { return a == b; }
|
|
|
|
assertFalse(foo());
|
|
assertFalse(foo());
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertFalse(foo());
|
|
})();
|
|
|
|
// Known null/receiver abstract equality.
|
|
(function() {
|
|
const a = null;
|
|
const b = {};
|
|
|
|
function foo() { return a == b; }
|
|
|
|
assertFalse(foo());
|
|
assertFalse(foo());
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertFalse(foo());
|
|
})();
|
|
|
|
// Known receiver/undefined abstract equality.
|
|
(function() {
|
|
const a = {};
|
|
const b = undefined;
|
|
|
|
function foo() { return a == b; }
|
|
|
|
assertFalse(foo());
|
|
assertFalse(foo());
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertFalse(foo());
|
|
})();
|
|
|
|
// Known undefined/receiver abstract equality.
|
|
(function() {
|
|
const a = undefined;
|
|
const b = {};
|
|
|
|
function foo() { return a == b; }
|
|
|
|
assertFalse(foo());
|
|
assertFalse(foo());
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertFalse(foo());
|
|
})();
|
|
|
|
// Known receiver on one side strict equality.
|
|
(function() {
|
|
const a = {};
|
|
const b = {};
|
|
|
|
function foo(a) { return a == b; }
|
|
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
|
|
// TurboFan bakes in feedback for the (unknown) left hand side.
|
|
assertFalse(foo(null));
|
|
assertUnoptimized(foo);
|
|
})();
|
|
|
|
// Known receiver on one side strict equality with null.
|
|
(function() {
|
|
const a = null;
|
|
const b = {};
|
|
|
|
function foo(a) { return a == b; }
|
|
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
|
|
// TurboFan bakes in feedback for the (unknown) left hand side.
|
|
assertFalse(foo(1));
|
|
assertUnoptimized(foo);
|
|
})();
|
|
|
|
// Known receiver on one side strict equality with undefined.
|
|
(function() {
|
|
const a = undefined;
|
|
const b = {};
|
|
|
|
function foo(a) { return a == b; }
|
|
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
|
|
// TurboFan bakes in feedback for the (unknown) left hand side.
|
|
assertFalse(foo(1));
|
|
assertUnoptimized(foo);
|
|
})();
|
|
|
|
// Known null on one side strict equality with receiver.
|
|
(function() {
|
|
const a = {};
|
|
const b = null;
|
|
|
|
function foo(a) { return a == b; }
|
|
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
assertTrue(foo(null));
|
|
assertTrue(foo(undefined));
|
|
assertOptimized(foo);
|
|
|
|
// TurboFan doesn't need to bake in feedback, since it sees the null.
|
|
assertFalse(foo(1));
|
|
assertOptimized(foo);
|
|
})();
|
|
|
|
// Known undefined on one side strict equality with receiver.
|
|
(function() {
|
|
const a = {};
|
|
const b = undefined;
|
|
|
|
function foo(a) { return a == b; }
|
|
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
assertTrue(foo(b));
|
|
assertFalse(foo(a));
|
|
assertTrue(foo(null));
|
|
assertTrue(foo(undefined));
|
|
assertOptimized(foo);
|
|
|
|
// TurboFan needs to bake in feedback, since undefined cannot
|
|
// be context specialized.
|
|
assertFalse(foo(1));
|
|
assertUnoptimized(foo);
|
|
})();
|