| Index: test/cctest/compiler/test-node.cc
|
| diff --git a/test/cctest/compiler/test-node.cc b/test/cctest/compiler/test-node.cc
|
| index 2c51e26f86c649ee179004925dcb2eccc88653c5..0aa1f1c54215fd070cfe9c560753c2c16853e8bc 100644
|
| --- a/test/cctest/compiler/test-node.cc
|
| +++ b/test/cctest/compiler/test-node.cc
|
| @@ -13,32 +13,143 @@
|
| using namespace v8::internal;
|
| using namespace v8::internal::compiler;
|
|
|
| +#define NONE reinterpret_cast<Node*>(1)
|
| +
|
| static Operator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
|
| "dummy", 0, 0, 0, 1, 0, 0);
|
|
|
| +#define CHECK_USES(node, ...) \
|
| + do { \
|
| + Node* __array[] = {__VA_ARGS__}; \
|
| + int __size = \
|
| + __array[0] != NONE ? static_cast<int>(arraysize(__array)) : 0; \
|
| + CheckUseChain(node, __array, __size); \
|
| + } while (false)
|
| +
|
| +
|
| +typedef std::multiset<Node*, std::less<Node*>> NodeMSet;
|
| +
|
| +static void CheckUseChain(Node* node, Node** uses, int use_count) {
|
| + // Check ownership.
|
| + if (use_count == 1) CHECK(node->OwnedBy(uses[0]));
|
| + if (use_count > 1) {
|
| + for (int i = 0; i < use_count; i++) {
|
| + CHECK(!node->OwnedBy(uses[i]));
|
| + }
|
| + }
|
| +
|
| + // Check the self-reported use count.
|
| + CHECK_EQ(use_count, node->UseCount());
|
| +
|
| + // Build the expectation set.
|
| + NodeMSet expect_set;
|
| + for (int i = 0; i < use_count; i++) {
|
| + expect_set.insert(uses[i]);
|
| + }
|
| +
|
| + {
|
| + // Check that iterating over the uses gives the right counts.
|
| + NodeMSet use_set;
|
| + for (auto use : node->uses()) {
|
| + use_set.insert(use);
|
| + }
|
| + CHECK(expect_set == use_set);
|
| + }
|
| +
|
| + {
|
| + // Check that iterating over the use edges gives the right counts,
|
| + // input indices, from(), and to() pointers.
|
| + NodeMSet use_set;
|
| + for (auto edge : node->use_edges()) {
|
| + CHECK_EQ(node, edge.to());
|
| + CHECK_EQ(node, edge.from()->InputAt(edge.index()));
|
| + use_set.insert(edge.from());
|
| + }
|
| + CHECK(expect_set == use_set);
|
| + }
|
| +
|
| + {
|
| + // Check the use nodes actually have the node as inputs.
|
| + for (Node* use : node->uses()) {
|
| + size_t count = 0;
|
| + for (Node* input : use->inputs()) {
|
| + if (input == node) count++;
|
| + }
|
| + CHECK_EQ(count, expect_set.count(use));
|
| + }
|
| + }
|
| +}
|
| +
|
| +
|
| +#define CHECK_INPUTS(node, ...) \
|
| + do { \
|
| + Node* __array[] = {__VA_ARGS__}; \
|
| + int __size = \
|
| + __array[0] != NONE ? static_cast<int>(arraysize(__array)) : 0; \
|
| + CheckInputs(node, __array, __size); \
|
| + } while (false)
|
| +
|
| +
|
| +static void CheckInputs(Node* node, Node** inputs, int input_count) {
|
| + CHECK_EQ(input_count, node->InputCount());
|
| + // Check InputAt().
|
| + for (int i = 0; i < static_cast<int>(input_count); i++) {
|
| + CHECK_EQ(inputs[i], node->InputAt(i));
|
| + }
|
| +
|
| + // Check input iterator.
|
| + int index = 0;
|
| + for (Node* input : node->inputs()) {
|
| + CHECK_EQ(inputs[index], input);
|
| + index++;
|
| + }
|
| +
|
| + // Check use lists of inputs.
|
| + for (int i = 0; i < static_cast<int>(input_count); i++) {
|
| + Node* input = inputs[i];
|
| + if (!input) continue; // skip null inputs
|
| + bool found = false;
|
| + // Check regular use list.
|
| + for (Node* use : input->uses()) {
|
| + if (use == node) {
|
| + found = true;
|
| + break;
|
| + }
|
| + }
|
| + CHECK(found);
|
| + int count = 0;
|
| + // Check use edge list.
|
| + for (auto edge : input->use_edges()) {
|
| + if (edge.from() == node && edge.to() == input && edge.index() == i) {
|
| + count++;
|
| + }
|
| + }
|
| + CHECK_EQ(1, count);
|
| + }
|
| +}
|
| +
|
| +
|
| TEST(NodeUseIteratorReplaceUses) {
|
| GraphTester graph;
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0);
|
| Node* n3 = graph.NewNode(&dummy_operator);
|
| - auto i1(n0->uses().begin());
|
| - CHECK_EQ(n1, *i1);
|
| - ++i1;
|
| - CHECK_EQ(n2, *i1);
|
| +
|
| + CHECK_USES(n0, n1, n2);
|
| +
|
| + CHECK_INPUTS(n1, n0);
|
| + CHECK_INPUTS(n2, n0);
|
| +
|
| n0->ReplaceUses(n3);
|
| - auto i2(n3->uses().begin());
|
| - CHECK_EQ(n1, *i2);
|
| - ++i2;
|
| - CHECK_EQ(n2, *i2);
|
| - auto i3(n1->inputs().begin());
|
| - CHECK_EQ(n3, *i3);
|
| - ++i3;
|
| - CHECK(n1->inputs().end() == i3);
|
| - auto i4(n2->inputs().begin());
|
| - CHECK_EQ(n3, *i4);
|
| - ++i4;
|
| - CHECK(n2->inputs().end() == i4);
|
| +
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, NONE);
|
| + CHECK_USES(n2, NONE);
|
| + CHECK_USES(n3, n1, n2);
|
| +
|
| + CHECK_INPUTS(n1, n3);
|
| + CHECK_INPUTS(n2, n3);
|
| }
|
|
|
|
|
| @@ -46,21 +157,22 @@ TEST(NodeUseIteratorReplaceUsesSelf) {
|
| GraphTester graph;
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| - Node* n3 = graph.NewNode(&dummy_operator);
|
| +
|
| + CHECK_USES(n0, n1);
|
| + CHECK_USES(n1, NONE);
|
|
|
| n1->ReplaceInput(0, n1); // Create self-reference.
|
|
|
| - auto i1(n1->uses().begin());
|
| - CHECK_EQ(n1, *i1);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, n1);
|
|
|
| - n1->ReplaceUses(n3);
|
| + Node* n2 = graph.NewNode(&dummy_operator);
|
|
|
| - CHECK(n1->uses().begin() == n1->uses().end());
|
| + n1->ReplaceUses(n2);
|
|
|
| - auto i2(n3->uses().begin());
|
| - CHECK_EQ(n1, *i2);
|
| - ++i2;
|
| - CHECK(n1->uses().end() == i2);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, NONE);
|
| + CHECK_USES(n2, n1);
|
| }
|
|
|
|
|
| @@ -70,48 +182,22 @@ TEST(ReplaceInput) {
|
| Node* n1 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator);
|
| Node* n3 = graph.NewNode(&dummy_operator, n0, n1, n2);
|
| - auto i1(n3->inputs().begin());
|
| - CHECK(n0 == *i1);
|
| - CHECK_EQ(n0, n3->InputAt(0));
|
| - ++i1;
|
| - CHECK_EQ(n1, *i1);
|
| - CHECK_EQ(n1, n3->InputAt(1));
|
| - ++i1;
|
| - CHECK_EQ(n2, *i1);
|
| - CHECK_EQ(n2, n3->InputAt(2));
|
| - ++i1;
|
| - CHECK(i1 == n3->inputs().end());
|
| -
|
| - auto i2(n1->uses().begin());
|
| - CHECK_EQ(n3, *i2);
|
| - ++i2;
|
| - CHECK(i2 == n1->uses().end());
|
| -
|
| Node* n4 = graph.NewNode(&dummy_operator);
|
| - auto i3(n4->uses().begin());
|
| - CHECK(i3 == n4->uses().end());
|
| +
|
| + CHECK_USES(n0, n3);
|
| + CHECK_USES(n1, n3);
|
| + CHECK_USES(n2, n3);
|
| + CHECK_USES(n3, NONE);
|
| + CHECK_USES(n4, NONE);
|
| +
|
| + CHECK_INPUTS(n3, n0, n1, n2);
|
|
|
| n3->ReplaceInput(1, n4);
|
|
|
| - auto i4(n1->uses().begin());
|
| - CHECK(i4 == n1->uses().end());
|
| -
|
| - auto i5(n4->uses().begin());
|
| - CHECK_EQ(n3, *i5);
|
| - ++i5;
|
| - CHECK(i5 == n4->uses().end());
|
| -
|
| - auto i6(n3->inputs().begin());
|
| - CHECK(n0 == *i6);
|
| - CHECK_EQ(n0, n3->InputAt(0));
|
| - ++i6;
|
| - CHECK_EQ(n4, *i6);
|
| - CHECK_EQ(n4, n3->InputAt(1));
|
| - ++i6;
|
| - CHECK_EQ(n2, *i6);
|
| - CHECK_EQ(n2, n3->InputAt(2));
|
| - ++i6;
|
| - CHECK(i6 == n3->inputs().end());
|
| + CHECK_USES(n1, NONE);
|
| + CHECK_USES(n4, n3);
|
| +
|
| + CHECK_INPUTS(n3, n0, n4, n2);
|
| }
|
|
|
|
|
| @@ -169,16 +255,19 @@ TEST(Uses) {
|
|
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| - CHECK_EQ(1, n0->UseCount());
|
| - printf("A: %d vs %d\n", n0->UseAt(0)->id(), n1->id());
|
| - CHECK(n0->UseAt(0) == n1);
|
| +
|
| + CHECK_USES(n0, n1);
|
| + CHECK_USES(n1, NONE);
|
| +
|
| Node* n2 = graph.NewNode(&dummy_operator, n0);
|
| - CHECK_EQ(2, n0->UseCount());
|
| - printf("B: %d vs %d\n", n0->UseAt(1)->id(), n2->id());
|
| - CHECK(n0->UseAt(1) == n2);
|
| +
|
| + CHECK_USES(n0, n1, n2);
|
| + CHECK_USES(n2, NONE);
|
| +
|
| Node* n3 = graph.NewNode(&dummy_operator, n0);
|
| - CHECK_EQ(3, n0->UseCount());
|
| - CHECK(n0->UseAt(2) == n3);
|
| +
|
| + CHECK_USES(n0, n1, n2, n3);
|
| + CHECK_USES(n3, NONE);
|
| }
|
|
|
|
|
| @@ -189,39 +278,23 @@ TEST(Inputs) {
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0);
|
| Node* n3 = graph.NewNode(&dummy_operator, n0, n1, n2);
|
| - CHECK_EQ(3, n3->InputCount());
|
| - CHECK(n3->InputAt(0) == n0);
|
| - CHECK(n3->InputAt(1) == n1);
|
| - CHECK(n3->InputAt(2) == n2);
|
| +
|
| + CHECK_INPUTS(n3, n0, n1, n2);
|
| +
|
| Node* n4 = graph.NewNode(&dummy_operator, n0, n1, n2);
|
| n3->AppendInput(graph.zone(), n4);
|
| - CHECK_EQ(4, n3->InputCount());
|
| - CHECK(n3->InputAt(0) == n0);
|
| - CHECK(n3->InputAt(1) == n1);
|
| - CHECK(n3->InputAt(2) == n2);
|
| - CHECK(n3->InputAt(3) == n4);
|
| - Node* n5 = graph.NewNode(&dummy_operator, n4);
|
| +
|
| + CHECK_INPUTS(n3, n0, n1, n2, n4);
|
| + CHECK_USES(n4, n3);
|
| +
|
| n3->AppendInput(graph.zone(), n4);
|
| - CHECK_EQ(5, n3->InputCount());
|
| - CHECK(n3->InputAt(0) == n0);
|
| - CHECK(n3->InputAt(1) == n1);
|
| - CHECK(n3->InputAt(2) == n2);
|
| - CHECK(n3->InputAt(3) == n4);
|
| - CHECK(n3->InputAt(4) == n4);
|
| -
|
| - // Make sure uses have been hooked op correctly.
|
| - Node::Uses uses(n4->uses());
|
| - auto current = uses.begin();
|
| - CHECK(current != uses.end());
|
| - CHECK(*current == n3);
|
| - ++current;
|
| - CHECK(current != uses.end());
|
| - CHECK(*current == n5);
|
| - ++current;
|
| - CHECK(current != uses.end());
|
| - CHECK(*current == n3);
|
| - ++current;
|
| - CHECK(current == uses.end());
|
| +
|
| + CHECK_INPUTS(n3, n0, n1, n2, n4, n4);
|
| + CHECK_USES(n4, n3, n3);
|
| +
|
| + Node* n5 = graph.NewNode(&dummy_operator, n4);
|
| +
|
| + CHECK_USES(n4, n3, n3, n5);
|
| }
|
|
|
|
|
| @@ -232,17 +305,25 @@ TEST(RemoveInput) {
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
|
|
|
| + CHECK_INPUTS(n0, NONE);
|
| + CHECK_INPUTS(n1, n0);
|
| + CHECK_INPUTS(n2, n0, n1);
|
| + CHECK_USES(n0, n1, n2);
|
| +
|
| n1->RemoveInput(0);
|
| - CHECK_EQ(0, n1->InputCount());
|
| - CHECK_EQ(1, n0->UseCount());
|
| + CHECK_INPUTS(n1, NONE);
|
| + CHECK_USES(n0, n2);
|
|
|
| n2->RemoveInput(0);
|
| - CHECK_EQ(1, n2->InputCount());
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(1, n1->UseCount());
|
| + CHECK_INPUTS(n2, n1);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, n2);
|
|
|
| n2->RemoveInput(0);
|
| - CHECK_EQ(0, n2->InputCount());
|
| + CHECK_INPUTS(n2, NONE);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, NONE);
|
| + CHECK_USES(n2, NONE);
|
| }
|
|
|
|
|
| @@ -253,33 +334,17 @@ TEST(AppendInputsAndIterator) {
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
|
|
|
| - Node::InputEdges inputs(n2->input_edges());
|
| - Node::InputEdges::iterator current = inputs.begin();
|
| - CHECK(current != inputs.end());
|
| - CHECK((*current).to() == n0);
|
| - ++current;
|
| - CHECK(current != inputs.end());
|
| - CHECK((*current).to() == n1);
|
| - ++current;
|
| - CHECK(current == inputs.end());
|
| + CHECK_INPUTS(n0, NONE);
|
| + CHECK_INPUTS(n1, n0);
|
| + CHECK_INPUTS(n2, n0, n1);
|
| + CHECK_USES(n0, n1, n2);
|
|
|
| Node* n3 = graph.NewNode(&dummy_operator);
|
| +
|
| n2->AppendInput(graph.zone(), n3);
|
| - inputs = n2->input_edges();
|
| - current = inputs.begin();
|
| - CHECK(current != inputs.end());
|
| - CHECK((*current).to() == n0);
|
| - CHECK_EQ(0, (*current).index());
|
| - ++current;
|
| - CHECK(current != inputs.end());
|
| - CHECK((*current).to() == n1);
|
| - CHECK_EQ(1, (*current).index());
|
| - ++current;
|
| - CHECK(current != inputs.end());
|
| - CHECK((*current).to() == n3);
|
| - CHECK_EQ(2, (*current).index());
|
| - ++current;
|
| - CHECK(current == inputs.end());
|
| +
|
| + CHECK_INPUTS(n2, n0, n1, n3);
|
| + CHECK_USES(n3, n2);
|
| }
|
|
|
|
|
| @@ -289,15 +354,23 @@ TEST(NullInputsSimple) {
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
|
| - CHECK_EQ(2, n2->InputCount());
|
| -
|
| - CHECK(n0 == n2->InputAt(0));
|
| - CHECK(n1 == n2->InputAt(1));
|
| - CHECK_EQ(2, n0->UseCount());
|
| - n2->ReplaceInput(0, NULL);
|
| - CHECK(NULL == n2->InputAt(0));
|
| - CHECK(n1 == n2->InputAt(1));
|
| - CHECK_EQ(1, n0->UseCount());
|
| +
|
| + CHECK_INPUTS(n0, NONE);
|
| + CHECK_INPUTS(n1, n0);
|
| + CHECK_INPUTS(n2, n0, n1);
|
| + CHECK_USES(n0, n1, n2);
|
| +
|
| + n2->ReplaceInput(0, nullptr);
|
| +
|
| + CHECK_INPUTS(n2, NULL, n1);
|
| +
|
| + CHECK_USES(n0, n1);
|
| +
|
| + n2->ReplaceInput(1, nullptr);
|
| +
|
| + CHECK_INPUTS(n2, NULL, NULL);
|
| +
|
| + CHECK_USES(n1, NONE);
|
| }
|
|
|
|
|
| @@ -310,17 +383,16 @@ TEST(NullInputsAppended) {
|
| Node* n3 = graph.NewNode(&dummy_operator, n0);
|
| n3->AppendInput(graph.zone(), n1);
|
| n3->AppendInput(graph.zone(), n2);
|
| - CHECK_EQ(3, n3->InputCount());
|
|
|
| - CHECK(n0 == n3->InputAt(0));
|
| - CHECK(n1 == n3->InputAt(1));
|
| - CHECK(n2 == n3->InputAt(2));
|
| - CHECK_EQ(1, n1->UseCount());
|
| + CHECK_INPUTS(n3, n0, n1, n2);
|
| + CHECK_USES(n0, n1, n2, n3);
|
| + CHECK_USES(n1, n3);
|
| + CHECK_USES(n2, n3);
|
| +
|
| n3->ReplaceInput(1, NULL);
|
| - CHECK(n0 == n3->InputAt(0));
|
| - CHECK(NULL == n3->InputAt(1));
|
| - CHECK(n2 == n3->InputAt(2));
|
| - CHECK_EQ(0, n1->UseCount());
|
| + CHECK_USES(n1, NONE);
|
| +
|
| + CHECK_INPUTS(n3, n0, NULL, n2);
|
| }
|
|
|
|
|
| @@ -331,26 +403,23 @@ TEST(ReplaceUsesFromAppendedInputs) {
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0);
|
| Node* n3 = graph.NewNode(&dummy_operator);
|
| +
|
| + CHECK_INPUTS(n2, n0);
|
| +
|
| n2->AppendInput(graph.zone(), n1);
|
| + CHECK_INPUTS(n2, n0, n1);
|
| + CHECK_USES(n1, n2);
|
| +
|
| n2->AppendInput(graph.zone(), n0);
|
| - CHECK_EQ(0, n3->UseCount());
|
| - CHECK_EQ(3, n0->UseCount());
|
| + CHECK_INPUTS(n2, n0, n1, n0);
|
| + CHECK_USES(n1, n2);
|
| + CHECK_USES(n0, n2, n1, n2);
|
| +
|
| n0->ReplaceUses(n3);
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(3, n3->UseCount());
|
| -
|
| - Node::Uses uses(n3->uses());
|
| - auto current = uses.begin();
|
| - CHECK(current != uses.end());
|
| - CHECK(*current == n1);
|
| - ++current;
|
| - CHECK(current != uses.end());
|
| - CHECK(*current == n2);
|
| - ++current;
|
| - CHECK(current != uses.end());
|
| - CHECK(*current == n2);
|
| - ++current;
|
| - CHECK(current == uses.end());
|
| +
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_INPUTS(n2, n3, n1, n3);
|
| + CHECK_USES(n3, n2, n1, n2);
|
| }
|
|
|
|
|
| @@ -378,17 +447,16 @@ TEST(TrimInputCountInline) {
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| n1->TrimInputCount(1);
|
| - CHECK_EQ(1, n1->InputCount());
|
| - CHECK_EQ(n0, n1->InputAt(0));
|
| - CHECK_EQ(1, n0->UseCount());
|
| + CHECK_INPUTS(n1, n0);
|
| + CHECK_USES(n0, n1);
|
| }
|
|
|
| {
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| n1->TrimInputCount(0);
|
| - CHECK_EQ(0, n1->InputCount());
|
| - CHECK_EQ(0, n0->UseCount());
|
| + CHECK_INPUTS(n1, NONE);
|
| + CHECK_USES(n0, NONE);
|
| }
|
|
|
| {
|
| @@ -396,10 +464,9 @@ TEST(TrimInputCountInline) {
|
| Node* n1 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
|
| n2->TrimInputCount(2);
|
| - CHECK_EQ(2, n2->InputCount());
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(1, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| + CHECK_USES(n0, n2);
|
| + CHECK_USES(n1, n2);
|
| }
|
|
|
| {
|
| @@ -407,10 +474,9 @@ TEST(TrimInputCountInline) {
|
| Node* n1 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
|
| n2->TrimInputCount(1);
|
| - CHECK_EQ(1, n2->InputCount());
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(0, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0);
|
| + CHECK_USES(n0, n2);
|
| + CHECK_USES(n1, NONE);
|
| }
|
|
|
| {
|
| @@ -418,28 +484,25 @@ TEST(TrimInputCountInline) {
|
| Node* n1 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
|
| n2->TrimInputCount(0);
|
| - CHECK_EQ(0, n2->InputCount());
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(0, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, NONE);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, NONE);
|
| }
|
|
|
| {
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0, n0);
|
| n2->TrimInputCount(1);
|
| - CHECK_EQ(1, n2->InputCount());
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0);
|
| + CHECK_USES(n0, n2);
|
| }
|
|
|
| {
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0, n0);
|
| n2->TrimInputCount(0);
|
| - CHECK_EQ(0, n2->InputCount());
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, NONE);
|
| + CHECK_USES(n0, NONE);
|
| }
|
| }
|
|
|
| @@ -451,10 +514,12 @@ TEST(TrimInputCountOutOfLine1) {
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n1 = graph.NewNode(&dummy_operator);
|
| n1->AppendInput(graph.zone(), n0);
|
| + CHECK_INPUTS(n1, n0);
|
| + CHECK_USES(n0, n1);
|
| +
|
| n1->TrimInputCount(1);
|
| - CHECK_EQ(1, n1->InputCount());
|
| - CHECK_EQ(n0, n1->InputAt(0));
|
| - CHECK_EQ(1, n0->UseCount());
|
| + CHECK_INPUTS(n1, n0);
|
| + CHECK_USES(n0, n1);
|
| }
|
|
|
| {
|
| @@ -473,14 +538,12 @@ TEST(TrimInputCountOutOfLine1) {
|
| Node* n2 = graph.NewNode(&dummy_operator);
|
| n2->AppendInput(graph.zone(), n0);
|
| n2->AppendInput(graph.zone(), n1);
|
| - CHECK_EQ(2, n2->InputCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| n2->TrimInputCount(2);
|
| - CHECK_EQ(2, n2->InputCount());
|
| - CHECK_EQ(n0, n2->InputAt(0));
|
| - CHECK_EQ(n1, n2->InputAt(1));
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(1, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| + CHECK_USES(n0, n2);
|
| + CHECK_USES(n1, n2);
|
| + CHECK_USES(n2, NONE);
|
| }
|
|
|
| {
|
| @@ -489,13 +552,12 @@ TEST(TrimInputCountOutOfLine1) {
|
| Node* n2 = graph.NewNode(&dummy_operator);
|
| n2->AppendInput(graph.zone(), n0);
|
| n2->AppendInput(graph.zone(), n1);
|
| - CHECK_EQ(2, n2->InputCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| n2->TrimInputCount(1);
|
| - CHECK_EQ(1, n2->InputCount());
|
| - CHECK_EQ(n0, n2->InputAt(0));
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(0, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0);
|
| + CHECK_USES(n0, n2);
|
| + CHECK_USES(n1, NONE);
|
| + CHECK_USES(n2, NONE);
|
| }
|
|
|
| {
|
| @@ -504,12 +566,12 @@ TEST(TrimInputCountOutOfLine1) {
|
| Node* n2 = graph.NewNode(&dummy_operator);
|
| n2->AppendInput(graph.zone(), n0);
|
| n2->AppendInput(graph.zone(), n1);
|
| - CHECK_EQ(2, n2->InputCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| n2->TrimInputCount(0);
|
| - CHECK_EQ(0, n2->InputCount());
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(0, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, NONE);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, NONE);
|
| + CHECK_USES(n2, NONE);
|
| }
|
|
|
| {
|
| @@ -517,12 +579,11 @@ TEST(TrimInputCountOutOfLine1) {
|
| Node* n2 = graph.NewNode(&dummy_operator);
|
| n2->AppendInput(graph.zone(), n0);
|
| n2->AppendInput(graph.zone(), n0);
|
| - CHECK_EQ(2, n2->InputCount());
|
| - CHECK_EQ(2, n0->UseCount());
|
| + CHECK_INPUTS(n2, n0, n0);
|
| + CHECK_USES(n0, n2, n2);
|
| n2->TrimInputCount(1);
|
| - CHECK_EQ(1, n2->InputCount());
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0);
|
| + CHECK_USES(n0, n2);
|
| }
|
|
|
| {
|
| @@ -530,12 +591,11 @@ TEST(TrimInputCountOutOfLine1) {
|
| Node* n2 = graph.NewNode(&dummy_operator);
|
| n2->AppendInput(graph.zone(), n0);
|
| n2->AppendInput(graph.zone(), n0);
|
| - CHECK_EQ(2, n2->InputCount());
|
| - CHECK_EQ(2, n0->UseCount());
|
| + CHECK_INPUTS(n2, n0, n0);
|
| + CHECK_USES(n0, n2, n2);
|
| n2->TrimInputCount(0);
|
| - CHECK_EQ(0, n2->InputCount());
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, NONE);
|
| + CHECK_USES(n0, NONE);
|
| }
|
| }
|
|
|
| @@ -548,14 +608,12 @@ TEST(TrimInputCountOutOfLine2) {
|
| Node* n1 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0);
|
| n2->AppendInput(graph.zone(), n1);
|
| - CHECK_EQ(2, n2->InputCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| n2->TrimInputCount(2);
|
| - CHECK_EQ(2, n2->InputCount());
|
| - CHECK_EQ(n0, n2->InputAt(0));
|
| - CHECK_EQ(n1, n2->InputAt(1));
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(1, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| + CHECK_USES(n0, n2);
|
| + CHECK_USES(n1, n2);
|
| + CHECK_USES(n2, NONE);
|
| }
|
|
|
| {
|
| @@ -563,13 +621,12 @@ TEST(TrimInputCountOutOfLine2) {
|
| Node* n1 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0);
|
| n2->AppendInput(graph.zone(), n1);
|
| - CHECK_EQ(2, n2->InputCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| n2->TrimInputCount(1);
|
| - CHECK_EQ(1, n2->InputCount());
|
| - CHECK_EQ(n0, n2->InputAt(0));
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(0, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0);
|
| + CHECK_USES(n0, n2);
|
| + CHECK_USES(n1, NONE);
|
| + CHECK_USES(n2, NONE);
|
| }
|
|
|
| {
|
| @@ -577,24 +634,24 @@ TEST(TrimInputCountOutOfLine2) {
|
| Node* n1 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0);
|
| n2->AppendInput(graph.zone(), n1);
|
| - CHECK_EQ(2, n2->InputCount());
|
| + CHECK_INPUTS(n2, n0, n1);
|
| n2->TrimInputCount(0);
|
| - CHECK_EQ(0, n2->InputCount());
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(0, n1->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, NONE);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, NONE);
|
| + CHECK_USES(n2, NONE);
|
| }
|
|
|
| {
|
| Node* n0 = graph.NewNode(&dummy_operator);
|
| Node* n2 = graph.NewNode(&dummy_operator, n0);
|
| n2->AppendInput(graph.zone(), n0);
|
| - CHECK_EQ(2, n2->InputCount());
|
| - CHECK_EQ(2, n0->UseCount());
|
| + CHECK_INPUTS(n2, n0, n0);
|
| + CHECK_USES(n0, n2, n2);
|
| n2->TrimInputCount(1);
|
| - CHECK_EQ(1, n2->InputCount());
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK_EQ(0, n2->UseCount());
|
| + CHECK_INPUTS(n2, n0);
|
| + CHECK_USES(n0, n2);
|
| + CHECK_USES(n2, NONE);
|
| }
|
|
|
| {
|
| @@ -620,27 +677,27 @@ TEST(RemoveAllInputs) {
|
| Node* n2;
|
| if (i == 0) {
|
| n2 = graph.NewNode(&dummy_operator, n0, n1);
|
| + CHECK_INPUTS(n2, n0, n1);
|
| } else {
|
| n2 = graph.NewNode(&dummy_operator, n0);
|
| + CHECK_INPUTS(n2, n0);
|
| n2->AppendInput(graph.zone(), n1); // with out-of-line input.
|
| + CHECK_INPUTS(n2, n0, n1);
|
| }
|
|
|
| n0->RemoveAllInputs();
|
| - CHECK_EQ(0, n0->InputCount());
|
| + CHECK_INPUTS(n0, NONE);
|
|
|
| - CHECK_EQ(2, n0->UseCount());
|
| + CHECK_USES(n0, n1, n2);
|
| n1->RemoveAllInputs();
|
| - CHECK_EQ(1, n1->InputCount());
|
| - CHECK_EQ(1, n0->UseCount());
|
| - CHECK(!n1->InputAt(0));
|
| + CHECK_INPUTS(n1, NULL);
|
| + CHECK_INPUTS(n2, n0, n1);
|
| + CHECK_USES(n0, n2);
|
|
|
| - CHECK_EQ(1, n1->UseCount());
|
| n2->RemoveAllInputs();
|
| - CHECK_EQ(2, n2->InputCount());
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(0, n1->UseCount());
|
| - CHECK(!n2->InputAt(0));
|
| - CHECK(!n2->InputAt(1));
|
| + CHECK_INPUTS(n1, NULL);
|
| + CHECK_INPUTS(n2, NULL, NULL);
|
| + CHECK_USES(n0, NONE);
|
| }
|
|
|
| {
|
| @@ -648,11 +705,53 @@ TEST(RemoveAllInputs) {
|
| Node* n1 = graph.NewNode(&dummy_operator, n0);
|
| n1->ReplaceInput(0, n1); // self-reference.
|
|
|
| - CHECK_EQ(0, n0->UseCount());
|
| - CHECK_EQ(1, n1->UseCount());
|
| + CHECK_INPUTS(n0, NONE);
|
| + CHECK_INPUTS(n1, n1);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, n1);
|
| n1->RemoveAllInputs();
|
| - CHECK_EQ(1, n1->InputCount());
|
| - CHECK_EQ(0, n1->UseCount());
|
| - CHECK(!n1->InputAt(0));
|
| +
|
| + CHECK_INPUTS(n0, NONE);
|
| + CHECK_INPUTS(n1, NULL);
|
| + CHECK_USES(n0, NONE);
|
| + CHECK_USES(n1, NONE);
|
| + }
|
| +}
|
| +
|
| +
|
| +TEST(AppendAndTrim) {
|
| + GraphTester graph;
|
| +
|
| + Node* nodes[] = {
|
| + graph.NewNode(&dummy_operator), graph.NewNode(&dummy_operator),
|
| + graph.NewNode(&dummy_operator), graph.NewNode(&dummy_operator),
|
| + graph.NewNode(&dummy_operator)};
|
| +
|
| + int max = static_cast<int>(arraysize(nodes));
|
| +
|
| + Node* last = graph.NewNode(&dummy_operator);
|
| +
|
| + for (int i = 0; i < max; i++) {
|
| + last->AppendInput(graph.zone(), nodes[i]);
|
| + CheckInputs(last, nodes, i + 1);
|
| +
|
| + for (int j = 0; j < max; j++) {
|
| + if (j <= i) CHECK_USES(nodes[j], last);
|
| + if (j > i) CHECK_USES(nodes[j], NONE);
|
| + }
|
| +
|
| + CHECK_USES(last, NONE);
|
| + }
|
| +
|
| + for (int i = max; i >= 0; i--) {
|
| + last->TrimInputCount(i);
|
| + CheckInputs(last, nodes, i);
|
| +
|
| + for (int j = 0; j < i; j++) {
|
| + if (j < i) CHECK_USES(nodes[j], last);
|
| + if (j >= i) CHECK_USES(nodes[j], NONE);
|
| + }
|
| +
|
| + CHECK_USES(last, NONE);
|
| }
|
| }
|
|
|