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 "src/v8.h" 31 32 #include "src/base/platform/platform.h" 33 #include "src/factory.h" 34 #include "src/macro-assembler.h" 35 #include "src/serialize.h" 36 #include "test/cctest/cctest.h" 37 38 namespace i = v8::internal; 39 using i::Address; 40 using i::Assembler; 41 using i::CodeDesc; 42 using i::Condition; 43 using i::FUNCTION_CAST; 44 using i::HandleScope; 45 using i::Immediate; 46 using i::Isolate; 47 using i::Label; 48 using i::MacroAssembler; 49 using i::Operand; 50 using i::RelocInfo; 51 using i::Representation; 52 using i::Smi; 53 using i::SmiIndex; 54 using i::byte; 55 using i::carry; 56 using i::greater; 57 using i::greater_equal; 58 using i::kIntSize; 59 using i::kPointerSize; 60 using i::kSmiTagMask; 61 using i::kSmiValueSize; 62 using i::less_equal; 63 using i::negative; 64 using i::not_carry; 65 using i::not_equal; 66 using i::equal; 67 using i::not_zero; 68 using i::positive; 69 using i::r11; 70 using i::r13; 71 using i::r14; 72 using i::r15; 73 using i::r8; 74 using i::r9; 75 using i::rax; 76 using i::rbp; 77 using i::rbx; 78 using i::rcx; 79 using i::rdi; 80 using i::rdx; 81 using i::rsi; 82 using i::rsp; 83 using i::times_pointer_size; 84 85 // Test the x64 assembler by compiling some simple functions into 86 // a buffer and executing them. These tests do not initialize the 87 // V8 library, create a context, or use any V8 objects. 88 // The AMD64 calling convention is used, with the first five arguments 89 // in RSI, RDI, RDX, RCX, R8, and R9, and floating point arguments in 90 // the XMM registers. The return value is in RAX. 91 // This calling convention is used on Linux, with GCC, and on Mac OS, 92 // with GCC. A different convention is used on 64-bit windows. 93 94 typedef int (*F0)(); 95 96 #define __ masm-> 97 98 99 static void EntryCode(MacroAssembler* masm) { 100 // Smi constant register is callee save. 101 __ pushq(i::kSmiConstantRegister); 102 __ pushq(i::kRootRegister); 103 __ InitializeSmiConstantRegister(); 104 __ InitializeRootRegister(); 105 } 106 107 108 static void ExitCode(MacroAssembler* masm) { 109 // Return -1 if kSmiConstantRegister was clobbered during the test. 110 __ Move(rdx, Smi::FromInt(1)); 111 __ cmpq(rdx, i::kSmiConstantRegister); 112 __ movq(rdx, Immediate(-1)); 113 __ cmovq(not_equal, rax, rdx); 114 __ popq(i::kRootRegister); 115 __ popq(i::kSmiConstantRegister); 116 } 117 118 119 TEST(Smi) { 120 // Check that C++ Smi operations work as expected. 121 int64_t test_numbers[] = { 122 0, 1, -1, 127, 128, -128, -129, 255, 256, -256, -257, 123 Smi::kMaxValue, static_cast<int64_t>(Smi::kMaxValue) + 1, 124 Smi::kMinValue, static_cast<int64_t>(Smi::kMinValue) - 1 125 }; 126 int test_number_count = 15; 127 for (int i = 0; i < test_number_count; i++) { 128 int64_t number = test_numbers[i]; 129 bool is_valid = Smi::IsValid(number); 130 bool is_in_range = number >= Smi::kMinValue && number <= Smi::kMaxValue; 131 CHECK_EQ(is_in_range, is_valid); 132 if (is_valid) { 133 Smi* smi_from_intptr = Smi::FromIntptr(number); 134 if (static_cast<int>(number) == number) { // Is a 32-bit int. 135 Smi* smi_from_int = Smi::FromInt(static_cast<int32_t>(number)); 136 CHECK_EQ(smi_from_int, smi_from_intptr); 137 } 138 int64_t smi_value = smi_from_intptr->value(); 139 CHECK_EQ(number, smi_value); 140 } 141 } 142 } 143 144 145 static void TestMoveSmi(MacroAssembler* masm, Label* exit, int id, Smi* value) { 146 __ movl(rax, Immediate(id)); 147 __ Move(rcx, value); 148 __ Set(rdx, reinterpret_cast<intptr_t>(value)); 149 __ cmpq(rcx, rdx); 150 __ j(not_equal, exit); 151 } 152 153 154 // Test that we can move a Smi value literally into a register. 155 TEST(SmiMove) { 156 // Allocate an executable page of memory. 157 size_t actual_size; 158 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 159 Assembler::kMinimalBufferSize, &actual_size, true)); 160 CHECK(buffer); 161 Isolate* isolate = CcTest::i_isolate(); 162 HandleScope handles(isolate); 163 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 164 MacroAssembler* masm = &assembler; // Create a pointer for the __ macro. 165 EntryCode(masm); 166 Label exit; 167 168 TestMoveSmi(masm, &exit, 1, Smi::FromInt(0)); 169 TestMoveSmi(masm, &exit, 2, Smi::FromInt(127)); 170 TestMoveSmi(masm, &exit, 3, Smi::FromInt(128)); 171 TestMoveSmi(masm, &exit, 4, Smi::FromInt(255)); 172 TestMoveSmi(masm, &exit, 5, Smi::FromInt(256)); 173 TestMoveSmi(masm, &exit, 6, Smi::FromInt(Smi::kMaxValue)); 174 TestMoveSmi(masm, &exit, 7, Smi::FromInt(-1)); 175 TestMoveSmi(masm, &exit, 8, Smi::FromInt(-128)); 176 TestMoveSmi(masm, &exit, 9, Smi::FromInt(-129)); 177 TestMoveSmi(masm, &exit, 10, Smi::FromInt(-256)); 178 TestMoveSmi(masm, &exit, 11, Smi::FromInt(-257)); 179 TestMoveSmi(masm, &exit, 12, Smi::FromInt(Smi::kMinValue)); 180 181 __ xorq(rax, rax); // Success. 182 __ bind(&exit); 183 ExitCode(masm); 184 __ ret(0); 185 186 CodeDesc desc; 187 masm->GetCode(&desc); 188 // Call the function from C++. 189 int result = FUNCTION_CAST<F0>(buffer)(); 190 CHECK_EQ(0, result); 191 } 192 193 194 void TestSmiCompare(MacroAssembler* masm, Label* exit, int id, int x, int y) { 195 __ Move(rcx, Smi::FromInt(x)); 196 __ movq(r8, rcx); 197 __ Move(rdx, Smi::FromInt(y)); 198 __ movq(r9, rdx); 199 __ SmiCompare(rcx, rdx); 200 if (x < y) { 201 __ movl(rax, Immediate(id + 1)); 202 __ j(greater_equal, exit); 203 } else if (x > y) { 204 __ movl(rax, Immediate(id + 2)); 205 __ j(less_equal, exit); 206 } else { 207 DCHECK_EQ(x, y); 208 __ movl(rax, Immediate(id + 3)); 209 __ j(not_equal, exit); 210 } 211 __ movl(rax, Immediate(id + 4)); 212 __ cmpq(rcx, r8); 213 __ j(not_equal, exit); 214 __ incq(rax); 215 __ cmpq(rdx, r9); 216 __ j(not_equal, exit); 217 218 if (x != y) { 219 __ SmiCompare(rdx, rcx); 220 if (y < x) { 221 __ movl(rax, Immediate(id + 9)); 222 __ j(greater_equal, exit); 223 } else { 224 DCHECK(y > x); 225 __ movl(rax, Immediate(id + 10)); 226 __ j(less_equal, exit); 227 } 228 } else { 229 __ cmpq(rcx, rcx); 230 __ movl(rax, Immediate(id + 11)); 231 __ j(not_equal, exit); 232 __ incq(rax); 233 __ cmpq(rcx, r8); 234 __ j(not_equal, exit); 235 } 236 } 237 238 239 // Test that we can compare smis for equality (and more). 240 TEST(SmiCompare) { 241 // Allocate an executable page of memory. 242 size_t actual_size; 243 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 244 Assembler::kMinimalBufferSize * 2, &actual_size, true)); 245 CHECK(buffer); 246 Isolate* isolate = CcTest::i_isolate(); 247 HandleScope handles(isolate); 248 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 249 250 MacroAssembler* masm = &assembler; 251 EntryCode(masm); 252 Label exit; 253 254 TestSmiCompare(masm, &exit, 0x10, 0, 0); 255 TestSmiCompare(masm, &exit, 0x20, 0, 1); 256 TestSmiCompare(masm, &exit, 0x30, 1, 0); 257 TestSmiCompare(masm, &exit, 0x40, 1, 1); 258 TestSmiCompare(masm, &exit, 0x50, 0, -1); 259 TestSmiCompare(masm, &exit, 0x60, -1, 0); 260 TestSmiCompare(masm, &exit, 0x70, -1, -1); 261 TestSmiCompare(masm, &exit, 0x80, 0, Smi::kMinValue); 262 TestSmiCompare(masm, &exit, 0x90, Smi::kMinValue, 0); 263 TestSmiCompare(masm, &exit, 0xA0, 0, Smi::kMaxValue); 264 TestSmiCompare(masm, &exit, 0xB0, Smi::kMaxValue, 0); 265 TestSmiCompare(masm, &exit, 0xC0, -1, Smi::kMinValue); 266 TestSmiCompare(masm, &exit, 0xD0, Smi::kMinValue, -1); 267 TestSmiCompare(masm, &exit, 0xE0, -1, Smi::kMaxValue); 268 TestSmiCompare(masm, &exit, 0xF0, Smi::kMaxValue, -1); 269 TestSmiCompare(masm, &exit, 0x100, Smi::kMinValue, Smi::kMinValue); 270 TestSmiCompare(masm, &exit, 0x110, Smi::kMinValue, Smi::kMaxValue); 271 TestSmiCompare(masm, &exit, 0x120, Smi::kMaxValue, Smi::kMinValue); 272 TestSmiCompare(masm, &exit, 0x130, Smi::kMaxValue, Smi::kMaxValue); 273 274 __ xorq(rax, rax); // Success. 275 __ bind(&exit); 276 ExitCode(masm); 277 __ ret(0); 278 279 CodeDesc desc; 280 masm->GetCode(&desc); 281 // Call the function from C++. 282 int result = FUNCTION_CAST<F0>(buffer)(); 283 CHECK_EQ(0, result); 284 } 285 286 287 288 TEST(Integer32ToSmi) { 289 // Allocate an executable page of memory. 290 size_t actual_size; 291 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 292 Assembler::kMinimalBufferSize, &actual_size, true)); 293 CHECK(buffer); 294 Isolate* isolate = CcTest::i_isolate(); 295 HandleScope handles(isolate); 296 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 297 298 MacroAssembler* masm = &assembler; 299 EntryCode(masm); 300 Label exit; 301 302 __ movq(rax, Immediate(1)); // Test number. 303 __ movl(rcx, Immediate(0)); 304 __ Integer32ToSmi(rcx, rcx); 305 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0))); 306 __ cmpq(rcx, rdx); 307 __ j(not_equal, &exit); 308 309 __ movq(rax, Immediate(2)); // Test number. 310 __ movl(rcx, Immediate(1024)); 311 __ Integer32ToSmi(rcx, rcx); 312 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024))); 313 __ cmpq(rcx, rdx); 314 __ j(not_equal, &exit); 315 316 __ movq(rax, Immediate(3)); // Test number. 317 __ movl(rcx, Immediate(-1)); 318 __ Integer32ToSmi(rcx, rcx); 319 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1))); 320 __ cmpq(rcx, rdx); 321 __ j(not_equal, &exit); 322 323 __ movq(rax, Immediate(4)); // Test number. 324 __ movl(rcx, Immediate(Smi::kMaxValue)); 325 __ Integer32ToSmi(rcx, rcx); 326 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue))); 327 __ cmpq(rcx, rdx); 328 __ j(not_equal, &exit); 329 330 __ movq(rax, Immediate(5)); // Test number. 331 __ movl(rcx, Immediate(Smi::kMinValue)); 332 __ Integer32ToSmi(rcx, rcx); 333 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue))); 334 __ cmpq(rcx, rdx); 335 __ j(not_equal, &exit); 336 337 // Different target register. 338 339 __ movq(rax, Immediate(6)); // Test number. 340 __ movl(rcx, Immediate(0)); 341 __ Integer32ToSmi(r8, rcx); 342 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0))); 343 __ cmpq(r8, rdx); 344 __ j(not_equal, &exit); 345 346 __ movq(rax, Immediate(7)); // Test number. 347 __ movl(rcx, Immediate(1024)); 348 __ Integer32ToSmi(r8, rcx); 349 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024))); 350 __ cmpq(r8, rdx); 351 __ j(not_equal, &exit); 352 353 __ movq(rax, Immediate(8)); // Test number. 354 __ movl(rcx, Immediate(-1)); 355 __ Integer32ToSmi(r8, rcx); 356 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1))); 357 __ cmpq(r8, rdx); 358 __ j(not_equal, &exit); 359 360 __ movq(rax, Immediate(9)); // Test number. 361 __ movl(rcx, Immediate(Smi::kMaxValue)); 362 __ Integer32ToSmi(r8, rcx); 363 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue))); 364 __ cmpq(r8, rdx); 365 __ j(not_equal, &exit); 366 367 __ movq(rax, Immediate(10)); // Test number. 368 __ movl(rcx, Immediate(Smi::kMinValue)); 369 __ Integer32ToSmi(r8, rcx); 370 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue))); 371 __ cmpq(r8, rdx); 372 __ j(not_equal, &exit); 373 374 375 __ xorq(rax, rax); // Success. 376 __ bind(&exit); 377 ExitCode(masm); 378 __ ret(0); 379 380 CodeDesc desc; 381 masm->GetCode(&desc); 382 // Call the function from C++. 383 int result = FUNCTION_CAST<F0>(buffer)(); 384 CHECK_EQ(0, result); 385 } 386 387 388 void TestI64PlusConstantToSmi(MacroAssembler* masm, 389 Label* exit, 390 int id, 391 int64_t x, 392 int y) { 393 int64_t result = x + y; 394 DCHECK(Smi::IsValid(result)); 395 __ movl(rax, Immediate(id)); 396 __ Move(r8, Smi::FromInt(static_cast<int>(result))); 397 __ movq(rcx, x); 398 __ movq(r11, rcx); 399 __ Integer64PlusConstantToSmi(rdx, rcx, y); 400 __ cmpq(rdx, r8); 401 __ j(not_equal, exit); 402 403 __ incq(rax); 404 __ cmpq(r11, rcx); 405 __ j(not_equal, exit); 406 407 __ incq(rax); 408 __ Integer64PlusConstantToSmi(rcx, rcx, y); 409 __ cmpq(rcx, r8); 410 __ j(not_equal, exit); 411 } 412 413 414 TEST(Integer64PlusConstantToSmi) { 415 // Allocate an executable page of memory. 416 size_t actual_size; 417 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 418 Assembler::kMinimalBufferSize, &actual_size, true)); 419 CHECK(buffer); 420 Isolate* isolate = CcTest::i_isolate(); 421 HandleScope handles(isolate); 422 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 423 424 MacroAssembler* masm = &assembler; 425 EntryCode(masm); 426 Label exit; 427 428 int64_t twice_max = static_cast<int64_t>(Smi::kMaxValue) * 2; 429 430 TestI64PlusConstantToSmi(masm, &exit, 0x10, 0, 0); 431 TestI64PlusConstantToSmi(masm, &exit, 0x20, 0, 1); 432 TestI64PlusConstantToSmi(masm, &exit, 0x30, 1, 0); 433 TestI64PlusConstantToSmi(masm, &exit, 0x40, Smi::kMaxValue - 5, 5); 434 TestI64PlusConstantToSmi(masm, &exit, 0x50, Smi::kMinValue + 5, 5); 435 TestI64PlusConstantToSmi(masm, &exit, 0x60, twice_max, -Smi::kMaxValue); 436 TestI64PlusConstantToSmi(masm, &exit, 0x70, -twice_max, Smi::kMaxValue); 437 TestI64PlusConstantToSmi(masm, &exit, 0x80, 0, Smi::kMinValue); 438 TestI64PlusConstantToSmi(masm, &exit, 0x90, 0, Smi::kMaxValue); 439 TestI64PlusConstantToSmi(masm, &exit, 0xA0, Smi::kMinValue, 0); 440 TestI64PlusConstantToSmi(masm, &exit, 0xB0, Smi::kMaxValue, 0); 441 TestI64PlusConstantToSmi(masm, &exit, 0xC0, twice_max, Smi::kMinValue); 442 443 __ xorq(rax, rax); // Success. 444 __ bind(&exit); 445 ExitCode(masm); 446 __ ret(0); 447 448 CodeDesc desc; 449 masm->GetCode(&desc); 450 // Call the function from C++. 451 int result = FUNCTION_CAST<F0>(buffer)(); 452 CHECK_EQ(0, result); 453 } 454 455 456 TEST(SmiCheck) { 457 // Allocate an executable page of memory. 458 size_t actual_size; 459 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 460 Assembler::kMinimalBufferSize, &actual_size, true)); 461 CHECK(buffer); 462 Isolate* isolate = CcTest::i_isolate(); 463 HandleScope handles(isolate); 464 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 465 466 MacroAssembler* masm = &assembler; 467 EntryCode(masm); 468 Label exit; 469 Condition cond; 470 471 __ movl(rax, Immediate(1)); // Test number. 472 473 // CheckSmi 474 475 __ movl(rcx, Immediate(0)); 476 __ Integer32ToSmi(rcx, rcx); 477 cond = masm->CheckSmi(rcx); 478 __ j(NegateCondition(cond), &exit); 479 480 __ incq(rax); 481 __ xorq(rcx, Immediate(kSmiTagMask)); 482 cond = masm->CheckSmi(rcx); 483 __ j(cond, &exit); 484 485 __ incq(rax); 486 __ movl(rcx, Immediate(-1)); 487 __ Integer32ToSmi(rcx, rcx); 488 cond = masm->CheckSmi(rcx); 489 __ j(NegateCondition(cond), &exit); 490 491 __ incq(rax); 492 __ xorq(rcx, Immediate(kSmiTagMask)); 493 cond = masm->CheckSmi(rcx); 494 __ j(cond, &exit); 495 496 __ incq(rax); 497 __ movl(rcx, Immediate(Smi::kMaxValue)); 498 __ Integer32ToSmi(rcx, rcx); 499 cond = masm->CheckSmi(rcx); 500 __ j(NegateCondition(cond), &exit); 501 502 __ incq(rax); 503 __ xorq(rcx, Immediate(kSmiTagMask)); 504 cond = masm->CheckSmi(rcx); 505 __ j(cond, &exit); 506 507 __ incq(rax); 508 __ movl(rcx, Immediate(Smi::kMinValue)); 509 __ Integer32ToSmi(rcx, rcx); 510 cond = masm->CheckSmi(rcx); 511 __ j(NegateCondition(cond), &exit); 512 513 __ incq(rax); 514 __ xorq(rcx, Immediate(kSmiTagMask)); 515 cond = masm->CheckSmi(rcx); 516 __ j(cond, &exit); 517 518 // CheckPositiveSmi 519 520 __ incq(rax); 521 __ movl(rcx, Immediate(0)); 522 __ Integer32ToSmi(rcx, rcx); 523 cond = masm->CheckNonNegativeSmi(rcx); 524 __ j(NegateCondition(cond), &exit); 525 526 __ incq(rax); 527 __ xorq(rcx, Immediate(kSmiTagMask)); 528 cond = masm->CheckNonNegativeSmi(rcx); // "zero" non-smi. 529 __ j(cond, &exit); 530 531 __ incq(rax); 532 __ movq(rcx, Immediate(-1)); 533 __ Integer32ToSmi(rcx, rcx); 534 cond = masm->CheckNonNegativeSmi(rcx); // Negative smis are not positive. 535 __ j(cond, &exit); 536 537 __ incq(rax); 538 __ movq(rcx, Immediate(Smi::kMinValue)); 539 __ Integer32ToSmi(rcx, rcx); 540 cond = masm->CheckNonNegativeSmi(rcx); // Most negative smi is not positive. 541 __ j(cond, &exit); 542 543 __ incq(rax); 544 __ xorq(rcx, Immediate(kSmiTagMask)); 545 cond = masm->CheckNonNegativeSmi(rcx); // "Negative" non-smi. 546 __ j(cond, &exit); 547 548 __ incq(rax); 549 __ movq(rcx, Immediate(Smi::kMaxValue)); 550 __ Integer32ToSmi(rcx, rcx); 551 cond = masm->CheckNonNegativeSmi(rcx); // Most positive smi is positive. 552 __ j(NegateCondition(cond), &exit); 553 554 __ incq(rax); 555 __ xorq(rcx, Immediate(kSmiTagMask)); 556 cond = masm->CheckNonNegativeSmi(rcx); // "Positive" non-smi. 557 __ j(cond, &exit); 558 559 // CheckIsMinSmi 560 561 __ incq(rax); 562 __ movq(rcx, Immediate(Smi::kMaxValue)); 563 __ Integer32ToSmi(rcx, rcx); 564 cond = masm->CheckIsMinSmi(rcx); 565 __ j(cond, &exit); 566 567 __ incq(rax); 568 __ movq(rcx, Immediate(0)); 569 __ Integer32ToSmi(rcx, rcx); 570 cond = masm->CheckIsMinSmi(rcx); 571 __ j(cond, &exit); 572 573 __ incq(rax); 574 __ movq(rcx, Immediate(Smi::kMinValue)); 575 __ Integer32ToSmi(rcx, rcx); 576 cond = masm->CheckIsMinSmi(rcx); 577 __ j(NegateCondition(cond), &exit); 578 579 __ incq(rax); 580 __ movq(rcx, Immediate(Smi::kMinValue + 1)); 581 __ Integer32ToSmi(rcx, rcx); 582 cond = masm->CheckIsMinSmi(rcx); 583 __ j(cond, &exit); 584 585 // CheckBothSmi 586 587 __ incq(rax); 588 __ movq(rcx, Immediate(Smi::kMaxValue)); 589 __ Integer32ToSmi(rcx, rcx); 590 __ movq(rdx, Immediate(Smi::kMinValue)); 591 __ Integer32ToSmi(rdx, rdx); 592 cond = masm->CheckBothSmi(rcx, rdx); 593 __ j(NegateCondition(cond), &exit); 594 595 __ incq(rax); 596 __ xorq(rcx, Immediate(kSmiTagMask)); 597 cond = masm->CheckBothSmi(rcx, rdx); 598 __ j(cond, &exit); 599 600 __ incq(rax); 601 __ xorq(rdx, Immediate(kSmiTagMask)); 602 cond = masm->CheckBothSmi(rcx, rdx); 603 __ j(cond, &exit); 604 605 __ incq(rax); 606 __ xorq(rcx, Immediate(kSmiTagMask)); 607 cond = masm->CheckBothSmi(rcx, rdx); 608 __ j(cond, &exit); 609 610 __ incq(rax); 611 cond = masm->CheckBothSmi(rcx, rcx); 612 __ j(NegateCondition(cond), &exit); 613 614 __ incq(rax); 615 cond = masm->CheckBothSmi(rdx, rdx); 616 __ j(cond, &exit); 617 618 // CheckInteger32ValidSmiValue 619 __ incq(rax); 620 __ movq(rcx, Immediate(0)); 621 cond = masm->CheckInteger32ValidSmiValue(rax); 622 __ j(NegateCondition(cond), &exit); 623 624 __ incq(rax); 625 __ movq(rcx, Immediate(-1)); 626 cond = masm->CheckInteger32ValidSmiValue(rax); 627 __ j(NegateCondition(cond), &exit); 628 629 __ incq(rax); 630 __ movq(rcx, Immediate(Smi::kMaxValue)); 631 cond = masm->CheckInteger32ValidSmiValue(rax); 632 __ j(NegateCondition(cond), &exit); 633 634 __ incq(rax); 635 __ movq(rcx, Immediate(Smi::kMinValue)); 636 cond = masm->CheckInteger32ValidSmiValue(rax); 637 __ j(NegateCondition(cond), &exit); 638 639 // Success 640 __ xorq(rax, rax); 641 642 __ bind(&exit); 643 ExitCode(masm); 644 __ ret(0); 645 646 CodeDesc desc; 647 masm->GetCode(&desc); 648 // Call the function from C++. 649 int result = FUNCTION_CAST<F0>(buffer)(); 650 CHECK_EQ(0, result); 651 } 652 653 654 655 void TestSmiNeg(MacroAssembler* masm, Label* exit, int id, int x) { 656 __ Move(rcx, Smi::FromInt(x)); 657 __ movq(r11, rcx); 658 if (x == Smi::kMinValue || x == 0) { 659 // Negation fails. 660 __ movl(rax, Immediate(id + 8)); 661 __ SmiNeg(r9, rcx, exit); 662 663 __ incq(rax); 664 __ cmpq(r11, rcx); 665 __ j(not_equal, exit); 666 667 __ incq(rax); 668 __ SmiNeg(rcx, rcx, exit); 669 670 __ incq(rax); 671 __ cmpq(r11, rcx); 672 __ j(not_equal, exit); 673 } else { 674 Label smi_ok, smi_ok2; 675 int result = -x; 676 __ movl(rax, Immediate(id)); 677 __ Move(r8, Smi::FromInt(result)); 678 679 __ SmiNeg(r9, rcx, &smi_ok); 680 __ jmp(exit); 681 __ bind(&smi_ok); 682 __ incq(rax); 683 __ cmpq(r9, r8); 684 __ j(not_equal, exit); 685 686 __ incq(rax); 687 __ cmpq(r11, rcx); 688 __ j(not_equal, exit); 689 690 __ incq(rax); 691 __ SmiNeg(rcx, rcx, &smi_ok2); 692 __ jmp(exit); 693 __ bind(&smi_ok2); 694 __ incq(rax); 695 __ cmpq(rcx, r8); 696 __ j(not_equal, exit); 697 } 698 } 699 700 701 TEST(SmiNeg) { 702 // Allocate an executable page of memory. 703 size_t actual_size; 704 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 705 Assembler::kMinimalBufferSize, &actual_size, true)); 706 CHECK(buffer); 707 Isolate* isolate = CcTest::i_isolate(); 708 HandleScope handles(isolate); 709 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 710 711 MacroAssembler* masm = &assembler; 712 EntryCode(masm); 713 Label exit; 714 715 TestSmiNeg(masm, &exit, 0x10, 0); 716 TestSmiNeg(masm, &exit, 0x20, 1); 717 TestSmiNeg(masm, &exit, 0x30, -1); 718 TestSmiNeg(masm, &exit, 0x40, 127); 719 TestSmiNeg(masm, &exit, 0x50, 65535); 720 TestSmiNeg(masm, &exit, 0x60, Smi::kMinValue); 721 TestSmiNeg(masm, &exit, 0x70, Smi::kMaxValue); 722 TestSmiNeg(masm, &exit, 0x80, -Smi::kMaxValue); 723 724 __ xorq(rax, rax); // Success. 725 __ bind(&exit); 726 ExitCode(masm); 727 __ ret(0); 728 729 CodeDesc desc; 730 masm->GetCode(&desc); 731 // Call the function from C++. 732 int result = FUNCTION_CAST<F0>(buffer)(); 733 CHECK_EQ(0, result); 734 } 735 736 737 static void SmiAddTest(MacroAssembler* masm, 738 Label* exit, 739 int id, 740 int first, 741 int second) { 742 __ movl(rcx, Immediate(first)); 743 __ Integer32ToSmi(rcx, rcx); 744 __ movl(rdx, Immediate(second)); 745 __ Integer32ToSmi(rdx, rdx); 746 __ movl(r8, Immediate(first + second)); 747 __ Integer32ToSmi(r8, r8); 748 749 __ movl(rax, Immediate(id)); // Test number. 750 __ SmiAdd(r9, rcx, rdx, exit); 751 __ cmpq(r9, r8); 752 __ j(not_equal, exit); 753 754 __ incq(rax); 755 __ SmiAdd(rcx, rcx, rdx, exit); 756 __ cmpq(rcx, r8); 757 __ j(not_equal, exit); 758 759 __ movl(rcx, Immediate(first)); 760 __ Integer32ToSmi(rcx, rcx); 761 762 __ incq(rax); 763 __ SmiAddConstant(r9, rcx, Smi::FromInt(second)); 764 __ cmpq(r9, r8); 765 __ j(not_equal, exit); 766 767 __ SmiAddConstant(rcx, rcx, Smi::FromInt(second)); 768 __ cmpq(rcx, r8); 769 __ j(not_equal, exit); 770 771 __ movl(rcx, Immediate(first)); 772 __ Integer32ToSmi(rcx, rcx); 773 774 i::SmiOperationExecutionMode mode; 775 mode.Add(i::PRESERVE_SOURCE_REGISTER); 776 mode.Add(i::BAILOUT_ON_OVERFLOW); 777 __ incq(rax); 778 __ SmiAddConstant(r9, rcx, Smi::FromInt(second), mode, exit); 779 __ cmpq(r9, r8); 780 __ j(not_equal, exit); 781 782 __ incq(rax); 783 __ SmiAddConstant(rcx, rcx, Smi::FromInt(second), mode, exit); 784 __ cmpq(rcx, r8); 785 __ j(not_equal, exit); 786 787 __ movl(rcx, Immediate(first)); 788 __ Integer32ToSmi(rcx, rcx); 789 790 mode.RemoveAll(); 791 mode.Add(i::PRESERVE_SOURCE_REGISTER); 792 mode.Add(i::BAILOUT_ON_NO_OVERFLOW); 793 Label done; 794 __ incq(rax); 795 __ SmiAddConstant(rcx, rcx, Smi::FromInt(second), mode, &done); 796 __ jmp(exit); 797 __ bind(&done); 798 __ cmpq(rcx, r8); 799 __ j(not_equal, exit); 800 } 801 802 803 static void SmiAddOverflowTest(MacroAssembler* masm, 804 Label* exit, 805 int id, 806 int x) { 807 // Adds a Smi to x so that the addition overflows. 808 DCHECK(x != 0); // Can't overflow by adding a Smi. 809 int y_max = (x > 0) ? (Smi::kMaxValue + 0) : (Smi::kMinValue - x - 1); 810 int y_min = (x > 0) ? (Smi::kMaxValue - x + 1) : (Smi::kMinValue + 0); 811 812 __ movl(rax, Immediate(id)); 813 __ Move(rcx, Smi::FromInt(x)); 814 __ movq(r11, rcx); // Store original Smi value of x in r11. 815 __ Move(rdx, Smi::FromInt(y_min)); 816 { 817 Label overflow_ok; 818 __ SmiAdd(r9, rcx, rdx, &overflow_ok); 819 __ jmp(exit); 820 __ bind(&overflow_ok); 821 __ incq(rax); 822 __ cmpq(rcx, r11); 823 __ j(not_equal, exit); 824 } 825 826 { 827 Label overflow_ok; 828 __ incq(rax); 829 __ SmiAdd(rcx, rcx, rdx, &overflow_ok); 830 __ jmp(exit); 831 __ bind(&overflow_ok); 832 __ incq(rax); 833 __ cmpq(rcx, r11); 834 __ j(not_equal, exit); 835 } 836 837 i::SmiOperationExecutionMode mode; 838 mode.Add(i::PRESERVE_SOURCE_REGISTER); 839 mode.Add(i::BAILOUT_ON_OVERFLOW); 840 __ movq(rcx, r11); 841 { 842 Label overflow_ok; 843 __ incq(rax); 844 __ SmiAddConstant(r9, rcx, Smi::FromInt(y_min), mode, &overflow_ok); 845 __ jmp(exit); 846 __ bind(&overflow_ok); 847 __ incq(rax); 848 __ cmpq(rcx, r11); 849 __ j(not_equal, exit); 850 } 851 852 { 853 Label overflow_ok; 854 __ incq(rax); 855 __ SmiAddConstant(rcx, rcx, Smi::FromInt(y_min), mode, &overflow_ok); 856 __ jmp(exit); 857 __ bind(&overflow_ok); 858 __ incq(rax); 859 __ cmpq(rcx, r11); 860 __ j(not_equal, exit); 861 } 862 863 __ Move(rdx, Smi::FromInt(y_max)); 864 865 { 866 Label overflow_ok; 867 __ incq(rax); 868 __ SmiAdd(r9, rcx, rdx, &overflow_ok); 869 __ jmp(exit); 870 __ bind(&overflow_ok); 871 __ incq(rax); 872 __ cmpq(rcx, r11); 873 __ j(not_equal, exit); 874 } 875 876 { 877 Label overflow_ok; 878 __ incq(rax); 879 __ SmiAdd(rcx, rcx, rdx, &overflow_ok); 880 __ jmp(exit); 881 __ bind(&overflow_ok); 882 __ incq(rax); 883 __ cmpq(rcx, r11); 884 __ j(not_equal, exit); 885 } 886 887 __ movq(rcx, r11); 888 { 889 Label overflow_ok; 890 __ incq(rax); 891 __ SmiAddConstant(r9, rcx, Smi::FromInt(y_max), mode, &overflow_ok); 892 __ jmp(exit); 893 __ bind(&overflow_ok); 894 __ incq(rax); 895 __ cmpq(rcx, r11); 896 __ j(not_equal, exit); 897 } 898 899 mode.RemoveAll(); 900 mode.Add(i::BAILOUT_ON_OVERFLOW); 901 { 902 Label overflow_ok; 903 __ incq(rax); 904 __ SmiAddConstant(rcx, rcx, Smi::FromInt(y_max), mode, &overflow_ok); 905 __ jmp(exit); 906 __ bind(&overflow_ok); 907 __ incq(rax); 908 __ cmpq(rcx, r11); 909 __ j(equal, exit); 910 } 911 } 912 913 914 TEST(SmiAdd) { 915 // Allocate an executable page of memory. 916 size_t actual_size; 917 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 918 Assembler::kMinimalBufferSize * 3, &actual_size, true)); 919 CHECK(buffer); 920 Isolate* isolate = CcTest::i_isolate(); 921 HandleScope handles(isolate); 922 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 923 924 MacroAssembler* masm = &assembler; 925 EntryCode(masm); 926 Label exit; 927 928 // No-overflow tests. 929 SmiAddTest(masm, &exit, 0x10, 1, 2); 930 SmiAddTest(masm, &exit, 0x20, 1, -2); 931 SmiAddTest(masm, &exit, 0x30, -1, 2); 932 SmiAddTest(masm, &exit, 0x40, -1, -2); 933 SmiAddTest(masm, &exit, 0x50, 0x1000, 0x2000); 934 SmiAddTest(masm, &exit, 0x60, Smi::kMinValue, 5); 935 SmiAddTest(masm, &exit, 0x70, Smi::kMaxValue, -5); 936 SmiAddTest(masm, &exit, 0x80, Smi::kMaxValue, Smi::kMinValue); 937 938 SmiAddOverflowTest(masm, &exit, 0x90, -1); 939 SmiAddOverflowTest(masm, &exit, 0xA0, 1); 940 SmiAddOverflowTest(masm, &exit, 0xB0, 1024); 941 SmiAddOverflowTest(masm, &exit, 0xC0, Smi::kMaxValue); 942 SmiAddOverflowTest(masm, &exit, 0xD0, -2); 943 SmiAddOverflowTest(masm, &exit, 0xE0, -42000); 944 SmiAddOverflowTest(masm, &exit, 0xF0, Smi::kMinValue); 945 946 __ xorq(rax, rax); // Success. 947 __ bind(&exit); 948 ExitCode(masm); 949 __ ret(0); 950 951 CodeDesc desc; 952 masm->GetCode(&desc); 953 // Call the function from C++. 954 int result = FUNCTION_CAST<F0>(buffer)(); 955 CHECK_EQ(0, result); 956 } 957 958 959 static void SmiSubTest(MacroAssembler* masm, 960 Label* exit, 961 int id, 962 int first, 963 int second) { 964 __ Move(rcx, Smi::FromInt(first)); 965 __ Move(rdx, Smi::FromInt(second)); 966 __ Move(r8, Smi::FromInt(first - second)); 967 968 __ movl(rax, Immediate(id)); // Test 0. 969 __ SmiSub(r9, rcx, rdx, exit); 970 __ cmpq(r9, r8); 971 __ j(not_equal, exit); 972 973 __ incq(rax); // Test 1. 974 __ SmiSub(rcx, rcx, rdx, exit); 975 __ cmpq(rcx, r8); 976 __ j(not_equal, exit); 977 978 __ Move(rcx, Smi::FromInt(first)); 979 980 __ incq(rax); // Test 2. 981 __ SmiSubConstant(r9, rcx, Smi::FromInt(second)); 982 __ cmpq(r9, r8); 983 __ j(not_equal, exit); 984 985 __ incq(rax); // Test 3. 986 __ SmiSubConstant(rcx, rcx, Smi::FromInt(second)); 987 __ cmpq(rcx, r8); 988 __ j(not_equal, exit); 989 990 i::SmiOperationExecutionMode mode; 991 mode.Add(i::PRESERVE_SOURCE_REGISTER); 992 mode.Add(i::BAILOUT_ON_OVERFLOW); 993 __ Move(rcx, Smi::FromInt(first)); 994 __ incq(rax); // Test 4. 995 __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), mode, exit); 996 __ cmpq(rcx, r8); 997 __ j(not_equal, exit); 998 999 __ Move(rcx, Smi::FromInt(first)); 1000 __ incq(rax); // Test 5. 1001 __ SmiSubConstant(r9, rcx, Smi::FromInt(second), mode, exit); 1002 __ cmpq(r9, r8); 1003 __ j(not_equal, exit); 1004 1005 mode.RemoveAll(); 1006 mode.Add(i::PRESERVE_SOURCE_REGISTER); 1007 mode.Add(i::BAILOUT_ON_NO_OVERFLOW); 1008 __ Move(rcx, Smi::FromInt(first)); 1009 Label done; 1010 __ incq(rax); // Test 6. 1011 __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), mode, &done); 1012 __ jmp(exit); 1013 __ bind(&done); 1014 __ cmpq(rcx, r8); 1015 __ j(not_equal, exit); 1016 } 1017 1018 1019 static void SmiSubOverflowTest(MacroAssembler* masm, 1020 Label* exit, 1021 int id, 1022 int x) { 1023 // Subtracts a Smi from x so that the subtraction overflows. 1024 DCHECK(x != -1); // Can't overflow by subtracting a Smi. 1025 int y_max = (x < 0) ? (Smi::kMaxValue + 0) : (Smi::kMinValue + 0); 1026 int y_min = (x < 0) ? (Smi::kMaxValue + x + 2) : (Smi::kMinValue + x); 1027 1028 __ movl(rax, Immediate(id)); 1029 __ Move(rcx, Smi::FromInt(x)); 1030 __ movq(r11, rcx); // Store original Smi value of x in r11. 1031 __ Move(rdx, Smi::FromInt(y_min)); 1032 { 1033 Label overflow_ok; 1034 __ SmiSub(r9, rcx, rdx, &overflow_ok); 1035 __ jmp(exit); 1036 __ bind(&overflow_ok); 1037 __ incq(rax); 1038 __ cmpq(rcx, r11); 1039 __ j(not_equal, exit); 1040 } 1041 1042 { 1043 Label overflow_ok; 1044 __ incq(rax); 1045 __ SmiSub(rcx, rcx, rdx, &overflow_ok); 1046 __ jmp(exit); 1047 __ bind(&overflow_ok); 1048 __ incq(rax); 1049 __ cmpq(rcx, r11); 1050 __ j(not_equal, exit); 1051 } 1052 1053 i::SmiOperationExecutionMode mode; 1054 mode.Add(i::PRESERVE_SOURCE_REGISTER); 1055 mode.Add(i::BAILOUT_ON_OVERFLOW); 1056 1057 __ movq(rcx, r11); 1058 { 1059 Label overflow_ok; 1060 __ incq(rax); 1061 __ SmiSubConstant(r9, rcx, Smi::FromInt(y_min), mode, &overflow_ok); 1062 __ jmp(exit); 1063 __ bind(&overflow_ok); 1064 __ incq(rax); 1065 __ cmpq(rcx, r11); 1066 __ j(not_equal, exit); 1067 } 1068 1069 { 1070 Label overflow_ok; 1071 __ incq(rax); 1072 __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_min), mode, &overflow_ok); 1073 __ jmp(exit); 1074 __ bind(&overflow_ok); 1075 __ incq(rax); 1076 __ cmpq(rcx, r11); 1077 __ j(not_equal, exit); 1078 } 1079 1080 __ Move(rdx, Smi::FromInt(y_max)); 1081 1082 { 1083 Label overflow_ok; 1084 __ incq(rax); 1085 __ SmiSub(r9, rcx, rdx, &overflow_ok); 1086 __ jmp(exit); 1087 __ bind(&overflow_ok); 1088 __ incq(rax); 1089 __ cmpq(rcx, r11); 1090 __ j(not_equal, exit); 1091 } 1092 1093 { 1094 Label overflow_ok; 1095 __ incq(rax); 1096 __ SmiSub(rcx, rcx, rdx, &overflow_ok); 1097 __ jmp(exit); 1098 __ bind(&overflow_ok); 1099 __ incq(rax); 1100 __ cmpq(rcx, r11); 1101 __ j(not_equal, exit); 1102 } 1103 1104 __ movq(rcx, r11); 1105 { 1106 Label overflow_ok; 1107 __ incq(rax); 1108 __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_max), mode, &overflow_ok); 1109 __ jmp(exit); 1110 __ bind(&overflow_ok); 1111 __ incq(rax); 1112 __ cmpq(rcx, r11); 1113 __ j(not_equal, exit); 1114 } 1115 1116 mode.RemoveAll(); 1117 mode.Add(i::BAILOUT_ON_OVERFLOW); 1118 __ movq(rcx, r11); 1119 { 1120 Label overflow_ok; 1121 __ incq(rax); 1122 __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_max), mode, &overflow_ok); 1123 __ jmp(exit); 1124 __ bind(&overflow_ok); 1125 __ incq(rax); 1126 __ cmpq(rcx, r11); 1127 __ j(equal, exit); 1128 } 1129 } 1130 1131 1132 TEST(SmiSub) { 1133 // Allocate an executable page of memory. 1134 size_t actual_size; 1135 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1136 Assembler::kMinimalBufferSize * 4, &actual_size, true)); 1137 CHECK(buffer); 1138 Isolate* isolate = CcTest::i_isolate(); 1139 HandleScope handles(isolate); 1140 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1141 1142 MacroAssembler* masm = &assembler; 1143 EntryCode(masm); 1144 Label exit; 1145 1146 SmiSubTest(masm, &exit, 0x10, 1, 2); 1147 SmiSubTest(masm, &exit, 0x20, 1, -2); 1148 SmiSubTest(masm, &exit, 0x30, -1, 2); 1149 SmiSubTest(masm, &exit, 0x40, -1, -2); 1150 SmiSubTest(masm, &exit, 0x50, 0x1000, 0x2000); 1151 SmiSubTest(masm, &exit, 0x60, Smi::kMinValue, -5); 1152 SmiSubTest(masm, &exit, 0x70, Smi::kMaxValue, 5); 1153 SmiSubTest(masm, &exit, 0x80, -Smi::kMaxValue, Smi::kMinValue); 1154 SmiSubTest(masm, &exit, 0x90, 0, Smi::kMaxValue); 1155 1156 SmiSubOverflowTest(masm, &exit, 0xA0, 1); 1157 SmiSubOverflowTest(masm, &exit, 0xB0, 1024); 1158 SmiSubOverflowTest(masm, &exit, 0xC0, Smi::kMaxValue); 1159 SmiSubOverflowTest(masm, &exit, 0xD0, -2); 1160 SmiSubOverflowTest(masm, &exit, 0xE0, -42000); 1161 SmiSubOverflowTest(masm, &exit, 0xF0, Smi::kMinValue); 1162 SmiSubOverflowTest(masm, &exit, 0x100, 0); 1163 1164 __ xorq(rax, rax); // Success. 1165 __ bind(&exit); 1166 ExitCode(masm); 1167 __ ret(0); 1168 1169 CodeDesc desc; 1170 masm->GetCode(&desc); 1171 // Call the function from C++. 1172 int result = FUNCTION_CAST<F0>(buffer)(); 1173 CHECK_EQ(0, result); 1174 } 1175 1176 1177 1178 void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) { 1179 int64_t result = static_cast<int64_t>(x) * static_cast<int64_t>(y); 1180 bool negative_zero = (result == 0) && (x < 0 || y < 0); 1181 __ Move(rcx, Smi::FromInt(x)); 1182 __ movq(r11, rcx); 1183 __ Move(rdx, Smi::FromInt(y)); 1184 if (Smi::IsValid(result) && !negative_zero) { 1185 __ movl(rax, Immediate(id)); 1186 __ Move(r8, Smi::FromIntptr(result)); 1187 __ SmiMul(r9, rcx, rdx, exit); 1188 __ incq(rax); 1189 __ cmpq(r11, rcx); 1190 __ j(not_equal, exit); 1191 __ incq(rax); 1192 __ cmpq(r9, r8); 1193 __ j(not_equal, exit); 1194 1195 __ incq(rax); 1196 __ SmiMul(rcx, rcx, rdx, exit); 1197 __ cmpq(rcx, r8); 1198 __ j(not_equal, exit); 1199 } else { 1200 __ movl(rax, Immediate(id + 8)); 1201 Label overflow_ok, overflow_ok2; 1202 __ SmiMul(r9, rcx, rdx, &overflow_ok); 1203 __ jmp(exit); 1204 __ bind(&overflow_ok); 1205 __ incq(rax); 1206 __ cmpq(r11, rcx); 1207 __ j(not_equal, exit); 1208 __ incq(rax); 1209 __ SmiMul(rcx, rcx, rdx, &overflow_ok2); 1210 __ jmp(exit); 1211 __ bind(&overflow_ok2); 1212 // 31-bit version doesn't preserve rcx on failure. 1213 // __ incq(rax); 1214 // __ cmpq(r11, rcx); 1215 // __ j(not_equal, exit); 1216 } 1217 } 1218 1219 1220 TEST(SmiMul) { 1221 // Allocate an executable page of memory. 1222 size_t actual_size; 1223 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1224 Assembler::kMinimalBufferSize, &actual_size, true)); 1225 CHECK(buffer); 1226 Isolate* isolate = CcTest::i_isolate(); 1227 HandleScope handles(isolate); 1228 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1229 1230 MacroAssembler* masm = &assembler; 1231 EntryCode(masm); 1232 Label exit; 1233 1234 TestSmiMul(masm, &exit, 0x10, 0, 0); 1235 TestSmiMul(masm, &exit, 0x20, -1, 0); 1236 TestSmiMul(masm, &exit, 0x30, 0, -1); 1237 TestSmiMul(masm, &exit, 0x40, -1, -1); 1238 TestSmiMul(masm, &exit, 0x50, 0x10000, 0x10000); 1239 TestSmiMul(masm, &exit, 0x60, 0x10000, 0xffff); 1240 TestSmiMul(masm, &exit, 0x70, 0x10000, 0xffff); 1241 TestSmiMul(masm, &exit, 0x80, Smi::kMaxValue, -1); 1242 TestSmiMul(masm, &exit, 0x90, Smi::kMaxValue, -2); 1243 TestSmiMul(masm, &exit, 0xa0, Smi::kMaxValue, 2); 1244 TestSmiMul(masm, &exit, 0xb0, (Smi::kMaxValue / 2), 2); 1245 TestSmiMul(masm, &exit, 0xc0, (Smi::kMaxValue / 2) + 1, 2); 1246 TestSmiMul(masm, &exit, 0xd0, (Smi::kMinValue / 2), 2); 1247 TestSmiMul(masm, &exit, 0xe0, (Smi::kMinValue / 2) - 1, 2); 1248 1249 __ xorq(rax, rax); // Success. 1250 __ bind(&exit); 1251 ExitCode(masm); 1252 __ ret(0); 1253 1254 CodeDesc desc; 1255 masm->GetCode(&desc); 1256 // Call the function from C++. 1257 int result = FUNCTION_CAST<F0>(buffer)(); 1258 CHECK_EQ(0, result); 1259 } 1260 1261 1262 void TestSmiDiv(MacroAssembler* masm, Label* exit, int id, int x, int y) { 1263 bool division_by_zero = (y == 0); 1264 bool negative_zero = (x == 0 && y < 0); 1265 #if V8_TARGET_ARCH_X64 1266 bool overflow = (x == Smi::kMinValue && y < 0); // Safe approx. used. 1267 #else 1268 bool overflow = (x == Smi::kMinValue && y == -1); 1269 #endif 1270 bool fraction = !division_by_zero && !overflow && (x % y != 0); 1271 __ Move(r11, Smi::FromInt(x)); 1272 __ Move(r14, Smi::FromInt(y)); 1273 if (!fraction && !overflow && !negative_zero && !division_by_zero) { 1274 // Division succeeds 1275 __ movq(rcx, r11); 1276 __ movq(r15, Immediate(id)); 1277 int result = x / y; 1278 __ Move(r8, Smi::FromInt(result)); 1279 __ SmiDiv(r9, rcx, r14, exit); 1280 // Might have destroyed rcx and r14. 1281 __ incq(r15); 1282 __ cmpq(r9, r8); 1283 __ j(not_equal, exit); 1284 1285 __ incq(r15); 1286 __ movq(rcx, r11); 1287 __ Move(r14, Smi::FromInt(y)); 1288 __ cmpq(rcx, r11); 1289 __ j(not_equal, exit); 1290 1291 __ incq(r15); 1292 __ SmiDiv(rcx, rcx, r14, exit); 1293 1294 __ incq(r15); 1295 __ cmpq(rcx, r8); 1296 __ j(not_equal, exit); 1297 } else { 1298 // Division fails. 1299 __ movq(r15, Immediate(id + 8)); 1300 1301 Label fail_ok, fail_ok2; 1302 __ movq(rcx, r11); 1303 __ SmiDiv(r9, rcx, r14, &fail_ok); 1304 __ jmp(exit); 1305 __ bind(&fail_ok); 1306 1307 __ incq(r15); 1308 __ cmpq(rcx, r11); 1309 __ j(not_equal, exit); 1310 1311 __ incq(r15); 1312 __ SmiDiv(rcx, rcx, r14, &fail_ok2); 1313 __ jmp(exit); 1314 __ bind(&fail_ok2); 1315 1316 __ incq(r15); 1317 __ cmpq(rcx, r11); 1318 __ j(not_equal, exit); 1319 } 1320 } 1321 1322 1323 TEST(SmiDiv) { 1324 // Allocate an executable page of memory. 1325 size_t actual_size; 1326 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1327 Assembler::kMinimalBufferSize * 2, &actual_size, true)); 1328 CHECK(buffer); 1329 Isolate* isolate = CcTest::i_isolate(); 1330 HandleScope handles(isolate); 1331 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1332 1333 MacroAssembler* masm = &assembler; 1334 EntryCode(masm); 1335 Label exit; 1336 1337 __ pushq(r14); 1338 __ pushq(r15); 1339 TestSmiDiv(masm, &exit, 0x10, 1, 1); 1340 TestSmiDiv(masm, &exit, 0x20, 1, 0); 1341 TestSmiDiv(masm, &exit, 0x30, -1, 0); 1342 TestSmiDiv(masm, &exit, 0x40, 0, 1); 1343 TestSmiDiv(masm, &exit, 0x50, 0, -1); 1344 TestSmiDiv(masm, &exit, 0x60, 4, 2); 1345 TestSmiDiv(masm, &exit, 0x70, -4, 2); 1346 TestSmiDiv(masm, &exit, 0x80, 4, -2); 1347 TestSmiDiv(masm, &exit, 0x90, -4, -2); 1348 TestSmiDiv(masm, &exit, 0xa0, 3, 2); 1349 TestSmiDiv(masm, &exit, 0xb0, 3, 4); 1350 TestSmiDiv(masm, &exit, 0xc0, 1, Smi::kMaxValue); 1351 TestSmiDiv(masm, &exit, 0xd0, -1, Smi::kMaxValue); 1352 TestSmiDiv(masm, &exit, 0xe0, Smi::kMaxValue, 1); 1353 TestSmiDiv(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue); 1354 TestSmiDiv(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue); 1355 TestSmiDiv(masm, &exit, 0x110, Smi::kMaxValue, -1); 1356 TestSmiDiv(masm, &exit, 0x120, Smi::kMinValue, 1); 1357 TestSmiDiv(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue); 1358 TestSmiDiv(masm, &exit, 0x140, Smi::kMinValue, -1); 1359 1360 __ xorq(r15, r15); // Success. 1361 __ bind(&exit); 1362 __ movq(rax, r15); 1363 __ popq(r15); 1364 __ popq(r14); 1365 ExitCode(masm); 1366 __ ret(0); 1367 1368 CodeDesc desc; 1369 masm->GetCode(&desc); 1370 // Call the function from C++. 1371 int result = FUNCTION_CAST<F0>(buffer)(); 1372 CHECK_EQ(0, result); 1373 } 1374 1375 1376 void TestSmiMod(MacroAssembler* masm, Label* exit, int id, int x, int y) { 1377 bool division_by_zero = (y == 0); 1378 bool division_overflow = (x == Smi::kMinValue) && (y == -1); 1379 bool fraction = !division_by_zero && !division_overflow && ((x % y) != 0); 1380 bool negative_zero = (!fraction && x < 0); 1381 __ Move(rcx, Smi::FromInt(x)); 1382 __ movq(r11, rcx); 1383 __ Move(r14, Smi::FromInt(y)); 1384 if (!division_overflow && !negative_zero && !division_by_zero) { 1385 // Modulo succeeds 1386 __ movq(r15, Immediate(id)); 1387 int result = x % y; 1388 __ Move(r8, Smi::FromInt(result)); 1389 __ SmiMod(r9, rcx, r14, exit); 1390 1391 __ incq(r15); 1392 __ cmpq(r9, r8); 1393 __ j(not_equal, exit); 1394 1395 __ incq(r15); 1396 __ cmpq(rcx, r11); 1397 __ j(not_equal, exit); 1398 1399 __ incq(r15); 1400 __ SmiMod(rcx, rcx, r14, exit); 1401 1402 __ incq(r15); 1403 __ cmpq(rcx, r8); 1404 __ j(not_equal, exit); 1405 } else { 1406 // Modulo fails. 1407 __ movq(r15, Immediate(id + 8)); 1408 1409 Label fail_ok, fail_ok2; 1410 __ SmiMod(r9, rcx, r14, &fail_ok); 1411 __ jmp(exit); 1412 __ bind(&fail_ok); 1413 1414 __ incq(r15); 1415 __ cmpq(rcx, r11); 1416 __ j(not_equal, exit); 1417 1418 __ incq(r15); 1419 __ SmiMod(rcx, rcx, r14, &fail_ok2); 1420 __ jmp(exit); 1421 __ bind(&fail_ok2); 1422 1423 __ incq(r15); 1424 __ cmpq(rcx, r11); 1425 __ j(not_equal, exit); 1426 } 1427 } 1428 1429 1430 TEST(SmiMod) { 1431 // Allocate an executable page of memory. 1432 size_t actual_size; 1433 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1434 Assembler::kMinimalBufferSize * 2, &actual_size, true)); 1435 CHECK(buffer); 1436 Isolate* isolate = CcTest::i_isolate(); 1437 HandleScope handles(isolate); 1438 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1439 1440 MacroAssembler* masm = &assembler; 1441 EntryCode(masm); 1442 Label exit; 1443 1444 __ pushq(r14); 1445 __ pushq(r15); 1446 TestSmiMod(masm, &exit, 0x10, 1, 1); 1447 TestSmiMod(masm, &exit, 0x20, 1, 0); 1448 TestSmiMod(masm, &exit, 0x30, -1, 0); 1449 TestSmiMod(masm, &exit, 0x40, 0, 1); 1450 TestSmiMod(masm, &exit, 0x50, 0, -1); 1451 TestSmiMod(masm, &exit, 0x60, 4, 2); 1452 TestSmiMod(masm, &exit, 0x70, -4, 2); 1453 TestSmiMod(masm, &exit, 0x80, 4, -2); 1454 TestSmiMod(masm, &exit, 0x90, -4, -2); 1455 TestSmiMod(masm, &exit, 0xa0, 3, 2); 1456 TestSmiMod(masm, &exit, 0xb0, 3, 4); 1457 TestSmiMod(masm, &exit, 0xc0, 1, Smi::kMaxValue); 1458 TestSmiMod(masm, &exit, 0xd0, -1, Smi::kMaxValue); 1459 TestSmiMod(masm, &exit, 0xe0, Smi::kMaxValue, 1); 1460 TestSmiMod(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue); 1461 TestSmiMod(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue); 1462 TestSmiMod(masm, &exit, 0x110, Smi::kMaxValue, -1); 1463 TestSmiMod(masm, &exit, 0x120, Smi::kMinValue, 1); 1464 TestSmiMod(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue); 1465 TestSmiMod(masm, &exit, 0x140, Smi::kMinValue, -1); 1466 1467 __ xorq(r15, r15); // Success. 1468 __ bind(&exit); 1469 __ movq(rax, r15); 1470 __ popq(r15); 1471 __ popq(r14); 1472 ExitCode(masm); 1473 __ ret(0); 1474 1475 CodeDesc desc; 1476 masm->GetCode(&desc); 1477 // Call the function from C++. 1478 int result = FUNCTION_CAST<F0>(buffer)(); 1479 CHECK_EQ(0, result); 1480 } 1481 1482 1483 void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) { 1484 __ movl(rax, Immediate(id)); 1485 1486 for (int i = 0; i < 8; i++) { 1487 __ Move(rcx, Smi::FromInt(x)); 1488 SmiIndex index = masm->SmiToIndex(rdx, rcx, i); 1489 DCHECK(index.reg.is(rcx) || index.reg.is(rdx)); 1490 __ shlq(index.reg, Immediate(index.scale)); 1491 __ Set(r8, static_cast<intptr_t>(x) << i); 1492 __ cmpq(index.reg, r8); 1493 __ j(not_equal, exit); 1494 __ incq(rax); 1495 __ Move(rcx, Smi::FromInt(x)); 1496 index = masm->SmiToIndex(rcx, rcx, i); 1497 DCHECK(index.reg.is(rcx)); 1498 __ shlq(rcx, Immediate(index.scale)); 1499 __ Set(r8, static_cast<intptr_t>(x) << i); 1500 __ cmpq(rcx, r8); 1501 __ j(not_equal, exit); 1502 __ incq(rax); 1503 1504 __ Move(rcx, Smi::FromInt(x)); 1505 index = masm->SmiToNegativeIndex(rdx, rcx, i); 1506 DCHECK(index.reg.is(rcx) || index.reg.is(rdx)); 1507 __ shlq(index.reg, Immediate(index.scale)); 1508 __ Set(r8, static_cast<intptr_t>(-x) << i); 1509 __ cmpq(index.reg, r8); 1510 __ j(not_equal, exit); 1511 __ incq(rax); 1512 __ Move(rcx, Smi::FromInt(x)); 1513 index = masm->SmiToNegativeIndex(rcx, rcx, i); 1514 DCHECK(index.reg.is(rcx)); 1515 __ shlq(rcx, Immediate(index.scale)); 1516 __ Set(r8, static_cast<intptr_t>(-x) << i); 1517 __ cmpq(rcx, r8); 1518 __ j(not_equal, exit); 1519 __ incq(rax); 1520 } 1521 } 1522 1523 1524 TEST(SmiIndex) { 1525 // Allocate an executable page of memory. 1526 size_t actual_size; 1527 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1528 Assembler::kMinimalBufferSize * 5, &actual_size, true)); 1529 CHECK(buffer); 1530 Isolate* isolate = CcTest::i_isolate(); 1531 HandleScope handles(isolate); 1532 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1533 1534 MacroAssembler* masm = &assembler; 1535 EntryCode(masm); 1536 Label exit; 1537 1538 TestSmiIndex(masm, &exit, 0x10, 0); 1539 TestSmiIndex(masm, &exit, 0x20, 1); 1540 TestSmiIndex(masm, &exit, 0x30, 100); 1541 TestSmiIndex(masm, &exit, 0x40, 1000); 1542 TestSmiIndex(masm, &exit, 0x50, Smi::kMaxValue); 1543 1544 __ xorq(rax, rax); // Success. 1545 __ bind(&exit); 1546 ExitCode(masm); 1547 __ ret(0); 1548 1549 CodeDesc desc; 1550 masm->GetCode(&desc); 1551 // Call the function from C++. 1552 int result = FUNCTION_CAST<F0>(buffer)(); 1553 CHECK_EQ(0, result); 1554 } 1555 1556 1557 void TestSelectNonSmi(MacroAssembler* masm, Label* exit, int id, int x, int y) { 1558 __ movl(rax, Immediate(id)); 1559 __ Move(rcx, Smi::FromInt(x)); 1560 __ Move(rdx, Smi::FromInt(y)); 1561 __ xorq(rdx, Immediate(kSmiTagMask)); 1562 __ SelectNonSmi(r9, rcx, rdx, exit); 1563 1564 __ incq(rax); 1565 __ cmpq(r9, rdx); 1566 __ j(not_equal, exit); 1567 1568 __ incq(rax); 1569 __ Move(rcx, Smi::FromInt(x)); 1570 __ Move(rdx, Smi::FromInt(y)); 1571 __ xorq(rcx, Immediate(kSmiTagMask)); 1572 __ SelectNonSmi(r9, rcx, rdx, exit); 1573 1574 __ incq(rax); 1575 __ cmpq(r9, rcx); 1576 __ j(not_equal, exit); 1577 1578 __ incq(rax); 1579 Label fail_ok; 1580 __ Move(rcx, Smi::FromInt(x)); 1581 __ Move(rdx, Smi::FromInt(y)); 1582 __ xorq(rcx, Immediate(kSmiTagMask)); 1583 __ xorq(rdx, Immediate(kSmiTagMask)); 1584 __ SelectNonSmi(r9, rcx, rdx, &fail_ok); 1585 __ jmp(exit); 1586 __ bind(&fail_ok); 1587 } 1588 1589 1590 TEST(SmiSelectNonSmi) { 1591 // Allocate an executable page of memory. 1592 size_t actual_size; 1593 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1594 Assembler::kMinimalBufferSize * 2, &actual_size, true)); 1595 CHECK(buffer); 1596 Isolate* isolate = CcTest::i_isolate(); 1597 HandleScope handles(isolate); 1598 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1599 1600 MacroAssembler* masm = &assembler; 1601 EntryCode(masm); 1602 Label exit; 1603 1604 TestSelectNonSmi(masm, &exit, 0x10, 0, 0); 1605 TestSelectNonSmi(masm, &exit, 0x20, 0, 1); 1606 TestSelectNonSmi(masm, &exit, 0x30, 1, 0); 1607 TestSelectNonSmi(masm, &exit, 0x40, 0, -1); 1608 TestSelectNonSmi(masm, &exit, 0x50, -1, 0); 1609 TestSelectNonSmi(masm, &exit, 0x60, -1, -1); 1610 TestSelectNonSmi(masm, &exit, 0x70, 1, 1); 1611 TestSelectNonSmi(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue); 1612 TestSelectNonSmi(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue); 1613 1614 __ xorq(rax, rax); // Success. 1615 __ bind(&exit); 1616 ExitCode(masm); 1617 __ ret(0); 1618 1619 CodeDesc desc; 1620 masm->GetCode(&desc); 1621 // Call the function from C++. 1622 int result = FUNCTION_CAST<F0>(buffer)(); 1623 CHECK_EQ(0, result); 1624 } 1625 1626 1627 void TestSmiAnd(MacroAssembler* masm, Label* exit, int id, int x, int y) { 1628 int result = x & y; 1629 1630 __ movl(rax, Immediate(id)); 1631 1632 __ Move(rcx, Smi::FromInt(x)); 1633 __ movq(r11, rcx); 1634 __ Move(rdx, Smi::FromInt(y)); 1635 __ Move(r8, Smi::FromInt(result)); 1636 __ SmiAnd(r9, rcx, rdx); 1637 __ cmpq(r8, r9); 1638 __ j(not_equal, exit); 1639 1640 __ incq(rax); 1641 __ cmpq(r11, rcx); 1642 __ j(not_equal, exit); 1643 1644 __ incq(rax); 1645 __ SmiAnd(rcx, rcx, rdx); 1646 __ cmpq(r8, rcx); 1647 __ j(not_equal, exit); 1648 1649 __ movq(rcx, r11); 1650 __ incq(rax); 1651 __ SmiAndConstant(r9, rcx, Smi::FromInt(y)); 1652 __ cmpq(r8, r9); 1653 __ j(not_equal, exit); 1654 1655 __ incq(rax); 1656 __ cmpq(r11, rcx); 1657 __ j(not_equal, exit); 1658 1659 __ incq(rax); 1660 __ SmiAndConstant(rcx, rcx, Smi::FromInt(y)); 1661 __ cmpq(r8, rcx); 1662 __ j(not_equal, exit); 1663 } 1664 1665 1666 TEST(SmiAnd) { 1667 // Allocate an executable page of memory. 1668 size_t actual_size; 1669 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1670 Assembler::kMinimalBufferSize * 2, &actual_size, true)); 1671 CHECK(buffer); 1672 Isolate* isolate = CcTest::i_isolate(); 1673 HandleScope handles(isolate); 1674 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1675 1676 MacroAssembler* masm = &assembler; 1677 EntryCode(masm); 1678 Label exit; 1679 1680 TestSmiAnd(masm, &exit, 0x10, 0, 0); 1681 TestSmiAnd(masm, &exit, 0x20, 0, 1); 1682 TestSmiAnd(masm, &exit, 0x30, 1, 0); 1683 TestSmiAnd(masm, &exit, 0x40, 0, -1); 1684 TestSmiAnd(masm, &exit, 0x50, -1, 0); 1685 TestSmiAnd(masm, &exit, 0x60, -1, -1); 1686 TestSmiAnd(masm, &exit, 0x70, 1, 1); 1687 TestSmiAnd(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue); 1688 TestSmiAnd(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue); 1689 TestSmiAnd(masm, &exit, 0xA0, Smi::kMinValue, -1); 1690 TestSmiAnd(masm, &exit, 0xB0, Smi::kMinValue, -1); 1691 1692 __ xorq(rax, rax); // Success. 1693 __ bind(&exit); 1694 ExitCode(masm); 1695 __ ret(0); 1696 1697 CodeDesc desc; 1698 masm->GetCode(&desc); 1699 // Call the function from C++. 1700 int result = FUNCTION_CAST<F0>(buffer)(); 1701 CHECK_EQ(0, result); 1702 } 1703 1704 1705 void TestSmiOr(MacroAssembler* masm, Label* exit, int id, int x, int y) { 1706 int result = x | y; 1707 1708 __ movl(rax, Immediate(id)); 1709 1710 __ Move(rcx, Smi::FromInt(x)); 1711 __ movq(r11, rcx); 1712 __ Move(rdx, Smi::FromInt(y)); 1713 __ Move(r8, Smi::FromInt(result)); 1714 __ SmiOr(r9, rcx, rdx); 1715 __ cmpq(r8, r9); 1716 __ j(not_equal, exit); 1717 1718 __ incq(rax); 1719 __ cmpq(r11, rcx); 1720 __ j(not_equal, exit); 1721 1722 __ incq(rax); 1723 __ SmiOr(rcx, rcx, rdx); 1724 __ cmpq(r8, rcx); 1725 __ j(not_equal, exit); 1726 1727 __ movq(rcx, r11); 1728 __ incq(rax); 1729 __ SmiOrConstant(r9, rcx, Smi::FromInt(y)); 1730 __ cmpq(r8, r9); 1731 __ j(not_equal, exit); 1732 1733 __ incq(rax); 1734 __ cmpq(r11, rcx); 1735 __ j(not_equal, exit); 1736 1737 __ incq(rax); 1738 __ SmiOrConstant(rcx, rcx, Smi::FromInt(y)); 1739 __ cmpq(r8, rcx); 1740 __ j(not_equal, exit); 1741 } 1742 1743 1744 TEST(SmiOr) { 1745 // Allocate an executable page of memory. 1746 size_t actual_size; 1747 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1748 Assembler::kMinimalBufferSize * 2, &actual_size, true)); 1749 CHECK(buffer); 1750 Isolate* isolate = CcTest::i_isolate(); 1751 HandleScope handles(isolate); 1752 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1753 1754 MacroAssembler* masm = &assembler; 1755 EntryCode(masm); 1756 Label exit; 1757 1758 TestSmiOr(masm, &exit, 0x10, 0, 0); 1759 TestSmiOr(masm, &exit, 0x20, 0, 1); 1760 TestSmiOr(masm, &exit, 0x30, 1, 0); 1761 TestSmiOr(masm, &exit, 0x40, 0, -1); 1762 TestSmiOr(masm, &exit, 0x50, -1, 0); 1763 TestSmiOr(masm, &exit, 0x60, -1, -1); 1764 TestSmiOr(masm, &exit, 0x70, 1, 1); 1765 TestSmiOr(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue); 1766 TestSmiOr(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue); 1767 TestSmiOr(masm, &exit, 0xA0, Smi::kMinValue, -1); 1768 TestSmiOr(masm, &exit, 0xB0, 0x05555555, 0x01234567); 1769 TestSmiOr(masm, &exit, 0xC0, 0x05555555, 0x0fedcba9); 1770 TestSmiOr(masm, &exit, 0xD0, Smi::kMinValue, -1); 1771 1772 __ xorq(rax, rax); // Success. 1773 __ bind(&exit); 1774 ExitCode(masm); 1775 __ ret(0); 1776 1777 CodeDesc desc; 1778 masm->GetCode(&desc); 1779 // Call the function from C++. 1780 int result = FUNCTION_CAST<F0>(buffer)(); 1781 CHECK_EQ(0, result); 1782 } 1783 1784 1785 void TestSmiXor(MacroAssembler* masm, Label* exit, int id, int x, int y) { 1786 int result = x ^ y; 1787 1788 __ movl(rax, Immediate(id)); 1789 1790 __ Move(rcx, Smi::FromInt(x)); 1791 __ movq(r11, rcx); 1792 __ Move(rdx, Smi::FromInt(y)); 1793 __ Move(r8, Smi::FromInt(result)); 1794 __ SmiXor(r9, rcx, rdx); 1795 __ cmpq(r8, r9); 1796 __ j(not_equal, exit); 1797 1798 __ incq(rax); 1799 __ cmpq(r11, rcx); 1800 __ j(not_equal, exit); 1801 1802 __ incq(rax); 1803 __ SmiXor(rcx, rcx, rdx); 1804 __ cmpq(r8, rcx); 1805 __ j(not_equal, exit); 1806 1807 __ movq(rcx, r11); 1808 __ incq(rax); 1809 __ SmiXorConstant(r9, rcx, Smi::FromInt(y)); 1810 __ cmpq(r8, r9); 1811 __ j(not_equal, exit); 1812 1813 __ incq(rax); 1814 __ cmpq(r11, rcx); 1815 __ j(not_equal, exit); 1816 1817 __ incq(rax); 1818 __ SmiXorConstant(rcx, rcx, Smi::FromInt(y)); 1819 __ cmpq(r8, rcx); 1820 __ j(not_equal, exit); 1821 } 1822 1823 1824 TEST(SmiXor) { 1825 // Allocate an executable page of memory. 1826 size_t actual_size; 1827 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1828 Assembler::kMinimalBufferSize * 2, &actual_size, true)); 1829 CHECK(buffer); 1830 Isolate* isolate = CcTest::i_isolate(); 1831 HandleScope handles(isolate); 1832 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1833 1834 MacroAssembler* masm = &assembler; 1835 EntryCode(masm); 1836 Label exit; 1837 1838 TestSmiXor(masm, &exit, 0x10, 0, 0); 1839 TestSmiXor(masm, &exit, 0x20, 0, 1); 1840 TestSmiXor(masm, &exit, 0x30, 1, 0); 1841 TestSmiXor(masm, &exit, 0x40, 0, -1); 1842 TestSmiXor(masm, &exit, 0x50, -1, 0); 1843 TestSmiXor(masm, &exit, 0x60, -1, -1); 1844 TestSmiXor(masm, &exit, 0x70, 1, 1); 1845 TestSmiXor(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue); 1846 TestSmiXor(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue); 1847 TestSmiXor(masm, &exit, 0xA0, Smi::kMinValue, -1); 1848 TestSmiXor(masm, &exit, 0xB0, 0x5555555, 0x01234567); 1849 TestSmiXor(masm, &exit, 0xC0, 0x5555555, 0x0fedcba9); 1850 TestSmiXor(masm, &exit, 0xD0, Smi::kMinValue, -1); 1851 1852 __ xorq(rax, rax); // Success. 1853 __ bind(&exit); 1854 ExitCode(masm); 1855 __ ret(0); 1856 1857 CodeDesc desc; 1858 masm->GetCode(&desc); 1859 // Call the function from C++. 1860 int result = FUNCTION_CAST<F0>(buffer)(); 1861 CHECK_EQ(0, result); 1862 } 1863 1864 1865 void TestSmiNot(MacroAssembler* masm, Label* exit, int id, int x) { 1866 int result = ~x; 1867 __ movl(rax, Immediate(id)); 1868 1869 __ Move(r8, Smi::FromInt(result)); 1870 __ Move(rcx, Smi::FromInt(x)); 1871 __ movq(r11, rcx); 1872 1873 __ SmiNot(r9, rcx); 1874 __ cmpq(r9, r8); 1875 __ j(not_equal, exit); 1876 1877 __ incq(rax); 1878 __ cmpq(r11, rcx); 1879 __ j(not_equal, exit); 1880 1881 __ incq(rax); 1882 __ SmiNot(rcx, rcx); 1883 __ cmpq(rcx, r8); 1884 __ j(not_equal, exit); 1885 } 1886 1887 1888 TEST(SmiNot) { 1889 // Allocate an executable page of memory. 1890 size_t actual_size; 1891 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1892 Assembler::kMinimalBufferSize, &actual_size, true)); 1893 CHECK(buffer); 1894 Isolate* isolate = CcTest::i_isolate(); 1895 HandleScope handles(isolate); 1896 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1897 1898 MacroAssembler* masm = &assembler; 1899 EntryCode(masm); 1900 Label exit; 1901 1902 TestSmiNot(masm, &exit, 0x10, 0); 1903 TestSmiNot(masm, &exit, 0x20, 1); 1904 TestSmiNot(masm, &exit, 0x30, -1); 1905 TestSmiNot(masm, &exit, 0x40, 127); 1906 TestSmiNot(masm, &exit, 0x50, 65535); 1907 TestSmiNot(masm, &exit, 0x60, Smi::kMinValue); 1908 TestSmiNot(masm, &exit, 0x70, Smi::kMaxValue); 1909 TestSmiNot(masm, &exit, 0x80, 0x05555555); 1910 1911 __ xorq(rax, rax); // Success. 1912 __ bind(&exit); 1913 ExitCode(masm); 1914 __ ret(0); 1915 1916 CodeDesc desc; 1917 masm->GetCode(&desc); 1918 // Call the function from C++. 1919 int result = FUNCTION_CAST<F0>(buffer)(); 1920 CHECK_EQ(0, result); 1921 } 1922 1923 1924 void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) { 1925 const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1}; 1926 const int kNumShifts = 5; 1927 __ movl(rax, Immediate(id)); 1928 for (int i = 0; i < kNumShifts; i++) { 1929 // rax == id + i * 10. 1930 int shift = shifts[i]; 1931 int result = x << shift; 1932 CHECK(Smi::IsValid(result)); 1933 __ Move(r8, Smi::FromInt(result)); 1934 __ Move(rcx, Smi::FromInt(x)); 1935 __ SmiShiftLeftConstant(r9, rcx, shift); 1936 1937 __ incq(rax); 1938 __ cmpq(r9, r8); 1939 __ j(not_equal, exit); 1940 1941 __ incq(rax); 1942 __ Move(rcx, Smi::FromInt(x)); 1943 __ SmiShiftLeftConstant(rcx, rcx, shift); 1944 1945 __ incq(rax); 1946 __ cmpq(rcx, r8); 1947 __ j(not_equal, exit); 1948 1949 __ incq(rax); 1950 __ Move(rdx, Smi::FromInt(x)); 1951 __ Move(rcx, Smi::FromInt(shift)); 1952 __ SmiShiftLeft(r9, rdx, rcx); 1953 1954 __ incq(rax); 1955 __ cmpq(r9, r8); 1956 __ j(not_equal, exit); 1957 1958 __ incq(rax); 1959 __ Move(rdx, Smi::FromInt(x)); 1960 __ Move(r11, Smi::FromInt(shift)); 1961 __ SmiShiftLeft(r9, rdx, r11); 1962 1963 __ incq(rax); 1964 __ cmpq(r9, r8); 1965 __ j(not_equal, exit); 1966 1967 __ incq(rax); 1968 __ Move(rdx, Smi::FromInt(x)); 1969 __ Move(r11, Smi::FromInt(shift)); 1970 __ SmiShiftLeft(rdx, rdx, r11); 1971 1972 __ incq(rax); 1973 __ cmpq(rdx, r8); 1974 __ j(not_equal, exit); 1975 1976 __ incq(rax); 1977 } 1978 } 1979 1980 1981 TEST(SmiShiftLeft) { 1982 // Allocate an executable page of memory. 1983 size_t actual_size; 1984 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 1985 Assembler::kMinimalBufferSize * 7, &actual_size, true)); 1986 CHECK(buffer); 1987 Isolate* isolate = CcTest::i_isolate(); 1988 HandleScope handles(isolate); 1989 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 1990 1991 MacroAssembler* masm = &assembler; 1992 EntryCode(masm); 1993 Label exit; 1994 1995 TestSmiShiftLeft(masm, &exit, 0x10, 0); 1996 TestSmiShiftLeft(masm, &exit, 0x50, 1); 1997 TestSmiShiftLeft(masm, &exit, 0x90, 127); 1998 TestSmiShiftLeft(masm, &exit, 0xD0, 65535); 1999 TestSmiShiftLeft(masm, &exit, 0x110, Smi::kMaxValue); 2000 TestSmiShiftLeft(masm, &exit, 0x150, Smi::kMinValue); 2001 TestSmiShiftLeft(masm, &exit, 0x190, -1); 2002 2003 __ xorq(rax, rax); // Success. 2004 __ bind(&exit); 2005 ExitCode(masm); 2006 __ ret(0); 2007 2008 CodeDesc desc; 2009 masm->GetCode(&desc); 2010 // Call the function from C++. 2011 int result = FUNCTION_CAST<F0>(buffer)(); 2012 CHECK_EQ(0, result); 2013 } 2014 2015 2016 void TestSmiShiftLogicalRight(MacroAssembler* masm, 2017 Label* exit, 2018 int id, 2019 int x) { 2020 const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1}; 2021 const int kNumShifts = 5; 2022 __ movl(rax, Immediate(id)); 2023 for (int i = 0; i < kNumShifts; i++) { 2024 int shift = shifts[i]; 2025 intptr_t result = static_cast<unsigned int>(x) >> shift; 2026 if (Smi::IsValid(result)) { 2027 __ Move(r8, Smi::FromInt(static_cast<int>(result))); 2028 __ Move(rcx, Smi::FromInt(x)); 2029 __ SmiShiftLogicalRightConstant(r9, rcx, shift, exit); 2030 2031 __ incq(rax); 2032 __ cmpq(r9, r8); 2033 __ j(not_equal, exit); 2034 2035 __ incq(rax); 2036 __ Move(rdx, Smi::FromInt(x)); 2037 __ Move(rcx, Smi::FromInt(shift)); 2038 __ SmiShiftLogicalRight(r9, rdx, rcx, exit); 2039 2040 __ incq(rax); 2041 __ cmpq(r9, r8); 2042 __ j(not_equal, exit); 2043 2044 __ incq(rax); 2045 __ Move(rdx, Smi::FromInt(x)); 2046 __ Move(r11, Smi::FromInt(shift)); 2047 __ SmiShiftLogicalRight(r9, rdx, r11, exit); 2048 2049 __ incq(rax); 2050 __ cmpq(r9, r8); 2051 __ j(not_equal, exit); 2052 2053 __ incq(rax); 2054 } else { 2055 // Cannot happen with long smis. 2056 Label fail_ok; 2057 __ Move(rcx, Smi::FromInt(x)); 2058 __ movq(r11, rcx); 2059 __ SmiShiftLogicalRightConstant(r9, rcx, shift, &fail_ok); 2060 __ jmp(exit); 2061 __ bind(&fail_ok); 2062 2063 __ incq(rax); 2064 __ cmpq(rcx, r11); 2065 __ j(not_equal, exit); 2066 2067 __ incq(rax); 2068 __ Move(r8, Smi::FromInt(shift)); 2069 Label fail_ok3; 2070 __ SmiShiftLogicalRight(r9, rcx, r8, &fail_ok3); 2071 __ jmp(exit); 2072 __ bind(&fail_ok3); 2073 2074 __ incq(rax); 2075 __ cmpq(rcx, r11); 2076 __ j(not_equal, exit); 2077 2078 __ addq(rax, Immediate(3)); 2079 } 2080 } 2081 } 2082 2083 2084 TEST(SmiShiftLogicalRight) { 2085 // Allocate an executable page of memory. 2086 size_t actual_size; 2087 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 2088 Assembler::kMinimalBufferSize * 5, &actual_size, true)); 2089 CHECK(buffer); 2090 Isolate* isolate = CcTest::i_isolate(); 2091 HandleScope handles(isolate); 2092 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 2093 2094 MacroAssembler* masm = &assembler; 2095 EntryCode(masm); 2096 Label exit; 2097 2098 TestSmiShiftLogicalRight(masm, &exit, 0x10, 0); 2099 TestSmiShiftLogicalRight(masm, &exit, 0x30, 1); 2100 TestSmiShiftLogicalRight(masm, &exit, 0x50, 127); 2101 TestSmiShiftLogicalRight(masm, &exit, 0x70, 65535); 2102 TestSmiShiftLogicalRight(masm, &exit, 0x90, Smi::kMaxValue); 2103 TestSmiShiftLogicalRight(masm, &exit, 0xB0, Smi::kMinValue); 2104 TestSmiShiftLogicalRight(masm, &exit, 0xD0, -1); 2105 2106 __ xorq(rax, rax); // Success. 2107 __ bind(&exit); 2108 ExitCode(masm); 2109 __ ret(0); 2110 2111 CodeDesc desc; 2112 masm->GetCode(&desc); 2113 // Call the function from C++. 2114 int result = FUNCTION_CAST<F0>(buffer)(); 2115 CHECK_EQ(0, result); 2116 } 2117 2118 2119 void TestSmiShiftArithmeticRight(MacroAssembler* masm, 2120 Label* exit, 2121 int id, 2122 int x) { 2123 const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1}; 2124 const int kNumShifts = 5; 2125 __ movl(rax, Immediate(id)); 2126 for (int i = 0; i < kNumShifts; i++) { 2127 int shift = shifts[i]; 2128 // Guaranteed arithmetic shift. 2129 int result = (x < 0) ? ~((~x) >> shift) : (x >> shift); 2130 __ Move(r8, Smi::FromInt(result)); 2131 __ Move(rcx, Smi::FromInt(x)); 2132 __ SmiShiftArithmeticRightConstant(rcx, rcx, shift); 2133 2134 __ cmpq(rcx, r8); 2135 __ j(not_equal, exit); 2136 2137 __ incq(rax); 2138 __ Move(rdx, Smi::FromInt(x)); 2139 __ Move(r11, Smi::FromInt(shift)); 2140 __ SmiShiftArithmeticRight(rdx, rdx, r11); 2141 2142 __ cmpq(rdx, r8); 2143 __ j(not_equal, exit); 2144 2145 __ incq(rax); 2146 } 2147 } 2148 2149 2150 TEST(SmiShiftArithmeticRight) { 2151 // Allocate an executable page of memory. 2152 size_t actual_size; 2153 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 2154 Assembler::kMinimalBufferSize * 3, &actual_size, true)); 2155 CHECK(buffer); 2156 Isolate* isolate = CcTest::i_isolate(); 2157 HandleScope handles(isolate); 2158 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 2159 2160 MacroAssembler* masm = &assembler; 2161 EntryCode(masm); 2162 Label exit; 2163 2164 TestSmiShiftArithmeticRight(masm, &exit, 0x10, 0); 2165 TestSmiShiftArithmeticRight(masm, &exit, 0x20, 1); 2166 TestSmiShiftArithmeticRight(masm, &exit, 0x30, 127); 2167 TestSmiShiftArithmeticRight(masm, &exit, 0x40, 65535); 2168 TestSmiShiftArithmeticRight(masm, &exit, 0x50, Smi::kMaxValue); 2169 TestSmiShiftArithmeticRight(masm, &exit, 0x60, Smi::kMinValue); 2170 TestSmiShiftArithmeticRight(masm, &exit, 0x70, -1); 2171 2172 __ xorq(rax, rax); // Success. 2173 __ bind(&exit); 2174 ExitCode(masm); 2175 __ ret(0); 2176 2177 CodeDesc desc; 2178 masm->GetCode(&desc); 2179 // Call the function from C++. 2180 int result = FUNCTION_CAST<F0>(buffer)(); 2181 CHECK_EQ(0, result); 2182 } 2183 2184 2185 void TestPositiveSmiPowerUp(MacroAssembler* masm, Label* exit, int id, int x) { 2186 DCHECK(x >= 0); 2187 int powers[] = { 0, 1, 2, 3, 8, 16, 24, 31 }; 2188 int power_count = 8; 2189 __ movl(rax, Immediate(id)); 2190 for (int i = 0; i < power_count; i++) { 2191 int power = powers[i]; 2192 intptr_t result = static_cast<intptr_t>(x) << power; 2193 __ Set(r8, result); 2194 __ Move(rcx, Smi::FromInt(x)); 2195 __ movq(r11, rcx); 2196 __ PositiveSmiTimesPowerOfTwoToInteger64(rdx, rcx, power); 2197 __ cmpq(rdx, r8); 2198 __ j(not_equal, exit); 2199 __ incq(rax); 2200 __ cmpq(r11, rcx); // rcx unchanged. 2201 __ j(not_equal, exit); 2202 __ incq(rax); 2203 __ PositiveSmiTimesPowerOfTwoToInteger64(rcx, rcx, power); 2204 __ cmpq(rdx, r8); 2205 __ j(not_equal, exit); 2206 __ incq(rax); 2207 } 2208 } 2209 2210 2211 TEST(PositiveSmiTimesPowerOfTwoToInteger64) { 2212 // Allocate an executable page of memory. 2213 size_t actual_size; 2214 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 2215 Assembler::kMinimalBufferSize * 4, &actual_size, true)); 2216 CHECK(buffer); 2217 Isolate* isolate = CcTest::i_isolate(); 2218 HandleScope handles(isolate); 2219 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 2220 2221 MacroAssembler* masm = &assembler; 2222 EntryCode(masm); 2223 Label exit; 2224 2225 TestPositiveSmiPowerUp(masm, &exit, 0x20, 0); 2226 TestPositiveSmiPowerUp(masm, &exit, 0x40, 1); 2227 TestPositiveSmiPowerUp(masm, &exit, 0x60, 127); 2228 TestPositiveSmiPowerUp(masm, &exit, 0x80, 128); 2229 TestPositiveSmiPowerUp(masm, &exit, 0xA0, 255); 2230 TestPositiveSmiPowerUp(masm, &exit, 0xC0, 256); 2231 TestPositiveSmiPowerUp(masm, &exit, 0x100, 65535); 2232 TestPositiveSmiPowerUp(masm, &exit, 0x120, 65536); 2233 TestPositiveSmiPowerUp(masm, &exit, 0x140, Smi::kMaxValue); 2234 2235 __ xorq(rax, rax); // Success. 2236 __ bind(&exit); 2237 ExitCode(masm); 2238 __ ret(0); 2239 2240 CodeDesc desc; 2241 masm->GetCode(&desc); 2242 // Call the function from C++. 2243 int result = FUNCTION_CAST<F0>(buffer)(); 2244 CHECK_EQ(0, result); 2245 } 2246 2247 2248 TEST(OperandOffset) { 2249 uint32_t data[256]; 2250 for (uint32_t i = 0; i < 256; i++) { data[i] = i * 0x01010101; } 2251 2252 // Allocate an executable page of memory. 2253 size_t actual_size; 2254 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 2255 Assembler::kMinimalBufferSize * 2, &actual_size, true)); 2256 CHECK(buffer); 2257 Isolate* isolate = CcTest::i_isolate(); 2258 HandleScope handles(isolate); 2259 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 2260 2261 MacroAssembler* masm = &assembler; 2262 Label exit; 2263 2264 EntryCode(masm); 2265 __ pushq(r13); 2266 __ pushq(r14); 2267 __ pushq(rbx); 2268 __ pushq(rbp); 2269 __ pushq(Immediate(0x100)); // <-- rbp 2270 __ movq(rbp, rsp); 2271 __ pushq(Immediate(0x101)); 2272 __ pushq(Immediate(0x102)); 2273 __ pushq(Immediate(0x103)); 2274 __ pushq(Immediate(0x104)); 2275 __ pushq(Immediate(0x105)); // <-- rbx 2276 __ pushq(Immediate(0x106)); 2277 __ pushq(Immediate(0x107)); 2278 __ pushq(Immediate(0x108)); 2279 __ pushq(Immediate(0x109)); // <-- rsp 2280 // rbp = rsp[9] 2281 // r15 = rsp[3] 2282 // rbx = rsp[5] 2283 // r13 = rsp[7] 2284 __ leaq(r14, Operand(rsp, 3 * kPointerSize)); 2285 __ leaq(r13, Operand(rbp, -3 * kPointerSize)); 2286 __ leaq(rbx, Operand(rbp, -5 * kPointerSize)); 2287 __ movl(rcx, Immediate(2)); 2288 __ Move(r8, reinterpret_cast<Address>(&data[128]), RelocInfo::NONE64); 2289 __ movl(rax, Immediate(1)); 2290 2291 Operand sp0 = Operand(rsp, 0); 2292 2293 // Test 1. 2294 __ movl(rdx, sp0); // Sanity check. 2295 __ cmpl(rdx, Immediate(0x109)); 2296 __ j(not_equal, &exit); 2297 __ incq(rax); 2298 2299 // Test 2. 2300 // Zero to non-zero displacement. 2301 __ movl(rdx, Operand(sp0, 2 * kPointerSize)); 2302 __ cmpl(rdx, Immediate(0x107)); 2303 __ j(not_equal, &exit); 2304 __ incq(rax); 2305 2306 Operand sp2 = Operand(rsp, 2 * kPointerSize); 2307 2308 // Test 3. 2309 __ movl(rdx, sp2); // Sanity check. 2310 __ cmpl(rdx, Immediate(0x107)); 2311 __ j(not_equal, &exit); 2312 __ incq(rax); 2313 2314 __ movl(rdx, Operand(sp2, 2 * kPointerSize)); 2315 __ cmpl(rdx, Immediate(0x105)); 2316 __ j(not_equal, &exit); 2317 __ incq(rax); 2318 2319 // Non-zero to zero displacement. 2320 __ movl(rdx, Operand(sp2, -2 * kPointerSize)); 2321 __ cmpl(rdx, Immediate(0x109)); 2322 __ j(not_equal, &exit); 2323 __ incq(rax); 2324 2325 Operand sp2c2 = Operand(rsp, rcx, times_pointer_size, 2 * kPointerSize); 2326 2327 // Test 6. 2328 __ movl(rdx, sp2c2); // Sanity check. 2329 __ cmpl(rdx, Immediate(0x105)); 2330 __ j(not_equal, &exit); 2331 __ incq(rax); 2332 2333 __ movl(rdx, Operand(sp2c2, 2 * kPointerSize)); 2334 __ cmpl(rdx, Immediate(0x103)); 2335 __ j(not_equal, &exit); 2336 __ incq(rax); 2337 2338 // Non-zero to zero displacement. 2339 __ movl(rdx, Operand(sp2c2, -2 * kPointerSize)); 2340 __ cmpl(rdx, Immediate(0x107)); 2341 __ j(not_equal, &exit); 2342 __ incq(rax); 2343 2344 2345 Operand bp0 = Operand(rbp, 0); 2346 2347 // Test 9. 2348 __ movl(rdx, bp0); // Sanity check. 2349 __ cmpl(rdx, Immediate(0x100)); 2350 __ j(not_equal, &exit); 2351 __ incq(rax); 2352 2353 // Zero to non-zero displacement. 2354 __ movl(rdx, Operand(bp0, -2 * kPointerSize)); 2355 __ cmpl(rdx, Immediate(0x102)); 2356 __ j(not_equal, &exit); 2357 __ incq(rax); 2358 2359 Operand bp2 = Operand(rbp, -2 * kPointerSize); 2360 2361 // Test 11. 2362 __ movl(rdx, bp2); // Sanity check. 2363 __ cmpl(rdx, Immediate(0x102)); 2364 __ j(not_equal, &exit); 2365 __ incq(rax); 2366 2367 // Non-zero to zero displacement. 2368 __ movl(rdx, Operand(bp2, 2 * kPointerSize)); 2369 __ cmpl(rdx, Immediate(0x100)); 2370 __ j(not_equal, &exit); 2371 __ incq(rax); 2372 2373 __ movl(rdx, Operand(bp2, -2 * kPointerSize)); 2374 __ cmpl(rdx, Immediate(0x104)); 2375 __ j(not_equal, &exit); 2376 __ incq(rax); 2377 2378 Operand bp2c4 = Operand(rbp, rcx, times_pointer_size, -4 * kPointerSize); 2379 2380 // Test 14: 2381 __ movl(rdx, bp2c4); // Sanity check. 2382 __ cmpl(rdx, Immediate(0x102)); 2383 __ j(not_equal, &exit); 2384 __ incq(rax); 2385 2386 __ movl(rdx, Operand(bp2c4, 2 * kPointerSize)); 2387 __ cmpl(rdx, Immediate(0x100)); 2388 __ j(not_equal, &exit); 2389 __ incq(rax); 2390 2391 __ movl(rdx, Operand(bp2c4, -2 * kPointerSize)); 2392 __ cmpl(rdx, Immediate(0x104)); 2393 __ j(not_equal, &exit); 2394 __ incq(rax); 2395 2396 Operand bx0 = Operand(rbx, 0); 2397 2398 // Test 17. 2399 __ movl(rdx, bx0); // Sanity check. 2400 __ cmpl(rdx, Immediate(0x105)); 2401 __ j(not_equal, &exit); 2402 __ incq(rax); 2403 2404 __ movl(rdx, Operand(bx0, 5 * kPointerSize)); 2405 __ cmpl(rdx, Immediate(0x100)); 2406 __ j(not_equal, &exit); 2407 __ incq(rax); 2408 2409 __ movl(rdx, Operand(bx0, -4 * kPointerSize)); 2410 __ cmpl(rdx, Immediate(0x109)); 2411 __ j(not_equal, &exit); 2412 __ incq(rax); 2413 2414 Operand bx2 = Operand(rbx, 2 * kPointerSize); 2415 2416 // Test 20. 2417 __ movl(rdx, bx2); // Sanity check. 2418 __ cmpl(rdx, Immediate(0x103)); 2419 __ j(not_equal, &exit); 2420 __ incq(rax); 2421 2422 __ movl(rdx, Operand(bx2, 2 * kPointerSize)); 2423 __ cmpl(rdx, Immediate(0x101)); 2424 __ j(not_equal, &exit); 2425 __ incq(rax); 2426 2427 // Non-zero to zero displacement. 2428 __ movl(rdx, Operand(bx2, -2 * kPointerSize)); 2429 __ cmpl(rdx, Immediate(0x105)); 2430 __ j(not_equal, &exit); 2431 __ incq(rax); 2432 2433 Operand bx2c2 = Operand(rbx, rcx, times_pointer_size, -2 * kPointerSize); 2434 2435 // Test 23. 2436 __ movl(rdx, bx2c2); // Sanity check. 2437 __ cmpl(rdx, Immediate(0x105)); 2438 __ j(not_equal, &exit); 2439 __ incq(rax); 2440 2441 __ movl(rdx, Operand(bx2c2, 2 * kPointerSize)); 2442 __ cmpl(rdx, Immediate(0x103)); 2443 __ j(not_equal, &exit); 2444 __ incq(rax); 2445 2446 __ movl(rdx, Operand(bx2c2, -2 * kPointerSize)); 2447 __ cmpl(rdx, Immediate(0x107)); 2448 __ j(not_equal, &exit); 2449 __ incq(rax); 2450 2451 Operand r80 = Operand(r8, 0); 2452 2453 // Test 26. 2454 __ movl(rdx, r80); // Sanity check. 2455 __ cmpl(rdx, Immediate(0x80808080)); 2456 __ j(not_equal, &exit); 2457 __ incq(rax); 2458 2459 __ movl(rdx, Operand(r80, -8 * kIntSize)); 2460 __ cmpl(rdx, Immediate(0x78787878)); 2461 __ j(not_equal, &exit); 2462 __ incq(rax); 2463 2464 __ movl(rdx, Operand(r80, 8 * kIntSize)); 2465 __ cmpl(rdx, Immediate(0x88888888)); 2466 __ j(not_equal, &exit); 2467 __ incq(rax); 2468 2469 __ movl(rdx, Operand(r80, -64 * kIntSize)); 2470 __ cmpl(rdx, Immediate(0x40404040)); 2471 __ j(not_equal, &exit); 2472 __ incq(rax); 2473 2474 __ movl(rdx, Operand(r80, 64 * kIntSize)); 2475 __ cmpl(rdx, Immediate(0xC0C0C0C0)); 2476 __ j(not_equal, &exit); 2477 __ incq(rax); 2478 2479 Operand r88 = Operand(r8, 8 * kIntSize); 2480 2481 // Test 31. 2482 __ movl(rdx, r88); // Sanity check. 2483 __ cmpl(rdx, Immediate(0x88888888)); 2484 __ j(not_equal, &exit); 2485 __ incq(rax); 2486 2487 __ movl(rdx, Operand(r88, -8 * kIntSize)); 2488 __ cmpl(rdx, Immediate(0x80808080)); 2489 __ j(not_equal, &exit); 2490 __ incq(rax); 2491 2492 __ movl(rdx, Operand(r88, 8 * kIntSize)); 2493 __ cmpl(rdx, Immediate(0x90909090)); 2494 __ j(not_equal, &exit); 2495 __ incq(rax); 2496 2497 __ movl(rdx, Operand(r88, -64 * kIntSize)); 2498 __ cmpl(rdx, Immediate(0x48484848)); 2499 __ j(not_equal, &exit); 2500 __ incq(rax); 2501 2502 __ movl(rdx, Operand(r88, 64 * kIntSize)); 2503 __ cmpl(rdx, Immediate(0xC8C8C8C8)); 2504 __ j(not_equal, &exit); 2505 __ incq(rax); 2506 2507 2508 Operand r864 = Operand(r8, 64 * kIntSize); 2509 2510 // Test 36. 2511 __ movl(rdx, r864); // Sanity check. 2512 __ cmpl(rdx, Immediate(0xC0C0C0C0)); 2513 __ j(not_equal, &exit); 2514 __ incq(rax); 2515 2516 __ movl(rdx, Operand(r864, -8 * kIntSize)); 2517 __ cmpl(rdx, Immediate(0xB8B8B8B8)); 2518 __ j(not_equal, &exit); 2519 __ incq(rax); 2520 2521 __ movl(rdx, Operand(r864, 8 * kIntSize)); 2522 __ cmpl(rdx, Immediate(0xC8C8C8C8)); 2523 __ j(not_equal, &exit); 2524 __ incq(rax); 2525 2526 __ movl(rdx, Operand(r864, -64 * kIntSize)); 2527 __ cmpl(rdx, Immediate(0x80808080)); 2528 __ j(not_equal, &exit); 2529 __ incq(rax); 2530 2531 __ movl(rdx, Operand(r864, 32 * kIntSize)); 2532 __ cmpl(rdx, Immediate(0xE0E0E0E0)); 2533 __ j(not_equal, &exit); 2534 __ incq(rax); 2535 2536 // 32-bit offset to 8-bit offset. 2537 __ movl(rdx, Operand(r864, -60 * kIntSize)); 2538 __ cmpl(rdx, Immediate(0x84848484)); 2539 __ j(not_equal, &exit); 2540 __ incq(rax); 2541 2542 __ movl(rdx, Operand(r864, 60 * kIntSize)); 2543 __ cmpl(rdx, Immediate(0xFCFCFCFC)); 2544 __ j(not_equal, &exit); 2545 __ incq(rax); 2546 2547 // Test unaligned offsets. 2548 2549 // Test 43. 2550 __ movl(rdx, Operand(r80, 2)); 2551 __ cmpl(rdx, Immediate(0x81818080)); 2552 __ j(not_equal, &exit); 2553 __ incq(rax); 2554 2555 __ movl(rdx, Operand(r80, -2)); 2556 __ cmpl(rdx, Immediate(0x80807F7F)); 2557 __ j(not_equal, &exit); 2558 __ incq(rax); 2559 2560 __ movl(rdx, Operand(r80, 126)); 2561 __ cmpl(rdx, Immediate(0xA0A09F9F)); 2562 __ j(not_equal, &exit); 2563 __ incq(rax); 2564 2565 __ movl(rdx, Operand(r80, -126)); 2566 __ cmpl(rdx, Immediate(0x61616060)); 2567 __ j(not_equal, &exit); 2568 __ incq(rax); 2569 2570 __ movl(rdx, Operand(r80, 254)); 2571 __ cmpl(rdx, Immediate(0xC0C0BFBF)); 2572 __ j(not_equal, &exit); 2573 __ incq(rax); 2574 2575 __ movl(rdx, Operand(r80, -254)); 2576 __ cmpl(rdx, Immediate(0x41414040)); 2577 __ j(not_equal, &exit); 2578 __ incq(rax); 2579 2580 // Success. 2581 2582 __ movl(rax, Immediate(0)); 2583 __ bind(&exit); 2584 __ leaq(rsp, Operand(rbp, kPointerSize)); 2585 __ popq(rbp); 2586 __ popq(rbx); 2587 __ popq(r14); 2588 __ popq(r13); 2589 ExitCode(masm); 2590 __ ret(0); 2591 2592 2593 CodeDesc desc; 2594 masm->GetCode(&desc); 2595 // Call the function from C++. 2596 int result = FUNCTION_CAST<F0>(buffer)(); 2597 CHECK_EQ(0, result); 2598 } 2599 2600 2601 TEST(LoadAndStoreWithRepresentation) { 2602 // Allocate an executable page of memory. 2603 size_t actual_size; 2604 byte* buffer = static_cast<byte*>(v8::base::OS::Allocate( 2605 Assembler::kMinimalBufferSize, &actual_size, true)); 2606 CHECK(buffer); 2607 Isolate* isolate = CcTest::i_isolate(); 2608 HandleScope handles(isolate); 2609 MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size)); 2610 MacroAssembler* masm = &assembler; // Create a pointer for the __ macro. 2611 EntryCode(masm); 2612 __ subq(rsp, Immediate(1 * kPointerSize)); 2613 Label exit; 2614 2615 // Test 1. 2616 __ movq(rax, Immediate(1)); // Test number. 2617 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2618 __ movq(rcx, Immediate(-1)); 2619 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::UInteger8()); 2620 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2621 __ movl(rdx, Immediate(255)); 2622 __ cmpq(rcx, rdx); 2623 __ j(not_equal, &exit); 2624 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::UInteger8()); 2625 __ cmpq(rcx, rdx); 2626 __ j(not_equal, &exit); 2627 2628 // Test 2. 2629 __ movq(rax, Immediate(2)); // Test number. 2630 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2631 __ Set(rcx, V8_2PART_UINT64_C(0xdeadbeaf, 12345678)); 2632 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Smi()); 2633 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2634 __ Set(rdx, V8_2PART_UINT64_C(0xdeadbeaf, 12345678)); 2635 __ cmpq(rcx, rdx); 2636 __ j(not_equal, &exit); 2637 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Smi()); 2638 __ cmpq(rcx, rdx); 2639 __ j(not_equal, &exit); 2640 2641 // Test 3. 2642 __ movq(rax, Immediate(3)); // Test number. 2643 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2644 __ movq(rcx, Immediate(-1)); 2645 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Integer32()); 2646 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2647 __ movl(rdx, Immediate(-1)); 2648 __ cmpq(rcx, rdx); 2649 __ j(not_equal, &exit); 2650 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Integer32()); 2651 __ cmpq(rcx, rdx); 2652 __ j(not_equal, &exit); 2653 2654 // Test 4. 2655 __ movq(rax, Immediate(4)); // Test number. 2656 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2657 __ movl(rcx, Immediate(0x44332211)); 2658 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::HeapObject()); 2659 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2660 __ movl(rdx, Immediate(0x44332211)); 2661 __ cmpq(rcx, rdx); 2662 __ j(not_equal, &exit); 2663 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::HeapObject()); 2664 __ cmpq(rcx, rdx); 2665 __ j(not_equal, &exit); 2666 2667 // Test 5. 2668 __ movq(rax, Immediate(5)); // Test number. 2669 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2670 __ Set(rcx, V8_2PART_UINT64_C(0x12345678, deadbeaf)); 2671 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Tagged()); 2672 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2673 __ Set(rdx, V8_2PART_UINT64_C(0x12345678, deadbeaf)); 2674 __ cmpq(rcx, rdx); 2675 __ j(not_equal, &exit); 2676 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Tagged()); 2677 __ cmpq(rcx, rdx); 2678 __ j(not_equal, &exit); 2679 2680 // Test 6. 2681 __ movq(rax, Immediate(6)); // Test number. 2682 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2683 __ Set(rcx, V8_2PART_UINT64_C(0x11223344, 55667788)); 2684 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::External()); 2685 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2686 __ Set(rdx, V8_2PART_UINT64_C(0x11223344, 55667788)); 2687 __ cmpq(rcx, rdx); 2688 __ j(not_equal, &exit); 2689 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::External()); 2690 __ cmpq(rcx, rdx); 2691 __ j(not_equal, &exit); 2692 2693 // Test 7. 2694 __ movq(rax, Immediate(7)); // Test number. 2695 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2696 __ movq(rcx, Immediate(-1)); 2697 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Integer8()); 2698 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2699 __ movl(rdx, Immediate(255)); 2700 __ cmpq(rcx, rdx); 2701 __ j(not_equal, &exit); 2702 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Integer8()); 2703 __ movq(rcx, Immediate(-1)); 2704 __ cmpq(rcx, rdx); 2705 __ j(not_equal, &exit); 2706 2707 // Test 8. 2708 __ movq(rax, Immediate(8)); // Test number. 2709 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2710 __ movq(rcx, Immediate(-1)); 2711 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Integer16()); 2712 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2713 __ movl(rdx, Immediate(65535)); 2714 __ cmpq(rcx, rdx); 2715 __ j(not_equal, &exit); 2716 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Integer16()); 2717 __ movq(rcx, Immediate(-1)); 2718 __ cmpq(rcx, rdx); 2719 __ j(not_equal, &exit); 2720 2721 // Test 9. 2722 __ movq(rax, Immediate(9)); // Test number. 2723 __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0)); 2724 __ movq(rcx, Immediate(-1)); 2725 __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::UInteger16()); 2726 __ movq(rcx, Operand(rsp, 0 * kPointerSize)); 2727 __ movl(rdx, Immediate(65535)); 2728 __ cmpq(rcx, rdx); 2729 __ j(not_equal, &exit); 2730 __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::UInteger16()); 2731 __ cmpq(rcx, rdx); 2732 __ j(not_equal, &exit); 2733 2734 __ xorq(rax, rax); // Success. 2735 __ bind(&exit); 2736 __ addq(rsp, Immediate(1 * kPointerSize)); 2737 ExitCode(masm); 2738 __ ret(0); 2739 2740 CodeDesc desc; 2741 masm->GetCode(&desc); 2742 // Call the function from C++. 2743 int result = FUNCTION_CAST<F0>(buffer)(); 2744 CHECK_EQ(0, result); 2745 } 2746 2747 2748 #undef __ 2749
