Line data Source code
1 : // Copyright 2013 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 <memory>
6 : #include <sstream>
7 :
8 : #include "src/compiler/operator.h"
9 : #include "test/cctest/cctest.h"
10 :
11 : namespace v8 {
12 : namespace internal {
13 : namespace compiler {
14 :
15 : #define NONE Operator::kNoProperties
16 : #define FOLD Operator::kFoldable
17 :
18 :
19 23724 : TEST(TestOperator_Mnemonic) {
20 6 : Operator op1(10, NONE, "ThisOne", 0, 0, 0, 0, 0, 0);
21 6 : CHECK_EQ(0, strcmp(op1.mnemonic(), "ThisOne"));
22 :
23 6 : Operator op2(11, NONE, "ThatOne", 0, 0, 0, 0, 0, 0);
24 6 : CHECK_EQ(0, strcmp(op2.mnemonic(), "ThatOne"));
25 :
26 : Operator1<int> op3(12, NONE, "Mnemonic1", 0, 0, 0, 1, 0, 0, 12333);
27 6 : CHECK_EQ(0, strcmp(op3.mnemonic(), "Mnemonic1"));
28 :
29 : Operator1<double> op4(13, NONE, "TheOther", 0, 0, 0, 1, 0, 0, 99.9);
30 6 : CHECK_EQ(0, strcmp(op4.mnemonic(), "TheOther"));
31 6 : }
32 :
33 :
34 23724 : TEST(TestOperator_Hash) {
35 6 : Operator op1(17, NONE, "Another", 0, 0, 0, 0, 0, 0);
36 6 : CHECK_EQ(17, static_cast<int>(op1.HashCode()));
37 :
38 6 : Operator op2(18, NONE, "Falsch", 0, 0, 0, 0, 0, 0);
39 6 : CHECK_EQ(18, static_cast<int>(op2.HashCode()));
40 6 : }
41 :
42 :
43 23724 : TEST(TestOperator_Equals) {
44 6 : Operator op1a(19, NONE, "Another1", 0, 0, 0, 0, 0, 0);
45 6 : Operator op1b(19, FOLD, "Another2", 2, 0, 0, 2, 0, 0);
46 :
47 6 : CHECK(op1a.Equals(&op1a));
48 6 : CHECK(op1a.Equals(&op1b));
49 6 : CHECK(op1b.Equals(&op1a));
50 6 : CHECK(op1b.Equals(&op1b));
51 :
52 6 : Operator op2a(20, NONE, "Falsch1", 0, 0, 0, 0, 0, 0);
53 6 : Operator op2b(20, FOLD, "Falsch2", 1, 0, 0, 1, 0, 0);
54 :
55 6 : CHECK(op2a.Equals(&op2a));
56 6 : CHECK(op2a.Equals(&op2b));
57 6 : CHECK(op2b.Equals(&op2a));
58 6 : CHECK(op2b.Equals(&op2b));
59 :
60 6 : CHECK(!op1a.Equals(&op2a));
61 6 : CHECK(!op1a.Equals(&op2b));
62 6 : CHECK(!op1b.Equals(&op2a));
63 6 : CHECK(!op1b.Equals(&op2b));
64 :
65 6 : CHECK(!op2a.Equals(&op1a));
66 6 : CHECK(!op2a.Equals(&op1b));
67 6 : CHECK(!op2b.Equals(&op1a));
68 6 : CHECK(!op2b.Equals(&op1b));
69 6 : }
70 :
71 60 : static std::unique_ptr<char[]> OperatorToString(Operator* op) {
72 60 : std::ostringstream os;
73 60 : os << *op;
74 120 : return std::unique_ptr<char[]>(StrDup(os.str().c_str()));
75 : }
76 :
77 :
78 23724 : TEST(TestOperator_Print) {
79 6 : Operator op1a(19, NONE, "Another1", 0, 0, 0, 0, 0, 0);
80 6 : Operator op1b(19, FOLD, "Another2", 2, 0, 0, 2, 0, 0);
81 :
82 18 : CHECK_EQ(0, strcmp("Another1", OperatorToString(&op1a).get()));
83 18 : CHECK_EQ(0, strcmp("Another2", OperatorToString(&op1b).get()));
84 :
85 6 : Operator op2a(20, NONE, "Flog1", 0, 0, 0, 0, 0, 0);
86 6 : Operator op2b(20, FOLD, "Flog2", 1, 0, 0, 1, 0, 0);
87 :
88 18 : CHECK_EQ(0, strcmp("Flog1", OperatorToString(&op2a).get()));
89 18 : CHECK_EQ(0, strcmp("Flog2", OperatorToString(&op2b).get()));
90 6 : }
91 :
92 :
93 23724 : TEST(TestOperator1int_Hash) {
94 : Operator1<int> op1a(23, NONE, "Wolfie", 0, 0, 0, 0, 0, 0, 11);
95 : Operator1<int> op1b(23, FOLD, "Doggie", 2, 0, 0, 2, 0, 0, 11);
96 :
97 6 : CHECK(op1a.HashCode() == op1b.HashCode());
98 :
99 : Operator1<int> op2a(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, 3);
100 : Operator1<int> op2b(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, 4);
101 :
102 6 : CHECK(op1a.HashCode() != op2a.HashCode());
103 6 : CHECK(op2a.HashCode() != op2b.HashCode());
104 6 : }
105 :
106 :
107 23724 : TEST(TestOperator1int_Equals) {
108 : Operator1<int> op1a(23, NONE, "Scratchy", 0, 0, 0, 0, 0, 0, 11);
109 : Operator1<int> op1b(23, FOLD, "Scratchy", 2, 0, 0, 2, 0, 0, 11);
110 :
111 6 : CHECK(op1a.Equals(&op1a));
112 6 : CHECK(op1a.Equals(&op1b));
113 6 : CHECK(op1b.Equals(&op1a));
114 6 : CHECK(op1b.Equals(&op1b));
115 :
116 : Operator1<int> op2a(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3);
117 : Operator1<int> op2b(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 4);
118 :
119 6 : CHECK(op2a.Equals(&op2a));
120 6 : CHECK(!op2a.Equals(&op2b));
121 6 : CHECK(!op2b.Equals(&op2a));
122 6 : CHECK(op2b.Equals(&op2b));
123 :
124 6 : CHECK(!op1a.Equals(&op2a));
125 6 : CHECK(!op1a.Equals(&op2b));
126 6 : CHECK(!op1b.Equals(&op2a));
127 6 : CHECK(!op1b.Equals(&op2b));
128 :
129 6 : CHECK(!op2a.Equals(&op1a));
130 6 : CHECK(!op2a.Equals(&op1b));
131 6 : CHECK(!op2b.Equals(&op1a));
132 6 : CHECK(!op2b.Equals(&op1b));
133 :
134 6 : Operator op3(25, NONE, "Weepy", 0, 0, 0, 0, 0, 0);
135 :
136 6 : CHECK(!op1a.Equals(&op3));
137 6 : CHECK(!op1b.Equals(&op3));
138 6 : CHECK(!op2a.Equals(&op3));
139 6 : CHECK(!op2b.Equals(&op3));
140 :
141 6 : CHECK(!op3.Equals(&op1a));
142 6 : CHECK(!op3.Equals(&op1b));
143 6 : CHECK(!op3.Equals(&op2a));
144 6 : CHECK(!op3.Equals(&op2b));
145 6 : }
146 :
147 :
148 23724 : TEST(TestOperator1int_Print) {
149 : Operator1<int> op1(12, NONE, "Op1Test", 0, 0, 0, 1, 0, 0, 0);
150 18 : CHECK_EQ(0, strcmp("Op1Test[0]", OperatorToString(&op1).get()));
151 :
152 : Operator1<int> op2(12, NONE, "Op1Test", 0, 0, 0, 1, 0, 0, 66666666);
153 18 : CHECK_EQ(0, strcmp("Op1Test[66666666]", OperatorToString(&op2).get()));
154 :
155 : Operator1<int> op3(12, NONE, "FooBar", 0, 0, 0, 1, 0, 0, 2347);
156 18 : CHECK_EQ(0, strcmp("FooBar[2347]", OperatorToString(&op3).get()));
157 :
158 : Operator1<int> op4(12, NONE, "BarFoo", 0, 0, 0, 1, 0, 0, -879);
159 18 : CHECK_EQ(0, strcmp("BarFoo[-879]", OperatorToString(&op4).get()));
160 6 : }
161 :
162 :
163 23724 : TEST(TestOperator1double_Hash) {
164 : Operator1<double> op1a(23, NONE, "Wolfie", 0, 0, 0, 0, 0, 0, 11.77);
165 : Operator1<double> op1b(23, FOLD, "Doggie", 2, 0, 0, 2, 0, 0, 11.77);
166 :
167 6 : CHECK(op1a.HashCode() == op1b.HashCode());
168 :
169 : Operator1<double> op2a(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, -6.7);
170 : Operator1<double> op2b(24, NONE, "Arfie", 0, 0, 0, 0, 0, 0, -6.8);
171 :
172 6 : CHECK(op1a.HashCode() != op2a.HashCode());
173 6 : CHECK(op2a.HashCode() != op2b.HashCode());
174 6 : }
175 :
176 :
177 23724 : TEST(TestOperator1doublePrint) {
178 : Operator1<double> op1a(23, NONE, "Canary", 0, 0, 0, 0, 0, 0, 0.5);
179 : Operator1<double> op1b(23, FOLD, "Finch", 2, 0, 0, 2, 0, 0, -1.5);
180 :
181 18 : CHECK_EQ(0, strcmp("Canary[0.5]", OperatorToString(&op1a).get()));
182 18 : CHECK_EQ(0, strcmp("Finch[-1.5]", OperatorToString(&op1b).get()));
183 6 : }
184 :
185 :
186 23724 : TEST(TestOperator1double_Equals) {
187 : Operator1<double> op1a(23, NONE, "Scratchy", 0, 0, 0, 0, 0, 0, 11.77);
188 : Operator1<double> op1b(23, FOLD, "Scratchy", 2, 0, 0, 2, 0, 0, 11.77);
189 :
190 6 : CHECK(op1a.Equals(&op1a));
191 6 : CHECK(op1a.Equals(&op1b));
192 6 : CHECK(op1b.Equals(&op1a));
193 6 : CHECK(op1b.Equals(&op1b));
194 :
195 : Operator1<double> op2a(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3.1);
196 : Operator1<double> op2b(24, NONE, "Im", 0, 0, 0, 0, 0, 0, 3.2);
197 :
198 6 : CHECK(op2a.Equals(&op2a));
199 6 : CHECK(!op2a.Equals(&op2b));
200 6 : CHECK(!op2b.Equals(&op2a));
201 6 : CHECK(op2b.Equals(&op2b));
202 :
203 6 : CHECK(!op1a.Equals(&op2a));
204 6 : CHECK(!op1a.Equals(&op2b));
205 6 : CHECK(!op1b.Equals(&op2a));
206 6 : CHECK(!op1b.Equals(&op2b));
207 :
208 6 : CHECK(!op2a.Equals(&op1a));
209 6 : CHECK(!op2a.Equals(&op1b));
210 6 : CHECK(!op2b.Equals(&op1a));
211 6 : CHECK(!op2b.Equals(&op1b));
212 :
213 6 : Operator op3(25, NONE, "Weepy", 0, 0, 0, 0, 0, 0);
214 :
215 6 : CHECK(!op1a.Equals(&op3));
216 6 : CHECK(!op1b.Equals(&op3));
217 6 : CHECK(!op2a.Equals(&op3));
218 6 : CHECK(!op2b.Equals(&op3));
219 :
220 6 : CHECK(!op3.Equals(&op1a));
221 6 : CHECK(!op3.Equals(&op1b));
222 6 : CHECK(!op3.Equals(&op2a));
223 6 : CHECK(!op3.Equals(&op2b));
224 :
225 : Operator1<double> op4a(24, NONE, "Bashful", 0, 0, 0, 0, 0, 0, 1.0);
226 : Operator1<double> op4b(24, NONE, "Bashful", 0, 0, 0, 0, 0, 0, 1.0);
227 :
228 6 : CHECK(op4a.Equals(&op4a));
229 6 : CHECK(op4a.Equals(&op4b));
230 6 : CHECK(op4b.Equals(&op4a));
231 6 : CHECK(op4b.Equals(&op4b));
232 :
233 6 : CHECK(!op3.Equals(&op4a));
234 6 : CHECK(!op3.Equals(&op4b));
235 6 : CHECK(!op3.Equals(&op4a));
236 6 : CHECK(!op3.Equals(&op4b));
237 6 : }
238 :
239 :
240 23724 : TEST(TestOpParameter_Operator1double) {
241 6 : double values[] = {7777.5, -66, 0, 11, 0.1};
242 :
243 36 : for (size_t i = 0; i < arraysize(values); i++) {
244 30 : Operator1<double> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
245 30 : CHECK_EQ(values[i], OpParameter<double>(&op));
246 : }
247 6 : }
248 :
249 :
250 23724 : TEST(TestOpParameter_Operator1float) {
251 : float values[] = {// thanks C++.
252 : static_cast<float>(7777.5), static_cast<float>(-66),
253 : static_cast<float>(0), static_cast<float>(11),
254 6 : static_cast<float>(0.1)};
255 :
256 36 : for (size_t i = 0; i < arraysize(values); i++) {
257 30 : Operator1<float> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
258 30 : CHECK_EQ(values[i], OpParameter<float>(&op));
259 : }
260 6 : }
261 :
262 :
263 23724 : TEST(TestOpParameter_Operator1int) {
264 6 : int values[] = {7777, -66, 0, 11, 1, 0x666aff};
265 :
266 42 : for (size_t i = 0; i < arraysize(values); i++) {
267 36 : Operator1<int> op(33, NONE, "Scurvy", 0, 0, 0, 0, 0, 0, values[i]);
268 36 : CHECK_EQ(values[i], OpParameter<int>(&op));
269 : }
270 6 : }
271 :
272 :
273 23724 : TEST(Operator_CountsOrder) {
274 6 : Operator op(29, NONE, "Flashy", 11, 22, 33, 44, 55, 66);
275 6 : CHECK_EQ(11, op.ValueInputCount());
276 6 : CHECK_EQ(22, op.EffectInputCount());
277 6 : CHECK_EQ(33, op.ControlInputCount());
278 :
279 6 : CHECK_EQ(44, op.ValueOutputCount());
280 6 : CHECK_EQ(55, op.EffectOutputCount());
281 6 : CHECK_EQ(66, op.ControlOutputCount());
282 6 : }
283 :
284 : #undef NONE
285 : #undef FOLD
286 :
287 : } // namespace compiler
288 : } // namespace internal
289 71154 : } // namespace v8
|
