fe552636be
This is preparation for using TF to create builtins that handle variable number of arguments and have to remove these arguments dynamically from the stack upon return. The gist of the changes: - Added a second argument to the Return node which specifies the number of stack slots to pop upon return in addition to those specified by the Linkage of the compiled function. - Removed Tail -> Non-Tail fallback in the instruction selector. Since TF now should handles all tail-call cases except where the return value type differs, this fallback was not really useful and in fact caused unexpected behavior with variable sized argument popping, since it wasn't possible to materialize a Return node with the right pop count from the TailCall without additional context. - Modified existing Return generation to pass a constant zero as the additional pop argument since the variable pop functionality LOG=N Review-Url: https://codereview.chromium.org/2446543002 Cr-Commit-Position: refs/heads/master@{#40699}
1031 lines
29 KiB
C++
1031 lines
29 KiB
C++
// Copyright 2014 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/access-builder.h"
|
|
#include "src/compiler/common-operator.h"
|
|
#include "src/compiler/graph.h"
|
|
#include "src/compiler/graph-visualizer.h"
|
|
#include "src/compiler/js-graph.h"
|
|
#include "src/compiler/js-operator.h"
|
|
#include "src/compiler/loop-analysis.h"
|
|
#include "src/compiler/node.h"
|
|
#include "src/compiler/opcodes.h"
|
|
#include "src/compiler/operator.h"
|
|
#include "src/compiler/schedule.h"
|
|
#include "src/compiler/scheduler.h"
|
|
#include "src/compiler/simplified-operator.h"
|
|
#include "src/compiler/verifier.h"
|
|
#include "test/cctest/cctest.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
namespace compiler {
|
|
|
|
static Operator kIntAdd(IrOpcode::kInt32Add, Operator::kPure, "Int32Add", 2, 0,
|
|
0, 1, 0, 0);
|
|
static Operator kIntLt(IrOpcode::kInt32LessThan, Operator::kPure,
|
|
"Int32LessThan", 2, 0, 0, 1, 0, 0);
|
|
static Operator kStore(IrOpcode::kStore, Operator::kNoProperties, "Store", 1, 1,
|
|
1, 0, 1, 0);
|
|
|
|
static const int kNumLeafs = 4;
|
|
|
|
// A helper for all tests dealing with LoopFinder.
|
|
class LoopFinderTester : HandleAndZoneScope {
|
|
public:
|
|
LoopFinderTester()
|
|
: isolate(main_isolate()),
|
|
common(main_zone()),
|
|
graph(main_zone()),
|
|
jsgraph(main_isolate(), &graph, &common, nullptr, nullptr, nullptr),
|
|
start(graph.NewNode(common.Start(1))),
|
|
end(graph.NewNode(common.End(1), start)),
|
|
p0(graph.NewNode(common.Parameter(0), start)),
|
|
zero(jsgraph.Int32Constant(0)),
|
|
one(jsgraph.OneConstant()),
|
|
half(jsgraph.Constant(0.5)),
|
|
self(graph.NewNode(common.Int32Constant(0xaabbccdd))),
|
|
dead(graph.NewNode(common.Dead())),
|
|
loop_tree(NULL) {
|
|
graph.SetEnd(end);
|
|
graph.SetStart(start);
|
|
leaf[0] = zero;
|
|
leaf[1] = one;
|
|
leaf[2] = half;
|
|
leaf[3] = p0;
|
|
}
|
|
|
|
Isolate* isolate;
|
|
CommonOperatorBuilder common;
|
|
Graph graph;
|
|
JSGraph jsgraph;
|
|
Node* start;
|
|
Node* end;
|
|
Node* p0;
|
|
Node* zero;
|
|
Node* one;
|
|
Node* half;
|
|
Node* self;
|
|
Node* dead;
|
|
Node* leaf[kNumLeafs];
|
|
LoopTree* loop_tree;
|
|
|
|
Node* Phi(Node* a) {
|
|
return SetSelfReferences(graph.NewNode(op(1, false), a, start));
|
|
}
|
|
|
|
Node* Phi(Node* a, Node* b) {
|
|
return SetSelfReferences(graph.NewNode(op(2, false), a, b, start));
|
|
}
|
|
|
|
Node* Phi(Node* a, Node* b, Node* c) {
|
|
return SetSelfReferences(graph.NewNode(op(3, false), a, b, c, start));
|
|
}
|
|
|
|
Node* Phi(Node* a, Node* b, Node* c, Node* d) {
|
|
return SetSelfReferences(graph.NewNode(op(4, false), a, b, c, d, start));
|
|
}
|
|
|
|
Node* EffectPhi(Node* a) {
|
|
return SetSelfReferences(graph.NewNode(op(1, true), a, start));
|
|
}
|
|
|
|
Node* EffectPhi(Node* a, Node* b) {
|
|
return SetSelfReferences(graph.NewNode(op(2, true), a, b, start));
|
|
}
|
|
|
|
Node* EffectPhi(Node* a, Node* b, Node* c) {
|
|
return SetSelfReferences(graph.NewNode(op(3, true), a, b, c, start));
|
|
}
|
|
|
|
Node* EffectPhi(Node* a, Node* b, Node* c, Node* d) {
|
|
return SetSelfReferences(graph.NewNode(op(4, true), a, b, c, d, start));
|
|
}
|
|
|
|
Node* SetSelfReferences(Node* node) {
|
|
for (Edge edge : node->input_edges()) {
|
|
if (edge.to() == self) node->ReplaceInput(edge.index(), node);
|
|
}
|
|
return node;
|
|
}
|
|
|
|
const Operator* op(int count, bool effect) {
|
|
return effect ? common.EffectPhi(count)
|
|
: common.Phi(MachineRepresentation::kTagged, count);
|
|
}
|
|
|
|
Node* Return(Node* val, Node* effect, Node* control) {
|
|
Node* zero = graph.NewNode(common.Int32Constant(0));
|
|
Node* ret = graph.NewNode(common.Return(), zero, val, effect, control);
|
|
end->ReplaceInput(0, ret);
|
|
return ret;
|
|
}
|
|
|
|
LoopTree* GetLoopTree() {
|
|
if (loop_tree == NULL) {
|
|
if (FLAG_trace_turbo_graph) {
|
|
OFStream os(stdout);
|
|
os << AsRPO(graph);
|
|
}
|
|
Zone zone(main_isolate()->allocator(), ZONE_NAME);
|
|
loop_tree = LoopFinder::BuildLoopTree(&graph, &zone);
|
|
}
|
|
return loop_tree;
|
|
}
|
|
|
|
void CheckLoop(Node** header, int header_count, Node** body, int body_count) {
|
|
LoopTree* tree = GetLoopTree();
|
|
LoopTree::Loop* loop = tree->ContainingLoop(header[0]);
|
|
CHECK(loop);
|
|
|
|
CHECK(header_count == static_cast<int>(loop->HeaderSize()));
|
|
for (int i = 0; i < header_count; i++) {
|
|
// Each header node should be in the loop.
|
|
CHECK_EQ(loop, tree->ContainingLoop(header[i]));
|
|
CheckRangeContains(tree->HeaderNodes(loop), header[i]);
|
|
}
|
|
|
|
CHECK_EQ(body_count, static_cast<int>(loop->BodySize()));
|
|
// TODO(turbofan): O(n^2) set equivalence in this test.
|
|
for (int i = 0; i < body_count; i++) {
|
|
// Each body node should be contained in the loop.
|
|
CHECK(tree->Contains(loop, body[i]));
|
|
CheckRangeContains(tree->BodyNodes(loop), body[i]);
|
|
}
|
|
}
|
|
|
|
void CheckRangeContains(NodeRange range, Node* node) {
|
|
CHECK_NE(range.end(), std::find(range.begin(), range.end(), node));
|
|
}
|
|
|
|
void CheckNestedLoops(Node** chain, int chain_count) {
|
|
LoopTree* tree = GetLoopTree();
|
|
for (int i = 0; i < chain_count; i++) {
|
|
Node* header = chain[i];
|
|
// Each header should be in a loop.
|
|
LoopTree::Loop* loop = tree->ContainingLoop(header);
|
|
CHECK(loop);
|
|
// Check parentage.
|
|
LoopTree::Loop* parent =
|
|
i == 0 ? NULL : tree->ContainingLoop(chain[i - 1]);
|
|
CHECK_EQ(parent, loop->parent());
|
|
for (int j = i - 1; j >= 0; j--) {
|
|
// This loop should be nested inside all the outer loops.
|
|
Node* outer_header = chain[j];
|
|
LoopTree::Loop* outer = tree->ContainingLoop(outer_header);
|
|
CHECK(tree->Contains(outer, header));
|
|
CHECK(!tree->Contains(loop, outer_header));
|
|
}
|
|
}
|
|
}
|
|
|
|
Zone* zone() { return main_zone(); }
|
|
};
|
|
|
|
|
|
struct While {
|
|
LoopFinderTester& t;
|
|
Node* branch;
|
|
Node* if_true;
|
|
Node* exit;
|
|
Node* loop;
|
|
|
|
While(LoopFinderTester& R, Node* cond) : t(R) {
|
|
loop = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
|
|
branch = t.graph.NewNode(t.common.Branch(), cond, loop);
|
|
if_true = t.graph.NewNode(t.common.IfTrue(), branch);
|
|
exit = t.graph.NewNode(t.common.IfFalse(), branch);
|
|
loop->ReplaceInput(1, if_true);
|
|
}
|
|
|
|
void chain(Node* control) { loop->ReplaceInput(0, control); }
|
|
void nest(While& that) {
|
|
that.loop->ReplaceInput(1, exit);
|
|
this->loop->ReplaceInput(0, that.if_true);
|
|
}
|
|
};
|
|
|
|
|
|
struct Counter {
|
|
Node* base;
|
|
Node* inc;
|
|
Node* phi;
|
|
Node* add;
|
|
|
|
Counter(While& w, int32_t b, int32_t k)
|
|
: base(w.t.jsgraph.Int32Constant(b)), inc(w.t.jsgraph.Int32Constant(k)) {
|
|
Build(w);
|
|
}
|
|
|
|
Counter(While& w, Node* b, Node* k) : base(b), inc(k) { Build(w); }
|
|
|
|
void Build(While& w) {
|
|
phi = w.t.graph.NewNode(w.t.op(2, false), base, base, w.loop);
|
|
add = w.t.graph.NewNode(&kIntAdd, phi, inc);
|
|
phi->ReplaceInput(1, add);
|
|
}
|
|
};
|
|
|
|
|
|
struct StoreLoop {
|
|
Node* base;
|
|
Node* val;
|
|
Node* phi;
|
|
Node* store;
|
|
|
|
explicit StoreLoop(While& w)
|
|
: base(w.t.graph.start()), val(w.t.jsgraph.Int32Constant(13)) {
|
|
Build(w);
|
|
}
|
|
|
|
StoreLoop(While& w, Node* b, Node* v) : base(b), val(v) { Build(w); }
|
|
|
|
void Build(While& w) {
|
|
phi = w.t.graph.NewNode(w.t.op(2, true), base, base, w.loop);
|
|
store = w.t.graph.NewNode(&kStore, val, phi, w.loop);
|
|
phi->ReplaceInput(1, store);
|
|
}
|
|
};
|
|
|
|
|
|
TEST(LaLoop1) {
|
|
// One loop.
|
|
LoopFinderTester t;
|
|
While w(t, t.p0);
|
|
t.Return(t.p0, t.start, w.exit);
|
|
|
|
Node* chain[] = {w.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w.loop};
|
|
Node* body[] = {w.branch, w.if_true};
|
|
t.CheckLoop(header, 1, body, 2);
|
|
}
|
|
|
|
|
|
TEST(LaLoop1phi) {
|
|
// One loop with a simple phi.
|
|
LoopFinderTester t;
|
|
While w(t, t.p0);
|
|
Node* phi = t.graph.NewNode(t.common.Phi(MachineRepresentation::kTagged, 2),
|
|
t.zero, t.one, w.loop);
|
|
t.Return(phi, t.start, w.exit);
|
|
|
|
Node* chain[] = {w.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w.loop, phi};
|
|
Node* body[] = {w.branch, w.if_true};
|
|
t.CheckLoop(header, 2, body, 2);
|
|
}
|
|
|
|
|
|
TEST(LaLoop1c) {
|
|
// One loop with a counter.
|
|
LoopFinderTester t;
|
|
While w(t, t.p0);
|
|
Counter c(w, 0, 1);
|
|
t.Return(c.phi, t.start, w.exit);
|
|
|
|
Node* chain[] = {w.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w.loop, c.phi};
|
|
Node* body[] = {w.branch, w.if_true, c.add};
|
|
t.CheckLoop(header, 2, body, 3);
|
|
}
|
|
|
|
|
|
TEST(LaLoop1e) {
|
|
// One loop with an effect phi.
|
|
LoopFinderTester t;
|
|
While w(t, t.p0);
|
|
StoreLoop c(w);
|
|
t.Return(t.p0, c.phi, w.exit);
|
|
|
|
Node* chain[] = {w.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w.loop, c.phi};
|
|
Node* body[] = {w.branch, w.if_true, c.store};
|
|
t.CheckLoop(header, 2, body, 3);
|
|
}
|
|
|
|
|
|
TEST(LaLoop1d) {
|
|
// One loop with two counters.
|
|
LoopFinderTester t;
|
|
While w(t, t.p0);
|
|
Counter c1(w, 0, 1);
|
|
Counter c2(w, 1, 1);
|
|
t.Return(t.graph.NewNode(&kIntAdd, c1.phi, c2.phi), t.start, w.exit);
|
|
|
|
Node* chain[] = {w.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w.loop, c1.phi, c2.phi};
|
|
Node* body[] = {w.branch, w.if_true, c1.add, c2.add};
|
|
t.CheckLoop(header, 3, body, 4);
|
|
}
|
|
|
|
|
|
TEST(LaLoop2) {
|
|
// One loop following another.
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
While w2(t, t.p0);
|
|
w2.chain(w1.exit);
|
|
t.Return(t.p0, t.start, w2.exit);
|
|
|
|
{
|
|
Node* chain[] = {w1.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w1.loop};
|
|
Node* body[] = {w1.branch, w1.if_true};
|
|
t.CheckLoop(header, 1, body, 2);
|
|
}
|
|
|
|
{
|
|
Node* chain[] = {w2.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w2.loop};
|
|
Node* body[] = {w2.branch, w2.if_true};
|
|
t.CheckLoop(header, 1, body, 2);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(LaLoop2c) {
|
|
// One loop following another, each with counters.
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
While w2(t, t.p0);
|
|
Counter c1(w1, 0, 1);
|
|
Counter c2(w2, 0, 1);
|
|
w2.chain(w1.exit);
|
|
t.Return(t.graph.NewNode(&kIntAdd, c1.phi, c2.phi), t.start, w2.exit);
|
|
|
|
{
|
|
Node* chain[] = {w1.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w1.loop, c1.phi};
|
|
Node* body[] = {w1.branch, w1.if_true, c1.add};
|
|
t.CheckLoop(header, 2, body, 3);
|
|
}
|
|
|
|
{
|
|
Node* chain[] = {w2.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w2.loop, c2.phi};
|
|
Node* body[] = {w2.branch, w2.if_true, c2.add};
|
|
t.CheckLoop(header, 2, body, 3);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(LaLoop2cc) {
|
|
// One loop following another; second loop uses phi from first.
|
|
for (int i = 0; i < 8; i++) {
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
While w2(t, t.p0);
|
|
Counter c1(w1, 0, 1);
|
|
|
|
// various usage scenarios for the second loop.
|
|
Counter c2(w2, i & 1 ? t.p0 : c1.phi, i & 2 ? t.p0 : c1.phi);
|
|
if (i & 3) w2.branch->ReplaceInput(0, c1.phi);
|
|
|
|
w2.chain(w1.exit);
|
|
t.Return(t.graph.NewNode(&kIntAdd, c1.phi, c2.phi), t.start, w2.exit);
|
|
|
|
{
|
|
Node* chain[] = {w1.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w1.loop, c1.phi};
|
|
Node* body[] = {w1.branch, w1.if_true, c1.add};
|
|
t.CheckLoop(header, 2, body, 3);
|
|
}
|
|
|
|
{
|
|
Node* chain[] = {w2.loop};
|
|
t.CheckNestedLoops(chain, 1);
|
|
|
|
Node* header[] = {w2.loop, c2.phi};
|
|
Node* body[] = {w2.branch, w2.if_true, c2.add};
|
|
t.CheckLoop(header, 2, body, 3);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(LaNestedLoop1) {
|
|
// One loop nested in another.
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
While w2(t, t.p0);
|
|
w2.nest(w1);
|
|
t.Return(t.p0, t.start, w1.exit);
|
|
|
|
Node* chain[] = {w1.loop, w2.loop};
|
|
t.CheckNestedLoops(chain, 2);
|
|
|
|
Node* h1[] = {w1.loop};
|
|
Node* b1[] = {w1.branch, w1.if_true, w2.loop, w2.branch, w2.if_true, w2.exit};
|
|
t.CheckLoop(h1, 1, b1, 6);
|
|
|
|
Node* h2[] = {w2.loop};
|
|
Node* b2[] = {w2.branch, w2.if_true};
|
|
t.CheckLoop(h2, 1, b2, 2);
|
|
}
|
|
|
|
|
|
TEST(LaNestedLoop1c) {
|
|
// One loop nested in another, each with a counter.
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
While w2(t, t.p0);
|
|
Counter c1(w1, 0, 1);
|
|
Counter c2(w2, 0, 1);
|
|
w2.branch->ReplaceInput(0, c2.phi);
|
|
w2.nest(w1);
|
|
t.Return(c1.phi, t.start, w1.exit);
|
|
|
|
Node* chain[] = {w1.loop, w2.loop};
|
|
t.CheckNestedLoops(chain, 2);
|
|
|
|
Node* h1[] = {w1.loop, c1.phi};
|
|
Node* b1[] = {w1.branch, w1.if_true, w2.loop, w2.branch, w2.if_true,
|
|
w2.exit, c2.phi, c1.add, c2.add};
|
|
t.CheckLoop(h1, 2, b1, 9);
|
|
|
|
Node* h2[] = {w2.loop, c2.phi};
|
|
Node* b2[] = {w2.branch, w2.if_true, c2.add};
|
|
t.CheckLoop(h2, 2, b2, 3);
|
|
}
|
|
|
|
|
|
TEST(LaNestedLoop1x) {
|
|
// One loop nested in another.
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
While w2(t, t.p0);
|
|
w2.nest(w1);
|
|
|
|
const Operator* op = t.common.Phi(MachineRepresentation::kWord32, 2);
|
|
Node* p1a = t.graph.NewNode(op, t.p0, t.p0, w1.loop);
|
|
Node* p1b = t.graph.NewNode(op, t.p0, t.p0, w1.loop);
|
|
Node* p2a = t.graph.NewNode(op, p1a, t.p0, w2.loop);
|
|
Node* p2b = t.graph.NewNode(op, p1b, t.p0, w2.loop);
|
|
|
|
p1a->ReplaceInput(1, p2b);
|
|
p1b->ReplaceInput(1, p2a);
|
|
|
|
p2a->ReplaceInput(1, p2b);
|
|
p2b->ReplaceInput(1, p2a);
|
|
|
|
t.Return(t.p0, t.start, w1.exit);
|
|
|
|
Node* chain[] = {w1.loop, w2.loop};
|
|
t.CheckNestedLoops(chain, 2);
|
|
|
|
Node* h1[] = {w1.loop, p1a, p1b};
|
|
Node* b1[] = {w1.branch, w1.if_true, w2.loop, p2a,
|
|
p2b, w2.branch, w2.if_true, w2.exit};
|
|
t.CheckLoop(h1, 3, b1, 8);
|
|
|
|
Node* h2[] = {w2.loop, p2a, p2b};
|
|
Node* b2[] = {w2.branch, w2.if_true};
|
|
t.CheckLoop(h2, 3, b2, 2);
|
|
}
|
|
|
|
|
|
TEST(LaNestedLoop2) {
|
|
// Two loops nested in an outer loop.
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
While w2(t, t.p0);
|
|
While w3(t, t.p0);
|
|
w2.nest(w1);
|
|
w3.nest(w1);
|
|
w3.chain(w2.exit);
|
|
t.Return(t.p0, t.start, w1.exit);
|
|
|
|
Node* chain1[] = {w1.loop, w2.loop};
|
|
t.CheckNestedLoops(chain1, 2);
|
|
|
|
Node* chain2[] = {w1.loop, w3.loop};
|
|
t.CheckNestedLoops(chain2, 2);
|
|
|
|
Node* h1[] = {w1.loop};
|
|
Node* b1[] = {w1.branch, w1.if_true, w2.loop, w2.branch, w2.if_true,
|
|
w2.exit, w3.loop, w3.branch, w3.if_true, w3.exit};
|
|
t.CheckLoop(h1, 1, b1, 10);
|
|
|
|
Node* h2[] = {w2.loop};
|
|
Node* b2[] = {w2.branch, w2.if_true};
|
|
t.CheckLoop(h2, 1, b2, 2);
|
|
|
|
Node* h3[] = {w3.loop};
|
|
Node* b3[] = {w3.branch, w3.if_true};
|
|
t.CheckLoop(h3, 1, b3, 2);
|
|
}
|
|
|
|
|
|
TEST(LaNestedLoop3) {
|
|
// Three nested loops.
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
While w2(t, t.p0);
|
|
While w3(t, t.p0);
|
|
w2.loop->ReplaceInput(0, w1.if_true);
|
|
w3.loop->ReplaceInput(0, w2.if_true);
|
|
w2.loop->ReplaceInput(1, w3.exit);
|
|
w1.loop->ReplaceInput(1, w2.exit);
|
|
t.Return(t.p0, t.start, w1.exit);
|
|
|
|
Node* chain[] = {w1.loop, w2.loop, w3.loop};
|
|
t.CheckNestedLoops(chain, 3);
|
|
|
|
Node* h1[] = {w1.loop};
|
|
Node* b1[] = {w1.branch, w1.if_true, w2.loop, w2.branch, w2.if_true,
|
|
w2.exit, w3.loop, w3.branch, w3.if_true, w3.exit};
|
|
t.CheckLoop(h1, 1, b1, 10);
|
|
|
|
Node* h2[] = {w2.loop};
|
|
Node* b2[] = {w2.branch, w2.if_true, w3.loop, w3.branch, w3.if_true, w3.exit};
|
|
t.CheckLoop(h2, 1, b2, 6);
|
|
|
|
Node* h3[] = {w3.loop};
|
|
Node* b3[] = {w3.branch, w3.if_true};
|
|
t.CheckLoop(h3, 1, b3, 2);
|
|
}
|
|
|
|
|
|
TEST(LaNestedLoop3c) {
|
|
// Three nested loops with counters.
|
|
LoopFinderTester t;
|
|
While w1(t, t.p0);
|
|
Counter c1(w1, 0, 1);
|
|
While w2(t, t.p0);
|
|
Counter c2(w2, 0, 1);
|
|
While w3(t, t.p0);
|
|
Counter c3(w3, 0, 1);
|
|
w2.loop->ReplaceInput(0, w1.if_true);
|
|
w3.loop->ReplaceInput(0, w2.if_true);
|
|
w2.loop->ReplaceInput(1, w3.exit);
|
|
w1.loop->ReplaceInput(1, w2.exit);
|
|
w1.branch->ReplaceInput(0, c1.phi);
|
|
w2.branch->ReplaceInput(0, c2.phi);
|
|
w3.branch->ReplaceInput(0, c3.phi);
|
|
t.Return(c1.phi, t.start, w1.exit);
|
|
|
|
Node* chain[] = {w1.loop, w2.loop, w3.loop};
|
|
t.CheckNestedLoops(chain, 3);
|
|
|
|
Node* h1[] = {w1.loop, c1.phi};
|
|
Node* b1[] = {w1.branch, w1.if_true, c1.add, c2.add, c2.add,
|
|
c2.phi, c3.phi, w2.loop, w2.branch, w2.if_true,
|
|
w2.exit, w3.loop, w3.branch, w3.if_true, w3.exit};
|
|
t.CheckLoop(h1, 2, b1, 15);
|
|
|
|
Node* h2[] = {w2.loop, c2.phi};
|
|
Node* b2[] = {w2.branch, w2.if_true, c2.add, c3.add, c3.phi,
|
|
w3.loop, w3.branch, w3.if_true, w3.exit};
|
|
t.CheckLoop(h2, 2, b2, 9);
|
|
|
|
Node* h3[] = {w3.loop, c3.phi};
|
|
Node* b3[] = {w3.branch, w3.if_true, c3.add};
|
|
t.CheckLoop(h3, 2, b3, 3);
|
|
}
|
|
|
|
|
|
TEST(LaMultipleExit1) {
|
|
const int kMaxExits = 10;
|
|
Node* merge[1 + kMaxExits];
|
|
Node* body[2 * kMaxExits];
|
|
|
|
// A single loop with {i} exits.
|
|
for (int i = 1; i < kMaxExits; i++) {
|
|
LoopFinderTester t;
|
|
Node* cond = t.p0;
|
|
|
|
int merge_count = 0;
|
|
int body_count = 0;
|
|
Node* loop = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
|
|
Node* last = loop;
|
|
|
|
for (int e = 0; e < i; e++) {
|
|
Node* branch = t.graph.NewNode(t.common.Branch(), cond, last);
|
|
Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
|
|
Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
|
|
last = if_true;
|
|
|
|
body[body_count++] = branch;
|
|
body[body_count++] = if_true;
|
|
merge[merge_count++] = exit;
|
|
}
|
|
|
|
loop->ReplaceInput(1, last); // form loop backedge.
|
|
Node* end = t.graph.NewNode(t.common.Merge(i), i, merge); // form exit.
|
|
t.graph.SetEnd(end);
|
|
|
|
Node* h[] = {loop};
|
|
t.CheckLoop(h, 1, body, body_count);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(LaMultipleBackedge1) {
|
|
const int kMaxBackedges = 10;
|
|
Node* loop_inputs[1 + kMaxBackedges];
|
|
Node* body[3 * kMaxBackedges];
|
|
|
|
// A single loop with {i} backedges.
|
|
for (int i = 1; i < kMaxBackedges; i++) {
|
|
LoopFinderTester t;
|
|
|
|
for (int j = 0; j <= i; j++) loop_inputs[j] = t.start;
|
|
Node* loop = t.graph.NewNode(t.common.Loop(1 + i), 1 + i, loop_inputs);
|
|
|
|
Node* cond = t.p0;
|
|
int body_count = 0;
|
|
Node* exit = loop;
|
|
|
|
for (int b = 0; b < i; b++) {
|
|
Node* branch = t.graph.NewNode(t.common.Branch(), cond, exit);
|
|
Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
|
|
Node* if_false = t.graph.NewNode(t.common.IfFalse(), branch);
|
|
exit = if_false;
|
|
|
|
body[body_count++] = branch;
|
|
body[body_count++] = if_true;
|
|
if (b != (i - 1)) body[body_count++] = if_false;
|
|
|
|
loop->ReplaceInput(1 + b, if_true);
|
|
}
|
|
|
|
t.graph.SetEnd(exit);
|
|
|
|
Node* h[] = {loop};
|
|
t.CheckLoop(h, 1, body, body_count);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(LaEdgeMatrix1) {
|
|
// Test various kinds of extra edges added to a simple loop.
|
|
for (int i = 0; i < 3; i++) {
|
|
for (int j = 0; j < 3; j++) {
|
|
for (int k = 0; k < 3; k++) {
|
|
LoopFinderTester t;
|
|
|
|
Node* p1 = t.jsgraph.Int32Constant(11);
|
|
Node* p2 = t.jsgraph.Int32Constant(22);
|
|
Node* p3 = t.jsgraph.Int32Constant(33);
|
|
|
|
Node* loop = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
|
|
Node* phi = t.graph.NewNode(
|
|
t.common.Phi(MachineRepresentation::kWord32, 2), t.one, p1, loop);
|
|
Node* cond = t.graph.NewNode(&kIntAdd, phi, p2);
|
|
Node* branch = t.graph.NewNode(t.common.Branch(), cond, loop);
|
|
Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
|
|
Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
|
|
loop->ReplaceInput(1, if_true);
|
|
Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
|
|
Node* ret = t.graph.NewNode(t.common.Return(), zero, p3, t.start, exit);
|
|
t.graph.SetEnd(ret);
|
|
|
|
Node* choices[] = {p1, phi, cond};
|
|
p1->ReplaceUses(choices[i]);
|
|
p2->ReplaceUses(choices[j]);
|
|
p3->ReplaceUses(choices[k]);
|
|
|
|
Node* header[] = {loop, phi};
|
|
Node* body[] = {cond, branch, if_true};
|
|
t.CheckLoop(header, 2, body, 3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void RunEdgeMatrix2(int i) {
|
|
CHECK(i >= 0 && i < 5);
|
|
for (int j = 0; j < 5; j++) {
|
|
for (int k = 0; k < 5; k++) {
|
|
LoopFinderTester t;
|
|
|
|
Node* p1 = t.jsgraph.Int32Constant(11);
|
|
Node* p2 = t.jsgraph.Int32Constant(22);
|
|
Node* p3 = t.jsgraph.Int32Constant(33);
|
|
|
|
// outer loop.
|
|
Node* loop1 = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
|
|
Node* phi1 = t.graph.NewNode(
|
|
t.common.Phi(MachineRepresentation::kWord32, 2), t.one, p1, loop1);
|
|
Node* cond1 = t.graph.NewNode(&kIntAdd, phi1, t.one);
|
|
Node* branch1 = t.graph.NewNode(t.common.Branch(), cond1, loop1);
|
|
Node* if_true1 = t.graph.NewNode(t.common.IfTrue(), branch1);
|
|
Node* exit1 = t.graph.NewNode(t.common.IfFalse(), branch1);
|
|
|
|
// inner loop.
|
|
Node* loop2 = t.graph.NewNode(t.common.Loop(2), if_true1, t.start);
|
|
Node* phi2 = t.graph.NewNode(
|
|
t.common.Phi(MachineRepresentation::kWord32, 2), t.one, p2, loop2);
|
|
Node* cond2 = t.graph.NewNode(&kIntAdd, phi2, p3);
|
|
Node* branch2 = t.graph.NewNode(t.common.Branch(), cond2, loop2);
|
|
Node* if_true2 = t.graph.NewNode(t.common.IfTrue(), branch2);
|
|
Node* exit2 = t.graph.NewNode(t.common.IfFalse(), branch2);
|
|
loop2->ReplaceInput(1, if_true2);
|
|
loop1->ReplaceInput(1, exit2);
|
|
|
|
Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
|
|
Node* ret =
|
|
t.graph.NewNode(t.common.Return(), zero, phi1, t.start, exit1);
|
|
t.graph.SetEnd(ret);
|
|
|
|
Node* choices[] = {p1, phi1, cond1, phi2, cond2};
|
|
p1->ReplaceUses(choices[i]);
|
|
p2->ReplaceUses(choices[j]);
|
|
p3->ReplaceUses(choices[k]);
|
|
|
|
Node* header1[] = {loop1, phi1};
|
|
Node* body1[] = {cond1, branch1, if_true1, exit2, loop2,
|
|
phi2, cond2, branch2, if_true2};
|
|
t.CheckLoop(header1, 2, body1, 9);
|
|
|
|
Node* header2[] = {loop2, phi2};
|
|
Node* body2[] = {cond2, branch2, if_true2};
|
|
t.CheckLoop(header2, 2, body2, 3);
|
|
|
|
Node* chain[] = {loop1, loop2};
|
|
t.CheckNestedLoops(chain, 2);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(LaEdgeMatrix2_0) { RunEdgeMatrix2(0); }
|
|
|
|
|
|
TEST(LaEdgeMatrix2_1) { RunEdgeMatrix2(1); }
|
|
|
|
|
|
TEST(LaEdgeMatrix2_2) { RunEdgeMatrix2(2); }
|
|
|
|
|
|
TEST(LaEdgeMatrix2_3) { RunEdgeMatrix2(3); }
|
|
|
|
|
|
TEST(LaEdgeMatrix2_4) { RunEdgeMatrix2(4); }
|
|
|
|
|
|
// Generates a triply-nested loop with extra edges between the phis and
|
|
// conditions according to the edge choice parameters.
|
|
void RunEdgeMatrix3(int c1a, int c1b, int c1c, // line break
|
|
int c2a, int c2b, int c2c, // line break
|
|
int c3a, int c3b, int c3c) { // line break
|
|
LoopFinderTester t;
|
|
|
|
Node* p1a = t.jsgraph.Int32Constant(11);
|
|
Node* p1b = t.jsgraph.Int32Constant(22);
|
|
Node* p1c = t.jsgraph.Int32Constant(33);
|
|
Node* p2a = t.jsgraph.Int32Constant(44);
|
|
Node* p2b = t.jsgraph.Int32Constant(55);
|
|
Node* p2c = t.jsgraph.Int32Constant(66);
|
|
Node* p3a = t.jsgraph.Int32Constant(77);
|
|
Node* p3b = t.jsgraph.Int32Constant(88);
|
|
Node* p3c = t.jsgraph.Int32Constant(99);
|
|
|
|
// L1 depth = 0
|
|
Node* loop1 = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
|
|
Node* phi1 = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
|
|
p1a, p1c, loop1);
|
|
Node* cond1 = t.graph.NewNode(&kIntAdd, phi1, p1b);
|
|
Node* branch1 = t.graph.NewNode(t.common.Branch(), cond1, loop1);
|
|
Node* if_true1 = t.graph.NewNode(t.common.IfTrue(), branch1);
|
|
Node* exit1 = t.graph.NewNode(t.common.IfFalse(), branch1);
|
|
|
|
// L2 depth = 1
|
|
Node* loop2 = t.graph.NewNode(t.common.Loop(2), if_true1, t.start);
|
|
Node* phi2 = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
|
|
p2a, p2c, loop2);
|
|
Node* cond2 = t.graph.NewNode(&kIntAdd, phi2, p2b);
|
|
Node* branch2 = t.graph.NewNode(t.common.Branch(), cond2, loop2);
|
|
Node* if_true2 = t.graph.NewNode(t.common.IfTrue(), branch2);
|
|
Node* exit2 = t.graph.NewNode(t.common.IfFalse(), branch2);
|
|
|
|
// L3 depth = 2
|
|
Node* loop3 = t.graph.NewNode(t.common.Loop(2), if_true2, t.start);
|
|
Node* phi3 = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
|
|
p3a, p3c, loop3);
|
|
Node* cond3 = t.graph.NewNode(&kIntAdd, phi3, p3b);
|
|
Node* branch3 = t.graph.NewNode(t.common.Branch(), cond3, loop3);
|
|
Node* if_true3 = t.graph.NewNode(t.common.IfTrue(), branch3);
|
|
Node* exit3 = t.graph.NewNode(t.common.IfFalse(), branch3);
|
|
|
|
loop3->ReplaceInput(1, if_true3);
|
|
loop2->ReplaceInput(1, exit3);
|
|
loop1->ReplaceInput(1, exit2);
|
|
|
|
Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
|
|
Node* ret = t.graph.NewNode(t.common.Return(), zero, phi1, t.start, exit1);
|
|
t.graph.SetEnd(ret);
|
|
|
|
// Mutate the graph according to the edge choices.
|
|
|
|
Node* o1[] = {t.one};
|
|
Node* o2[] = {t.one, phi1, cond1};
|
|
Node* o3[] = {t.one, phi1, cond1, phi2, cond2};
|
|
|
|
p1a->ReplaceUses(o1[c1a]);
|
|
p1b->ReplaceUses(o1[c1b]);
|
|
|
|
p2a->ReplaceUses(o2[c2a]);
|
|
p2b->ReplaceUses(o2[c2b]);
|
|
|
|
p3a->ReplaceUses(o3[c3a]);
|
|
p3b->ReplaceUses(o3[c3b]);
|
|
|
|
Node* l2[] = {phi1, cond1, phi2, cond2};
|
|
Node* l3[] = {phi1, cond1, phi2, cond2, phi3, cond3};
|
|
|
|
p1c->ReplaceUses(l2[c1c]);
|
|
p2c->ReplaceUses(l3[c2c]);
|
|
p3c->ReplaceUses(l3[c3c]);
|
|
|
|
// Run the tests and verify loop structure.
|
|
|
|
Node* chain[] = {loop1, loop2, loop3};
|
|
t.CheckNestedLoops(chain, 3);
|
|
|
|
Node* header1[] = {loop1, phi1};
|
|
Node* body1[] = {cond1, branch1, if_true1, exit2, loop2,
|
|
phi2, cond2, branch2, if_true2, exit3,
|
|
loop3, phi3, cond3, branch3, if_true3};
|
|
t.CheckLoop(header1, 2, body1, 15);
|
|
|
|
Node* header2[] = {loop2, phi2};
|
|
Node* body2[] = {cond2, branch2, if_true2, exit3, loop3,
|
|
phi3, cond3, branch3, if_true3};
|
|
t.CheckLoop(header2, 2, body2, 9);
|
|
|
|
Node* header3[] = {loop3, phi3};
|
|
Node* body3[] = {cond3, branch3, if_true3};
|
|
t.CheckLoop(header3, 2, body3, 3);
|
|
}
|
|
|
|
|
|
// Runs all combinations with a fixed {i}.
|
|
static void RunEdgeMatrix3_i(int i) {
|
|
for (int a = 0; a < 1; a++) {
|
|
for (int b = 0; b < 1; b++) {
|
|
for (int c = 0; c < 4; c++) {
|
|
for (int d = 0; d < 3; d++) {
|
|
for (int e = 0; e < 3; e++) {
|
|
for (int f = 0; f < 6; f++) {
|
|
for (int g = 0; g < 5; g++) {
|
|
for (int h = 0; h < 5; h++) {
|
|
RunEdgeMatrix3(a, b, c, d, e, f, g, h, i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Test all possible legal triply-nested loops with conditions and phis.
|
|
TEST(LaEdgeMatrix3_0) { RunEdgeMatrix3_i(0); }
|
|
|
|
|
|
TEST(LaEdgeMatrix3_1) { RunEdgeMatrix3_i(1); }
|
|
|
|
|
|
TEST(LaEdgeMatrix3_2) { RunEdgeMatrix3_i(2); }
|
|
|
|
|
|
TEST(LaEdgeMatrix3_3) { RunEdgeMatrix3_i(3); }
|
|
|
|
|
|
TEST(LaEdgeMatrix3_4) { RunEdgeMatrix3_i(4); }
|
|
|
|
|
|
TEST(LaEdgeMatrix3_5) { RunEdgeMatrix3_i(5); }
|
|
|
|
|
|
static void RunManyChainedLoops_i(int count) {
|
|
LoopFinderTester t;
|
|
Node** nodes = t.zone()->NewArray<Node*>(count * 4);
|
|
Node* k11 = t.jsgraph.Int32Constant(11);
|
|
Node* k12 = t.jsgraph.Int32Constant(12);
|
|
Node* last = t.start;
|
|
|
|
// Build loops.
|
|
for (int i = 0; i < count; i++) {
|
|
Node* loop = t.graph.NewNode(t.common.Loop(2), last, t.start);
|
|
Node* phi = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
|
|
k11, k12, loop);
|
|
Node* branch = t.graph.NewNode(t.common.Branch(), phi, loop);
|
|
Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
|
|
Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
|
|
loop->ReplaceInput(1, if_true);
|
|
|
|
nodes[i * 4 + 0] = loop;
|
|
nodes[i * 4 + 1] = phi;
|
|
nodes[i * 4 + 2] = branch;
|
|
nodes[i * 4 + 3] = if_true;
|
|
|
|
last = exit;
|
|
}
|
|
|
|
Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
|
|
Node* ret = t.graph.NewNode(t.common.Return(), zero, t.p0, t.start, last);
|
|
t.graph.SetEnd(ret);
|
|
|
|
// Verify loops.
|
|
for (int i = 0; i < count; i++) {
|
|
t.CheckLoop(nodes + i * 4, 2, nodes + i * 4 + 2, 2);
|
|
}
|
|
}
|
|
|
|
|
|
static void RunManyNestedLoops_i(int count) {
|
|
LoopFinderTester t;
|
|
Node** nodes = t.zone()->NewArray<Node*>(count * 5);
|
|
Node* k11 = t.jsgraph.Int32Constant(11);
|
|
Node* k12 = t.jsgraph.Int32Constant(12);
|
|
Node* outer = nullptr;
|
|
Node* entry = t.start;
|
|
|
|
// Build loops.
|
|
Node* zero = t.graph.NewNode(t.common.Int32Constant(0));
|
|
for (int i = 0; i < count; i++) {
|
|
Node* loop = t.graph.NewNode(t.common.Loop(2), entry, t.start);
|
|
Node* phi = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
|
|
k11, k12, loop);
|
|
Node* branch = t.graph.NewNode(t.common.Branch(), phi, loop);
|
|
Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
|
|
Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
|
|
|
|
nodes[i * 5 + 0] = exit; // outside
|
|
nodes[i * 5 + 1] = loop; // header
|
|
nodes[i * 5 + 2] = phi; // header
|
|
nodes[i * 5 + 3] = branch; // body
|
|
nodes[i * 5 + 4] = if_true; // body
|
|
|
|
if (outer != nullptr) {
|
|
// inner loop.
|
|
outer->ReplaceInput(1, exit);
|
|
} else {
|
|
// outer loop.
|
|
Node* ret = t.graph.NewNode(t.common.Return(), zero, t.p0, t.start, exit);
|
|
t.graph.SetEnd(ret);
|
|
}
|
|
outer = loop;
|
|
entry = if_true;
|
|
}
|
|
outer->ReplaceInput(1, entry); // innermost loop.
|
|
|
|
// Verify loops.
|
|
for (int i = 0; i < count; i++) {
|
|
int k = i * 5;
|
|
t.CheckLoop(nodes + k + 1, 2, nodes + k + 3, count * 5 - k - 3);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(LaManyChained_30) { RunManyChainedLoops_i(30); }
|
|
TEST(LaManyChained_31) { RunManyChainedLoops_i(31); }
|
|
TEST(LaManyChained_32) { RunManyChainedLoops_i(32); }
|
|
TEST(LaManyChained_33) { RunManyChainedLoops_i(33); }
|
|
TEST(LaManyChained_34) { RunManyChainedLoops_i(34); }
|
|
TEST(LaManyChained_62) { RunManyChainedLoops_i(62); }
|
|
TEST(LaManyChained_63) { RunManyChainedLoops_i(63); }
|
|
TEST(LaManyChained_64) { RunManyChainedLoops_i(64); }
|
|
|
|
TEST(LaManyNested_30) { RunManyNestedLoops_i(30); }
|
|
TEST(LaManyNested_31) { RunManyNestedLoops_i(31); }
|
|
TEST(LaManyNested_32) { RunManyNestedLoops_i(32); }
|
|
TEST(LaManyNested_33) { RunManyNestedLoops_i(33); }
|
|
TEST(LaManyNested_34) { RunManyNestedLoops_i(34); }
|
|
TEST(LaManyNested_62) { RunManyNestedLoops_i(62); }
|
|
TEST(LaManyNested_63) { RunManyNestedLoops_i(63); }
|
|
TEST(LaManyNested_64) { RunManyNestedLoops_i(64); }
|
|
|
|
|
|
TEST(LaPhiTangle) { LoopFinderTester t; }
|
|
|
|
} // namespace compiler
|
|
} // namespace internal
|
|
} // namespace v8
|