OLD | NEW |
| (Empty) |
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/interface-descriptors.h" | |
6 #include "src/isolate.h" | |
7 #include "test/cctest/compiler/function-tester.h" | |
8 | |
9 namespace v8 { | |
10 namespace internal { | |
11 namespace compiler { | |
12 | |
13 | |
14 class CodeStubAssemblerTester : public CodeStubAssembler { | |
15 public: | |
16 // Test generating code for a stub. | |
17 CodeStubAssemblerTester(Isolate* isolate, | |
18 const CallInterfaceDescriptor& descriptor) | |
19 : CodeStubAssembler(isolate, isolate->runtime_zone(), descriptor, | |
20 Code::ComputeFlags(Code::STUB), "test"), | |
21 scope_(isolate) {} | |
22 | |
23 // Test generating code for a JS function (e.g. builtins). | |
24 CodeStubAssemblerTester(Isolate* isolate, int parameter_count) | |
25 : CodeStubAssembler(isolate, isolate->runtime_zone(), parameter_count, | |
26 Code::ComputeFlags(Code::FUNCTION), "test"), | |
27 scope_(isolate) {} | |
28 | |
29 private: | |
30 HandleScope scope_; | |
31 LocalContext context_; | |
32 }; | |
33 | |
34 | |
35 TEST(SimpleSmiReturn) { | |
36 Isolate* isolate(CcTest::InitIsolateOnce()); | |
37 VoidDescriptor descriptor(isolate); | |
38 CodeStubAssemblerTester m(isolate, descriptor); | |
39 m.Return(m.SmiTag(m.Int32Constant(37))); | |
40 Handle<Code> code = m.GenerateCode(); | |
41 FunctionTester ft(descriptor, code); | |
42 MaybeHandle<Object> result = ft.Call(); | |
43 CHECK_EQ(37, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
44 } | |
45 | |
46 | |
47 TEST(SimpleIntPtrReturn) { | |
48 Isolate* isolate(CcTest::InitIsolateOnce()); | |
49 VoidDescriptor descriptor(isolate); | |
50 CodeStubAssemblerTester m(isolate, descriptor); | |
51 int test; | |
52 m.Return(m.IntPtrConstant(reinterpret_cast<intptr_t>(&test))); | |
53 Handle<Code> code = m.GenerateCode(); | |
54 FunctionTester ft(descriptor, code); | |
55 MaybeHandle<Object> result = ft.Call(); | |
56 CHECK_EQ(reinterpret_cast<intptr_t>(&test), | |
57 reinterpret_cast<intptr_t>(*result.ToHandleChecked())); | |
58 } | |
59 | |
60 | |
61 TEST(SimpleDoubleReturn) { | |
62 Isolate* isolate(CcTest::InitIsolateOnce()); | |
63 VoidDescriptor descriptor(isolate); | |
64 CodeStubAssemblerTester m(isolate, descriptor); | |
65 m.Return(m.NumberConstant(0.5)); | |
66 Handle<Code> code = m.GenerateCode(); | |
67 FunctionTester ft(descriptor, code); | |
68 MaybeHandle<Object> result = ft.Call(); | |
69 CHECK_EQ(0.5, Handle<HeapNumber>::cast(result.ToHandleChecked())->value()); | |
70 } | |
71 | |
72 | |
73 TEST(SimpleCallRuntime1Arg) { | |
74 Isolate* isolate(CcTest::InitIsolateOnce()); | |
75 VoidDescriptor descriptor(isolate); | |
76 CodeStubAssemblerTester m(isolate, descriptor); | |
77 Node* context = m.HeapConstant(Handle<Context>(isolate->native_context())); | |
78 Node* b = m.SmiTag(m.Int32Constant(0)); | |
79 m.Return(m.CallRuntime(Runtime::kNumberToSmi, context, b)); | |
80 Handle<Code> code = m.GenerateCode(); | |
81 FunctionTester ft(descriptor, code); | |
82 MaybeHandle<Object> result = ft.Call(); | |
83 CHECK_EQ(0, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
84 } | |
85 | |
86 | |
87 TEST(SimpleTailCallRuntime1Arg) { | |
88 Isolate* isolate(CcTest::InitIsolateOnce()); | |
89 VoidDescriptor descriptor(isolate); | |
90 CodeStubAssemblerTester m(isolate, descriptor); | |
91 Node* context = m.HeapConstant(Handle<Context>(isolate->native_context())); | |
92 Node* b = m.SmiTag(m.Int32Constant(0)); | |
93 m.TailCallRuntime(Runtime::kNumberToSmi, context, b); | |
94 Handle<Code> code = m.GenerateCode(); | |
95 FunctionTester ft(descriptor, code); | |
96 MaybeHandle<Object> result = ft.Call(); | |
97 CHECK_EQ(0, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
98 } | |
99 | |
100 | |
101 TEST(SimpleCallRuntime2Arg) { | |
102 Isolate* isolate(CcTest::InitIsolateOnce()); | |
103 VoidDescriptor descriptor(isolate); | |
104 CodeStubAssemblerTester m(isolate, descriptor); | |
105 Node* context = m.HeapConstant(Handle<Context>(isolate->native_context())); | |
106 Node* a = m.SmiTag(m.Int32Constant(2)); | |
107 Node* b = m.SmiTag(m.Int32Constant(4)); | |
108 m.Return(m.CallRuntime(Runtime::kMathPow, context, a, b)); | |
109 Handle<Code> code = m.GenerateCode(); | |
110 FunctionTester ft(descriptor, code); | |
111 MaybeHandle<Object> result = ft.Call(); | |
112 CHECK_EQ(16, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
113 } | |
114 | |
115 | |
116 TEST(SimpleTailCallRuntime2Arg) { | |
117 Isolate* isolate(CcTest::InitIsolateOnce()); | |
118 VoidDescriptor descriptor(isolate); | |
119 CodeStubAssemblerTester m(isolate, descriptor); | |
120 Node* context = m.HeapConstant(Handle<Context>(isolate->native_context())); | |
121 Node* a = m.SmiTag(m.Int32Constant(2)); | |
122 Node* b = m.SmiTag(m.Int32Constant(4)); | |
123 m.TailCallRuntime(Runtime::kMathPow, context, a, b); | |
124 Handle<Code> code = m.GenerateCode(); | |
125 FunctionTester ft(descriptor, code); | |
126 MaybeHandle<Object> result = ft.Call(); | |
127 CHECK_EQ(16, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
128 } | |
129 | |
130 TEST(VariableMerge1) { | |
131 Isolate* isolate(CcTest::InitIsolateOnce()); | |
132 VoidDescriptor descriptor(isolate); | |
133 CodeStubAssemblerTester m(isolate, descriptor); | |
134 CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged); | |
135 CodeStubAssembler::Label l1(&m), l2(&m), merge(&m); | |
136 Node* temp = m.Int32Constant(0); | |
137 var1.Bind(temp); | |
138 m.Branch(m.Int32Constant(1), &l1, &l2); | |
139 m.Bind(&l1); | |
140 CHECK_EQ(var1.value(), temp); | |
141 m.Goto(&merge); | |
142 m.Bind(&l2); | |
143 CHECK_EQ(var1.value(), temp); | |
144 m.Goto(&merge); | |
145 m.Bind(&merge); | |
146 CHECK_EQ(var1.value(), temp); | |
147 } | |
148 | |
149 TEST(VariableMerge2) { | |
150 Isolate* isolate(CcTest::InitIsolateOnce()); | |
151 VoidDescriptor descriptor(isolate); | |
152 CodeStubAssemblerTester m(isolate, descriptor); | |
153 CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged); | |
154 CodeStubAssembler::Label l1(&m), l2(&m), merge(&m); | |
155 Node* temp = m.Int32Constant(0); | |
156 var1.Bind(temp); | |
157 m.Branch(m.Int32Constant(1), &l1, &l2); | |
158 m.Bind(&l1); | |
159 CHECK_EQ(var1.value(), temp); | |
160 m.Goto(&merge); | |
161 m.Bind(&l2); | |
162 Node* temp2 = m.Int32Constant(2); | |
163 var1.Bind(temp2); | |
164 CHECK_EQ(var1.value(), temp2); | |
165 m.Goto(&merge); | |
166 m.Bind(&merge); | |
167 CHECK_NE(var1.value(), temp); | |
168 } | |
169 | |
170 TEST(VariableMerge3) { | |
171 Isolate* isolate(CcTest::InitIsolateOnce()); | |
172 VoidDescriptor descriptor(isolate); | |
173 CodeStubAssemblerTester m(isolate, descriptor); | |
174 CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged); | |
175 CodeStubAssembler::Variable var2(&m, MachineRepresentation::kTagged); | |
176 CodeStubAssembler::Label l1(&m), l2(&m), merge(&m); | |
177 Node* temp = m.Int32Constant(0); | |
178 var1.Bind(temp); | |
179 var2.Bind(temp); | |
180 m.Branch(m.Int32Constant(1), &l1, &l2); | |
181 m.Bind(&l1); | |
182 CHECK_EQ(var1.value(), temp); | |
183 m.Goto(&merge); | |
184 m.Bind(&l2); | |
185 Node* temp2 = m.Int32Constant(2); | |
186 var1.Bind(temp2); | |
187 CHECK_EQ(var1.value(), temp2); | |
188 m.Goto(&merge); | |
189 m.Bind(&merge); | |
190 CHECK_NE(var1.value(), temp); | |
191 CHECK_NE(var1.value(), temp2); | |
192 CHECK_EQ(var2.value(), temp); | |
193 } | |
194 | |
195 TEST(VariableMergeBindFirst) { | |
196 Isolate* isolate(CcTest::InitIsolateOnce()); | |
197 VoidDescriptor descriptor(isolate); | |
198 CodeStubAssemblerTester m(isolate, descriptor); | |
199 CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged); | |
200 CodeStubAssembler::Label l1(&m), l2(&m), merge(&m, &var1), end(&m); | |
201 Node* temp = m.Int32Constant(0); | |
202 var1.Bind(temp); | |
203 m.Branch(m.Int32Constant(1), &l1, &l2); | |
204 m.Bind(&l1); | |
205 CHECK_EQ(var1.value(), temp); | |
206 m.Goto(&merge); | |
207 m.Bind(&merge); | |
208 CHECK(var1.value() != temp); | |
209 CHECK(var1.value() != nullptr); | |
210 m.Goto(&end); | |
211 m.Bind(&l2); | |
212 Node* temp2 = m.Int32Constant(2); | |
213 var1.Bind(temp2); | |
214 CHECK_EQ(var1.value(), temp2); | |
215 m.Goto(&merge); | |
216 m.Bind(&end); | |
217 CHECK(var1.value() != temp); | |
218 CHECK(var1.value() != nullptr); | |
219 } | |
220 | |
221 TEST(VariableMergeSwitch) { | |
222 Isolate* isolate(CcTest::InitIsolateOnce()); | |
223 VoidDescriptor descriptor(isolate); | |
224 CodeStubAssemblerTester m(isolate, descriptor); | |
225 CodeStubAssembler::Variable var1(&m, MachineRepresentation::kTagged); | |
226 CodeStubAssembler::Label l1(&m), l2(&m), default_label(&m); | |
227 CodeStubAssembler::Label* labels[] = {&l1, &l2}; | |
228 int32_t values[] = {1, 2}; | |
229 Node* temp = m.Int32Constant(0); | |
230 var1.Bind(temp); | |
231 m.Switch(m.Int32Constant(2), &default_label, values, labels, 2); | |
232 m.Bind(&l1); | |
233 DCHECK_EQ(temp, var1.value()); | |
234 m.Return(temp); | |
235 m.Bind(&l2); | |
236 DCHECK_EQ(temp, var1.value()); | |
237 m.Return(temp); | |
238 m.Bind(&default_label); | |
239 DCHECK_EQ(temp, var1.value()); | |
240 m.Return(temp); | |
241 } | |
242 | |
243 TEST(FixedArrayAccessSmiIndex) { | |
244 Isolate* isolate(CcTest::InitIsolateOnce()); | |
245 VoidDescriptor descriptor(isolate); | |
246 CodeStubAssemblerTester m(isolate, descriptor); | |
247 Handle<FixedArray> array = isolate->factory()->NewFixedArray(5); | |
248 array->set(4, Smi::FromInt(733)); | |
249 m.Return(m.LoadFixedArrayElement(m.HeapConstant(array), | |
250 m.SmiTag(m.Int32Constant(4)), 0, | |
251 CodeStubAssembler::SMI_PARAMETERS)); | |
252 Handle<Code> code = m.GenerateCode(); | |
253 FunctionTester ft(descriptor, code); | |
254 MaybeHandle<Object> result = ft.Call(); | |
255 CHECK_EQ(733, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
256 } | |
257 | |
258 TEST(LoadHeapNumberValue) { | |
259 Isolate* isolate(CcTest::InitIsolateOnce()); | |
260 VoidDescriptor descriptor(isolate); | |
261 CodeStubAssemblerTester m(isolate, descriptor); | |
262 Handle<HeapNumber> number = isolate->factory()->NewHeapNumber(1234); | |
263 m.Return(m.SmiTag( | |
264 m.ChangeFloat64ToUint32(m.LoadHeapNumberValue(m.HeapConstant(number))))); | |
265 Handle<Code> code = m.GenerateCode(); | |
266 FunctionTester ft(descriptor, code); | |
267 MaybeHandle<Object> result = ft.Call(); | |
268 CHECK_EQ(1234, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
269 } | |
270 | |
271 TEST(LoadInstanceType) { | |
272 Isolate* isolate(CcTest::InitIsolateOnce()); | |
273 VoidDescriptor descriptor(isolate); | |
274 CodeStubAssemblerTester m(isolate, descriptor); | |
275 Handle<HeapObject> undefined = isolate->factory()->undefined_value(); | |
276 m.Return(m.SmiTag(m.LoadInstanceType(m.HeapConstant(undefined)))); | |
277 Handle<Code> code = m.GenerateCode(); | |
278 FunctionTester ft(descriptor, code); | |
279 MaybeHandle<Object> result = ft.Call(); | |
280 CHECK_EQ(InstanceType::ODDBALL_TYPE, | |
281 Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
282 } | |
283 | |
284 namespace { | |
285 | |
286 class TestBitField : public BitField<unsigned, 3, 3> {}; | |
287 | |
288 } // namespace | |
289 | |
290 TEST(BitFieldDecode) { | |
291 Isolate* isolate(CcTest::InitIsolateOnce()); | |
292 VoidDescriptor descriptor(isolate); | |
293 CodeStubAssemblerTester m(isolate, descriptor); | |
294 m.Return(m.SmiTag(m.BitFieldDecode<TestBitField>(m.Int32Constant(0x2f)))); | |
295 Handle<Code> code = m.GenerateCode(); | |
296 FunctionTester ft(descriptor, code); | |
297 MaybeHandle<Object> result = ft.Call(); | |
298 // value = 00101111 | |
299 // mask = 00111000 | |
300 // result = 101 | |
301 CHECK_EQ(5, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
302 } | |
303 | |
304 namespace { | |
305 | |
306 Handle<JSFunction> CreateFunctionFromCode(int parameter_count_with_receiver, | |
307 Handle<Code> code) { | |
308 Isolate* isolate = code->GetIsolate(); | |
309 Handle<String> name = isolate->factory()->InternalizeUtf8String("test"); | |
310 Handle<JSFunction> function = | |
311 isolate->factory()->NewFunctionWithoutPrototype(name, code); | |
312 function->shared()->set_internal_formal_parameter_count( | |
313 parameter_count_with_receiver - 1); // Implicit undefined receiver. | |
314 return function; | |
315 } | |
316 | |
317 } // namespace | |
318 | |
319 TEST(JSFunction) { | |
320 const int kNumParams = 3; // Receiver, left, right. | |
321 Isolate* isolate(CcTest::InitIsolateOnce()); | |
322 CodeStubAssemblerTester m(isolate, kNumParams); | |
323 m.Return(m.SmiTag(m.Int32Add(m.SmiToWord32(m.Parameter(1)), | |
324 m.SmiToWord32(m.Parameter(2))))); | |
325 Handle<Code> code = m.GenerateCode(); | |
326 Handle<JSFunction> function = CreateFunctionFromCode(kNumParams, code); | |
327 Handle<Object> args[] = {Handle<Smi>(Smi::FromInt(23), isolate), | |
328 Handle<Smi>(Smi::FromInt(34), isolate)}; | |
329 MaybeHandle<Object> result = | |
330 Execution::Call(isolate, function, isolate->factory()->undefined_value(), | |
331 arraysize(args), args); | |
332 CHECK_EQ(57, Handle<Smi>::cast(result.ToHandleChecked())->value()); | |
333 } | |
334 | |
335 TEST(SplitEdgeBranchMerge) { | |
336 Isolate* isolate(CcTest::InitIsolateOnce()); | |
337 VoidDescriptor descriptor(isolate); | |
338 CodeStubAssemblerTester m(isolate, descriptor); | |
339 CodeStubAssembler::Label l1(&m), merge(&m); | |
340 m.Branch(m.Int32Constant(1), &l1, &merge); | |
341 m.Bind(&l1); | |
342 m.Goto(&merge); | |
343 m.Bind(&merge); | |
344 USE(m.GenerateCode()); | |
345 } | |
346 | |
347 TEST(SplitEdgeSwitchMerge) { | |
348 Isolate* isolate(CcTest::InitIsolateOnce()); | |
349 VoidDescriptor descriptor(isolate); | |
350 CodeStubAssemblerTester m(isolate, descriptor); | |
351 CodeStubAssembler::Label l1(&m), l2(&m), l3(&m), default_label(&m); | |
352 CodeStubAssembler::Label* labels[] = {&l1, &l2}; | |
353 int32_t values[] = {1, 2}; | |
354 m.Branch(m.Int32Constant(1), &l3, &l1); | |
355 m.Bind(&l3); | |
356 m.Switch(m.Int32Constant(2), &default_label, values, labels, 2); | |
357 m.Bind(&l1); | |
358 m.Goto(&l2); | |
359 m.Bind(&l2); | |
360 m.Goto(&default_label); | |
361 m.Bind(&default_label); | |
362 USE(m.GenerateCode()); | |
363 } | |
364 | |
365 TEST(TestToConstant) { | |
366 Isolate* isolate(CcTest::InitIsolateOnce()); | |
367 VoidDescriptor descriptor(isolate); | |
368 CodeStubAssemblerTester m(isolate, descriptor); | |
369 int32_t value32; | |
370 int64_t value64; | |
371 Node* a = m.Int32Constant(5); | |
372 CHECK(m.ToInt32Constant(a, value32)); | |
373 CHECK(m.ToInt64Constant(a, value64)); | |
374 | |
375 a = m.Int64Constant(static_cast<int64_t>(1) << 32); | |
376 CHECK(!m.ToInt32Constant(a, value32)); | |
377 CHECK(m.ToInt64Constant(a, value64)); | |
378 | |
379 a = m.Int64Constant(13); | |
380 CHECK(m.ToInt32Constant(a, value32)); | |
381 CHECK(m.ToInt64Constant(a, value64)); | |
382 | |
383 a = m.UndefinedConstant(); | |
384 CHECK(!m.ToInt32Constant(a, value32)); | |
385 CHECK(!m.ToInt64Constant(a, value64)); | |
386 | |
387 a = m.UndefinedConstant(); | |
388 CHECK(!m.ToInt32Constant(a, value32)); | |
389 CHECK(!m.ToInt64Constant(a, value64)); | |
390 } | |
391 | |
392 } // namespace compiler | |
393 } // namespace internal | |
394 } // namespace v8 | |
OLD | NEW |