Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame^] | 1 | // Copyright 2015 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "src/compiler/node.h" |
| 6 | #include "src/compiler/operator.h" |
| 7 | #include "test/unittests/test-utils.h" |
| 8 | #include "testing/gmock-support.h" |
| 9 | |
| 10 | using testing::ElementsAre; |
| 11 | using testing::UnorderedElementsAre; |
| 12 | |
| 13 | namespace v8 { |
| 14 | namespace internal { |
| 15 | namespace compiler { |
| 16 | |
| 17 | typedef TestWithZone NodeTest; |
| 18 | |
| 19 | |
| 20 | namespace { |
| 21 | |
| 22 | const IrOpcode::Value kOpcode0 = static_cast<IrOpcode::Value>(0); |
| 23 | const IrOpcode::Value kOpcode1 = static_cast<IrOpcode::Value>(1); |
| 24 | const IrOpcode::Value kOpcode2 = static_cast<IrOpcode::Value>(2); |
| 25 | |
| 26 | const Operator kOp0(kOpcode0, Operator::kNoProperties, "Op0", 0, 0, 0, 1, 0, 0); |
| 27 | const Operator kOp1(kOpcode1, Operator::kNoProperties, "Op1", 1, 0, 0, 1, 0, 0); |
| 28 | const Operator kOp2(kOpcode2, Operator::kNoProperties, "Op2", 2, 0, 0, 1, 0, 0); |
| 29 | |
| 30 | } // namespace |
| 31 | |
| 32 | |
| 33 | TEST_F(NodeTest, New) { |
| 34 | Node* const node = Node::New(zone(), 1, &kOp0, 0, nullptr, false); |
| 35 | EXPECT_EQ(1U, node->id()); |
| 36 | EXPECT_EQ(0, node->UseCount()); |
| 37 | EXPECT_TRUE(node->uses().empty()); |
| 38 | EXPECT_EQ(0, node->InputCount()); |
| 39 | EXPECT_TRUE(node->inputs().empty()); |
| 40 | EXPECT_EQ(&kOp0, node->op()); |
| 41 | EXPECT_EQ(kOpcode0, node->opcode()); |
| 42 | } |
| 43 | |
| 44 | |
| 45 | TEST_F(NodeTest, NewWithInputs) { |
| 46 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 47 | EXPECT_EQ(0, n0->UseCount()); |
| 48 | EXPECT_EQ(0, n0->InputCount()); |
| 49 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 50 | EXPECT_EQ(1, n0->UseCount()); |
| 51 | EXPECT_THAT(n0->uses(), UnorderedElementsAre(n1)); |
| 52 | EXPECT_EQ(0, n1->UseCount()); |
| 53 | EXPECT_EQ(1, n1->InputCount()); |
| 54 | EXPECT_EQ(n0, n1->InputAt(0)); |
| 55 | Node* n0_n1[] = {n0, n1}; |
| 56 | Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false); |
| 57 | EXPECT_EQ(2, n0->UseCount()); |
| 58 | EXPECT_THAT(n0->uses(), UnorderedElementsAre(n1, n2)); |
| 59 | EXPECT_THAT(n1->uses(), UnorderedElementsAre(n2)); |
| 60 | EXPECT_EQ(2, n2->InputCount()); |
| 61 | EXPECT_EQ(n0, n2->InputAt(0)); |
| 62 | EXPECT_EQ(n1, n2->InputAt(1)); |
| 63 | } |
| 64 | |
| 65 | |
| 66 | TEST_F(NodeTest, InputIteratorEmpty) { |
| 67 | Node* node = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 68 | EXPECT_EQ(node->inputs().begin(), node->inputs().end()); |
| 69 | } |
| 70 | |
| 71 | |
| 72 | TEST_F(NodeTest, InputIteratorOne) { |
| 73 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 74 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 75 | EXPECT_THAT(n1->inputs(), ElementsAre(n0)); |
| 76 | } |
| 77 | |
| 78 | |
| 79 | TEST_F(NodeTest, InputIteratorTwo) { |
| 80 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 81 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 82 | Node* n0_n1[] = {n0, n1}; |
| 83 | Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false); |
| 84 | EXPECT_THAT(n2->inputs(), ElementsAre(n0, n1)); |
| 85 | } |
| 86 | |
| 87 | |
| 88 | TEST_F(NodeTest, UseIteratorEmpty) { |
| 89 | Node* node = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 90 | EXPECT_EQ(node->uses().begin(), node->uses().end()); |
| 91 | } |
| 92 | |
| 93 | |
| 94 | TEST_F(NodeTest, UseIteratorOne) { |
| 95 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 96 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 97 | EXPECT_THAT(n0->uses(), ElementsAre(n1)); |
| 98 | } |
| 99 | |
| 100 | |
| 101 | TEST_F(NodeTest, UseIteratorTwo) { |
| 102 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 103 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 104 | Node* n0_n1[] = {n0, n1}; |
| 105 | Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false); |
| 106 | EXPECT_THAT(n0->uses(), UnorderedElementsAre(n1, n2)); |
| 107 | } |
| 108 | |
| 109 | |
| 110 | TEST_F(NodeTest, OwnedBy) { |
| 111 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 112 | EXPECT_FALSE(n0->OwnedBy(n0)); |
| 113 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 114 | EXPECT_FALSE(n0->OwnedBy(n0)); |
| 115 | EXPECT_FALSE(n1->OwnedBy(n1)); |
| 116 | EXPECT_TRUE(n0->OwnedBy(n1)); |
| 117 | Node* n0_n1[] = {n0, n1}; |
| 118 | Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false); |
| 119 | EXPECT_FALSE(n0->OwnedBy(n0)); |
| 120 | EXPECT_FALSE(n1->OwnedBy(n1)); |
| 121 | EXPECT_FALSE(n2->OwnedBy(n2)); |
| 122 | EXPECT_FALSE(n0->OwnedBy(n1)); |
| 123 | EXPECT_FALSE(n0->OwnedBy(n2)); |
| 124 | EXPECT_TRUE(n1->OwnedBy(n2)); |
| 125 | EXPECT_TRUE(n0->OwnedBy(n1, n2)); |
| 126 | n2->ReplaceInput(0, n2); |
| 127 | EXPECT_TRUE(n0->OwnedBy(n1)); |
| 128 | EXPECT_TRUE(n1->OwnedBy(n2)); |
| 129 | n2->ReplaceInput(1, n0); |
| 130 | EXPECT_FALSE(n0->OwnedBy(n1)); |
| 131 | EXPECT_FALSE(n1->OwnedBy(n2)); |
| 132 | } |
| 133 | |
| 134 | |
| 135 | TEST_F(NodeTest, ReplaceUsesNone) { |
| 136 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 137 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 138 | Node* n0_n1[] = {n0, n1}; |
| 139 | Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false); |
| 140 | Node* node = Node::New(zone(), 42, &kOp0, 0, nullptr, false); |
| 141 | EXPECT_TRUE(node->uses().empty()); |
| 142 | node->ReplaceUses(n0); |
| 143 | EXPECT_TRUE(node->uses().empty()); |
| 144 | node->ReplaceUses(n1); |
| 145 | EXPECT_TRUE(node->uses().empty()); |
| 146 | node->ReplaceUses(n2); |
| 147 | EXPECT_TRUE(node->uses().empty()); |
| 148 | } |
| 149 | |
| 150 | |
| 151 | TEST_F(NodeTest, AppendInput) { |
| 152 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 153 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 154 | Node* node = Node::New(zone(), 12345, &kOp0, 0, nullptr, true); |
| 155 | EXPECT_TRUE(node->inputs().empty()); |
| 156 | node->AppendInput(zone(), n0); |
| 157 | EXPECT_FALSE(node->inputs().empty()); |
| 158 | EXPECT_THAT(node->inputs(), ElementsAre(n0)); |
| 159 | node->AppendInput(zone(), n1); |
| 160 | EXPECT_THAT(node->inputs(), ElementsAre(n0, n1)); |
| 161 | node->AppendInput(zone(), n0); |
| 162 | EXPECT_THAT(node->inputs(), ElementsAre(n0, n1, n0)); |
| 163 | node->AppendInput(zone(), n0); |
| 164 | EXPECT_THAT(node->inputs(), ElementsAre(n0, n1, n0, n0)); |
| 165 | node->AppendInput(zone(), n1); |
| 166 | EXPECT_THAT(node->inputs(), ElementsAre(n0, n1, n0, n0, n1)); |
| 167 | } |
| 168 | |
| 169 | |
| 170 | TEST_F(NodeTest, TrimThenAppend) { |
| 171 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 172 | Node* n1 = Node::New(zone(), 1, &kOp0, 0, nullptr, false); |
| 173 | Node* n2 = Node::New(zone(), 2, &kOp0, 0, nullptr, false); |
| 174 | Node* n3 = Node::New(zone(), 3, &kOp0, 0, nullptr, false); |
| 175 | Node* n4 = Node::New(zone(), 4, &kOp0, 0, nullptr, false); |
| 176 | Node* n5 = Node::New(zone(), 5, &kOp0, 0, nullptr, false); |
| 177 | Node* n6 = Node::New(zone(), 6, &kOp0, 0, nullptr, false); |
| 178 | Node* n7 = Node::New(zone(), 7, &kOp0, 0, nullptr, false); |
| 179 | Node* n8 = Node::New(zone(), 8, &kOp0, 0, nullptr, false); |
| 180 | Node* n9 = Node::New(zone(), 9, &kOp0, 0, nullptr, false); |
| 181 | Node* node = Node::New(zone(), 12345, &kOp0, 0, nullptr, true); |
| 182 | |
| 183 | EXPECT_TRUE(node->inputs().empty()); |
| 184 | |
| 185 | node->AppendInput(zone(), n0); |
| 186 | EXPECT_FALSE(node->inputs().empty()); |
| 187 | EXPECT_THAT(node->inputs(), ElementsAre(n0)); |
| 188 | |
| 189 | node->TrimInputCount(0); |
| 190 | EXPECT_TRUE(node->inputs().empty()); |
| 191 | |
| 192 | node->AppendInput(zone(), n1); |
| 193 | EXPECT_FALSE(node->inputs().empty()); |
| 194 | EXPECT_THAT(node->inputs(), ElementsAre(n1)); |
| 195 | |
| 196 | node->AppendInput(zone(), n2); |
| 197 | EXPECT_FALSE(node->inputs().empty()); |
| 198 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n2)); |
| 199 | |
| 200 | node->TrimInputCount(1); |
| 201 | EXPECT_FALSE(node->inputs().empty()); |
| 202 | EXPECT_THAT(node->inputs(), ElementsAre(n1)); |
| 203 | |
| 204 | node->AppendInput(zone(), n3); |
| 205 | EXPECT_FALSE(node->inputs().empty()); |
| 206 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n3)); |
| 207 | |
| 208 | node->AppendInput(zone(), n4); |
| 209 | EXPECT_FALSE(node->inputs().empty()); |
| 210 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4)); |
| 211 | |
| 212 | node->AppendInput(zone(), n5); |
| 213 | EXPECT_FALSE(node->inputs().empty()); |
| 214 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5)); |
| 215 | |
| 216 | node->AppendInput(zone(), n6); |
| 217 | EXPECT_FALSE(node->inputs().empty()); |
| 218 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5, n6)); |
| 219 | |
| 220 | node->AppendInput(zone(), n7); |
| 221 | EXPECT_FALSE(node->inputs().empty()); |
| 222 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5, n6, n7)); |
| 223 | |
| 224 | node->TrimInputCount(4); |
| 225 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5)); |
| 226 | |
| 227 | node->AppendInput(zone(), n8); |
| 228 | EXPECT_FALSE(node->inputs().empty()); |
| 229 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5, n8)); |
| 230 | |
| 231 | node->AppendInput(zone(), n9); |
| 232 | EXPECT_FALSE(node->inputs().empty()); |
| 233 | EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5, n8, n9)); |
| 234 | } |
| 235 | |
| 236 | |
| 237 | TEST_F(NodeTest, BigNodes) { |
| 238 | static const int kMaxSize = 512; |
| 239 | Node* inputs[kMaxSize]; |
| 240 | |
| 241 | Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false); |
| 242 | Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false); |
| 243 | |
| 244 | for (int i = 0; i < kMaxSize; i++) { |
| 245 | inputs[i] = i & 1 ? n0 : n1; |
| 246 | } |
| 247 | |
| 248 | for (int size = 13; size <= kMaxSize; size += 9) { |
| 249 | Node* node = Node::New(zone(), 12345, &kOp0, size, inputs, false); |
| 250 | EXPECT_EQ(size, node->InputCount()); |
| 251 | |
| 252 | for (int i = 0; i < size; i++) { |
| 253 | EXPECT_EQ(inputs[i], node->InputAt(i)); |
| 254 | } |
| 255 | } |
| 256 | } |
| 257 | |
| 258 | |
| 259 | } // namespace compiler |
| 260 | } // namespace internal |
| 261 | } // namespace v8 |