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 "src/v8.h"
6 
7 #include "test/cctest/cctest.h"
8 #include "test/cctest/compiler/codegen-tester.h"
9 #include "test/cctest/compiler/value-helper.h"
10 
11 using namespace v8::internal;
12 using namespace v8::internal::compiler;
13 
TEST(CompareWrapper)14 TEST(CompareWrapper) {
15   // Who tests the testers?
16   // If CompareWrapper is broken, then test expectations will be broken.
17   RawMachineAssemblerTester<int32_t> m;
18   CompareWrapper wWord32Equal(IrOpcode::kWord32Equal);
19   CompareWrapper wInt32LessThan(IrOpcode::kInt32LessThan);
20   CompareWrapper wInt32LessThanOrEqual(IrOpcode::kInt32LessThanOrEqual);
21   CompareWrapper wUint32LessThan(IrOpcode::kUint32LessThan);
22   CompareWrapper wUint32LessThanOrEqual(IrOpcode::kUint32LessThanOrEqual);
23 
24   {
25     FOR_INT32_INPUTS(pl) {
26       FOR_INT32_INPUTS(pr) {
27         int32_t a = *pl;
28         int32_t b = *pr;
29         CHECK_EQ(a == b, wWord32Equal.Int32Compare(a, b));
30         CHECK_EQ(a < b, wInt32LessThan.Int32Compare(a, b));
31         CHECK_EQ(a <= b, wInt32LessThanOrEqual.Int32Compare(a, b));
32       }
33     }
34   }
35 
36   {
37     FOR_UINT32_INPUTS(pl) {
38       FOR_UINT32_INPUTS(pr) {
39         uint32_t a = *pl;
40         uint32_t b = *pr;
41         CHECK_EQ(a == b, wWord32Equal.Int32Compare(a, b));
42         CHECK_EQ(a < b, wUint32LessThan.Int32Compare(a, b));
43         CHECK_EQ(a <= b, wUint32LessThanOrEqual.Int32Compare(a, b));
44       }
45     }
46   }
47 
48   CHECK_EQ(true, wWord32Equal.Int32Compare(0, 0));
49   CHECK_EQ(true, wWord32Equal.Int32Compare(257, 257));
50   CHECK_EQ(true, wWord32Equal.Int32Compare(65539, 65539));
51   CHECK_EQ(true, wWord32Equal.Int32Compare(-1, -1));
52   CHECK_EQ(true, wWord32Equal.Int32Compare(0xffffffff, 0xffffffff));
53 
54   CHECK_EQ(false, wWord32Equal.Int32Compare(0, 1));
55   CHECK_EQ(false, wWord32Equal.Int32Compare(257, 256));
56   CHECK_EQ(false, wWord32Equal.Int32Compare(65539, 65537));
57   CHECK_EQ(false, wWord32Equal.Int32Compare(-1, -2));
58   CHECK_EQ(false, wWord32Equal.Int32Compare(0xffffffff, 0xfffffffe));
59 
60   CHECK_EQ(false, wInt32LessThan.Int32Compare(0, 0));
61   CHECK_EQ(false, wInt32LessThan.Int32Compare(357, 357));
62   CHECK_EQ(false, wInt32LessThan.Int32Compare(75539, 75539));
63   CHECK_EQ(false, wInt32LessThan.Int32Compare(-1, -1));
64   CHECK_EQ(false, wInt32LessThan.Int32Compare(0xffffffff, 0xffffffff));
65 
66   CHECK_EQ(true, wInt32LessThan.Int32Compare(0, 1));
67   CHECK_EQ(true, wInt32LessThan.Int32Compare(456, 457));
68   CHECK_EQ(true, wInt32LessThan.Int32Compare(85537, 85539));
69   CHECK_EQ(true, wInt32LessThan.Int32Compare(-2, -1));
70   CHECK_EQ(true, wInt32LessThan.Int32Compare(0xfffffffe, 0xffffffff));
71 
72   CHECK_EQ(false, wInt32LessThan.Int32Compare(1, 0));
73   CHECK_EQ(false, wInt32LessThan.Int32Compare(457, 456));
74   CHECK_EQ(false, wInt32LessThan.Int32Compare(85539, 85537));
75   CHECK_EQ(false, wInt32LessThan.Int32Compare(-1, -2));
76   CHECK_EQ(false, wInt32LessThan.Int32Compare(0xffffffff, 0xfffffffe));
77 
78   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0, 0));
79   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(357, 357));
80   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(75539, 75539));
81   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(-1, -1));
82   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0xffffffff, 0xffffffff));
83 
84   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0, 1));
85   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(456, 457));
86   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(85537, 85539));
87   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(-2, -1));
88   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0xfffffffe, 0xffffffff));
89 
90   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(1, 0));
91   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(457, 456));
92   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(85539, 85537));
93   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(-1, -2));
94   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(0xffffffff, 0xfffffffe));
95 
96   // Unsigned comparisons.
97   CHECK_EQ(false, wUint32LessThan.Int32Compare(0, 0));
98   CHECK_EQ(false, wUint32LessThan.Int32Compare(357, 357));
99   CHECK_EQ(false, wUint32LessThan.Int32Compare(75539, 75539));
100   CHECK_EQ(false, wUint32LessThan.Int32Compare(-1, -1));
101   CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0xffffffff));
102   CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0));
103   CHECK_EQ(false, wUint32LessThan.Int32Compare(-2999, 0));
104 
105   CHECK_EQ(true, wUint32LessThan.Int32Compare(0, 1));
106   CHECK_EQ(true, wUint32LessThan.Int32Compare(456, 457));
107   CHECK_EQ(true, wUint32LessThan.Int32Compare(85537, 85539));
108   CHECK_EQ(true, wUint32LessThan.Int32Compare(-11, -10));
109   CHECK_EQ(true, wUint32LessThan.Int32Compare(0xfffffffe, 0xffffffff));
110   CHECK_EQ(true, wUint32LessThan.Int32Compare(0, 0xffffffff));
111   CHECK_EQ(true, wUint32LessThan.Int32Compare(0, -2996));
112 
113   CHECK_EQ(false, wUint32LessThan.Int32Compare(1, 0));
114   CHECK_EQ(false, wUint32LessThan.Int32Compare(457, 456));
115   CHECK_EQ(false, wUint32LessThan.Int32Compare(85539, 85537));
116   CHECK_EQ(false, wUint32LessThan.Int32Compare(-10, -21));
117   CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0xfffffffe));
118 
119   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, 0));
120   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(357, 357));
121   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(75539, 75539));
122   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-1, -1));
123   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0xffffffff, 0xffffffff));
124 
125   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, 1));
126   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(456, 457));
127   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(85537, 85539));
128   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-300, -299));
129   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-300, -300));
130   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0xfffffffe, 0xffffffff));
131   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, -2995));
132 
133   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(1, 0));
134   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(457, 456));
135   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(85539, 85537));
136   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(-130, -170));
137   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(0xffffffff, 0xfffffffe));
138   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(-2997, 0));
139 
140   CompareWrapper wFloat64Equal(IrOpcode::kFloat64Equal);
141   CompareWrapper wFloat64LessThan(IrOpcode::kFloat64LessThan);
142   CompareWrapper wFloat64LessThanOrEqual(IrOpcode::kFloat64LessThanOrEqual);
143 
144   // Check NaN handling.
145   double nan = v8::base::OS::nan_value();
146   double inf = V8_INFINITY;
147   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, 0.0));
148   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, 1.0));
149   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, inf));
150   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, -inf));
151   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, nan));
152 
153   CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, nan));
154   CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, nan));
155   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, nan));
156   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, nan));
157   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, nan));
158 
159   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, 0.0));
160   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, 1.0));
161   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, inf));
162   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, -inf));
163   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, nan));
164 
165   CHECK_EQ(false, wFloat64LessThan.Float64Compare(0.0, nan));
166   CHECK_EQ(false, wFloat64LessThan.Float64Compare(1.0, nan));
167   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, nan));
168   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, nan));
169   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, nan));
170 
171   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, 0.0));
172   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, 1.0));
173   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, inf));
174   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, -inf));
175   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, nan));
176 
177   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(0.0, nan));
178   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1.0, nan));
179   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, nan));
180   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(-inf, nan));
181   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, nan));
182 
183   // Check inf handling.
184   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, 0.0));
185   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, 1.0));
186   CHECK_EQ(true, wFloat64Equal.Float64Compare(inf, inf));
187   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, -inf));
188 
189   CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, inf));
190   CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, inf));
191   CHECK_EQ(true, wFloat64Equal.Float64Compare(inf, inf));
192   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, inf));
193 
194   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, 0.0));
195   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, 1.0));
196   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, inf));
197   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, -inf));
198 
199   CHECK_EQ(true, wFloat64LessThan.Float64Compare(0.0, inf));
200   CHECK_EQ(true, wFloat64LessThan.Float64Compare(1.0, inf));
201   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, inf));
202   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, inf));
203 
204   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, 0.0));
205   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, 1.0));
206   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(inf, inf));
207   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, -inf));
208 
209   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0.0, inf));
210   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(1.0, inf));
211   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(inf, inf));
212   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, inf));
213 
214   // Check -inf handling.
215   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, 0.0));
216   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, 1.0));
217   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, inf));
218   CHECK_EQ(true, wFloat64Equal.Float64Compare(-inf, -inf));
219 
220   CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, -inf));
221   CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, -inf));
222   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, -inf));
223   CHECK_EQ(true, wFloat64Equal.Float64Compare(-inf, -inf));
224 
225   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, 0.0));
226   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, 1.0));
227   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, inf));
228   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, -inf));
229 
230   CHECK_EQ(false, wFloat64LessThan.Float64Compare(0.0, -inf));
231   CHECK_EQ(false, wFloat64LessThan.Float64Compare(1.0, -inf));
232   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, -inf));
233   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, -inf));
234 
235   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, 0.0));
236   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, 1.0));
237   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, inf));
238   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, -inf));
239 
240   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(0.0, -inf));
241   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1.0, -inf));
242   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, -inf));
243   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, -inf));
244 
245   // Check basic values.
246   CHECK_EQ(true, wFloat64Equal.Float64Compare(0, 0));
247   CHECK_EQ(true, wFloat64Equal.Float64Compare(257.1, 257.1));
248   CHECK_EQ(true, wFloat64Equal.Float64Compare(65539.1, 65539.1));
249   CHECK_EQ(true, wFloat64Equal.Float64Compare(-1.1, -1.1));
250 
251   CHECK_EQ(false, wFloat64Equal.Float64Compare(0, 1));
252   CHECK_EQ(false, wFloat64Equal.Float64Compare(257.2, 256.2));
253   CHECK_EQ(false, wFloat64Equal.Float64Compare(65539.2, 65537.2));
254   CHECK_EQ(false, wFloat64Equal.Float64Compare(-1.2, -2.2));
255 
256   CHECK_EQ(false, wFloat64LessThan.Float64Compare(0, 0));
257   CHECK_EQ(false, wFloat64LessThan.Float64Compare(357.3, 357.3));
258   CHECK_EQ(false, wFloat64LessThan.Float64Compare(75539.3, 75539.3));
259   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-1.3, -1.3));
260 
261   CHECK_EQ(true, wFloat64LessThan.Float64Compare(0, 1));
262   CHECK_EQ(true, wFloat64LessThan.Float64Compare(456.4, 457.4));
263   CHECK_EQ(true, wFloat64LessThan.Float64Compare(85537.4, 85539.4));
264   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-2.4, -1.4));
265 
266   CHECK_EQ(false, wFloat64LessThan.Float64Compare(1, 0));
267   CHECK_EQ(false, wFloat64LessThan.Float64Compare(457.5, 456.5));
268   CHECK_EQ(false, wFloat64LessThan.Float64Compare(85539.5, 85537.5));
269   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-1.5, -2.5));
270 
271   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0, 0));
272   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(357.6, 357.6));
273   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(75539.6, 75539.6));
274   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-1.6, -1.6));
275 
276   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0, 1));
277   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(456.7, 457.7));
278   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(85537.7, 85539.7));
279   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-2.7, -1.7));
280 
281   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1, 0));
282   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(457.8, 456.8));
283   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(85539.8, 85537.8));
284   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(-1.8, -2.8));
285 }
286 
287 
TestAllInputShapes()288 void Int32BinopInputShapeTester::TestAllInputShapes() {
289   std::vector<int32_t> inputs = ValueHelper::int32_vector();
290   int num_int_inputs = static_cast<int>(inputs.size());
291   if (num_int_inputs > 16) num_int_inputs = 16;  // limit to 16 inputs
292 
293   for (int i = -2; i < num_int_inputs; i++) {    // for all left shapes
294     for (int j = -2; j < num_int_inputs; j++) {  // for all right shapes
295       if (i >= 0 && j >= 0) break;               // No constant/constant combos
296       RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
297       Node* p0 = m.Parameter(0);
298       Node* p1 = m.Parameter(1);
299       Node* n0;
300       Node* n1;
301 
302       // left = Parameter | Load | Constant
303       if (i == -2) {
304         n0 = p0;
305       } else if (i == -1) {
306         n0 = m.LoadFromPointer(&input_a, kMachInt32);
307       } else {
308         n0 = m.Int32Constant(inputs[i]);
309       }
310 
311       // right = Parameter | Load | Constant
312       if (j == -2) {
313         n1 = p1;
314       } else if (j == -1) {
315         n1 = m.LoadFromPointer(&input_b, kMachInt32);
316       } else {
317         n1 = m.Int32Constant(inputs[j]);
318       }
319 
320       gen->gen(&m, n0, n1);
321 
322       if (false) printf("Int32BinopInputShapeTester i=%d, j=%d\n", i, j);
323       if (i >= 0) {
324         input_a = inputs[i];
325         RunRight(&m);
326       } else if (j >= 0) {
327         input_b = inputs[j];
328         RunLeft(&m);
329       } else {
330         Run(&m);
331       }
332     }
333   }
334 }
335 
336 
Run(RawMachineAssemblerTester<int32_t> * m)337 void Int32BinopInputShapeTester::Run(RawMachineAssemblerTester<int32_t>* m) {
338   FOR_INT32_INPUTS(pl) {
339     FOR_INT32_INPUTS(pr) {
340       input_a = *pl;
341       input_b = *pr;
342       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       CHECK_EQ(expect, m->Call(input_a, input_b));
345     }
346   }
347 }
348 
349 
RunLeft(RawMachineAssemblerTester<int32_t> * m)350 void Int32BinopInputShapeTester::RunLeft(
351     RawMachineAssemblerTester<int32_t>* m) {
352   FOR_UINT32_INPUTS(i) {
353     input_a = *i;
354     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     CHECK_EQ(expect, m->Call(input_a, input_b));
357   }
358 }
359 
360 
RunRight(RawMachineAssemblerTester<int32_t> * m)361 void Int32BinopInputShapeTester::RunRight(
362     RawMachineAssemblerTester<int32_t>* m) {
363   FOR_UINT32_INPUTS(i) {
364     input_b = *i;
365     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     CHECK_EQ(expect, m->Call(input_a, input_b));
368   }
369 }
370 
371 
372 #if V8_TURBOFAN_TARGET
373 
TEST(ParametersEqual)374 TEST(ParametersEqual) {
375   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
376   Node* p1 = m.Parameter(1);
377   CHECK_NE(NULL, p1);
378   Node* p0 = m.Parameter(0);
379   CHECK_NE(NULL, p0);
380   CHECK_EQ(p0, m.Parameter(0));
381   CHECK_EQ(p1, m.Parameter(1));
382 }
383 
384 
RunSmiConstant(int32_t v)385 void RunSmiConstant(int32_t v) {
386 // TODO(dcarney): on x64 Smis are generated with the SmiConstantRegister
387 #if !V8_TARGET_ARCH_X64
388   if (Smi::IsValid(v)) {
389     RawMachineAssemblerTester<Object*> m;
390     m.Return(m.NumberConstant(v));
391     CHECK_EQ(Smi::FromInt(v), m.Call());
392   }
393 #endif
394 }
395 
396 
RunNumberConstant(double v)397 void RunNumberConstant(double v) {
398   RawMachineAssemblerTester<Object*> m;
399 #if V8_TARGET_ARCH_X64
400   // TODO(dcarney): on x64 Smis are generated with the SmiConstantRegister
401   Handle<Object> number = m.isolate()->factory()->NewNumber(v);
402   if (number->IsSmi()) return;
403 #endif
404   m.Return(m.NumberConstant(v));
405   Object* result = m.Call();
406   m.CheckNumber(v, result);
407 }
408 
409 
TEST(RunEmpty)410 TEST(RunEmpty) {
411   RawMachineAssemblerTester<int32_t> m;
412   m.Return(m.Int32Constant(0));
413   CHECK_EQ(0, m.Call());
414 }
415 
416 
TEST(RunInt32Constants)417 TEST(RunInt32Constants) {
418   FOR_INT32_INPUTS(i) {
419     RawMachineAssemblerTester<int32_t> m;
420     m.Return(m.Int32Constant(*i));
421     CHECK_EQ(*i, m.Call());
422   }
423 }
424 
425 
TEST(RunSmiConstants)426 TEST(RunSmiConstants) {
427   for (int32_t i = 1; i < Smi::kMaxValue && i != 0; i = i << 1) {
428     RunSmiConstant(i);
429     RunSmiConstant(3 * i);
430     RunSmiConstant(5 * i);
431     RunSmiConstant(-i);
432     RunSmiConstant(i | 1);
433     RunSmiConstant(i | 3);
434   }
435   RunSmiConstant(Smi::kMaxValue);
436   RunSmiConstant(Smi::kMaxValue - 1);
437   RunSmiConstant(Smi::kMinValue);
438   RunSmiConstant(Smi::kMinValue + 1);
439 
440   FOR_INT32_INPUTS(i) { RunSmiConstant(*i); }
441 }
442 
443 
TEST(RunNumberConstants)444 TEST(RunNumberConstants) {
445   {
446     FOR_FLOAT64_INPUTS(i) { RunNumberConstant(*i); }
447   }
448   {
449     FOR_INT32_INPUTS(i) { RunNumberConstant(*i); }
450   }
451 
452   for (int32_t i = 1; i < Smi::kMaxValue && i != 0; i = i << 1) {
453     RunNumberConstant(i);
454     RunNumberConstant(-i);
455     RunNumberConstant(i | 1);
456     RunNumberConstant(i | 3);
457   }
458   RunNumberConstant(Smi::kMaxValue);
459   RunNumberConstant(Smi::kMaxValue - 1);
460   RunNumberConstant(Smi::kMinValue);
461   RunNumberConstant(Smi::kMinValue + 1);
462 }
463 
464 
TEST(RunEmptyString)465 TEST(RunEmptyString) {
466   RawMachineAssemblerTester<Object*> m;
467   m.Return(m.StringConstant("empty"));
468   m.CheckString("empty", m.Call());
469 }
470 
471 
TEST(RunHeapConstant)472 TEST(RunHeapConstant) {
473   RawMachineAssemblerTester<Object*> m;
474   m.Return(m.StringConstant("empty"));
475   m.CheckString("empty", m.Call());
476 }
477 
478 
TEST(RunHeapNumberConstant)479 TEST(RunHeapNumberConstant) {
480   RawMachineAssemblerTester<Object*> m;
481   Handle<Object> number = m.isolate()->factory()->NewHeapNumber(100.5);
482   m.Return(m.HeapConstant(number));
483   Object* result = m.Call();
484   CHECK_EQ(result, *number);
485 }
486 
487 
TEST(RunParam1)488 TEST(RunParam1) {
489   RawMachineAssemblerTester<int32_t> m(kMachInt32);
490   m.Return(m.Parameter(0));
491 
492   FOR_INT32_INPUTS(i) {
493     int32_t result = m.Call(*i);
494     CHECK_EQ(*i, result);
495   }
496 }
497 
498 
TEST(RunParam2_1)499 TEST(RunParam2_1) {
500   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
501   Node* p0 = m.Parameter(0);
502   Node* p1 = m.Parameter(1);
503   m.Return(p0);
504   USE(p1);
505 
506   FOR_INT32_INPUTS(i) {
507     int32_t result = m.Call(*i, -9999);
508     CHECK_EQ(*i, result);
509   }
510 }
511 
512 
TEST(RunParam2_2)513 TEST(RunParam2_2) {
514   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
515   Node* p0 = m.Parameter(0);
516   Node* p1 = m.Parameter(1);
517   m.Return(p1);
518   USE(p0);
519 
520   FOR_INT32_INPUTS(i) {
521     int32_t result = m.Call(-7777, *i);
522     CHECK_EQ(*i, result);
523   }
524 }
525 
526 
TEST(RunParam3)527 TEST(RunParam3) {
528   for (int i = 0; i < 3; i++) {
529     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
530     Node* nodes[] = {m.Parameter(0), m.Parameter(1), m.Parameter(2)};
531     m.Return(nodes[i]);
532 
533     int p[] = {-99, -77, -88};
534     FOR_INT32_INPUTS(j) {
535       p[i] = *j;
536       int32_t result = m.Call(p[0], p[1], p[2]);
537       CHECK_EQ(*j, result);
538     }
539   }
540 }
541 
542 
TEST(RunBinopTester)543 TEST(RunBinopTester) {
544   {
545     RawMachineAssemblerTester<int32_t> m;
546     Int32BinopTester bt(&m);
547     bt.AddReturn(bt.param0);
548 
549     FOR_INT32_INPUTS(i) { CHECK_EQ(*i, bt.call(*i, 777)); }
550   }
551 
552   {
553     RawMachineAssemblerTester<int32_t> m;
554     Int32BinopTester bt(&m);
555     bt.AddReturn(bt.param1);
556 
557     FOR_INT32_INPUTS(i) { CHECK_EQ(*i, bt.call(666, *i)); }
558   }
559 
560   {
561     RawMachineAssemblerTester<int32_t> m;
562     Float64BinopTester bt(&m);
563     bt.AddReturn(bt.param0);
564 
565     FOR_FLOAT64_INPUTS(i) { CHECK_EQ(*i, bt.call(*i, 9.0)); }
566   }
567 
568   {
569     RawMachineAssemblerTester<int32_t> m;
570     Float64BinopTester bt(&m);
571     bt.AddReturn(bt.param1);
572 
573     FOR_FLOAT64_INPUTS(i) { CHECK_EQ(*i, bt.call(-11.25, *i)); }
574   }
575 }
576 
577 #endif  // V8_TURBOFAN_TARGET
578