Line data Source code
1 : // Copyright 2014 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 "test/cctest/compiler/codegen-tester.h"
6 : #include "src/objects-inl.h"
7 : #include "test/cctest/cctest.h"
8 : #include "test/cctest/compiler/value-helper.h"
9 :
10 : namespace v8 {
11 : namespace internal {
12 : namespace compiler {
13 :
14 23724 : TEST(CompareWrapper) {
15 : // Who tests the testers?
16 : // If CompareWrapper is broken, then test expectations will be broken.
17 : CompareWrapper wWord32Equal(IrOpcode::kWord32Equal);
18 : CompareWrapper wInt32LessThan(IrOpcode::kInt32LessThan);
19 : CompareWrapper wInt32LessThanOrEqual(IrOpcode::kInt32LessThanOrEqual);
20 : CompareWrapper wUint32LessThan(IrOpcode::kUint32LessThan);
21 : CompareWrapper wUint32LessThanOrEqual(IrOpcode::kUint32LessThanOrEqual);
22 :
23 : {
24 354 : FOR_INT32_INPUTS(pl) {
25 20184 : FOR_INT32_INPUTS(pr) {
26 20184 : int32_t a = *pl;
27 20184 : int32_t b = *pr;
28 20184 : CHECK_EQ(a == b, wWord32Equal.Int32Compare(a, b));
29 20184 : CHECK_EQ(a < b, wInt32LessThan.Int32Compare(a, b));
30 20184 : CHECK_EQ(a <= b, wInt32LessThanOrEqual.Int32Compare(a, b));
31 : }
32 : }
33 : }
34 :
35 : {
36 348 : FOR_UINT32_INPUTS(pl) {
37 20184 : FOR_UINT32_INPUTS(pr) {
38 20184 : uint32_t a = *pl;
39 20184 : uint32_t b = *pr;
40 20184 : CHECK_EQ(a == b, wWord32Equal.Int32Compare(a, b));
41 20184 : CHECK_EQ(a < b, wUint32LessThan.Int32Compare(a, b));
42 20184 : CHECK_EQ(a <= b, wUint32LessThanOrEqual.Int32Compare(a, b));
43 : }
44 : }
45 : }
46 :
47 6 : CHECK_EQ(true, wWord32Equal.Int32Compare(0, 0));
48 6 : CHECK_EQ(true, wWord32Equal.Int32Compare(257, 257));
49 6 : CHECK_EQ(true, wWord32Equal.Int32Compare(65539, 65539));
50 6 : CHECK_EQ(true, wWord32Equal.Int32Compare(-1, -1));
51 6 : CHECK_EQ(true, wWord32Equal.Int32Compare(0xffffffff, 0xffffffff));
52 :
53 12 : CHECK_EQ(false, wWord32Equal.Int32Compare(0, 1));
54 12 : CHECK_EQ(false, wWord32Equal.Int32Compare(257, 256));
55 12 : CHECK_EQ(false, wWord32Equal.Int32Compare(65539, 65537));
56 12 : CHECK_EQ(false, wWord32Equal.Int32Compare(-1, -2));
57 6 : CHECK_EQ(false, wWord32Equal.Int32Compare(0xffffffff, 0xfffffffe));
58 :
59 12 : CHECK_EQ(false, wInt32LessThan.Int32Compare(0, 0));
60 12 : CHECK_EQ(false, wInt32LessThan.Int32Compare(357, 357));
61 12 : CHECK_EQ(false, wInt32LessThan.Int32Compare(75539, 75539));
62 12 : CHECK_EQ(false, wInt32LessThan.Int32Compare(-1, -1));
63 6 : CHECK_EQ(false, wInt32LessThan.Int32Compare(0xffffffff, 0xffffffff));
64 :
65 6 : CHECK_EQ(true, wInt32LessThan.Int32Compare(0, 1));
66 6 : CHECK_EQ(true, wInt32LessThan.Int32Compare(456, 457));
67 6 : CHECK_EQ(true, wInt32LessThan.Int32Compare(85537, 85539));
68 6 : CHECK_EQ(true, wInt32LessThan.Int32Compare(-2, -1));
69 6 : CHECK_EQ(true, wInt32LessThan.Int32Compare(0xfffffffe, 0xffffffff));
70 :
71 12 : CHECK_EQ(false, wInt32LessThan.Int32Compare(1, 0));
72 12 : CHECK_EQ(false, wInt32LessThan.Int32Compare(457, 456));
73 12 : CHECK_EQ(false, wInt32LessThan.Int32Compare(85539, 85537));
74 12 : CHECK_EQ(false, wInt32LessThan.Int32Compare(-1, -2));
75 6 : CHECK_EQ(false, wInt32LessThan.Int32Compare(0xffffffff, 0xfffffffe));
76 :
77 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0, 0));
78 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(357, 357));
79 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(75539, 75539));
80 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(-1, -1));
81 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0xffffffff, 0xffffffff));
82 :
83 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0, 1));
84 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(456, 457));
85 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(85537, 85539));
86 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(-2, -1));
87 6 : CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0xfffffffe, 0xffffffff));
88 :
89 12 : CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(1, 0));
90 12 : CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(457, 456));
91 12 : CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(85539, 85537));
92 12 : CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(-1, -2));
93 6 : CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(0xffffffff, 0xfffffffe));
94 :
95 : // Unsigned comparisons.
96 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(0, 0));
97 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(357, 357));
98 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(75539, 75539));
99 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(-1, -1));
100 6 : CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0xffffffff));
101 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0));
102 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(-2999, 0));
103 :
104 6 : CHECK_EQ(true, wUint32LessThan.Int32Compare(0, 1));
105 6 : CHECK_EQ(true, wUint32LessThan.Int32Compare(456, 457));
106 6 : CHECK_EQ(true, wUint32LessThan.Int32Compare(85537, 85539));
107 6 : CHECK_EQ(true, wUint32LessThan.Int32Compare(-11, -10));
108 6 : CHECK_EQ(true, wUint32LessThan.Int32Compare(0xfffffffe, 0xffffffff));
109 6 : CHECK_EQ(true, wUint32LessThan.Int32Compare(0, 0xffffffff));
110 6 : CHECK_EQ(true, wUint32LessThan.Int32Compare(0, -2996));
111 :
112 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(1, 0));
113 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(457, 456));
114 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(85539, 85537));
115 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(-10, -21));
116 12 : CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0xfffffffe));
117 :
118 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, 0));
119 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(357, 357));
120 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(75539, 75539));
121 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-1, -1));
122 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0xffffffff, 0xffffffff));
123 :
124 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, 1));
125 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(456, 457));
126 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(85537, 85539));
127 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-300, -299));
128 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-300, -300));
129 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0xfffffffe, 0xffffffff));
130 6 : CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, -2995));
131 :
132 12 : CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(1, 0));
133 12 : CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(457, 456));
134 12 : CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(85539, 85537));
135 12 : CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(-130, -170));
136 12 : CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(0xffffffff, 0xfffffffe));
137 12 : CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(-2997, 0));
138 :
139 : CompareWrapper wFloat64Equal(IrOpcode::kFloat64Equal);
140 : CompareWrapper wFloat64LessThan(IrOpcode::kFloat64LessThan);
141 : CompareWrapper wFloat64LessThanOrEqual(IrOpcode::kFloat64LessThanOrEqual);
142 :
143 : // Check NaN handling.
144 : double nan = std::numeric_limits<double>::quiet_NaN();
145 : double inf = V8_INFINITY;
146 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, 0.0));
147 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, 1.0));
148 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, inf));
149 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, -inf));
150 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, nan));
151 :
152 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, nan));
153 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, nan));
154 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, nan));
155 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, nan));
156 6 : CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, nan));
157 :
158 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, 0.0));
159 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, 1.0));
160 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, inf));
161 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, -inf));
162 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, nan));
163 :
164 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(0.0, nan));
165 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(1.0, nan));
166 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, nan));
167 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, nan));
168 6 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, nan));
169 :
170 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, 0.0));
171 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, 1.0));
172 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, inf));
173 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, -inf));
174 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, nan));
175 :
176 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(0.0, nan));
177 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1.0, nan));
178 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, nan));
179 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(-inf, nan));
180 6 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, nan));
181 :
182 : // Check inf handling.
183 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, 0.0));
184 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, 1.0));
185 6 : CHECK_EQ(true, wFloat64Equal.Float64Compare(inf, inf));
186 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, -inf));
187 :
188 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, inf));
189 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, inf));
190 6 : CHECK_EQ(true, wFloat64Equal.Float64Compare(inf, inf));
191 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, inf));
192 :
193 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, 0.0));
194 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, 1.0));
195 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, inf));
196 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, -inf));
197 :
198 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(0.0, inf));
199 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(1.0, inf));
200 6 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, inf));
201 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, inf));
202 :
203 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, 0.0));
204 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, 1.0));
205 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(inf, inf));
206 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, -inf));
207 :
208 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0.0, inf));
209 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(1.0, inf));
210 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(inf, inf));
211 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, inf));
212 :
213 : // Check -inf handling.
214 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, 0.0));
215 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, 1.0));
216 6 : CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, inf));
217 6 : CHECK_EQ(true, wFloat64Equal.Float64Compare(-inf, -inf));
218 :
219 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, -inf));
220 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, -inf));
221 6 : CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, -inf));
222 6 : CHECK_EQ(true, wFloat64Equal.Float64Compare(-inf, -inf));
223 :
224 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, 0.0));
225 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, 1.0));
226 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, inf));
227 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, -inf));
228 :
229 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(0.0, -inf));
230 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(1.0, -inf));
231 6 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, -inf));
232 6 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, -inf));
233 :
234 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, 0.0));
235 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, 1.0));
236 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, inf));
237 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, -inf));
238 :
239 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(0.0, -inf));
240 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1.0, -inf));
241 6 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, -inf));
242 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, -inf));
243 :
244 : // Check basic values.
245 6 : CHECK_EQ(true, wFloat64Equal.Float64Compare(0, 0));
246 6 : CHECK_EQ(true, wFloat64Equal.Float64Compare(257.1, 257.1));
247 6 : CHECK_EQ(true, wFloat64Equal.Float64Compare(65539.1, 65539.1));
248 6 : CHECK_EQ(true, wFloat64Equal.Float64Compare(-1.1, -1.1));
249 :
250 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(0, 1));
251 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(257.2, 256.2));
252 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(65539.2, 65537.2));
253 12 : CHECK_EQ(false, wFloat64Equal.Float64Compare(-1.2, -2.2));
254 :
255 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(0, 0));
256 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(357.3, 357.3));
257 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(75539.3, 75539.3));
258 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(-1.3, -1.3));
259 :
260 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(0, 1));
261 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(456.4, 457.4));
262 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(85537.4, 85539.4));
263 6 : CHECK_EQ(true, wFloat64LessThan.Float64Compare(-2.4, -1.4));
264 :
265 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(1, 0));
266 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(457.5, 456.5));
267 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(85539.5, 85537.5));
268 12 : CHECK_EQ(false, wFloat64LessThan.Float64Compare(-1.5, -2.5));
269 :
270 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0, 0));
271 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(357.6, 357.6));
272 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(75539.6, 75539.6));
273 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-1.6, -1.6));
274 :
275 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0, 1));
276 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(456.7, 457.7));
277 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(85537.7, 85539.7));
278 6 : CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-2.7, -1.7));
279 :
280 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1, 0));
281 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(457.8, 456.8));
282 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(85539.8, 85537.8));
283 12 : CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(-1.8, -2.8));
284 6 : }
285 :
286 :
287 180 : void Int32BinopInputShapeTester::TestAllInputShapes() {
288 : Vector<const int32_t> inputs = ValueHelper::int32_vector();
289 : int num_int_inputs = static_cast<int>(inputs.size());
290 : if (num_int_inputs > 16) num_int_inputs = 16; // limit to 16 inputs
291 :
292 3420 : for (int i = -2; i < num_int_inputs; i++) { // for all left shapes
293 12240 : for (int j = -2; j < num_int_inputs; j++) { // for all right shapes
294 15120 : if (i >= 0 && j >= 0) break; // No constant/constant combos
295 : RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
296 12240 : MachineType::Int32());
297 12240 : Node* p0 = m.Parameter(0);
298 12240 : Node* p1 = m.Parameter(1);
299 : Node* n0;
300 : Node* n1;
301 :
302 : // left = Parameter | Load | Constant
303 12240 : if (i == -2) {
304 : n0 = p0;
305 9000 : } else if (i == -1) {
306 3240 : n0 = m.LoadFromPointer(&input_a, MachineType::Int32());
307 : } else {
308 11520 : n0 = m.Int32Constant(inputs[i]);
309 : }
310 :
311 : // right = Parameter | Load | Constant
312 12240 : if (j == -2) {
313 : n1 = p1;
314 9000 : } else if (j == -1) {
315 3240 : n1 = m.LoadFromPointer(&input_b, MachineType::Int32());
316 : } else {
317 11520 : n1 = m.Int32Constant(inputs[j]);
318 : }
319 :
320 12240 : gen->gen(&m, n0, n1);
321 :
322 : if (false) printf("Int32BinopInputShapeTester i=%d, j=%d\n", i, j);
323 12240 : if (i >= 0) {
324 11520 : input_a = inputs[i];
325 5760 : RunRight(&m);
326 6480 : } else if (j >= 0) {
327 11520 : input_b = inputs[j];
328 5760 : RunLeft(&m);
329 : } else {
330 720 : Run(&m);
331 : }
332 : }
333 : }
334 180 : }
335 :
336 :
337 720 : void Int32BinopInputShapeTester::Run(RawMachineAssemblerTester<int32_t>* m) {
338 42480 : FOR_INT32_INPUTS(pl) {
339 2422080 : FOR_INT32_INPUTS(pr) {
340 2422080 : input_a = *pl;
341 2422080 : input_b = *pr;
342 2422080 : int32_t expect = gen->expected(input_a, input_b);
343 : if (false) printf(" cmp(a=%d, b=%d) ?== %d\n", input_a, input_b, expect);
344 2422080 : CHECK_EQ(expect, m->Call(input_a, input_b));
345 : }
346 : }
347 720 : }
348 :
349 :
350 5760 : void Int32BinopInputShapeTester::RunLeft(
351 : RawMachineAssemblerTester<int32_t>* m) {
352 339840 : FOR_UINT32_INPUTS(i) {
353 334080 : input_a = *i;
354 334080 : int32_t expect = gen->expected(input_a, input_b);
355 : if (false) printf(" cmp(a=%d, b=%d) ?== %d\n", input_a, input_b, expect);
356 334080 : CHECK_EQ(expect, m->Call(input_a, input_b));
357 : }
358 5760 : }
359 :
360 :
361 5760 : void Int32BinopInputShapeTester::RunRight(
362 : RawMachineAssemblerTester<int32_t>* m) {
363 339840 : FOR_UINT32_INPUTS(i) {
364 334080 : input_b = *i;
365 334080 : int32_t expect = gen->expected(input_a, input_b);
366 : if (false) printf(" cmp(a=%d, b=%d) ?== %d\n", input_a, input_b, expect);
367 334080 : CHECK_EQ(expect, m->Call(input_a, input_b));
368 : }
369 5760 : }
370 :
371 :
372 23724 : TEST(ParametersEqual) {
373 : RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
374 6 : MachineType::Int32());
375 6 : Node* p1 = m.Parameter(1);
376 6 : CHECK(p1);
377 6 : Node* p0 = m.Parameter(0);
378 6 : CHECK(p0);
379 6 : CHECK_EQ(p0, m.Parameter(0));
380 6 : CHECK_EQ(p1, m.Parameter(1));
381 6 : }
382 :
383 :
384 0 : void RunSmiConstant(int32_t v) {
385 : // TODO(dcarney): on x64 Smis are generated with the SmiConstantRegister
386 : #if !V8_TARGET_ARCH_X64
387 : if (Smi::IsValid(v)) {
388 : RawMachineAssemblerTester<Object*> m;
389 : m.Return(m.NumberConstant(v));
390 : CHECK_EQ(Smi::FromInt(v), m.Call());
391 : }
392 : #endif
393 0 : }
394 :
395 :
396 1434 : void RunNumberConstant(double v) {
397 1434 : RawMachineAssemblerTester<Object*> m;
398 : #if V8_TARGET_ARCH_X64
399 : // TODO(dcarney): on x64 Smis are generated with the SmiConstantRegister
400 1434 : Handle<Object> number = m.isolate()->factory()->NewNumber(v);
401 2868 : if (number->IsSmi()) return;
402 : #endif
403 240 : m.Return(m.NumberConstant(v));
404 240 : Object* result = m.Call();
405 240 : m.CheckNumber(v, result);
406 : }
407 :
408 :
409 23724 : TEST(RunEmpty) {
410 6 : RawMachineAssemblerTester<int32_t> m;
411 6 : m.Return(m.Int32Constant(0));
412 6 : CHECK_EQ(0, m.Call());
413 6 : }
414 :
415 :
416 23724 : TEST(RunInt32Constants) {
417 354 : FOR_INT32_INPUTS(i) {
418 348 : RawMachineAssemblerTester<int32_t> m;
419 348 : m.Return(m.Int32Constant(*i));
420 348 : CHECK_EQ(*i, m.Call());
421 : }
422 6 : }
423 :
424 :
425 23724 : TEST(RunSmiConstants) {
426 6 : for (int32_t i = 1; i < Smi::kMaxValue && i != 0; i = i << 1) {
427 : RunSmiConstant(i);
428 : RunSmiConstant(3 * i);
429 : RunSmiConstant(5 * i);
430 : RunSmiConstant(-i);
431 : RunSmiConstant(i | 1);
432 : RunSmiConstant(i | 3);
433 : }
434 : RunSmiConstant(Smi::kMaxValue);
435 : RunSmiConstant(Smi::kMaxValue - 1);
436 : RunSmiConstant(Smi::kMinValue);
437 : RunSmiConstant(Smi::kMinValue + 1);
438 :
439 : FOR_INT32_INPUTS(i) { RunSmiConstant(*i); }
440 6 : }
441 :
442 :
443 23724 : TEST(RunNumberConstants) {
444 : {
445 6 : FOR_FLOAT64_INPUTS(i) { RunNumberConstant(*i); }
446 : }
447 : {
448 348 : FOR_INT32_INPUTS(i) { RunNumberConstant(*i); }
449 : }
450 :
451 192 : for (int32_t i = 1; i < Smi::kMaxValue && i != 0; i = i << 1) {
452 192 : RunNumberConstant(i);
453 192 : RunNumberConstant(-i);
454 192 : RunNumberConstant(i | 1);
455 192 : RunNumberConstant(i | 3);
456 : }
457 6 : RunNumberConstant(Smi::kMaxValue);
458 6 : RunNumberConstant(Smi::kMaxValue - 1);
459 6 : RunNumberConstant(Smi::kMinValue);
460 6 : RunNumberConstant(Smi::kMinValue + 1);
461 6 : }
462 :
463 :
464 23724 : TEST(RunEmptyString) {
465 6 : RawMachineAssemblerTester<Object*> m;
466 6 : m.Return(m.StringConstant("empty"));
467 6 : m.CheckString("empty", m.Call());
468 6 : }
469 :
470 :
471 23724 : TEST(RunHeapConstant) {
472 6 : RawMachineAssemblerTester<Object*> m;
473 6 : m.Return(m.StringConstant("empty"));
474 6 : m.CheckString("empty", m.Call());
475 6 : }
476 :
477 :
478 23724 : TEST(RunHeapNumberConstant) {
479 6 : RawMachineAssemblerTester<HeapObject*> m;
480 6 : Handle<HeapObject> number = m.isolate()->factory()->NewHeapNumber(100.5);
481 6 : m.Return(m.HeapConstant(number));
482 6 : HeapObject* result = m.Call();
483 6 : CHECK_EQ(result, *number);
484 6 : }
485 :
486 :
487 23724 : TEST(RunParam1) {
488 6 : RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
489 6 : m.Return(m.Parameter(0));
490 :
491 354 : FOR_INT32_INPUTS(i) {
492 348 : int32_t result = m.Call(*i);
493 348 : CHECK_EQ(*i, result);
494 : }
495 6 : }
496 :
497 :
498 23724 : TEST(RunParam2_1) {
499 : RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
500 6 : MachineType::Int32());
501 6 : Node* p0 = m.Parameter(0);
502 6 : Node* p1 = m.Parameter(1);
503 6 : m.Return(p0);
504 : USE(p1);
505 :
506 354 : FOR_INT32_INPUTS(i) {
507 348 : int32_t result = m.Call(*i, -9999);
508 348 : CHECK_EQ(*i, result);
509 : }
510 6 : }
511 :
512 :
513 23724 : TEST(RunParam2_2) {
514 : RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
515 6 : MachineType::Int32());
516 6 : Node* p0 = m.Parameter(0);
517 6 : Node* p1 = m.Parameter(1);
518 6 : m.Return(p1);
519 : USE(p0);
520 :
521 354 : FOR_INT32_INPUTS(i) {
522 348 : int32_t result = m.Call(-7777, *i);
523 348 : CHECK_EQ(*i, result);
524 : }
525 6 : }
526 :
527 :
528 23724 : TEST(RunParam3) {
529 24 : for (int i = 0; i < 3; i++) {
530 : RawMachineAssemblerTester<int32_t> m(
531 18 : MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
532 18 : Node* nodes[] = {m.Parameter(0), m.Parameter(1), m.Parameter(2)};
533 18 : m.Return(nodes[i]);
534 :
535 18 : int p[] = {-99, -77, -88};
536 1062 : FOR_INT32_INPUTS(j) {
537 1044 : p[i] = *j;
538 1044 : int32_t result = m.Call(p[0], p[1], p[2]);
539 1044 : CHECK_EQ(*j, result);
540 : }
541 : }
542 6 : }
543 :
544 :
545 23724 : TEST(RunBinopTester) {
546 : {
547 6 : RawMachineAssemblerTester<int32_t> m;
548 : Int32BinopTester bt(&m);
549 6 : bt.AddReturn(bt.param0);
550 :
551 354 : FOR_INT32_INPUTS(i) { CHECK_EQ(*i, bt.call(*i, 777)); }
552 : }
553 :
554 : {
555 6 : RawMachineAssemblerTester<int32_t> m;
556 : Int32BinopTester bt(&m);
557 6 : bt.AddReturn(bt.param1);
558 :
559 354 : FOR_INT32_INPUTS(i) { CHECK_EQ(*i, bt.call(666, *i)); }
560 : }
561 :
562 : {
563 6 : RawMachineAssemblerTester<int32_t> m;
564 : Float64BinopTester bt(&m);
565 6 : bt.AddReturn(bt.param0);
566 :
567 6 : FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(*i, bt.call(*i, 9.0)); }
568 : }
569 :
570 : {
571 6 : RawMachineAssemblerTester<int32_t> m;
572 : Float64BinopTester bt(&m);
573 6 : bt.AddReturn(bt.param1);
574 :
575 6 : FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(*i, bt.call(-11.25, *i)); }
576 : }
577 6 : }
578 :
579 :
580 : #if V8_TARGET_ARCH_64_BIT
581 : // TODO(ahaas): run int64 tests on all platforms when supported.
582 23724 : TEST(RunBufferedRawMachineAssemblerTesterTester) {
583 : {
584 6 : BufferedRawMachineAssemblerTester<int64_t> m;
585 6 : m.Return(m.Int64Constant(0x12500000000));
586 6 : CHECK_EQ(0x12500000000, m.Call());
587 : }
588 : {
589 6 : BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
590 6 : m.Return(m.Parameter(0));
591 6 : FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(*i, m.Call(*i)); }
592 : }
593 : {
594 : BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Int64(),
595 6 : MachineType::Int64());
596 6 : m.Return(m.Int64Add(m.Parameter(0), m.Parameter(1)));
597 492 : FOR_INT64_INPUTS(i) {
598 39366 : FOR_INT64_INPUTS(j) {
599 39366 : CHECK_EQ(*i + *j, m.Call(*i, *j));
600 39366 : CHECK_EQ(*j + *i, m.Call(*j, *i));
601 : }
602 : }
603 : }
604 : {
605 : BufferedRawMachineAssemblerTester<int64_t> m(
606 6 : MachineType::Int64(), MachineType::Int64(), MachineType::Int64());
607 : m.Return(
608 6 : m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)), m.Parameter(2)));
609 492 : FOR_INT64_INPUTS(i) {
610 39366 : FOR_INT64_INPUTS(j) {
611 39366 : CHECK_EQ(*i + *i + *j, m.Call(*i, *i, *j));
612 39366 : CHECK_EQ(*i + *j + *i, m.Call(*i, *j, *i));
613 39366 : CHECK_EQ(*j + *i + *i, m.Call(*j, *i, *i));
614 : }
615 : }
616 : }
617 : {
618 : BufferedRawMachineAssemblerTester<int64_t> m(
619 : MachineType::Int64(), MachineType::Int64(), MachineType::Int64(),
620 6 : MachineType::Int64());
621 : m.Return(m.Int64Add(
622 : m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)), m.Parameter(2)),
623 6 : m.Parameter(3)));
624 492 : FOR_INT64_INPUTS(i) {
625 39366 : FOR_INT64_INPUTS(j) {
626 39366 : CHECK_EQ(*i + *i + *i + *j, m.Call(*i, *i, *i, *j));
627 39366 : CHECK_EQ(*i + *i + *j + *i, m.Call(*i, *i, *j, *i));
628 39366 : CHECK_EQ(*i + *j + *i + *i, m.Call(*i, *j, *i, *i));
629 39366 : CHECK_EQ(*j + *i + *i + *i, m.Call(*j, *i, *i, *i));
630 : }
631 : }
632 : }
633 : {
634 6 : BufferedRawMachineAssemblerTester<void> m;
635 : int64_t result;
636 : m.Store(MachineTypeForC<int64_t>().representation(),
637 : m.PointerConstant(&result), m.Int64Constant(0x12500000000),
638 12 : kNoWriteBarrier);
639 6 : m.Return(m.Int32Constant(0));
640 : m.Call();
641 6 : CHECK_EQ(0x12500000000, result);
642 : }
643 : {
644 6 : BufferedRawMachineAssemblerTester<void> m(MachineType::Float64());
645 : double result;
646 : m.Store(MachineTypeForC<double>().representation(),
647 12 : m.PointerConstant(&result), m.Parameter(0), kNoWriteBarrier);
648 6 : m.Return(m.Int32Constant(0));
649 300 : FOR_FLOAT64_INPUTS(i) {
650 294 : m.Call(*i);
651 294 : CHECK_DOUBLE_EQ(*i, result);
652 : }
653 : }
654 : {
655 : BufferedRawMachineAssemblerTester<void> m(MachineType::Int64(),
656 6 : MachineType::Int64());
657 : int64_t result;
658 : m.Store(MachineTypeForC<int64_t>().representation(),
659 : m.PointerConstant(&result),
660 12 : m.Int64Add(m.Parameter(0), m.Parameter(1)), kNoWriteBarrier);
661 6 : m.Return(m.Int32Constant(0));
662 492 : FOR_INT64_INPUTS(i) {
663 39366 : FOR_INT64_INPUTS(j) {
664 39366 : m.Call(*i, *j);
665 39366 : CHECK_EQ(*i + *j, result);
666 :
667 : m.Call(*j, *i);
668 39366 : CHECK_EQ(*j + *i, result);
669 : }
670 : }
671 : }
672 : {
673 : BufferedRawMachineAssemblerTester<void> m(
674 6 : MachineType::Int64(), MachineType::Int64(), MachineType::Int64());
675 : int64_t result;
676 : m.Store(
677 : MachineTypeForC<int64_t>().representation(), m.PointerConstant(&result),
678 : m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)), m.Parameter(2)),
679 12 : kNoWriteBarrier);
680 6 : m.Return(m.Int32Constant(0));
681 492 : FOR_INT64_INPUTS(i) {
682 39366 : FOR_INT64_INPUTS(j) {
683 39366 : m.Call(*i, *i, *j);
684 39366 : CHECK_EQ(*i + *i + *j, result);
685 :
686 : m.Call(*i, *j, *i);
687 39366 : CHECK_EQ(*i + *j + *i, result);
688 :
689 : m.Call(*j, *i, *i);
690 39366 : CHECK_EQ(*j + *i + *i, result);
691 : }
692 : }
693 : }
694 : {
695 : BufferedRawMachineAssemblerTester<void> m(
696 : MachineType::Int64(), MachineType::Int64(), MachineType::Int64(),
697 6 : MachineType::Int64());
698 : int64_t result;
699 : m.Store(MachineTypeForC<int64_t>().representation(),
700 : m.PointerConstant(&result),
701 : m.Int64Add(m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)),
702 : m.Parameter(2)),
703 : m.Parameter(3)),
704 12 : kNoWriteBarrier);
705 6 : m.Return(m.Int32Constant(0));
706 492 : FOR_INT64_INPUTS(i) {
707 39366 : FOR_INT64_INPUTS(j) {
708 39366 : m.Call(*i, *i, *i, *j);
709 39366 : CHECK_EQ(*i + *i + *i + *j, result);
710 :
711 : m.Call(*i, *i, *j, *i);
712 39366 : CHECK_EQ(*i + *i + *j + *i, result);
713 :
714 : m.Call(*i, *j, *i, *i);
715 39366 : CHECK_EQ(*i + *j + *i + *i, result);
716 :
717 : m.Call(*j, *i, *i, *i);
718 39366 : CHECK_EQ(*j + *i + *i + *i, result);
719 : }
720 : }
721 : }
722 6 : }
723 :
724 : #endif
725 : } // namespace compiler
726 : } // namespace internal
727 71154 : } // namespace v8
|
