e97b29a4c5
This gives us more precise type information, so we can avoid some type
guards to refine the type information back.
The motivation for this is to help escape analysis by not introducing
redundant type guards (which escape analysis cannot handle yet even
though it could and should do).
Motivating example:
In the example below, the out-of-object property array for properties
fld5 and fld6 gets type Any when it is created by "o.fld5 = 5" (for
object literals, we store 4 properties in-objeca, the rest goes out
of object).
When we run load elimination for the load the out-of-object property
array (to store 6 into o.fld6), load elimination inserts TypeGuard to
enforce the Type::Internal() type. This makes escape analysis bail out
on this object, and we do not eliminate the object creation.
function f() {
var o = {};
o.fld1 = 1;
o.fld2 = 2;
o.fld3 = 3;
o.fld4 = 4;
o.fld5 = 5;
o.fld6 = 6;
}
f();
f();
%OptimizeFunctionOnNextCall(f);
f();
Review-Url: https://codereview.chromium.org/2797993006
Cr-Commit-Position: refs/heads/master@{#44470}
524 lines
16 KiB
C++
524 lines
16 KiB
C++
// Copyright 2015 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.
|
|
|
|
#include "src/compiler/escape-analysis.h"
|
|
#include "src/bit-vector.h"
|
|
#include "src/compiler/escape-analysis-reducer.h"
|
|
#include "src/compiler/graph-visualizer.h"
|
|
#include "src/compiler/js-graph.h"
|
|
#include "src/compiler/node-properties.h"
|
|
#include "src/compiler/simplified-operator.h"
|
|
#include "src/compiler/types.h"
|
|
#include "src/zone/zone-containers.h"
|
|
#include "test/unittests/compiler/graph-unittest.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
namespace compiler {
|
|
|
|
class EscapeAnalysisTest : public TypedGraphTest {
|
|
public:
|
|
EscapeAnalysisTest()
|
|
: simplified_(zone()),
|
|
jsgraph_(isolate(), graph(), common(), nullptr, nullptr, nullptr),
|
|
escape_analysis_(graph(), common(), zone()),
|
|
effect_(graph()->start()),
|
|
control_(graph()->start()) {}
|
|
|
|
~EscapeAnalysisTest() {}
|
|
|
|
EscapeAnalysis* escape_analysis() { return &escape_analysis_; }
|
|
|
|
protected:
|
|
void Analysis() { escape_analysis_.Run(); }
|
|
|
|
void Transformation() {
|
|
GraphReducer graph_reducer(zone(), graph());
|
|
EscapeAnalysisReducer escape_reducer(&graph_reducer, &jsgraph_,
|
|
&escape_analysis_, zone());
|
|
graph_reducer.AddReducer(&escape_reducer);
|
|
graph_reducer.ReduceGraph();
|
|
}
|
|
|
|
// ---------------------------------Node Creation Helper----------------------
|
|
|
|
Node* BeginRegion(Node* effect = nullptr) {
|
|
if (!effect) {
|
|
effect = effect_;
|
|
}
|
|
|
|
return effect_ = graph()->NewNode(
|
|
common()->BeginRegion(RegionObservability::kObservable), effect);
|
|
}
|
|
|
|
Node* FinishRegion(Node* value, Node* effect = nullptr) {
|
|
if (!effect) {
|
|
effect = effect_;
|
|
}
|
|
return effect_ = graph()->NewNode(common()->FinishRegion(), value, effect);
|
|
}
|
|
|
|
Node* Allocate(Node* size, Node* effect = nullptr, Node* control = nullptr) {
|
|
if (!effect) {
|
|
effect = effect_;
|
|
}
|
|
if (!control) {
|
|
control = control_;
|
|
}
|
|
return effect_ = graph()->NewNode(simplified()->Allocate(Type::Any()), size,
|
|
effect, control);
|
|
}
|
|
|
|
Node* Constant(int num) {
|
|
return graph()->NewNode(common()->NumberConstant(num));
|
|
}
|
|
|
|
Node* Store(const FieldAccess& access, Node* allocation, Node* value,
|
|
Node* effect = nullptr, Node* control = nullptr) {
|
|
if (!effect) {
|
|
effect = effect_;
|
|
}
|
|
if (!control) {
|
|
control = control_;
|
|
}
|
|
return effect_ = graph()->NewNode(simplified()->StoreField(access),
|
|
allocation, value, effect, control);
|
|
}
|
|
|
|
Node* StoreElement(const ElementAccess& access, Node* allocation, Node* index,
|
|
Node* value, Node* effect = nullptr,
|
|
Node* control = nullptr) {
|
|
if (!effect) {
|
|
effect = effect_;
|
|
}
|
|
if (!control) {
|
|
control = control_;
|
|
}
|
|
return effect_ =
|
|
graph()->NewNode(simplified()->StoreElement(access), allocation,
|
|
index, value, effect, control);
|
|
}
|
|
|
|
Node* Load(const FieldAccess& access, Node* from, Node* effect = nullptr,
|
|
Node* control = nullptr) {
|
|
if (!effect) {
|
|
effect = effect_;
|
|
}
|
|
if (!control) {
|
|
control = control_;
|
|
}
|
|
return graph()->NewNode(simplified()->LoadField(access), from, effect,
|
|
control);
|
|
}
|
|
|
|
Node* Return(Node* value, Node* effect = nullptr, Node* control = nullptr) {
|
|
if (!effect) {
|
|
effect = effect_;
|
|
}
|
|
if (!control) {
|
|
control = control_;
|
|
}
|
|
Node* zero = graph()->NewNode(common()->NumberConstant(0));
|
|
return control_ = graph()->NewNode(common()->Return(), zero, value, effect,
|
|
control);
|
|
}
|
|
|
|
void EndGraph() {
|
|
for (Edge edge : graph()->end()->input_edges()) {
|
|
if (NodeProperties::IsControlEdge(edge)) {
|
|
edge.UpdateTo(control_);
|
|
}
|
|
}
|
|
}
|
|
|
|
Node* Branch() {
|
|
return control_ =
|
|
graph()->NewNode(common()->Branch(), Constant(0), control_);
|
|
}
|
|
|
|
Node* IfTrue() {
|
|
return control_ = graph()->NewNode(common()->IfTrue(), control_);
|
|
}
|
|
|
|
Node* IfFalse() { return graph()->NewNode(common()->IfFalse(), control_); }
|
|
|
|
Node* Merge2(Node* control1, Node* control2) {
|
|
return control_ = graph()->NewNode(common()->Merge(2), control1, control2);
|
|
}
|
|
|
|
FieldAccess FieldAccessAtIndex(int offset) {
|
|
FieldAccess access = {kTaggedBase, offset,
|
|
MaybeHandle<Name>(), MaybeHandle<Map>(),
|
|
Type::Any(), MachineType::AnyTagged(),
|
|
kFullWriteBarrier};
|
|
return access;
|
|
}
|
|
|
|
ElementAccess MakeElementAccess(int header_size) {
|
|
ElementAccess access = {kTaggedBase, header_size, Type::Any(),
|
|
MachineType::AnyTagged(), kFullWriteBarrier};
|
|
return access;
|
|
}
|
|
|
|
// ---------------------------------Assertion Helper--------------------------
|
|
|
|
void ExpectReplacement(Node* node, Node* rep) {
|
|
EXPECT_EQ(rep, escape_analysis()->GetReplacement(node));
|
|
}
|
|
|
|
void ExpectReplacementPhi(Node* node, Node* left, Node* right) {
|
|
Node* rep = escape_analysis()->GetReplacement(node);
|
|
ASSERT_NE(nullptr, rep);
|
|
ASSERT_EQ(IrOpcode::kPhi, rep->opcode());
|
|
EXPECT_EQ(left, NodeProperties::GetValueInput(rep, 0));
|
|
EXPECT_EQ(right, NodeProperties::GetValueInput(rep, 1));
|
|
}
|
|
|
|
void ExpectVirtual(Node* node) {
|
|
EXPECT_TRUE(node->opcode() == IrOpcode::kAllocate ||
|
|
node->opcode() == IrOpcode::kFinishRegion);
|
|
EXPECT_TRUE(escape_analysis()->IsVirtual(node));
|
|
}
|
|
|
|
void ExpectEscaped(Node* node) {
|
|
EXPECT_TRUE(node->opcode() == IrOpcode::kAllocate ||
|
|
node->opcode() == IrOpcode::kFinishRegion);
|
|
EXPECT_TRUE(escape_analysis()->IsEscaped(node));
|
|
}
|
|
|
|
SimplifiedOperatorBuilder* simplified() { return &simplified_; }
|
|
|
|
Node* effect() { return effect_; }
|
|
Node* control() { return control_; }
|
|
|
|
private:
|
|
SimplifiedOperatorBuilder simplified_;
|
|
JSGraph jsgraph_;
|
|
EscapeAnalysis escape_analysis_;
|
|
|
|
Node* effect_;
|
|
Node* control_;
|
|
};
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Test cases.
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, StraightNonEscape) {
|
|
Node* object1 = Constant(1);
|
|
BeginRegion();
|
|
Node* allocation = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation, object1);
|
|
Node* finish = FinishRegion(allocation);
|
|
Node* load = Load(FieldAccessAtIndex(0), finish);
|
|
Node* result = Return(load);
|
|
EndGraph();
|
|
|
|
Analysis();
|
|
|
|
ExpectVirtual(allocation);
|
|
ExpectReplacement(load, object1);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 1));
|
|
}
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, StraightNonEscapeNonConstStore) {
|
|
Node* object1 = Constant(1);
|
|
Node* object2 = Constant(2);
|
|
BeginRegion();
|
|
Node* allocation = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation, object1);
|
|
Node* index =
|
|
graph()->NewNode(common()->Select(MachineRepresentation::kTagged),
|
|
object1, object2, control());
|
|
StoreElement(MakeElementAccess(0), allocation, index, object1);
|
|
Node* finish = FinishRegion(allocation);
|
|
Node* load = Load(FieldAccessAtIndex(0), finish);
|
|
Node* result = Return(load);
|
|
EndGraph();
|
|
|
|
Analysis();
|
|
|
|
ExpectEscaped(allocation);
|
|
ExpectReplacement(load, nullptr);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(load, NodeProperties::GetValueInput(result, 1));
|
|
}
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, StraightEscape) {
|
|
Node* object1 = Constant(1);
|
|
BeginRegion();
|
|
Node* allocation = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation, object1);
|
|
Node* finish = FinishRegion(allocation);
|
|
Node* load = Load(FieldAccessAtIndex(0), finish);
|
|
Node* result = Return(allocation);
|
|
EndGraph();
|
|
graph()->end()->AppendInput(zone(), load);
|
|
|
|
Analysis();
|
|
|
|
ExpectEscaped(allocation);
|
|
ExpectReplacement(load, object1);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(allocation, NodeProperties::GetValueInput(result, 1));
|
|
}
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, StoreLoadEscape) {
|
|
Node* object1 = Constant(1);
|
|
|
|
BeginRegion();
|
|
Node* allocation1 = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation1, object1);
|
|
Node* finish1 = FinishRegion(allocation1);
|
|
|
|
BeginRegion();
|
|
Node* allocation2 = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation2, finish1);
|
|
Node* finish2 = FinishRegion(allocation2);
|
|
|
|
Node* load = Load(FieldAccessAtIndex(0), finish2);
|
|
Node* result = Return(load);
|
|
EndGraph();
|
|
Analysis();
|
|
|
|
ExpectEscaped(allocation1);
|
|
ExpectVirtual(allocation2);
|
|
ExpectReplacement(load, finish1);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(finish1, NodeProperties::GetValueInput(result, 1));
|
|
}
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, BranchNonEscape) {
|
|
Node* object1 = Constant(1);
|
|
Node* object2 = Constant(2);
|
|
BeginRegion();
|
|
Node* allocation = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation, object1);
|
|
Node* finish = FinishRegion(allocation);
|
|
Branch();
|
|
Node* ifFalse = IfFalse();
|
|
Node* ifTrue = IfTrue();
|
|
Node* effect1 =
|
|
Store(FieldAccessAtIndex(0), allocation, object1, finish, ifFalse);
|
|
Node* effect2 =
|
|
Store(FieldAccessAtIndex(0), allocation, object2, finish, ifTrue);
|
|
Node* merge = Merge2(ifFalse, ifTrue);
|
|
Node* phi = graph()->NewNode(common()->EffectPhi(2), effect1, effect2, merge);
|
|
Node* load = Load(FieldAccessAtIndex(0), finish, phi, merge);
|
|
Node* result = Return(load, phi);
|
|
EndGraph();
|
|
graph()->end()->AppendInput(zone(), result);
|
|
|
|
Analysis();
|
|
|
|
ExpectVirtual(allocation);
|
|
ExpectReplacementPhi(load, object1, object2);
|
|
Node* replacement_phi = escape_analysis()->GetReplacement(load);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(replacement_phi, NodeProperties::GetValueInput(result, 1));
|
|
}
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, BranchEscapeOne) {
|
|
Node* object1 = Constant(1);
|
|
Node* object2 = Constant(2);
|
|
Node* index = graph()->NewNode(common()->Parameter(0), start());
|
|
BeginRegion();
|
|
Node* allocation = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation, object1);
|
|
Node* finish = FinishRegion(allocation);
|
|
Branch();
|
|
Node* ifFalse = IfFalse();
|
|
Node* ifTrue = IfTrue();
|
|
Node* effect1 =
|
|
Store(FieldAccessAtIndex(0), allocation, object1, finish, ifFalse);
|
|
Node* effect2 = StoreElement(MakeElementAccess(0), allocation, index, object2,
|
|
finish, ifTrue);
|
|
Node* merge = Merge2(ifFalse, ifTrue);
|
|
Node* phi = graph()->NewNode(common()->EffectPhi(2), effect1, effect2, merge);
|
|
Node* load = Load(FieldAccessAtIndex(0), finish, phi, merge);
|
|
Node* result = Return(load, phi);
|
|
EndGraph();
|
|
|
|
Analysis();
|
|
|
|
ExpectEscaped(allocation);
|
|
ExpectReplacement(load, nullptr);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(load, NodeProperties::GetValueInput(result, 1));
|
|
}
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, BranchEscapeThroughStore) {
|
|
Node* object1 = Constant(1);
|
|
Node* object2 = Constant(2);
|
|
BeginRegion();
|
|
Node* allocation = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation, object1);
|
|
FinishRegion(allocation);
|
|
BeginRegion();
|
|
Node* allocation2 = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation, object2);
|
|
Node* finish2 = FinishRegion(allocation2);
|
|
Branch();
|
|
Node* ifFalse = IfFalse();
|
|
Node* ifTrue = IfTrue();
|
|
Node* effect1 =
|
|
Store(FieldAccessAtIndex(0), allocation, allocation2, finish2, ifFalse);
|
|
Node* merge = Merge2(ifFalse, ifTrue);
|
|
Node* phi = graph()->NewNode(common()->EffectPhi(2), effect1, finish2, merge);
|
|
Node* load = Load(FieldAccessAtIndex(0), finish2, phi, merge);
|
|
Node* result = Return(allocation, phi);
|
|
EndGraph();
|
|
graph()->end()->AppendInput(zone(), load);
|
|
|
|
Analysis();
|
|
|
|
ExpectEscaped(allocation);
|
|
ExpectEscaped(allocation2);
|
|
ExpectReplacement(load, nullptr);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(allocation, NodeProperties::GetValueInput(result, 1));
|
|
}
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, DanglingLoadOrder) {
|
|
Node* object1 = Constant(1);
|
|
Node* object2 = Constant(2);
|
|
Node* allocation = Allocate(Constant(kPointerSize));
|
|
Node* store1 = Store(FieldAccessAtIndex(0), allocation, object1);
|
|
Node* load1 = Load(FieldAccessAtIndex(0), allocation);
|
|
Node* store2 = Store(FieldAccessAtIndex(0), allocation, object2);
|
|
Node* load2 = Load(FieldAccessAtIndex(0), allocation, store1);
|
|
Node* result = Return(load2);
|
|
EndGraph();
|
|
graph()->end()->AppendInput(zone(), store2);
|
|
graph()->end()->AppendInput(zone(), load1);
|
|
|
|
Analysis();
|
|
|
|
ExpectVirtual(allocation);
|
|
ExpectReplacement(load1, object1);
|
|
ExpectReplacement(load2, object1);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 1));
|
|
}
|
|
|
|
|
|
TEST_F(EscapeAnalysisTest, DeoptReplacement) {
|
|
Node* object1 = Constant(1);
|
|
BeginRegion();
|
|
Node* allocation = Allocate(Constant(kPointerSize));
|
|
Store(FieldAccessAtIndex(0), allocation, object1);
|
|
Node* finish = FinishRegion(allocation);
|
|
Node* effect1 = Store(FieldAccessAtIndex(0), allocation, object1, finish);
|
|
Branch();
|
|
Node* ifFalse = IfFalse();
|
|
Node* state_values1 = graph()->NewNode(
|
|
common()->StateValues(1, SparseInputMask::Dense()), finish);
|
|
Node* state_values2 =
|
|
graph()->NewNode(common()->StateValues(0, SparseInputMask::Dense()));
|
|
Node* state_values3 =
|
|
graph()->NewNode(common()->StateValues(0, SparseInputMask::Dense()));
|
|
Node* frame_state = graph()->NewNode(
|
|
common()->FrameState(BailoutId::None(), OutputFrameStateCombine::Ignore(),
|
|
nullptr),
|
|
state_values1, state_values2, state_values3, UndefinedConstant(),
|
|
graph()->start(), graph()->start());
|
|
Node* deopt = graph()->NewNode(
|
|
common()->Deoptimize(DeoptimizeKind::kEager, DeoptimizeReason::kNoReason),
|
|
frame_state, effect1, ifFalse);
|
|
Node* ifTrue = IfTrue();
|
|
Node* load = Load(FieldAccessAtIndex(0), finish, effect1, ifTrue);
|
|
Node* result = Return(load, effect1, ifTrue);
|
|
EndGraph();
|
|
graph()->end()->AppendInput(zone(), deopt);
|
|
Analysis();
|
|
|
|
ExpectVirtual(allocation);
|
|
ExpectReplacement(load, object1);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 1));
|
|
Node* object_state = NodeProperties::GetValueInput(state_values1, 0);
|
|
ASSERT_EQ(object_state->opcode(), IrOpcode::kObjectState);
|
|
ASSERT_EQ(1, object_state->op()->ValueInputCount());
|
|
ASSERT_EQ(object1, NodeProperties::GetValueInput(object_state, 0));
|
|
}
|
|
|
|
TEST_F(EscapeAnalysisTest, DISABLED_DeoptReplacementIdentity) {
|
|
Node* object1 = Constant(1);
|
|
BeginRegion();
|
|
Node* allocation = Allocate(Constant(kPointerSize * 2));
|
|
Store(FieldAccessAtIndex(0), allocation, object1);
|
|
Store(FieldAccessAtIndex(kPointerSize), allocation, allocation);
|
|
Node* finish = FinishRegion(allocation);
|
|
Node* effect1 = Store(FieldAccessAtIndex(0), allocation, object1, finish);
|
|
Branch();
|
|
Node* ifFalse = IfFalse();
|
|
Node* state_values1 = graph()->NewNode(
|
|
common()->StateValues(1, SparseInputMask::Dense()), finish);
|
|
Node* state_values2 = graph()->NewNode(
|
|
common()->StateValues(1, SparseInputMask::Dense()), finish);
|
|
Node* state_values3 =
|
|
graph()->NewNode(common()->StateValues(0, SparseInputMask::Dense()));
|
|
Node* frame_state = graph()->NewNode(
|
|
common()->FrameState(BailoutId::None(), OutputFrameStateCombine::Ignore(),
|
|
nullptr),
|
|
state_values1, state_values2, state_values3, UndefinedConstant(),
|
|
graph()->start(), graph()->start());
|
|
Node* deopt = graph()->NewNode(
|
|
common()->Deoptimize(DeoptimizeKind::kEager, DeoptimizeReason::kNoReason),
|
|
frame_state, effect1, ifFalse);
|
|
Node* ifTrue = IfTrue();
|
|
Node* load = Load(FieldAccessAtIndex(0), finish, effect1, ifTrue);
|
|
Node* result = Return(load, effect1, ifTrue);
|
|
EndGraph();
|
|
graph()->end()->AppendInput(zone(), deopt);
|
|
Analysis();
|
|
|
|
ExpectVirtual(allocation);
|
|
ExpectReplacement(load, object1);
|
|
|
|
Transformation();
|
|
|
|
ASSERT_EQ(object1, NodeProperties::GetValueInput(result, 1));
|
|
|
|
Node* object_state = NodeProperties::GetValueInput(state_values1, 0);
|
|
ASSERT_EQ(object_state->opcode(), IrOpcode::kObjectState);
|
|
ASSERT_EQ(2, object_state->op()->ValueInputCount());
|
|
ASSERT_EQ(object1, NodeProperties::GetValueInput(object_state, 0));
|
|
ASSERT_EQ(object_state, NodeProperties::GetValueInput(object_state, 1));
|
|
|
|
Node* object_state2 = NodeProperties::GetValueInput(state_values1, 0);
|
|
ASSERT_EQ(object_state, object_state2);
|
|
}
|
|
|
|
} // namespace compiler
|
|
} // namespace internal
|
|
} // namespace v8
|