Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(231)

Side by Side Diff: test/cctest/test-macro-assembler-x64.cc

Issue 196139: X64: Convert smis to holding 32 bits of payload. (Closed)
Patch Set: Addressed review comments. Forwarded to head. Created 11 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « test/cctest/test-heap.cc ('k') | test/mjsunit/for-in.js » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2009 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 #include <stdlib.h>
29
30 #include "v8.h"
31
32 #include "macro-assembler.h"
33 #include "factory.h"
34 #include "platform.h"
35 #include "serialize.h"
36 #include "cctest.h"
37
38 using v8::internal::byte;
39 using v8::internal::OS;
40 using v8::internal::Assembler;
41 using v8::internal::Condition;
42 using v8::internal::MacroAssembler;
43 using v8::internal::HandleScope;
44 using v8::internal::Operand;
45 using v8::internal::Immediate;
46 using v8::internal::SmiIndex;
47 using v8::internal::Label;
48 using v8::internal::RelocInfo;
49 using v8::internal::rax;
50 using v8::internal::rbx;
51 using v8::internal::rsi;
52 using v8::internal::rdi;
53 using v8::internal::rcx;
54 using v8::internal::rdx;
55 using v8::internal::rbp;
56 using v8::internal::rsp;
57 using v8::internal::r8;
58 using v8::internal::r9;
59 using v8::internal::r11;
60 using v8::internal::r12;
61 using v8::internal::r13;
62 using v8::internal::r14;
63 using v8::internal::r15;
64 using v8::internal::FUNCTION_CAST;
65 using v8::internal::CodeDesc;
66 using v8::internal::less_equal;
67 using v8::internal::not_equal;
68 using v8::internal::not_zero;
69 using v8::internal::greater;
70 using v8::internal::greater_equal;
71 using v8::internal::carry;
72 using v8::internal::not_carry;
73 using v8::internal::negative;
74 using v8::internal::positive;
75 using v8::internal::Smi;
76 using v8::internal::kSmiTagMask;
77 using v8::internal::kSmiValueSize;
78
79 // Test the x64 assembler by compiling some simple functions into
80 // a buffer and executing them. These tests do not initialize the
81 // V8 library, create a context, or use any V8 objects.
82 // The AMD64 calling convention is used, with the first five arguments
83 // in RSI, RDI, RDX, RCX, R8, and R9, and floating point arguments in
84 // the XMM registers. The return value is in RAX.
85 // This calling convention is used on Linux, with GCC, and on Mac OS,
86 // with GCC. A different convention is used on 64-bit windows.
87
88 typedef int (*F0)();
89
90 #define __ masm->
91
92 TEST(Smi) {
93 // Check that C++ Smi operations work as expected.
94 intptr_t test_numbers[] = {
95 0, 1, -1, 127, 128, -128, -129, 255, 256, -256, -257,
96 Smi::kMaxValue, static_cast<intptr_t>(Smi::kMaxValue) + 1,
97 Smi::kMinValue, static_cast<intptr_t>(Smi::kMinValue) - 1
98 };
99 int test_number_count = 15;
100 for (int i = 0; i < test_number_count; i++) {
101 intptr_t number = test_numbers[i];
102 bool is_valid = Smi::IsValid(number);
103 bool is_in_range = number >= Smi::kMinValue && number <= Smi::kMaxValue;
104 CHECK_EQ(is_in_range, is_valid);
105 if (is_valid) {
106 Smi* smi_from_intptr = Smi::FromIntptr(number);
107 if (static_cast<int>(number) == number) { // Is a 32-bit int.
108 Smi* smi_from_int = Smi::FromInt(static_cast<int32_t>(number));
109 CHECK_EQ(smi_from_int, smi_from_intptr);
110 }
111 int smi_value = smi_from_intptr->value();
112 CHECK_EQ(number, smi_value);
113 }
114 }
115 }
116
117
118 static void TestMoveSmi(MacroAssembler* masm, Label* exit, int id, Smi* value) {
119 __ movl(rax, Immediate(id));
120 __ Move(rcx, Smi::FromInt(0));
121 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
122 __ cmpq(rcx, rdx);
123 __ j(not_equal, exit);
124 }
125
126
127 // Test that we can move a Smi value literally into a register.
128 TEST(SmiMove) {
129 // Allocate an executable page of memory.
130 size_t actual_size;
131 byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
132 &actual_size,
133 true));
134 CHECK(buffer);
135 HandleScope handles;
136 MacroAssembler assembler(buffer, actual_size);
137 MacroAssembler* masm = &assembler; // Create a pointer for the __ macro.
138 masm->set_allow_stub_calls(false);
139 Label exit;
140
141 TestMoveSmi(masm, &exit, 1, Smi::FromInt(0));
142 TestMoveSmi(masm, &exit, 2, Smi::FromInt(127));
143 TestMoveSmi(masm, &exit, 3, Smi::FromInt(128));
144 TestMoveSmi(masm, &exit, 4, Smi::FromInt(255));
145 TestMoveSmi(masm, &exit, 5, Smi::FromInt(256));
146 TestMoveSmi(masm, &exit, 6, Smi::FromInt(Smi::kMaxValue));
147 TestMoveSmi(masm, &exit, 7, Smi::FromInt(-1));
148 TestMoveSmi(masm, &exit, 8, Smi::FromInt(-128));
149 TestMoveSmi(masm, &exit, 9, Smi::FromInt(-129));
150 TestMoveSmi(masm, &exit, 10, Smi::FromInt(-256));
151 TestMoveSmi(masm, &exit, 11, Smi::FromInt(-257));
152 TestMoveSmi(masm, &exit, 12, Smi::FromInt(Smi::kMinValue));
153
154 __ xor_(rax, rax); // Success.
155 __ bind(&exit);
156 __ ret(0);
157
158 CodeDesc desc;
159 masm->GetCode(&desc);
160 // Call the function from C++.
161 int result = FUNCTION_CAST<F0>(buffer)();
162 CHECK_EQ(0, result);
163 }
164
165
166 void TestSmiCompare(MacroAssembler* masm, Label* exit, int id, int x, int y) {
167 __ Move(rcx, Smi::FromInt(x));
168 __ movq(r8, rcx);
169 __ Move(rdx, Smi::FromInt(y));
170 __ movq(r9, rdx);
171 __ SmiCompare(rcx, rdx);
172 if (x < y) {
173 __ movl(rax, Immediate(id + 1));
174 __ j(greater_equal, exit);
175 } else if (x > y) {
176 __ movl(rax, Immediate(id + 2));
177 __ j(less_equal, exit);
178 } else {
179 ASSERT_EQ(x, y);
180 __ movl(rax, Immediate(id + 3));
181 __ j(not_equal, exit);
182 }
183 __ movl(rax, Immediate(id + 4));
184 __ cmpq(rcx, r8);
185 __ j(not_equal, exit);
186 __ incq(rax);
187 __ cmpq(rdx, r9);
188 __ j(not_equal, exit);
189
190 if (x != y) {
191 __ SmiCompare(rdx, rcx);
192 if (y < x) {
193 __ movl(rax, Immediate(id + 9));
194 __ j(greater_equal, exit);
195 } else {
196 ASSERT(y > x);
197 __ movl(rax, Immediate(id + 10));
198 __ j(less_equal, exit);
199 }
200 } else {
201 __ SmiCompare(rcx, rcx);
202 __ movl(rax, Immediate(id + 11));
203 __ j(not_equal, exit);
204 __ incq(rax);
205 __ cmpq(rcx, r8);
206 __ j(not_equal, exit);
207 }
208 }
209
210
211 // Test that we can compare smis for equality (and more).
212 TEST(SmiCompare) {
213 // Allocate an executable page of memory.
214 size_t actual_size;
215 byte* buffer =
216 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
217 &actual_size,
218 true));
219 CHECK(buffer);
220 HandleScope handles;
221 MacroAssembler assembler(buffer, actual_size);
222
223 MacroAssembler* masm = &assembler;
224 masm->set_allow_stub_calls(false);
225 Label exit;
226
227 TestSmiCompare(masm, &exit, 0x10, 0, 0);
228 TestSmiCompare(masm, &exit, 0x20, 0, 1);
229 TestSmiCompare(masm, &exit, 0x30, 1, 0);
230 TestSmiCompare(masm, &exit, 0x40, 1, 1);
231 TestSmiCompare(masm, &exit, 0x50, 0, -1);
232 TestSmiCompare(masm, &exit, 0x60, -1, 0);
233 TestSmiCompare(masm, &exit, 0x70, -1, -1);
234 TestSmiCompare(masm, &exit, 0x80, 0, Smi::kMinValue);
235 TestSmiCompare(masm, &exit, 0x90, Smi::kMinValue, 0);
236 TestSmiCompare(masm, &exit, 0xA0, 0, Smi::kMaxValue);
237 TestSmiCompare(masm, &exit, 0xB0, Smi::kMaxValue, 0);
238 TestSmiCompare(masm, &exit, 0xC0, -1, Smi::kMinValue);
239 TestSmiCompare(masm, &exit, 0xD0, Smi::kMinValue, -1);
240 TestSmiCompare(masm, &exit, 0xE0, -1, Smi::kMaxValue);
241 TestSmiCompare(masm, &exit, 0xF0, Smi::kMaxValue, -1);
242 TestSmiCompare(masm, &exit, 0x100, Smi::kMinValue, Smi::kMinValue);
243 TestSmiCompare(masm, &exit, 0x110, Smi::kMinValue, Smi::kMaxValue);
244 TestSmiCompare(masm, &exit, 0x120, Smi::kMaxValue, Smi::kMinValue);
245 TestSmiCompare(masm, &exit, 0x130, Smi::kMaxValue, Smi::kMaxValue);
246
247 __ xor_(rax, rax); // Success.
248 __ bind(&exit);
249 __ ret(0);
250
251 CodeDesc desc;
252 masm->GetCode(&desc);
253 // Call the function from C++.
254 int result = FUNCTION_CAST<F0>(buffer)();
255 CHECK_EQ(0, result);
256 }
257
258
259
260 TEST(Integer32ToSmi) {
261 // Allocate an executable page of memory.
262 size_t actual_size;
263 byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
264 &actual_size,
265 true));
266 CHECK(buffer);
267 HandleScope handles;
268 MacroAssembler assembler(buffer, actual_size);
269
270 MacroAssembler* masm = &assembler;
271 masm->set_allow_stub_calls(false);
272 Label exit;
273
274 __ movq(rax, Immediate(1)); // Test number.
275 __ movl(rcx, Immediate(0));
276 __ Integer32ToSmi(rcx, rcx);
277 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
278 __ SmiCompare(rcx, rdx);
279 __ j(not_equal, &exit);
280
281 __ movq(rax, Immediate(2)); // Test number.
282 __ movl(rcx, Immediate(1024));
283 __ Integer32ToSmi(rcx, rcx);
284 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024)));
285 __ SmiCompare(rcx, rdx);
286 __ j(not_equal, &exit);
287
288 __ movq(rax, Immediate(3)); // Test number.
289 __ movl(rcx, Immediate(-1));
290 __ Integer32ToSmi(rcx, rcx);
291 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1)));
292 __ SmiCompare(rcx, rdx);
293 __ j(not_equal, &exit);
294
295 __ movq(rax, Immediate(4)); // Test number.
296 __ movl(rcx, Immediate(Smi::kMaxValue));
297 __ Integer32ToSmi(rcx, rcx);
298 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue)));
299 __ SmiCompare(rcx, rdx);
300 __ j(not_equal, &exit);
301
302 __ movq(rax, Immediate(5)); // Test number.
303 __ movl(rcx, Immediate(Smi::kMinValue));
304 __ Integer32ToSmi(rcx, rcx);
305 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue)));
306 __ SmiCompare(rcx, rdx);
307 __ j(not_equal, &exit);
308
309 // Different target register.
310
311 __ movq(rax, Immediate(6)); // Test number.
312 __ movl(rcx, Immediate(0));
313 __ Integer32ToSmi(r8, rcx);
314 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
315 __ SmiCompare(r8, rdx);
316 __ j(not_equal, &exit);
317
318 __ movq(rax, Immediate(7)); // Test number.
319 __ movl(rcx, Immediate(1024));
320 __ Integer32ToSmi(r8, rcx);
321 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024)));
322 __ SmiCompare(r8, rdx);
323 __ j(not_equal, &exit);
324
325 __ movq(rax, Immediate(8)); // Test number.
326 __ movl(rcx, Immediate(-1));
327 __ Integer32ToSmi(r8, rcx);
328 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1)));
329 __ SmiCompare(r8, rdx);
330 __ j(not_equal, &exit);
331
332 __ movq(rax, Immediate(9)); // Test number.
333 __ movl(rcx, Immediate(Smi::kMaxValue));
334 __ Integer32ToSmi(r8, rcx);
335 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue)));
336 __ SmiCompare(r8, rdx);
337 __ j(not_equal, &exit);
338
339 __ movq(rax, Immediate(10)); // Test number.
340 __ movl(rcx, Immediate(Smi::kMinValue));
341 __ Integer32ToSmi(r8, rcx);
342 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue)));
343 __ SmiCompare(r8, rdx);
344 __ j(not_equal, &exit);
345
346
347 __ xor_(rax, rax); // Success.
348 __ bind(&exit);
349 __ ret(0);
350
351 CodeDesc desc;
352 masm->GetCode(&desc);
353 // Call the function from C++.
354 int result = FUNCTION_CAST<F0>(buffer)();
355 CHECK_EQ(0, result);
356 }
357
358
359 void TestI64PlusConstantToSmi(MacroAssembler* masm,
360 Label* exit,
361 int id,
362 int64_t x,
363 int y) {
364 int64_t result = x + y;
365 ASSERT(Smi::IsValid(result));
366 __ movl(rax, Immediate(id));
367 __ Move(r8, Smi::FromInt(result));
368 __ movq(rcx, x, RelocInfo::NONE);
369 __ movq(r11, rcx);
370 __ Integer64PlusConstantToSmi(rdx, rcx, y);
371 __ SmiCompare(rdx, r8);
372 __ j(not_equal, exit);
373
374 __ incq(rax);
375 __ SmiCompare(r11, rcx);
376 __ j(not_equal, exit);
377
378 __ incq(rax);
379 __ Integer64PlusConstantToSmi(rcx, rcx, y);
380 __ SmiCompare(rcx, r8);
381 __ j(not_equal, exit);
382 }
383
384
385 TEST(Integer64PlusConstantToSmi) {
386 // Allocate an executable page of memory.
387 size_t actual_size;
388 byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
389 &actual_size,
390 true));
391 CHECK(buffer);
392 HandleScope handles;
393 MacroAssembler assembler(buffer, actual_size);
394
395 MacroAssembler* masm = &assembler;
396 masm->set_allow_stub_calls(false);
397 Label exit;
398
399 int64_t twice_max = static_cast<int64_t>(Smi::kMaxValue) * 2;
400
401 TestI64PlusConstantToSmi(masm, &exit, 0x10, 0, 0);
402 TestI64PlusConstantToSmi(masm, &exit, 0x20, 0, 1);
403 TestI64PlusConstantToSmi(masm, &exit, 0x30, 1, 0);
404 TestI64PlusConstantToSmi(masm, &exit, 0x40, Smi::kMaxValue - 5, 5);
405 TestI64PlusConstantToSmi(masm, &exit, 0x50, Smi::kMinValue + 5, 5);
406 TestI64PlusConstantToSmi(masm, &exit, 0x60, twice_max, -Smi::kMaxValue);
407 TestI64PlusConstantToSmi(masm, &exit, 0x70, -twice_max, Smi::kMaxValue);
408 TestI64PlusConstantToSmi(masm, &exit, 0x80, 0, Smi::kMinValue);
409 TestI64PlusConstantToSmi(masm, &exit, 0x90, 0, Smi::kMaxValue);
410 TestI64PlusConstantToSmi(masm, &exit, 0xA0, Smi::kMinValue, 0);
411 TestI64PlusConstantToSmi(masm, &exit, 0xB0, Smi::kMaxValue, 0);
412 TestI64PlusConstantToSmi(masm, &exit, 0xC0, twice_max, Smi::kMinValue);
413
414 __ xor_(rax, rax); // Success.
415 __ bind(&exit);
416 __ ret(0);
417
418 CodeDesc desc;
419 masm->GetCode(&desc);
420 // Call the function from C++.
421 int result = FUNCTION_CAST<F0>(buffer)();
422 CHECK_EQ(0, result);
423 }
424
425
426 TEST(SmiCheck) {
427 // Allocate an executable page of memory.
428 size_t actual_size;
429 byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
430 &actual_size,
431 true));
432 CHECK(buffer);
433 HandleScope handles;
434 MacroAssembler assembler(buffer, actual_size);
435
436 MacroAssembler* masm = &assembler;
437 masm->set_allow_stub_calls(false);
438 Label exit;
439 Condition cond;
440
441 __ movl(rax, Immediate(1)); // Test number.
442
443 // CheckSmi
444
445 __ movl(rcx, Immediate(0));
446 __ Integer32ToSmi(rcx, rcx);
447 cond = masm->CheckSmi(rcx);
448 __ j(NegateCondition(cond), &exit);
449
450 __ incq(rax);
451 __ xor_(rcx, Immediate(kSmiTagMask));
452 cond = masm->CheckSmi(rcx);
453 __ j(cond, &exit);
454
455 __ incq(rax);
456 __ movl(rcx, Immediate(-1));
457 __ Integer32ToSmi(rcx, rcx);
458 cond = masm->CheckSmi(rcx);
459 __ j(NegateCondition(cond), &exit);
460
461 __ incq(rax);
462 __ xor_(rcx, Immediate(kSmiTagMask));
463 cond = masm->CheckSmi(rcx);
464 __ j(cond, &exit);
465
466 __ incq(rax);
467 __ movl(rcx, Immediate(Smi::kMaxValue));
468 __ Integer32ToSmi(rcx, rcx);
469 cond = masm->CheckSmi(rcx);
470 __ j(NegateCondition(cond), &exit);
471
472 __ incq(rax);
473 __ xor_(rcx, Immediate(kSmiTagMask));
474 cond = masm->CheckSmi(rcx);
475 __ j(cond, &exit);
476
477 __ incq(rax);
478 __ movl(rcx, Immediate(Smi::kMinValue));
479 __ Integer32ToSmi(rcx, rcx);
480 cond = masm->CheckSmi(rcx);
481 __ j(NegateCondition(cond), &exit);
482
483 __ incq(rax);
484 __ xor_(rcx, Immediate(kSmiTagMask));
485 cond = masm->CheckSmi(rcx);
486 __ j(cond, &exit);
487
488 // CheckPositiveSmi
489
490 __ incq(rax);
491 __ movl(rcx, Immediate(0));
492 __ Integer32ToSmi(rcx, rcx);
493 cond = masm->CheckPositiveSmi(rcx); // Zero counts as positive.
494 __ j(NegateCondition(cond), &exit);
495
496 __ incq(rax);
497 __ xor_(rcx, Immediate(kSmiTagMask));
498 cond = masm->CheckPositiveSmi(rcx); // "zero" non-smi.
499 __ j(cond, &exit);
500
501 __ incq(rax);
502 __ movq(rcx, Immediate(-1));
503 __ Integer32ToSmi(rcx, rcx);
504 cond = masm->CheckPositiveSmi(rcx); // Negative smis are not positive.
505 __ j(cond, &exit);
506
507 __ incq(rax);
508 __ movq(rcx, Immediate(Smi::kMinValue));
509 __ Integer32ToSmi(rcx, rcx);
510 cond = masm->CheckPositiveSmi(rcx); // Most negative smi is not positive.
511 __ j(cond, &exit);
512
513 __ incq(rax);
514 __ xor_(rcx, Immediate(kSmiTagMask));
515 cond = masm->CheckPositiveSmi(rcx); // "Negative" non-smi.
516 __ j(cond, &exit);
517
518 __ incq(rax);
519 __ movq(rcx, Immediate(Smi::kMaxValue));
520 __ Integer32ToSmi(rcx, rcx);
521 cond = masm->CheckPositiveSmi(rcx); // Most positive smi is positive.
522 __ j(NegateCondition(cond), &exit);
523
524 __ incq(rax);
525 __ xor_(rcx, Immediate(kSmiTagMask));
526 cond = masm->CheckPositiveSmi(rcx); // "Positive" non-smi.
527 __ j(cond, &exit);
528
529 // CheckIsMinSmi
530
531 __ incq(rax);
532 __ movq(rcx, Immediate(Smi::kMaxValue));
533 __ Integer32ToSmi(rcx, rcx);
534 cond = masm->CheckIsMinSmi(rcx);
535 __ j(cond, &exit);
536
537 __ incq(rax);
538 __ movq(rcx, Immediate(0));
539 __ Integer32ToSmi(rcx, rcx);
540 cond = masm->CheckIsMinSmi(rcx);
541 __ j(cond, &exit);
542
543 __ incq(rax);
544 __ movq(rcx, Immediate(Smi::kMinValue));
545 __ Integer32ToSmi(rcx, rcx);
546 cond = masm->CheckIsMinSmi(rcx);
547 __ j(NegateCondition(cond), &exit);
548
549 __ incq(rax);
550 __ movq(rcx, Immediate(Smi::kMinValue + 1));
551 __ Integer32ToSmi(rcx, rcx);
552 cond = masm->CheckIsMinSmi(rcx);
553 __ j(cond, &exit);
554
555 // CheckBothSmi
556
557 __ incq(rax);
558 __ movq(rcx, Immediate(Smi::kMaxValue));
559 __ Integer32ToSmi(rcx, rcx);
560 __ movq(rdx, Immediate(Smi::kMinValue));
561 __ Integer32ToSmi(rdx, rdx);
562 cond = masm->CheckBothSmi(rcx, rdx);
563 __ j(NegateCondition(cond), &exit);
564
565 __ incq(rax);
566 __ xor_(rcx, Immediate(kSmiTagMask));
567 cond = masm->CheckBothSmi(rcx, rdx);
568 __ j(cond, &exit);
569
570 __ incq(rax);
571 __ xor_(rdx, Immediate(kSmiTagMask));
572 cond = masm->CheckBothSmi(rcx, rdx);
573 __ j(cond, &exit);
574
575 __ incq(rax);
576 __ xor_(rcx, Immediate(kSmiTagMask));
577 cond = masm->CheckBothSmi(rcx, rdx);
578 __ j(cond, &exit);
579
580 __ incq(rax);
581 cond = masm->CheckBothSmi(rcx, rcx);
582 __ j(NegateCondition(cond), &exit);
583
584 __ incq(rax);
585 cond = masm->CheckBothSmi(rdx, rdx);
586 __ j(cond, &exit);
587
588 // CheckInteger32ValidSmiValue
589 __ incq(rax);
590 __ movq(rcx, Immediate(0));
591 cond = masm->CheckInteger32ValidSmiValue(rax);
592 __ j(NegateCondition(cond), &exit);
593
594 __ incq(rax);
595 __ movq(rcx, Immediate(-1));
596 cond = masm->CheckInteger32ValidSmiValue(rax);
597 __ j(NegateCondition(cond), &exit);
598
599 __ incq(rax);
600 __ movq(rcx, Immediate(Smi::kMaxValue));
601 cond = masm->CheckInteger32ValidSmiValue(rax);
602 __ j(NegateCondition(cond), &exit);
603
604 __ incq(rax);
605 __ movq(rcx, Immediate(Smi::kMinValue));
606 cond = masm->CheckInteger32ValidSmiValue(rax);
607 __ j(NegateCondition(cond), &exit);
608
609 // Success
610 __ xor_(rax, rax);
611
612 __ bind(&exit);
613 __ ret(0);
614
615 CodeDesc desc;
616 masm->GetCode(&desc);
617 // Call the function from C++.
618 int result = FUNCTION_CAST<F0>(buffer)();
619 CHECK_EQ(0, result);
620 }
621
622
623
624 void TestSmiNeg(MacroAssembler* masm, Label* exit, int id, int x) {
625 __ Move(rcx, Smi::FromInt(x));
626 __ movq(r11, rcx);
627 if (x == Smi::kMinValue || x == 0) {
628 // Negation fails.
629 __ movl(rax, Immediate(id + 8));
630 __ SmiNeg(r9, rcx, exit);
631
632 __ incq(rax);
633 __ SmiCompare(r11, rcx);
634 __ j(not_equal, exit);
635
636 __ incq(rax);
637 __ SmiNeg(rcx, rcx, exit);
638
639 __ incq(rax);
640 __ SmiCompare(r11, rcx);
641 __ j(not_equal, exit);
642 } else {
643 Label smi_ok, smi_ok2;
644 int result = -x;
645 __ movl(rax, Immediate(id));
646 __ Move(r8, Smi::FromInt(result));
647
648 __ SmiNeg(r9, rcx, &smi_ok);
649 __ jmp(exit);
650 __ bind(&smi_ok);
651 __ incq(rax);
652 __ SmiCompare(r9, r8);
653 __ j(not_equal, exit);
654
655 __ incq(rax);
656 __ SmiCompare(r11, rcx);
657 __ j(not_equal, exit);
658
659 __ incq(rax);
660 __ SmiNeg(rcx, rcx, &smi_ok2);
661 __ jmp(exit);
662 __ bind(&smi_ok2);
663 __ incq(rax);
664 __ SmiCompare(rcx, r8);
665 __ j(not_equal, exit);
666 }
667 }
668
669
670 TEST(SmiNeg) {
671 // Allocate an executable page of memory.
672 size_t actual_size;
673 byte* buffer =
674 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
675 &actual_size,
676 true));
677 CHECK(buffer);
678 HandleScope handles;
679 MacroAssembler assembler(buffer, actual_size);
680
681 MacroAssembler* masm = &assembler;
682 masm->set_allow_stub_calls(false);
683 Label exit;
684
685 TestSmiNeg(masm, &exit, 0x10, 0);
686 TestSmiNeg(masm, &exit, 0x20, 1);
687 TestSmiNeg(masm, &exit, 0x30, -1);
688 TestSmiNeg(masm, &exit, 0x40, 127);
689 TestSmiNeg(masm, &exit, 0x50, 65535);
690 TestSmiNeg(masm, &exit, 0x60, Smi::kMinValue);
691 TestSmiNeg(masm, &exit, 0x70, Smi::kMaxValue);
692 TestSmiNeg(masm, &exit, 0x80, -Smi::kMaxValue);
693
694 __ xor_(rax, rax); // Success.
695 __ bind(&exit);
696 __ ret(0);
697
698 CodeDesc desc;
699 masm->GetCode(&desc);
700 // Call the function from C++.
701 int result = FUNCTION_CAST<F0>(buffer)();
702 CHECK_EQ(0, result);
703 }
704
705
706
707
708 static void SmiAddTest(MacroAssembler* masm,
709 Label* exit,
710 int id,
711 int first,
712 int second) {
713 __ movl(rcx, Immediate(first));
714 __ Integer32ToSmi(rcx, rcx);
715 __ movl(rdx, Immediate(second));
716 __ Integer32ToSmi(rdx, rdx);
717 __ movl(r8, Immediate(first + second));
718 __ Integer32ToSmi(r8, r8);
719
720 __ movl(rax, Immediate(id)); // Test number.
721 __ SmiAdd(r9, rcx, rdx, exit);
722 __ SmiCompare(r9, r8);
723 __ j(not_equal, exit);
724
725 __ incq(rax);
726 __ SmiAdd(rcx, rcx, rdx, exit); \
727 __ SmiCompare(rcx, r8);
728 __ j(not_equal, exit);
729
730 __ movl(rcx, Immediate(first));
731 __ Integer32ToSmi(rcx, rcx);
732
733 __ incq(rax);
734 __ SmiAddConstant(r9, rcx, Smi::FromInt(second));
735 __ SmiCompare(r9, r8);
736 __ j(not_equal, exit);
737
738 __ SmiAddConstant(rcx, rcx, Smi::FromInt(second));
739 __ SmiCompare(rcx, r8);
740 __ j(not_equal, exit);
741
742 __ movl(rcx, Immediate(first));
743 __ Integer32ToSmi(rcx, rcx);
744
745 __ incq(rax);
746 __ SmiAddConstant(r9, rcx, Smi::FromInt(second), exit);
747 __ SmiCompare(r9, r8);
748 __ j(not_equal, exit);
749
750 __ incq(rax);
751 __ SmiAddConstant(rcx, rcx, Smi::FromInt(second), exit);
752 __ SmiCompare(rcx, r8);
753 __ j(not_equal, exit);
754 }
755
756 TEST(SmiAdd) {
757 // Allocate an executable page of memory.
758 size_t actual_size;
759 byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
760 &actual_size,
761 true));
762 CHECK(buffer);
763 HandleScope handles;
764 MacroAssembler assembler(buffer, actual_size);
765
766 MacroAssembler* masm = &assembler;
767 masm->set_allow_stub_calls(false);
768 Label exit;
769
770 // No-overflow tests.
771 SmiAddTest(masm, &exit, 0x10, 1, 2);
772 SmiAddTest(masm, &exit, 0x20, 1, -2);
773 SmiAddTest(masm, &exit, 0x30, -1, 2);
774 SmiAddTest(masm, &exit, 0x40, -1, -2);
775 SmiAddTest(masm, &exit, 0x50, 0x1000, 0x2000);
776 SmiAddTest(masm, &exit, 0x60, Smi::kMinValue, 5);
777 SmiAddTest(masm, &exit, 0x70, Smi::kMaxValue, -5);
778 SmiAddTest(masm, &exit, 0x80, Smi::kMaxValue, Smi::kMinValue);
779
780 __ xor_(rax, rax); // Success.
781 __ bind(&exit);
782 __ ret(0);
783
784 CodeDesc desc;
785 masm->GetCode(&desc);
786 // Call the function from C++.
787 int result = FUNCTION_CAST<F0>(buffer)();
788 CHECK_EQ(0, result);
789 }
790
791
792 static void SmiSubTest(MacroAssembler* masm,
793 Label* exit,
794 int id,
795 int first,
796 int second) {
797 __ Move(rcx, Smi::FromInt(first));
798 __ Move(rdx, Smi::FromInt(second));
799 __ Move(r8, Smi::FromInt(first - second));
800
801 __ movl(rax, Immediate(id)); // Test 0.
802 __ SmiSub(r9, rcx, rdx, exit);
803 __ SmiCompare(r9, r8);
804 __ j(not_equal, exit);
805
806 __ incq(rax); // Test 1.
807 __ SmiSub(rcx, rcx, rdx, exit);
808 __ SmiCompare(rcx, r8);
809 __ j(not_equal, exit);
810
811 __ Move(rcx, Smi::FromInt(first));
812
813 __ incq(rax); // Test 2.
814 __ SmiSubConstant(r9, rcx, Smi::FromInt(second));
815 __ SmiCompare(r9, r8);
816 __ j(not_equal, exit);
817
818 __ incq(rax); // Test 3.
819 __ SmiSubConstant(rcx, rcx, Smi::FromInt(second));
820 __ SmiCompare(rcx, r8);
821 __ j(not_equal, exit);
822
823 __ Move(rcx, Smi::FromInt(first));
824
825 __ incq(rax); // Test 4.
826 __ SmiSubConstant(r9, rcx, Smi::FromInt(second), exit);
827 __ SmiCompare(r9, r8);
828 __ j(not_equal, exit);
829
830 __ incq(rax); // Test 5.
831 __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), exit);
832 __ SmiCompare(rcx, r8);
833 __ j(not_equal, exit);
834 }
835
836 static void SmiSubOverflowTest(MacroAssembler* masm,
837 Label* exit,
838 int id,
839 int x) {
840 // Subtracts a Smi from x so that the subtraction overflows.
841 ASSERT(x != -1); // Can't overflow by subtracting a Smi.
842 int y_max = (x < 0) ? (Smi::kMaxValue + 0) : (Smi::kMinValue + 0);
843 int y_min = (x < 0) ? (Smi::kMaxValue + x + 2) : (Smi::kMinValue + x);
844
845 __ movl(rax, Immediate(id));
846 __ Move(rcx, Smi::FromInt(x));
847 __ movq(r11, rcx); // Store original Smi value of x in r11.
848 __ Move(rdx, Smi::FromInt(y_min));
849 {
850 Label overflow_ok;
851 __ SmiSub(r9, rcx, rdx, &overflow_ok);
852 __ jmp(exit);
853 __ bind(&overflow_ok);
854 __ incq(rax);
855 __ SmiCompare(rcx, r11);
856 __ j(not_equal, exit);
857 }
858
859 {
860 Label overflow_ok;
861 __ incq(rax);
862 __ SmiSub(rcx, rcx, rdx, &overflow_ok);
863 __ jmp(exit);
864 __ bind(&overflow_ok);
865 __ incq(rax);
866 __ SmiCompare(rcx, r11);
867 __ j(not_equal, exit);
868 }
869
870 __ movq(rcx, r11);
871 {
872 Label overflow_ok;
873 __ incq(rax);
874 __ SmiSubConstant(r9, rcx, Smi::FromInt(y_min), &overflow_ok);
875 __ jmp(exit);
876 __ bind(&overflow_ok);
877 __ incq(rax);
878 __ SmiCompare(rcx, r11);
879 __ j(not_equal, exit);
880 }
881
882 {
883 Label overflow_ok;
884 __ incq(rax);
885 __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_min), &overflow_ok);
886 __ jmp(exit);
887 __ bind(&overflow_ok);
888 __ incq(rax);
889 __ SmiCompare(rcx, r11);
890 __ j(not_equal, exit);
891 }
892
893 __ Move(rdx, Smi::FromInt(y_max));
894
895 {
896 Label overflow_ok;
897 __ incq(rax);
898 __ SmiSub(r9, rcx, rdx, &overflow_ok);
899 __ jmp(exit);
900 __ bind(&overflow_ok);
901 __ incq(rax);
902 __ SmiCompare(rcx, r11);
903 __ j(not_equal, exit);
904 }
905
906 {
907 Label overflow_ok;
908 __ incq(rax);
909 __ SmiSub(rcx, rcx, rdx, &overflow_ok);
910 __ jmp(exit);
911 __ bind(&overflow_ok);
912 __ incq(rax);
913 __ SmiCompare(rcx, r11);
914 __ j(not_equal, exit);
915 }
916
917 __ movq(rcx, r11);
918 {
919 Label overflow_ok;
920 __ incq(rax);
921 __ SmiSubConstant(r9, rcx, Smi::FromInt(y_max), &overflow_ok);
922 __ jmp(exit);
923 __ bind(&overflow_ok);
924 __ incq(rax);
925 __ SmiCompare(rcx, r11);
926 __ j(not_equal, exit);
927 }
928
929 {
930 Label overflow_ok;
931 __ incq(rax);
932 __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_max), &overflow_ok);
933 __ jmp(exit);
934 __ bind(&overflow_ok);
935 __ incq(rax);
936 __ SmiCompare(rcx, r11);
937 __ j(not_equal, exit);
938 }
939 }
940
941
942 TEST(SmiSub) {
943 // Allocate an executable page of memory.
944 size_t actual_size;
945 byte* buffer =
946 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
947 &actual_size,
948 true));
949 CHECK(buffer);
950 HandleScope handles;
951 MacroAssembler assembler(buffer, actual_size);
952
953 MacroAssembler* masm = &assembler;
954 masm->set_allow_stub_calls(false);
955 Label exit;
956
957 SmiSubTest(masm, &exit, 0x10, 1, 2);
958 SmiSubTest(masm, &exit, 0x20, 1, -2);
959 SmiSubTest(masm, &exit, 0x30, -1, 2);
960 SmiSubTest(masm, &exit, 0x40, -1, -2);
961 SmiSubTest(masm, &exit, 0x50, 0x1000, 0x2000);
962 SmiSubTest(masm, &exit, 0x60, Smi::kMinValue, -5);
963 SmiSubTest(masm, &exit, 0x70, Smi::kMaxValue, 5);
964 SmiSubTest(masm, &exit, 0x80, -Smi::kMaxValue, Smi::kMinValue);
965 SmiSubTest(masm, &exit, 0x90, 0, Smi::kMaxValue);
966
967 SmiSubOverflowTest(masm, &exit, 0xA0, 1);
968 SmiSubOverflowTest(masm, &exit, 0xB0, 1024);
969 SmiSubOverflowTest(masm, &exit, 0xC0, Smi::kMaxValue);
970 SmiSubOverflowTest(masm, &exit, 0xD0, -2);
971 SmiSubOverflowTest(masm, &exit, 0xE0, -42000);
972 SmiSubOverflowTest(masm, &exit, 0xF0, Smi::kMinValue);
973 SmiSubOverflowTest(masm, &exit, 0x100, 0);
974
975 __ xor_(rax, rax); // Success.
976 __ bind(&exit);
977 __ ret(0);
978
979 CodeDesc desc;
980 masm->GetCode(&desc);
981 // Call the function from C++.
982 int result = FUNCTION_CAST<F0>(buffer)();
983 CHECK_EQ(0, result);
984 }
985
986
987
988 void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) {
989 int64_t result = static_cast<int64_t>(x) * static_cast<int64_t>(y);
990 bool negative_zero = (result == 0) && (x < 0 || y < 0);
991 __ Move(rcx, Smi::FromInt(x));
992 __ movq(r11, rcx);
993 __ Move(rdx, Smi::FromInt(y));
994 if (Smi::IsValid(result) && !negative_zero) {
995 __ movl(rax, Immediate(id));
996 __ Move(r8, Smi::FromIntptr(result));
997 __ SmiMul(r9, rcx, rdx, exit);
998 __ incq(rax);
999 __ SmiCompare(r11, rcx);
1000 __ j(not_equal, exit);
1001 __ incq(rax);
1002 __ SmiCompare(r9, r8);
1003 __ j(not_equal, exit);
1004
1005 __ incq(rax);
1006 __ SmiMul(rcx, rcx, rdx, exit);
1007 __ SmiCompare(rcx, r8);
1008 __ j(not_equal, exit);
1009 } else {
1010 __ movl(rax, Immediate(id + 8));
1011 Label overflow_ok, overflow_ok2;
1012 __ SmiMul(r9, rcx, rdx, &overflow_ok);
1013 __ jmp(exit);
1014 __ bind(&overflow_ok);
1015 __ incq(rax);
1016 __ SmiCompare(r11, rcx);
1017 __ j(not_equal, exit);
1018 __ incq(rax);
1019 __ SmiMul(rcx, rcx, rdx, &overflow_ok2);
1020 __ jmp(exit);
1021 __ bind(&overflow_ok2);
1022 // 31-bit version doesn't preserve rcx on failure.
1023 // __ incq(rax);
1024 // __ SmiCompare(r11, rcx);
1025 // __ j(not_equal, exit);
1026 }
1027 }
1028
1029
1030 TEST(SmiMul) {
1031 // Allocate an executable page of memory.
1032 size_t actual_size;
1033 byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
1034 &actual_size,
1035 true));
1036 CHECK(buffer);
1037 HandleScope handles;
1038 MacroAssembler assembler(buffer, actual_size);
1039
1040 MacroAssembler* masm = &assembler;
1041 masm->set_allow_stub_calls(false);
1042 Label exit;
1043
1044 TestSmiMul(masm, &exit, 0x10, 0, 0);
1045 TestSmiMul(masm, &exit, 0x20, -1, 0);
1046 TestSmiMul(masm, &exit, 0x30, 0, -1);
1047 TestSmiMul(masm, &exit, 0x40, -1, -1);
1048 TestSmiMul(masm, &exit, 0x50, 0x10000, 0x10000);
1049 TestSmiMul(masm, &exit, 0x60, 0x10000, 0xffff);
1050 TestSmiMul(masm, &exit, 0x70, 0x10000, 0xffff);
1051 TestSmiMul(masm, &exit, 0x80, Smi::kMaxValue, -1);
1052 TestSmiMul(masm, &exit, 0x90, Smi::kMaxValue, -2);
1053 TestSmiMul(masm, &exit, 0xa0, Smi::kMaxValue, 2);
1054 TestSmiMul(masm, &exit, 0xb0, (Smi::kMaxValue / 2), 2);
1055 TestSmiMul(masm, &exit, 0xc0, (Smi::kMaxValue / 2) + 1, 2);
1056 TestSmiMul(masm, &exit, 0xd0, (Smi::kMinValue / 2), 2);
1057 TestSmiMul(masm, &exit, 0xe0, (Smi::kMinValue / 2) - 1, 2);
1058
1059 __ xor_(rax, rax); // Success.
1060 __ bind(&exit);
1061 __ ret(0);
1062
1063 CodeDesc desc;
1064 masm->GetCode(&desc);
1065 // Call the function from C++.
1066 int result = FUNCTION_CAST<F0>(buffer)();
1067 CHECK_EQ(0, result);
1068 }
1069
1070
1071 void TestSmiDiv(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1072 bool division_by_zero = (y == 0);
1073 bool negative_zero = (x == 0 && y < 0);
1074 #ifdef V8_LONG_SMI
1075 bool overflow = (x == Smi::kMinValue && y < 0); // Safe approx. used.
1076 #else
1077 bool overflow = (x == Smi::kMinValue && y == -1);
1078 #endif
1079 bool fraction = !division_by_zero && !overflow && (x % y != 0);
1080 __ Move(r11, Smi::FromInt(x));
1081 __ Move(r12, Smi::FromInt(y));
1082 if (!fraction && !overflow && !negative_zero && !division_by_zero) {
1083 // Division succeeds
1084 __ movq(rcx, r11);
1085 __ movq(r15, Immediate(id));
1086 int result = x / y;
1087 __ Move(r8, Smi::FromInt(result));
1088 __ SmiDiv(r9, rcx, r12, exit);
1089 // Might have destroyed rcx and r12.
1090 __ incq(r15);
1091 __ SmiCompare(r9, r8);
1092 __ j(not_equal, exit);
1093
1094 __ incq(r15);
1095 __ movq(rcx, r11);
1096 __ Move(r12, Smi::FromInt(y));
1097 __ SmiCompare(rcx, r11);
1098 __ j(not_equal, exit);
1099
1100 __ incq(r15);
1101 __ SmiDiv(rcx, rcx, r12, exit);
1102
1103 __ incq(r15);
1104 __ SmiCompare(rcx, r8);
1105 __ j(not_equal, exit);
1106 } else {
1107 // Division fails.
1108 __ movq(r15, Immediate(id + 8));
1109
1110 Label fail_ok, fail_ok2;
1111 __ movq(rcx, r11);
1112 __ SmiDiv(r9, rcx, r12, &fail_ok);
1113 __ jmp(exit);
1114 __ bind(&fail_ok);
1115
1116 __ incq(r15);
1117 __ SmiCompare(rcx, r11);
1118 __ j(not_equal, exit);
1119
1120 __ incq(r15);
1121 __ SmiDiv(rcx, rcx, r12, &fail_ok2);
1122 __ jmp(exit);
1123 __ bind(&fail_ok2);
1124
1125 __ incq(r15);
1126 __ SmiCompare(rcx, r11);
1127 __ j(not_equal, exit);
1128 }
1129 }
1130
1131
1132 TEST(SmiDiv) {
1133 // Allocate an executable page of memory.
1134 size_t actual_size;
1135 byte* buffer =
1136 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
1137 &actual_size,
1138 true));
1139 CHECK(buffer);
1140 HandleScope handles;
1141 MacroAssembler assembler(buffer, actual_size);
1142
1143 MacroAssembler* masm = &assembler;
1144 masm->set_allow_stub_calls(false);
1145 Label exit;
1146
1147 TestSmiDiv(masm, &exit, 0x10, 1, 1);
1148 TestSmiDiv(masm, &exit, 0x20, 1, 0);
1149 TestSmiDiv(masm, &exit, 0x30, -1, 0);
1150 TestSmiDiv(masm, &exit, 0x40, 0, 1);
1151 TestSmiDiv(masm, &exit, 0x50, 0, -1);
1152 TestSmiDiv(masm, &exit, 0x60, 4, 2);
1153 TestSmiDiv(masm, &exit, 0x70, -4, 2);
1154 TestSmiDiv(masm, &exit, 0x80, 4, -2);
1155 TestSmiDiv(masm, &exit, 0x90, -4, -2);
1156 TestSmiDiv(masm, &exit, 0xa0, 3, 2);
1157 TestSmiDiv(masm, &exit, 0xb0, 3, 4);
1158 TestSmiDiv(masm, &exit, 0xc0, 1, Smi::kMaxValue);
1159 TestSmiDiv(masm, &exit, 0xd0, -1, Smi::kMaxValue);
1160 TestSmiDiv(masm, &exit, 0xe0, Smi::kMaxValue, 1);
1161 TestSmiDiv(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue);
1162 TestSmiDiv(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue);
1163 TestSmiDiv(masm, &exit, 0x110, Smi::kMaxValue, -1);
1164 TestSmiDiv(masm, &exit, 0x120, Smi::kMinValue, 1);
1165 TestSmiDiv(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue);
1166 TestSmiDiv(masm, &exit, 0x140, Smi::kMinValue, -1);
1167
1168 __ xor_(r15, r15); // Success.
1169 __ bind(&exit);
1170 __ movq(rax, r15);
1171 __ ret(0);
1172
1173 CodeDesc desc;
1174 masm->GetCode(&desc);
1175 // Call the function from C++.
1176 int result = FUNCTION_CAST<F0>(buffer)();
1177 CHECK_EQ(0, result);
1178 }
1179
1180
1181 void TestSmiMod(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1182 bool division_by_zero = (y == 0);
1183 bool division_overflow = (x == Smi::kMinValue) && (y == -1);
1184 bool fraction = !division_by_zero && !division_overflow && ((x % y) != 0);
1185 bool negative_zero = (!fraction && x < 0);
1186 __ Move(rcx, Smi::FromInt(x));
1187 __ movq(r11, rcx);
1188 __ Move(r12, Smi::FromInt(y));
1189 if (!division_overflow && !negative_zero && !division_by_zero) {
1190 // Modulo succeeds
1191 __ movq(r15, Immediate(id));
1192 int result = x % y;
1193 __ Move(r8, Smi::FromInt(result));
1194 __ SmiMod(r9, rcx, r12, exit);
1195
1196 __ incq(r15);
1197 __ SmiCompare(r9, r8);
1198 __ j(not_equal, exit);
1199
1200 __ incq(r15);
1201 __ SmiCompare(rcx, r11);
1202 __ j(not_equal, exit);
1203
1204 __ incq(r15);
1205 __ SmiMod(rcx, rcx, r12, exit);
1206
1207 __ incq(r15);
1208 __ SmiCompare(rcx, r8);
1209 __ j(not_equal, exit);
1210 } else {
1211 // Modulo fails.
1212 __ movq(r15, Immediate(id + 8));
1213
1214 Label fail_ok, fail_ok2;
1215 __ SmiMod(r9, rcx, r12, &fail_ok);
1216 __ jmp(exit);
1217 __ bind(&fail_ok);
1218
1219 __ incq(r15);
1220 __ SmiCompare(rcx, r11);
1221 __ j(not_equal, exit);
1222
1223 __ incq(r15);
1224 __ SmiMod(rcx, rcx, r12, &fail_ok2);
1225 __ jmp(exit);
1226 __ bind(&fail_ok2);
1227
1228 __ incq(r15);
1229 __ SmiCompare(rcx, r11);
1230 __ j(not_equal, exit);
1231 }
1232 }
1233
1234
1235 TEST(SmiMod) {
1236 // Allocate an executable page of memory.
1237 size_t actual_size;
1238 byte* buffer =
1239 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
1240 &actual_size,
1241 true));
1242 CHECK(buffer);
1243 HandleScope handles;
1244 MacroAssembler assembler(buffer, actual_size);
1245
1246 MacroAssembler* masm = &assembler;
1247 masm->set_allow_stub_calls(false);
1248 Label exit;
1249
1250 TestSmiMod(masm, &exit, 0x10, 1, 1);
1251 TestSmiMod(masm, &exit, 0x20, 1, 0);
1252 TestSmiMod(masm, &exit, 0x30, -1, 0);
1253 TestSmiMod(masm, &exit, 0x40, 0, 1);
1254 TestSmiMod(masm, &exit, 0x50, 0, -1);
1255 TestSmiMod(masm, &exit, 0x60, 4, 2);
1256 TestSmiMod(masm, &exit, 0x70, -4, 2);
1257 TestSmiMod(masm, &exit, 0x80, 4, -2);
1258 TestSmiMod(masm, &exit, 0x90, -4, -2);
1259 TestSmiMod(masm, &exit, 0xa0, 3, 2);
1260 TestSmiMod(masm, &exit, 0xb0, 3, 4);
1261 TestSmiMod(masm, &exit, 0xc0, 1, Smi::kMaxValue);
1262 TestSmiMod(masm, &exit, 0xd0, -1, Smi::kMaxValue);
1263 TestSmiMod(masm, &exit, 0xe0, Smi::kMaxValue, 1);
1264 TestSmiMod(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue);
1265 TestSmiMod(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue);
1266 TestSmiMod(masm, &exit, 0x110, Smi::kMaxValue, -1);
1267 TestSmiMod(masm, &exit, 0x120, Smi::kMinValue, 1);
1268 TestSmiMod(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue);
1269 TestSmiMod(masm, &exit, 0x140, Smi::kMinValue, -1);
1270
1271 __ xor_(r15, r15); // Success.
1272 __ bind(&exit);
1273 __ movq(rax, r15);
1274 __ ret(0);
1275
1276 CodeDesc desc;
1277 masm->GetCode(&desc);
1278 // Call the function from C++.
1279 int result = FUNCTION_CAST<F0>(buffer)();
1280 CHECK_EQ(0, result);
1281 }
1282
1283
1284 void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) {
1285 __ movl(rax, Immediate(id));
1286
1287 for (int i = 0; i < 8; i++) {
1288 __ Move(rcx, Smi::FromInt(x));
1289 SmiIndex index = masm->SmiToIndex(rdx, rcx, i);
1290 ASSERT(index.reg.is(rcx) || index.reg.is(rdx));
1291 __ shl(index.reg, Immediate(index.scale));
1292 __ Set(r8, static_cast<intptr_t>(x) << i);
1293 __ SmiCompare(index.reg, r8);
1294 __ j(not_equal, exit);
1295 __ incq(rax);
1296 __ Move(rcx, Smi::FromInt(x));
1297 index = masm->SmiToIndex(rcx, rcx, i);
1298 ASSERT(index.reg.is(rcx));
1299 __ shl(rcx, Immediate(index.scale));
1300 __ Set(r8, static_cast<intptr_t>(x) << i);
1301 __ SmiCompare(rcx, r8);
1302 __ j(not_equal, exit);
1303 __ incq(rax);
1304
1305 __ Move(rcx, Smi::FromInt(x));
1306 index = masm->SmiToNegativeIndex(rdx, rcx, i);
1307 ASSERT(index.reg.is(rcx) || index.reg.is(rdx));
1308 __ shl(index.reg, Immediate(index.scale));
1309 __ Set(r8, static_cast<intptr_t>(-x) << i);
1310 __ SmiCompare(index.reg, r8);
1311 __ j(not_equal, exit);
1312 __ incq(rax);
1313 __ Move(rcx, Smi::FromInt(x));
1314 index = masm->SmiToNegativeIndex(rcx, rcx, i);
1315 ASSERT(index.reg.is(rcx));
1316 __ shl(rcx, Immediate(index.scale));
1317 __ Set(r8, static_cast<intptr_t>(-x) << i);
1318 __ SmiCompare(rcx, r8);
1319 __ j(not_equal, exit);
1320 __ incq(rax);
1321 }
1322 }
1323
1324 TEST(SmiIndex) {
1325 // Allocate an executable page of memory.
1326 size_t actual_size;
1327 byte* buffer =
1328 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
1329 &actual_size,
1330 true));
1331 CHECK(buffer);
1332 HandleScope handles;
1333 MacroAssembler assembler(buffer, actual_size);
1334
1335 MacroAssembler* masm = &assembler;
1336 masm->set_allow_stub_calls(false);
1337 Label exit;
1338
1339 TestSmiIndex(masm, &exit, 0x10, 0);
1340 TestSmiIndex(masm, &exit, 0x20, 1);
1341 TestSmiIndex(masm, &exit, 0x30, 100);
1342 TestSmiIndex(masm, &exit, 0x40, 1000);
1343 TestSmiIndex(masm, &exit, 0x50, Smi::kMaxValue);
1344
1345 __ xor_(rax, rax); // Success.
1346 __ bind(&exit);
1347 __ ret(0);
1348
1349 CodeDesc desc;
1350 masm->GetCode(&desc);
1351 // Call the function from C++.
1352 int result = FUNCTION_CAST<F0>(buffer)();
1353 CHECK_EQ(0, result);
1354 }
1355
1356
1357 void TestSelectNonSmi(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1358 __ movl(rax, Immediate(id));
1359 __ Move(rcx, Smi::FromInt(x));
1360 __ Move(rdx, Smi::FromInt(y));
1361 __ xor_(rdx, Immediate(kSmiTagMask));
1362 __ SelectNonSmi(r9, rcx, rdx, exit);
1363
1364 __ incq(rax);
1365 __ SmiCompare(r9, rdx);
1366 __ j(not_equal, exit);
1367
1368 __ incq(rax);
1369 __ Move(rcx, Smi::FromInt(x));
1370 __ Move(rdx, Smi::FromInt(y));
1371 __ xor_(rcx, Immediate(kSmiTagMask));
1372 __ SelectNonSmi(r9, rcx, rdx, exit);
1373
1374 __ incq(rax);
1375 __ SmiCompare(r9, rcx);
1376 __ j(not_equal, exit);
1377
1378 __ incq(rax);
1379 Label fail_ok;
1380 __ Move(rcx, Smi::FromInt(x));
1381 __ Move(rdx, Smi::FromInt(y));
1382 __ xor_(rcx, Immediate(kSmiTagMask));
1383 __ xor_(rdx, Immediate(kSmiTagMask));
1384 __ SelectNonSmi(r9, rcx, rdx, &fail_ok);
1385 __ jmp(exit);
1386 __ bind(&fail_ok);
1387 }
1388
1389
1390 TEST(SmiSelectNonSmi) {
1391 // Allocate an executable page of memory.
1392 size_t actual_size;
1393 byte* buffer =
1394 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
1395 &actual_size,
1396 true));
1397 CHECK(buffer);
1398 HandleScope handles;
1399 MacroAssembler assembler(buffer, actual_size);
1400
1401 MacroAssembler* masm = &assembler;
1402 masm->set_allow_stub_calls(false); // Avoid inline checks.
1403 Label exit;
1404
1405 TestSelectNonSmi(masm, &exit, 0x10, 0, 0);
1406 TestSelectNonSmi(masm, &exit, 0x20, 0, 1);
1407 TestSelectNonSmi(masm, &exit, 0x30, 1, 0);
1408 TestSelectNonSmi(masm, &exit, 0x40, 0, -1);
1409 TestSelectNonSmi(masm, &exit, 0x50, -1, 0);
1410 TestSelectNonSmi(masm, &exit, 0x60, -1, -1);
1411 TestSelectNonSmi(masm, &exit, 0x70, 1, 1);
1412 TestSelectNonSmi(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1413 TestSelectNonSmi(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1414
1415 __ xor_(rax, rax); // Success.
1416 __ bind(&exit);
1417 __ ret(0);
1418
1419 CodeDesc desc;
1420 masm->GetCode(&desc);
1421 // Call the function from C++.
1422 int result = FUNCTION_CAST<F0>(buffer)();
1423 CHECK_EQ(0, result);
1424 }
1425
1426
1427 void TestSmiAnd(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1428 int result = x & y;
1429
1430 __ movl(rax, Immediate(id));
1431
1432 __ Move(rcx, Smi::FromInt(x));
1433 __ movq(r11, rcx);
1434 __ Move(rdx, Smi::FromInt(y));
1435 __ Move(r8, Smi::FromInt(result));
1436 __ SmiAnd(r9, rcx, rdx);
1437 __ SmiCompare(r8, r9);
1438 __ j(not_equal, exit);
1439
1440 __ incq(rax);
1441 __ SmiCompare(r11, rcx);
1442 __ j(not_equal, exit);
1443
1444 __ incq(rax);
1445 __ SmiAnd(rcx, rcx, rdx);
1446 __ SmiCompare(r8, rcx);
1447 __ j(not_equal, exit);
1448
1449 __ movq(rcx, r11);
1450 __ incq(rax);
1451 __ SmiAndConstant(r9, rcx, Smi::FromInt(y));
1452 __ SmiCompare(r8, r9);
1453 __ j(not_equal, exit);
1454
1455 __ incq(rax);
1456 __ SmiCompare(r11, rcx);
1457 __ j(not_equal, exit);
1458
1459 __ incq(rax);
1460 __ SmiAndConstant(rcx, rcx, Smi::FromInt(y));
1461 __ SmiCompare(r8, rcx);
1462 __ j(not_equal, exit);
1463 }
1464
1465
1466 TEST(SmiAnd) {
1467 // Allocate an executable page of memory.
1468 size_t actual_size;
1469 byte* buffer =
1470 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
1471 &actual_size,
1472 true));
1473 CHECK(buffer);
1474 HandleScope handles;
1475 MacroAssembler assembler(buffer, actual_size);
1476
1477 MacroAssembler* masm = &assembler;
1478 masm->set_allow_stub_calls(false);
1479 Label exit;
1480
1481 TestSmiAnd(masm, &exit, 0x10, 0, 0);
1482 TestSmiAnd(masm, &exit, 0x20, 0, 1);
1483 TestSmiAnd(masm, &exit, 0x30, 1, 0);
1484 TestSmiAnd(masm, &exit, 0x40, 0, -1);
1485 TestSmiAnd(masm, &exit, 0x50, -1, 0);
1486 TestSmiAnd(masm, &exit, 0x60, -1, -1);
1487 TestSmiAnd(masm, &exit, 0x70, 1, 1);
1488 TestSmiAnd(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1489 TestSmiAnd(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1490 TestSmiAnd(masm, &exit, 0xA0, Smi::kMinValue, -1);
1491 TestSmiAnd(masm, &exit, 0xB0, Smi::kMinValue, -1);
1492
1493 __ xor_(rax, rax); // Success.
1494 __ bind(&exit);
1495 __ ret(0);
1496
1497 CodeDesc desc;
1498 masm->GetCode(&desc);
1499 // Call the function from C++.
1500 int result = FUNCTION_CAST<F0>(buffer)();
1501 CHECK_EQ(0, result);
1502 }
1503
1504
1505 void TestSmiOr(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1506 int result = x | y;
1507
1508 __ movl(rax, Immediate(id));
1509
1510 __ Move(rcx, Smi::FromInt(x));
1511 __ movq(r11, rcx);
1512 __ Move(rdx, Smi::FromInt(y));
1513 __ Move(r8, Smi::FromInt(result));
1514 __ SmiOr(r9, rcx, rdx);
1515 __ SmiCompare(r8, r9);
1516 __ j(not_equal, exit);
1517
1518 __ incq(rax);
1519 __ SmiCompare(r11, rcx);
1520 __ j(not_equal, exit);
1521
1522 __ incq(rax);
1523 __ SmiOr(rcx, rcx, rdx);
1524 __ SmiCompare(r8, rcx);
1525 __ j(not_equal, exit);
1526
1527 __ movq(rcx, r11);
1528 __ incq(rax);
1529 __ SmiOrConstant(r9, rcx, Smi::FromInt(y));
1530 __ SmiCompare(r8, r9);
1531 __ j(not_equal, exit);
1532
1533 __ incq(rax);
1534 __ SmiCompare(r11, rcx);
1535 __ j(not_equal, exit);
1536
1537 __ incq(rax);
1538 __ SmiOrConstant(rcx, rcx, Smi::FromInt(y));
1539 __ SmiCompare(r8, rcx);
1540 __ j(not_equal, exit);
1541 }
1542
1543
1544 TEST(SmiOr) {
1545 // Allocate an executable page of memory.
1546 size_t actual_size;
1547 byte* buffer =
1548 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
1549 &actual_size,
1550 true));
1551 CHECK(buffer);
1552 HandleScope handles;
1553 MacroAssembler assembler(buffer, actual_size);
1554
1555 MacroAssembler* masm = &assembler;
1556 masm->set_allow_stub_calls(false);
1557 Label exit;
1558
1559 TestSmiOr(masm, &exit, 0x10, 0, 0);
1560 TestSmiOr(masm, &exit, 0x20, 0, 1);
1561 TestSmiOr(masm, &exit, 0x30, 1, 0);
1562 TestSmiOr(masm, &exit, 0x40, 0, -1);
1563 TestSmiOr(masm, &exit, 0x50, -1, 0);
1564 TestSmiOr(masm, &exit, 0x60, -1, -1);
1565 TestSmiOr(masm, &exit, 0x70, 1, 1);
1566 TestSmiOr(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1567 TestSmiOr(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1568 TestSmiOr(masm, &exit, 0xA0, Smi::kMinValue, -1);
1569 TestSmiOr(masm, &exit, 0xB0, 0x05555555, 0x01234567);
1570 TestSmiOr(masm, &exit, 0xC0, 0x05555555, 0x0fedcba9);
1571 TestSmiOr(masm, &exit, 0xD0, Smi::kMinValue, -1);
1572
1573 __ xor_(rax, rax); // Success.
1574 __ bind(&exit);
1575 __ ret(0);
1576
1577 CodeDesc desc;
1578 masm->GetCode(&desc);
1579 // Call the function from C++.
1580 int result = FUNCTION_CAST<F0>(buffer)();
1581 CHECK_EQ(0, result);
1582 }
1583
1584
1585 void TestSmiXor(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1586 int result = x ^ y;
1587
1588 __ movl(rax, Immediate(id));
1589
1590 __ Move(rcx, Smi::FromInt(x));
1591 __ movq(r11, rcx);
1592 __ Move(rdx, Smi::FromInt(y));
1593 __ Move(r8, Smi::FromInt(result));
1594 __ SmiXor(r9, rcx, rdx);
1595 __ SmiCompare(r8, r9);
1596 __ j(not_equal, exit);
1597
1598 __ incq(rax);
1599 __ SmiCompare(r11, rcx);
1600 __ j(not_equal, exit);
1601
1602 __ incq(rax);
1603 __ SmiXor(rcx, rcx, rdx);
1604 __ SmiCompare(r8, rcx);
1605 __ j(not_equal, exit);
1606
1607 __ movq(rcx, r11);
1608 __ incq(rax);
1609 __ SmiXorConstant(r9, rcx, Smi::FromInt(y));
1610 __ SmiCompare(r8, r9);
1611 __ j(not_equal, exit);
1612
1613 __ incq(rax);
1614 __ SmiCompare(r11, rcx);
1615 __ j(not_equal, exit);
1616
1617 __ incq(rax);
1618 __ SmiXorConstant(rcx, rcx, Smi::FromInt(y));
1619 __ SmiCompare(r8, rcx);
1620 __ j(not_equal, exit);
1621 }
1622
1623
1624 TEST(SmiXor) {
1625 // Allocate an executable page of memory.
1626 size_t actual_size;
1627 byte* buffer =
1628 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
1629 &actual_size,
1630 true));
1631 CHECK(buffer);
1632 HandleScope handles;
1633 MacroAssembler assembler(buffer, actual_size);
1634
1635 MacroAssembler* masm = &assembler;
1636 masm->set_allow_stub_calls(false);
1637 Label exit;
1638
1639 TestSmiXor(masm, &exit, 0x10, 0, 0);
1640 TestSmiXor(masm, &exit, 0x20, 0, 1);
1641 TestSmiXor(masm, &exit, 0x30, 1, 0);
1642 TestSmiXor(masm, &exit, 0x40, 0, -1);
1643 TestSmiXor(masm, &exit, 0x50, -1, 0);
1644 TestSmiXor(masm, &exit, 0x60, -1, -1);
1645 TestSmiXor(masm, &exit, 0x70, 1, 1);
1646 TestSmiXor(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1647 TestSmiXor(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1648 TestSmiXor(masm, &exit, 0xA0, Smi::kMinValue, -1);
1649 TestSmiXor(masm, &exit, 0xB0, 0x5555555, 0x01234567);
1650 TestSmiXor(masm, &exit, 0xC0, 0x5555555, 0x0fedcba9);
1651 TestSmiXor(masm, &exit, 0xD0, Smi::kMinValue, -1);
1652
1653 __ xor_(rax, rax); // Success.
1654 __ bind(&exit);
1655 __ ret(0);
1656
1657 CodeDesc desc;
1658 masm->GetCode(&desc);
1659 // Call the function from C++.
1660 int result = FUNCTION_CAST<F0>(buffer)();
1661 CHECK_EQ(0, result);
1662 }
1663
1664
1665 void TestSmiNot(MacroAssembler* masm, Label* exit, int id, int x) {
1666 int result = ~x;
1667 __ movl(rax, Immediate(id));
1668
1669 __ Move(r8, Smi::FromInt(result));
1670 __ Move(rcx, Smi::FromInt(x));
1671 __ movq(r11, rcx);
1672
1673 __ SmiNot(r9, rcx);
1674 __ SmiCompare(r9, r8);
1675 __ j(not_equal, exit);
1676
1677 __ incq(rax);
1678 __ SmiCompare(r11, rcx);
1679 __ j(not_equal, exit);
1680
1681 __ incq(rax);
1682 __ SmiNot(rcx, rcx);
1683 __ SmiCompare(rcx, r8);
1684 __ j(not_equal, exit);
1685 }
1686
1687
1688 TEST(SmiNot) {
1689 // Allocate an executable page of memory.
1690 size_t actual_size;
1691 byte* buffer =
1692 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
1693 &actual_size,
1694 true));
1695 CHECK(buffer);
1696 HandleScope handles;
1697 MacroAssembler assembler(buffer, actual_size);
1698
1699 MacroAssembler* masm = &assembler;
1700 masm->set_allow_stub_calls(false);
1701 Label exit;
1702
1703 TestSmiNot(masm, &exit, 0x10, 0);
1704 TestSmiNot(masm, &exit, 0x20, 1);
1705 TestSmiNot(masm, &exit, 0x30, -1);
1706 TestSmiNot(masm, &exit, 0x40, 127);
1707 TestSmiNot(masm, &exit, 0x50, 65535);
1708 TestSmiNot(masm, &exit, 0x60, Smi::kMinValue);
1709 TestSmiNot(masm, &exit, 0x70, Smi::kMaxValue);
1710 TestSmiNot(masm, &exit, 0x80, 0x05555555);
1711
1712 __ xor_(rax, rax); // Success.
1713 __ bind(&exit);
1714 __ ret(0);
1715
1716 CodeDesc desc;
1717 masm->GetCode(&desc);
1718 // Call the function from C++.
1719 int result = FUNCTION_CAST<F0>(buffer)();
1720 CHECK_EQ(0, result);
1721 }
1722
1723
1724 void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
1725 const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1};
1726 const int kNumShifts = 5;
1727 __ movl(rax, Immediate(id));
1728 for (int i = 0; i < kNumShifts; i++) {
1729 // rax == id + i * 10.
1730 int shift = shifts[i];
1731 int result = x << shift;
1732 if (Smi::IsValid(result)) {
1733 __ Move(r8, Smi::FromInt(result));
1734 __ Move(rcx, Smi::FromInt(x));
1735 __ SmiShiftLeftConstant(r9, rcx, shift, exit);
1736
1737 __ incq(rax);
1738 __ SmiCompare(r9, r8);
1739 __ j(not_equal, exit);
1740
1741 __ incq(rax);
1742 __ Move(rcx, Smi::FromInt(x));
1743 __ SmiShiftLeftConstant(rcx, rcx, shift, exit);
1744
1745 __ incq(rax);
1746 __ SmiCompare(rcx, r8);
1747 __ j(not_equal, exit);
1748
1749 __ incq(rax);
1750 __ Move(rdx, Smi::FromInt(x));
1751 __ Move(rcx, Smi::FromInt(shift));
1752 __ SmiShiftLeft(r9, rdx, rcx, exit);
1753
1754 __ incq(rax);
1755 __ SmiCompare(r9, r8);
1756 __ j(not_equal, exit);
1757
1758 __ incq(rax);
1759 __ Move(rdx, Smi::FromInt(x));
1760 __ Move(r11, Smi::FromInt(shift));
1761 __ SmiShiftLeft(r9, rdx, r11, exit);
1762
1763 __ incq(rax);
1764 __ SmiCompare(r9, r8);
1765 __ j(not_equal, exit);
1766
1767 __ incq(rax);
1768 __ Move(rdx, Smi::FromInt(x));
1769 __ Move(r11, Smi::FromInt(shift));
1770 __ SmiShiftLeft(rdx, rdx, r11, exit);
1771
1772 __ incq(rax);
1773 __ SmiCompare(rdx, r8);
1774 __ j(not_equal, exit);
1775
1776 __ incq(rax);
1777 } else {
1778 // Cannot happen with long smis.
1779 Label fail_ok;
1780 __ Move(rcx, Smi::FromInt(x));
1781 __ movq(r11, rcx);
1782 __ SmiShiftLeftConstant(r9, rcx, shift, &fail_ok);
1783 __ jmp(exit);
1784 __ bind(&fail_ok);
1785
1786 __ incq(rax);
1787 __ SmiCompare(rcx, r11);
1788 __ j(not_equal, exit);
1789
1790 __ incq(rax);
1791 Label fail_ok2;
1792 __ SmiShiftLeftConstant(rcx, rcx, shift, &fail_ok2);
1793 __ jmp(exit);
1794 __ bind(&fail_ok2);
1795
1796 __ incq(rax);
1797 __ SmiCompare(rcx, r11);
1798 __ j(not_equal, exit);
1799
1800 __ incq(rax);
1801 __ Move(r8, Smi::FromInt(shift));
1802 Label fail_ok3;
1803 __ SmiShiftLeft(r9, rcx, r8, &fail_ok3);
1804 __ jmp(exit);
1805 __ bind(&fail_ok3);
1806
1807 __ incq(rax);
1808 __ SmiCompare(rcx, r11);
1809 __ j(not_equal, exit);
1810
1811 __ incq(rax);
1812 __ Move(r8, Smi::FromInt(shift));
1813 __ movq(rdx, r11);
1814 Label fail_ok4;
1815 __ SmiShiftLeft(rdx, rdx, r8, &fail_ok4);
1816 __ jmp(exit);
1817 __ bind(&fail_ok4);
1818
1819 __ incq(rax);
1820 __ SmiCompare(rdx, r11);
1821 __ j(not_equal, exit);
1822
1823 __ addq(rax, Immediate(3));
1824 }
1825 }
1826 }
1827
1828
1829 TEST(SmiShiftLeft) {
1830 // Allocate an executable page of memory.
1831 size_t actual_size;
1832 byte* buffer =
1833 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 3,
1834 &actual_size,
1835 true));
1836 CHECK(buffer);
1837 HandleScope handles;
1838 MacroAssembler assembler(buffer, actual_size);
1839
1840 MacroAssembler* masm = &assembler;
1841 masm->set_allow_stub_calls(false);
1842 Label exit;
1843
1844 TestSmiShiftLeft(masm, &exit, 0x10, 0);
1845 TestSmiShiftLeft(masm, &exit, 0x50, 1);
1846 TestSmiShiftLeft(masm, &exit, 0x90, 127);
1847 TestSmiShiftLeft(masm, &exit, 0xD0, 65535);
1848 TestSmiShiftLeft(masm, &exit, 0x110, Smi::kMaxValue);
1849 TestSmiShiftLeft(masm, &exit, 0x150, Smi::kMinValue);
1850 TestSmiShiftLeft(masm, &exit, 0x190, -1);
1851
1852 __ xor_(rax, rax); // Success.
1853 __ bind(&exit);
1854 __ ret(0);
1855
1856 CodeDesc desc;
1857 masm->GetCode(&desc);
1858 // Call the function from C++.
1859 int result = FUNCTION_CAST<F0>(buffer)();
1860 CHECK_EQ(0, result);
1861 }
1862
1863
1864 void TestSmiShiftLogicalRight(MacroAssembler* masm,
1865 Label* exit,
1866 int id,
1867 int x) {
1868 const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1};
1869 const int kNumShifts = 5;
1870 __ movl(rax, Immediate(id));
1871 for (int i = 0; i < kNumShifts; i++) {
1872 int shift = shifts[i];
1873 intptr_t result = static_cast<unsigned int>(x) >> shift;
1874 if (Smi::IsValid(result)) {
1875 __ Move(r8, Smi::FromInt(result));
1876 __ Move(rcx, Smi::FromInt(x));
1877 __ SmiShiftLogicalRightConstant(r9, rcx, shift, exit);
1878
1879 __ incq(rax);
1880 __ SmiCompare(r9, r8);
1881 __ j(not_equal, exit);
1882
1883 __ incq(rax);
1884 __ Move(rdx, Smi::FromInt(x));
1885 __ Move(rcx, Smi::FromInt(shift));
1886 __ SmiShiftLogicalRight(r9, rdx, rcx, exit);
1887
1888 __ incq(rax);
1889 __ SmiCompare(r9, r8);
1890 __ j(not_equal, exit);
1891
1892 __ incq(rax);
1893 __ Move(rdx, Smi::FromInt(x));
1894 __ Move(r11, Smi::FromInt(shift));
1895 __ SmiShiftLogicalRight(r9, rdx, r11, exit);
1896
1897 __ incq(rax);
1898 __ SmiCompare(r9, r8);
1899 __ j(not_equal, exit);
1900
1901 __ incq(rax);
1902 } else {
1903 // Cannot happen with long smis.
1904 Label fail_ok;
1905 __ Move(rcx, Smi::FromInt(x));
1906 __ movq(r11, rcx);
1907 __ SmiShiftLogicalRightConstant(r9, rcx, shift, &fail_ok);
1908 __ jmp(exit);
1909 __ bind(&fail_ok);
1910
1911 __ incq(rax);
1912 __ SmiCompare(rcx, r11);
1913 __ j(not_equal, exit);
1914
1915 __ incq(rax);
1916 __ Move(r8, Smi::FromInt(shift));
1917 Label fail_ok3;
1918 __ SmiShiftLogicalRight(r9, rcx, r8, &fail_ok3);
1919 __ jmp(exit);
1920 __ bind(&fail_ok3);
1921
1922 __ incq(rax);
1923 __ SmiCompare(rcx, r11);
1924 __ j(not_equal, exit);
1925
1926 __ addq(rax, Immediate(3));
1927 }
1928 }
1929 }
1930
1931
1932 TEST(SmiShiftLogicalRight) {
1933 // Allocate an executable page of memory.
1934 size_t actual_size;
1935 byte* buffer =
1936 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
1937 &actual_size,
1938 true));
1939 CHECK(buffer);
1940 HandleScope handles;
1941 MacroAssembler assembler(buffer, actual_size);
1942
1943 MacroAssembler* masm = &assembler;
1944 masm->set_allow_stub_calls(false);
1945 Label exit;
1946
1947 TestSmiShiftLogicalRight(masm, &exit, 0x10, 0);
1948 TestSmiShiftLogicalRight(masm, &exit, 0x30, 1);
1949 TestSmiShiftLogicalRight(masm, &exit, 0x50, 127);
1950 TestSmiShiftLogicalRight(masm, &exit, 0x70, 65535);
1951 TestSmiShiftLogicalRight(masm, &exit, 0x90, Smi::kMaxValue);
1952 TestSmiShiftLogicalRight(masm, &exit, 0xB0, Smi::kMinValue);
1953 TestSmiShiftLogicalRight(masm, &exit, 0xD0, -1);
1954
1955 __ xor_(rax, rax); // Success.
1956 __ bind(&exit);
1957 __ ret(0);
1958
1959 CodeDesc desc;
1960 masm->GetCode(&desc);
1961 // Call the function from C++.
1962 int result = FUNCTION_CAST<F0>(buffer)();
1963 CHECK_EQ(0, result);
1964 }
1965
1966
1967 void TestSmiShiftArithmeticRight(MacroAssembler* masm,
1968 Label* exit,
1969 int id,
1970 int x) {
1971 const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1};
1972 const int kNumShifts = 5;
1973 __ movl(rax, Immediate(id));
1974 for (int i = 0; i < kNumShifts; i++) {
1975 int shift = shifts[i];
1976 // Guaranteed arithmetic shift.
1977 int result = (x < 0) ? ~((~x) >> shift) : (x >> shift);
1978 __ Move(r8, Smi::FromInt(result));
1979 __ Move(rcx, Smi::FromInt(x));
1980 __ SmiShiftArithmeticRightConstant(rcx, rcx, shift);
1981
1982 __ SmiCompare(rcx, r8);
1983 __ j(not_equal, exit);
1984
1985 __ incq(rax);
1986 __ Move(rdx, Smi::FromInt(x));
1987 __ Move(r11, Smi::FromInt(shift));
1988 __ SmiShiftArithmeticRight(rdx, rdx, r11);
1989
1990 __ SmiCompare(rdx, r8);
1991 __ j(not_equal, exit);
1992
1993 __ incq(rax);
1994 }
1995 }
1996
1997
1998 TEST(SmiShiftArithmeticRight) {
1999 // Allocate an executable page of memory.
2000 size_t actual_size;
2001 byte* buffer =
2002 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
2003 &actual_size,
2004 true));
2005 CHECK(buffer);
2006 HandleScope handles;
2007 MacroAssembler assembler(buffer, actual_size);
2008
2009 MacroAssembler* masm = &assembler;
2010 masm->set_allow_stub_calls(false);
2011 Label exit;
2012
2013 TestSmiShiftArithmeticRight(masm, &exit, 0x10, 0);
2014 TestSmiShiftArithmeticRight(masm, &exit, 0x20, 1);
2015 TestSmiShiftArithmeticRight(masm, &exit, 0x30, 127);
2016 TestSmiShiftArithmeticRight(masm, &exit, 0x40, 65535);
2017 TestSmiShiftArithmeticRight(masm, &exit, 0x50, Smi::kMaxValue);
2018 TestSmiShiftArithmeticRight(masm, &exit, 0x60, Smi::kMinValue);
2019 TestSmiShiftArithmeticRight(masm, &exit, 0x70, -1);
2020
2021 __ xor_(rax, rax); // Success.
2022 __ bind(&exit);
2023 __ ret(0);
2024
2025 CodeDesc desc;
2026 masm->GetCode(&desc);
2027 // Call the function from C++.
2028 int result = FUNCTION_CAST<F0>(buffer)();
2029 CHECK_EQ(0, result);
2030 }
2031
2032
2033 void TestPositiveSmiPowerUp(MacroAssembler* masm, Label* exit, int id, int x) {
2034 ASSERT(x >= 0);
2035 int powers[] = { 0, 1, 2, 3, 8, 16, 24, 31 };
2036 int power_count = 8;
2037 __ movl(rax, Immediate(id));
2038 for (int i = 0; i < power_count; i++) {
2039 int power = powers[i];
2040 intptr_t result = static_cast<intptr_t>(x) << power;
2041 __ Set(r8, result);
2042 __ Move(rcx, Smi::FromInt(x));
2043 __ movq(r11, rcx);
2044 __ PositiveSmiTimesPowerOfTwoToInteger64(rdx, rcx, power);
2045 __ SmiCompare(rdx, r8);
2046 __ j(not_equal, exit);
2047 __ incq(rax);
2048 __ SmiCompare(r11, rcx); // rcx unchanged.
2049 __ j(not_equal, exit);
2050 __ incq(rax);
2051 __ PositiveSmiTimesPowerOfTwoToInteger64(rcx, rcx, power);
2052 __ SmiCompare(rdx, r8);
2053 __ j(not_equal, exit);
2054 __ incq(rax);
2055 }
2056 }
2057
2058
2059 TEST(PositiveSmiTimesPowerOfTwoToInteger64) {
2060 // Allocate an executable page of memory.
2061 size_t actual_size;
2062 byte* buffer =
2063 static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2,
2064 &actual_size,
2065 true));
2066 CHECK(buffer);
2067 HandleScope handles;
2068 MacroAssembler assembler(buffer, actual_size);
2069
2070 MacroAssembler* masm = &assembler;
2071 masm->set_allow_stub_calls(false);
2072 Label exit;
2073
2074 TestPositiveSmiPowerUp(masm, &exit, 0x20, 0);
2075 TestPositiveSmiPowerUp(masm, &exit, 0x40, 1);
2076 TestPositiveSmiPowerUp(masm, &exit, 0x60, 127);
2077 TestPositiveSmiPowerUp(masm, &exit, 0x80, 128);
2078 TestPositiveSmiPowerUp(masm, &exit, 0xA0, 255);
2079 TestPositiveSmiPowerUp(masm, &exit, 0xC0, 256);
2080 TestPositiveSmiPowerUp(masm, &exit, 0x100, 65535);
2081 TestPositiveSmiPowerUp(masm, &exit, 0x120, 65536);
2082 TestPositiveSmiPowerUp(masm, &exit, 0x140, Smi::kMaxValue);
2083
2084 __ xor_(rax, rax); // Success.
2085 __ bind(&exit);
2086 __ ret(0);
2087
2088 CodeDesc desc;
2089 masm->GetCode(&desc);
2090 // Call the function from C++.
2091 int result = FUNCTION_CAST<F0>(buffer)();
2092 CHECK_EQ(0, result);
2093 }
2094
2095
2096 #undef __
OLDNEW
« no previous file with comments | « test/cctest/test-heap.cc ('k') | test/mjsunit/for-in.js » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698