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