| // Copyright 2009 the V8 project authors. All rights reserved. |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following |
| // disclaimer in the documentation and/or other materials provided |
| // with the distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include <stdlib.h> |
| |
| #include "v8.h" |
| |
| #include "macro-assembler.h" |
| #include "factory.h" |
| #include "platform.h" |
| #include "serialize.h" |
| #include "cctest.h" |
| |
| using v8::internal::Assembler; |
| using v8::internal::CodeDesc; |
| using v8::internal::Condition; |
| using v8::internal::FUNCTION_CAST; |
| using v8::internal::HandleScope; |
| using v8::internal::Immediate; |
| using v8::internal::Isolate; |
| using v8::internal::Label; |
| using v8::internal::MacroAssembler; |
| using v8::internal::OS; |
| using v8::internal::Operand; |
| using v8::internal::RelocInfo; |
| using v8::internal::Smi; |
| using v8::internal::SmiIndex; |
| using v8::internal::byte; |
| using v8::internal::carry; |
| using v8::internal::greater; |
| using v8::internal::greater_equal; |
| using v8::internal::kIntSize; |
| using v8::internal::kPointerSize; |
| using v8::internal::kSmiTagMask; |
| using v8::internal::kSmiValueSize; |
| using v8::internal::less_equal; |
| using v8::internal::negative; |
| using v8::internal::not_carry; |
| using v8::internal::not_equal; |
| using v8::internal::not_zero; |
| using v8::internal::positive; |
| using v8::internal::r11; |
| using v8::internal::r13; |
| using v8::internal::r14; |
| using v8::internal::r15; |
| using v8::internal::r8; |
| using v8::internal::r9; |
| using v8::internal::rax; |
| using v8::internal::rbp; |
| using v8::internal::rbx; |
| using v8::internal::rcx; |
| using v8::internal::rdi; |
| using v8::internal::rdx; |
| using v8::internal::rsi; |
| using v8::internal::rsp; |
| using v8::internal::times_pointer_size; |
| |
| // Test the x64 assembler by compiling some simple functions into |
| // a buffer and executing them. These tests do not initialize the |
| // V8 library, create a context, or use any V8 objects. |
| // The AMD64 calling convention is used, with the first five arguments |
| // in RSI, RDI, RDX, RCX, R8, and R9, and floating point arguments in |
| // the XMM registers. The return value is in RAX. |
| // This calling convention is used on Linux, with GCC, and on Mac OS, |
| // with GCC. A different convention is used on 64-bit windows. |
| |
| typedef int (*F0)(); |
| |
| #define __ masm-> |
| |
| |
| static void EntryCode(MacroAssembler* masm) { |
| // Smi constant register is callee save. |
| __ push(v8::internal::kSmiConstantRegister); |
| __ push(v8::internal::kRootRegister); |
| __ InitializeSmiConstantRegister(); |
| __ InitializeRootRegister(); |
| } |
| |
| |
| static void ExitCode(MacroAssembler* masm) { |
| // Return -1 if kSmiConstantRegister was clobbered during the test. |
| __ Move(rdx, Smi::FromInt(1)); |
| __ cmpq(rdx, v8::internal::kSmiConstantRegister); |
| __ movq(rdx, Immediate(-1)); |
| __ cmovq(not_equal, rax, rdx); |
| __ pop(v8::internal::kRootRegister); |
| __ pop(v8::internal::kSmiConstantRegister); |
| } |
| |
| |
| TEST(Smi) { |
| // Check that C++ Smi operations work as expected. |
| int64_t test_numbers[] = { |
| 0, 1, -1, 127, 128, -128, -129, 255, 256, -256, -257, |
| Smi::kMaxValue, static_cast<int64_t>(Smi::kMaxValue) + 1, |
| Smi::kMinValue, static_cast<int64_t>(Smi::kMinValue) - 1 |
| }; |
| int test_number_count = 15; |
| for (int i = 0; i < test_number_count; i++) { |
| int64_t number = test_numbers[i]; |
| bool is_valid = Smi::IsValid(number); |
| bool is_in_range = number >= Smi::kMinValue && number <= Smi::kMaxValue; |
| CHECK_EQ(is_in_range, is_valid); |
| if (is_valid) { |
| Smi* smi_from_intptr = Smi::FromIntptr(number); |
| if (static_cast<int>(number) == number) { // Is a 32-bit int. |
| Smi* smi_from_int = Smi::FromInt(static_cast<int32_t>(number)); |
| CHECK_EQ(smi_from_int, smi_from_intptr); |
| } |
| int64_t smi_value = smi_from_intptr->value(); |
| CHECK_EQ(number, smi_value); |
| } |
| } |
| } |
| |
| |
| static void TestMoveSmi(MacroAssembler* masm, Label* exit, int id, Smi* value) { |
| __ movl(rax, Immediate(id)); |
| __ Move(rcx, Smi::FromInt(0)); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0))); |
| __ cmpq(rcx, rdx); |
| __ j(not_equal, exit); |
| } |
| |
| |
| // Test that we can move a Smi value literally into a register. |
| TEST(SmiMove) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| MacroAssembler* masm = &assembler; // Create a pointer for the __ macro. |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestMoveSmi(masm, &exit, 1, Smi::FromInt(0)); |
| TestMoveSmi(masm, &exit, 2, Smi::FromInt(127)); |
| TestMoveSmi(masm, &exit, 3, Smi::FromInt(128)); |
| TestMoveSmi(masm, &exit, 4, Smi::FromInt(255)); |
| TestMoveSmi(masm, &exit, 5, Smi::FromInt(256)); |
| TestMoveSmi(masm, &exit, 6, Smi::FromInt(Smi::kMaxValue)); |
| TestMoveSmi(masm, &exit, 7, Smi::FromInt(-1)); |
| TestMoveSmi(masm, &exit, 8, Smi::FromInt(-128)); |
| TestMoveSmi(masm, &exit, 9, Smi::FromInt(-129)); |
| TestMoveSmi(masm, &exit, 10, Smi::FromInt(-256)); |
| TestMoveSmi(masm, &exit, 11, Smi::FromInt(-257)); |
| TestMoveSmi(masm, &exit, 12, Smi::FromInt(Smi::kMinValue)); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiCompare(MacroAssembler* masm, Label* exit, int id, int x, int y) { |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r8, rcx); |
| __ Move(rdx, Smi::FromInt(y)); |
| __ movq(r9, rdx); |
| __ SmiCompare(rcx, rdx); |
| if (x < y) { |
| __ movl(rax, Immediate(id + 1)); |
| __ j(greater_equal, exit); |
| } else if (x > y) { |
| __ movl(rax, Immediate(id + 2)); |
| __ j(less_equal, exit); |
| } else { |
| ASSERT_EQ(x, y); |
| __ movl(rax, Immediate(id + 3)); |
| __ j(not_equal, exit); |
| } |
| __ movl(rax, Immediate(id + 4)); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| __ cmpq(rdx, r9); |
| __ j(not_equal, exit); |
| |
| if (x != y) { |
| __ SmiCompare(rdx, rcx); |
| if (y < x) { |
| __ movl(rax, Immediate(id + 9)); |
| __ j(greater_equal, exit); |
| } else { |
| ASSERT(y > x); |
| __ movl(rax, Immediate(id + 10)); |
| __ j(less_equal, exit); |
| } |
| } else { |
| __ cmpq(rcx, rcx); |
| __ movl(rax, Immediate(id + 11)); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } |
| } |
| |
| |
| // Test that we can compare smis for equality (and more). |
| TEST(SmiCompare) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiCompare(masm, &exit, 0x10, 0, 0); |
| TestSmiCompare(masm, &exit, 0x20, 0, 1); |
| TestSmiCompare(masm, &exit, 0x30, 1, 0); |
| TestSmiCompare(masm, &exit, 0x40, 1, 1); |
| TestSmiCompare(masm, &exit, 0x50, 0, -1); |
| TestSmiCompare(masm, &exit, 0x60, -1, 0); |
| TestSmiCompare(masm, &exit, 0x70, -1, -1); |
| TestSmiCompare(masm, &exit, 0x80, 0, Smi::kMinValue); |
| TestSmiCompare(masm, &exit, 0x90, Smi::kMinValue, 0); |
| TestSmiCompare(masm, &exit, 0xA0, 0, Smi::kMaxValue); |
| TestSmiCompare(masm, &exit, 0xB0, Smi::kMaxValue, 0); |
| TestSmiCompare(masm, &exit, 0xC0, -1, Smi::kMinValue); |
| TestSmiCompare(masm, &exit, 0xD0, Smi::kMinValue, -1); |
| TestSmiCompare(masm, &exit, 0xE0, -1, Smi::kMaxValue); |
| TestSmiCompare(masm, &exit, 0xF0, Smi::kMaxValue, -1); |
| TestSmiCompare(masm, &exit, 0x100, Smi::kMinValue, Smi::kMinValue); |
| TestSmiCompare(masm, &exit, 0x110, Smi::kMinValue, Smi::kMaxValue); |
| TestSmiCompare(masm, &exit, 0x120, Smi::kMaxValue, Smi::kMinValue); |
| TestSmiCompare(masm, &exit, 0x130, Smi::kMaxValue, Smi::kMaxValue); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| |
| TEST(Integer32ToSmi) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| __ movq(rax, Immediate(1)); // Test number. |
| __ movl(rcx, Immediate(0)); |
| __ Integer32ToSmi(rcx, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0))); |
| __ cmpq(rcx, rdx); |
| __ j(not_equal, &exit); |
| |
| __ movq(rax, Immediate(2)); // Test number. |
| __ movl(rcx, Immediate(1024)); |
| __ Integer32ToSmi(rcx, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024))); |
| __ cmpq(rcx, rdx); |
| __ j(not_equal, &exit); |
| |
| __ movq(rax, Immediate(3)); // Test number. |
| __ movl(rcx, Immediate(-1)); |
| __ Integer32ToSmi(rcx, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1))); |
| __ cmpq(rcx, rdx); |
| __ j(not_equal, &exit); |
| |
| __ movq(rax, Immediate(4)); // Test number. |
| __ movl(rcx, Immediate(Smi::kMaxValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue))); |
| __ cmpq(rcx, rdx); |
| __ j(not_equal, &exit); |
| |
| __ movq(rax, Immediate(5)); // Test number. |
| __ movl(rcx, Immediate(Smi::kMinValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue))); |
| __ cmpq(rcx, rdx); |
| __ j(not_equal, &exit); |
| |
| // Different target register. |
| |
| __ movq(rax, Immediate(6)); // Test number. |
| __ movl(rcx, Immediate(0)); |
| __ Integer32ToSmi(r8, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0))); |
| __ cmpq(r8, rdx); |
| __ j(not_equal, &exit); |
| |
| __ movq(rax, Immediate(7)); // Test number. |
| __ movl(rcx, Immediate(1024)); |
| __ Integer32ToSmi(r8, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024))); |
| __ cmpq(r8, rdx); |
| __ j(not_equal, &exit); |
| |
| __ movq(rax, Immediate(8)); // Test number. |
| __ movl(rcx, Immediate(-1)); |
| __ Integer32ToSmi(r8, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1))); |
| __ cmpq(r8, rdx); |
| __ j(not_equal, &exit); |
| |
| __ movq(rax, Immediate(9)); // Test number. |
| __ movl(rcx, Immediate(Smi::kMaxValue)); |
| __ Integer32ToSmi(r8, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue))); |
| __ cmpq(r8, rdx); |
| __ j(not_equal, &exit); |
| |
| __ movq(rax, Immediate(10)); // Test number. |
| __ movl(rcx, Immediate(Smi::kMinValue)); |
| __ Integer32ToSmi(r8, rcx); |
| __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue))); |
| __ cmpq(r8, rdx); |
| __ j(not_equal, &exit); |
| |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestI64PlusConstantToSmi(MacroAssembler* masm, |
| Label* exit, |
| int id, |
| int64_t x, |
| int y) { |
| int64_t result = x + y; |
| ASSERT(Smi::IsValid(result)); |
| __ movl(rax, Immediate(id)); |
| __ Move(r8, Smi::FromInt(static_cast<int>(result))); |
| __ movq(rcx, x, RelocInfo::NONE64); |
| __ movq(r11, rcx); |
| __ Integer64PlusConstantToSmi(rdx, rcx, y); |
| __ cmpq(rdx, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Integer64PlusConstantToSmi(rcx, rcx, y); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } |
| |
| |
| TEST(Integer64PlusConstantToSmi) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| int64_t twice_max = static_cast<int64_t>(Smi::kMaxValue) * 2; |
| |
| TestI64PlusConstantToSmi(masm, &exit, 0x10, 0, 0); |
| TestI64PlusConstantToSmi(masm, &exit, 0x20, 0, 1); |
| TestI64PlusConstantToSmi(masm, &exit, 0x30, 1, 0); |
| TestI64PlusConstantToSmi(masm, &exit, 0x40, Smi::kMaxValue - 5, 5); |
| TestI64PlusConstantToSmi(masm, &exit, 0x50, Smi::kMinValue + 5, 5); |
| TestI64PlusConstantToSmi(masm, &exit, 0x60, twice_max, -Smi::kMaxValue); |
| TestI64PlusConstantToSmi(masm, &exit, 0x70, -twice_max, Smi::kMaxValue); |
| TestI64PlusConstantToSmi(masm, &exit, 0x80, 0, Smi::kMinValue); |
| TestI64PlusConstantToSmi(masm, &exit, 0x90, 0, Smi::kMaxValue); |
| TestI64PlusConstantToSmi(masm, &exit, 0xA0, Smi::kMinValue, 0); |
| TestI64PlusConstantToSmi(masm, &exit, 0xB0, Smi::kMaxValue, 0); |
| TestI64PlusConstantToSmi(masm, &exit, 0xC0, twice_max, Smi::kMinValue); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| TEST(SmiCheck) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| Condition cond; |
| |
| __ movl(rax, Immediate(1)); // Test number. |
| |
| // CheckSmi |
| |
| __ movl(rcx, Immediate(0)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckSmi(rcx); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckSmi(rcx); |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ movl(rcx, Immediate(-1)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckSmi(rcx); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckSmi(rcx); |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ movl(rcx, Immediate(Smi::kMaxValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckSmi(rcx); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckSmi(rcx); |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ movl(rcx, Immediate(Smi::kMinValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckSmi(rcx); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckSmi(rcx); |
| __ j(cond, &exit); |
| |
| // CheckPositiveSmi |
| |
| __ incq(rax); |
| __ movl(rcx, Immediate(0)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckNonNegativeSmi(rcx); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckNonNegativeSmi(rcx); // "zero" non-smi. |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(-1)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckNonNegativeSmi(rcx); // Negative smis are not positive. |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(Smi::kMinValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckNonNegativeSmi(rcx); // Most negative smi is not positive. |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckNonNegativeSmi(rcx); // "Negative" non-smi. |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(Smi::kMaxValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckNonNegativeSmi(rcx); // Most positive smi is positive. |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckNonNegativeSmi(rcx); // "Positive" non-smi. |
| __ j(cond, &exit); |
| |
| // CheckIsMinSmi |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(Smi::kMaxValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckIsMinSmi(rcx); |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(0)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckIsMinSmi(rcx); |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(Smi::kMinValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckIsMinSmi(rcx); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(Smi::kMinValue + 1)); |
| __ Integer32ToSmi(rcx, rcx); |
| cond = masm->CheckIsMinSmi(rcx); |
| __ j(cond, &exit); |
| |
| // CheckBothSmi |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(Smi::kMaxValue)); |
| __ Integer32ToSmi(rcx, rcx); |
| __ movq(rdx, Immediate(Smi::kMinValue)); |
| __ Integer32ToSmi(rdx, rdx); |
| cond = masm->CheckBothSmi(rcx, rdx); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckBothSmi(rcx, rdx); |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ xor_(rdx, Immediate(kSmiTagMask)); |
| cond = masm->CheckBothSmi(rcx, rdx); |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| cond = masm->CheckBothSmi(rcx, rdx); |
| __ j(cond, &exit); |
| |
| __ incq(rax); |
| cond = masm->CheckBothSmi(rcx, rcx); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| cond = masm->CheckBothSmi(rdx, rdx); |
| __ j(cond, &exit); |
| |
| // CheckInteger32ValidSmiValue |
| __ incq(rax); |
| __ movq(rcx, Immediate(0)); |
| cond = masm->CheckInteger32ValidSmiValue(rax); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(-1)); |
| cond = masm->CheckInteger32ValidSmiValue(rax); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(Smi::kMaxValue)); |
| cond = masm->CheckInteger32ValidSmiValue(rax); |
| __ j(NegateCondition(cond), &exit); |
| |
| __ incq(rax); |
| __ movq(rcx, Immediate(Smi::kMinValue)); |
| cond = masm->CheckInteger32ValidSmiValue(rax); |
| __ j(NegateCondition(cond), &exit); |
| |
| // Success |
| __ xor_(rax, rax); |
| |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| |
| void TestSmiNeg(MacroAssembler* masm, Label* exit, int id, int x) { |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| if (x == Smi::kMinValue || x == 0) { |
| // Negation fails. |
| __ movl(rax, Immediate(id + 8)); |
| __ SmiNeg(r9, rcx, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiNeg(rcx, rcx, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| } else { |
| Label smi_ok, smi_ok2; |
| int result = -x; |
| __ movl(rax, Immediate(id)); |
| __ Move(r8, Smi::FromInt(result)); |
| |
| __ SmiNeg(r9, rcx, &smi_ok); |
| __ jmp(exit); |
| __ bind(&smi_ok); |
| __ incq(rax); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiNeg(rcx, rcx, &smi_ok2); |
| __ jmp(exit); |
| __ bind(&smi_ok2); |
| __ incq(rax); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } |
| } |
| |
| |
| TEST(SmiNeg) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiNeg(masm, &exit, 0x10, 0); |
| TestSmiNeg(masm, &exit, 0x20, 1); |
| TestSmiNeg(masm, &exit, 0x30, -1); |
| TestSmiNeg(masm, &exit, 0x40, 127); |
| TestSmiNeg(masm, &exit, 0x50, 65535); |
| TestSmiNeg(masm, &exit, 0x60, Smi::kMinValue); |
| TestSmiNeg(masm, &exit, 0x70, Smi::kMaxValue); |
| TestSmiNeg(masm, &exit, 0x80, -Smi::kMaxValue); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| |
| |
| static void SmiAddTest(MacroAssembler* masm, |
| Label* exit, |
| int id, |
| int first, |
| int second) { |
| __ movl(rcx, Immediate(first)); |
| __ Integer32ToSmi(rcx, rcx); |
| __ movl(rdx, Immediate(second)); |
| __ Integer32ToSmi(rdx, rdx); |
| __ movl(r8, Immediate(first + second)); |
| __ Integer32ToSmi(r8, r8); |
| |
| __ movl(rax, Immediate(id)); // Test number. |
| __ SmiAdd(r9, rcx, rdx, exit); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiAdd(rcx, rcx, rdx, exit); \ |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| |
| __ movl(rcx, Immediate(first)); |
| __ Integer32ToSmi(rcx, rcx); |
| |
| __ incq(rax); |
| __ SmiAddConstant(r9, rcx, Smi::FromInt(second)); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ SmiAddConstant(rcx, rcx, Smi::FromInt(second)); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| |
| __ movl(rcx, Immediate(first)); |
| __ Integer32ToSmi(rcx, rcx); |
| |
| __ incq(rax); |
| __ SmiAddConstant(r9, rcx, Smi::FromInt(second), exit); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiAddConstant(rcx, rcx, Smi::FromInt(second), exit); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } |
| |
| TEST(SmiAdd) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| // No-overflow tests. |
| SmiAddTest(masm, &exit, 0x10, 1, 2); |
| SmiAddTest(masm, &exit, 0x20, 1, -2); |
| SmiAddTest(masm, &exit, 0x30, -1, 2); |
| SmiAddTest(masm, &exit, 0x40, -1, -2); |
| SmiAddTest(masm, &exit, 0x50, 0x1000, 0x2000); |
| SmiAddTest(masm, &exit, 0x60, Smi::kMinValue, 5); |
| SmiAddTest(masm, &exit, 0x70, Smi::kMaxValue, -5); |
| SmiAddTest(masm, &exit, 0x80, Smi::kMaxValue, Smi::kMinValue); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| static void SmiSubTest(MacroAssembler* masm, |
| Label* exit, |
| int id, |
| int first, |
| int second) { |
| __ Move(rcx, Smi::FromInt(first)); |
| __ Move(rdx, Smi::FromInt(second)); |
| __ Move(r8, Smi::FromInt(first - second)); |
| |
| __ movl(rax, Immediate(id)); // Test 0. |
| __ SmiSub(r9, rcx, rdx, exit); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); // Test 1. |
| __ SmiSub(rcx, rcx, rdx, exit); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| |
| __ Move(rcx, Smi::FromInt(first)); |
| |
| __ incq(rax); // Test 2. |
| __ SmiSubConstant(r9, rcx, Smi::FromInt(second)); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); // Test 3. |
| __ SmiSubConstant(rcx, rcx, Smi::FromInt(second)); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| |
| __ Move(rcx, Smi::FromInt(first)); |
| |
| __ incq(rax); // Test 4. |
| __ SmiSubConstant(r9, rcx, Smi::FromInt(second), exit); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); // Test 5. |
| __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), exit); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } |
| |
| static void SmiSubOverflowTest(MacroAssembler* masm, |
| Label* exit, |
| int id, |
| int x) { |
| // Subtracts a Smi from x so that the subtraction overflows. |
| ASSERT(x != -1); // Can't overflow by subtracting a Smi. |
| int y_max = (x < 0) ? (Smi::kMaxValue + 0) : (Smi::kMinValue + 0); |
| int y_min = (x < 0) ? (Smi::kMaxValue + x + 2) : (Smi::kMinValue + x); |
| |
| __ movl(rax, Immediate(id)); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); // Store original Smi value of x in r11. |
| __ Move(rdx, Smi::FromInt(y_min)); |
| { |
| Label overflow_ok; |
| __ SmiSub(r9, rcx, rdx, &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| |
| { |
| Label overflow_ok; |
| __ incq(rax); |
| __ SmiSub(rcx, rcx, rdx, &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| |
| __ movq(rcx, r11); |
| { |
| Label overflow_ok; |
| __ incq(rax); |
| __ SmiSubConstant(r9, rcx, Smi::FromInt(y_min), &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| |
| { |
| Label overflow_ok; |
| __ incq(rax); |
| __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_min), &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| |
| __ Move(rdx, Smi::FromInt(y_max)); |
| |
| { |
| Label overflow_ok; |
| __ incq(rax); |
| __ SmiSub(r9, rcx, rdx, &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| |
| { |
| Label overflow_ok; |
| __ incq(rax); |
| __ SmiSub(rcx, rcx, rdx, &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| |
| __ movq(rcx, r11); |
| { |
| Label overflow_ok; |
| __ incq(rax); |
| __ SmiSubConstant(r9, rcx, Smi::FromInt(y_max), &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| |
| { |
| Label overflow_ok; |
| __ incq(rax); |
| __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_max), &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| } |
| |
| |
| TEST(SmiSub) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| SmiSubTest(masm, &exit, 0x10, 1, 2); |
| SmiSubTest(masm, &exit, 0x20, 1, -2); |
| SmiSubTest(masm, &exit, 0x30, -1, 2); |
| SmiSubTest(masm, &exit, 0x40, -1, -2); |
| SmiSubTest(masm, &exit, 0x50, 0x1000, 0x2000); |
| SmiSubTest(masm, &exit, 0x60, Smi::kMinValue, -5); |
| SmiSubTest(masm, &exit, 0x70, Smi::kMaxValue, 5); |
| SmiSubTest(masm, &exit, 0x80, -Smi::kMaxValue, Smi::kMinValue); |
| SmiSubTest(masm, &exit, 0x90, 0, Smi::kMaxValue); |
| |
| SmiSubOverflowTest(masm, &exit, 0xA0, 1); |
| SmiSubOverflowTest(masm, &exit, 0xB0, 1024); |
| SmiSubOverflowTest(masm, &exit, 0xC0, Smi::kMaxValue); |
| SmiSubOverflowTest(masm, &exit, 0xD0, -2); |
| SmiSubOverflowTest(masm, &exit, 0xE0, -42000); |
| SmiSubOverflowTest(masm, &exit, 0xF0, Smi::kMinValue); |
| SmiSubOverflowTest(masm, &exit, 0x100, 0); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| |
| void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) { |
| int64_t result = static_cast<int64_t>(x) * static_cast<int64_t>(y); |
| bool negative_zero = (result == 0) && (x < 0 || y < 0); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| __ Move(rdx, Smi::FromInt(y)); |
| if (Smi::IsValid(result) && !negative_zero) { |
| __ movl(rax, Immediate(id)); |
| __ Move(r8, Smi::FromIntptr(result)); |
| __ SmiMul(r9, rcx, rdx, exit); |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiMul(rcx, rcx, rdx, exit); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } else { |
| __ movl(rax, Immediate(id + 8)); |
| Label overflow_ok, overflow_ok2; |
| __ SmiMul(r9, rcx, rdx, &overflow_ok); |
| __ jmp(exit); |
| __ bind(&overflow_ok); |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| __ SmiMul(rcx, rcx, rdx, &overflow_ok2); |
| __ jmp(exit); |
| __ bind(&overflow_ok2); |
| // 31-bit version doesn't preserve rcx on failure. |
| // __ incq(rax); |
| // __ cmpq(r11, rcx); |
| // __ j(not_equal, exit); |
| } |
| } |
| |
| |
| TEST(SmiMul) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiMul(masm, &exit, 0x10, 0, 0); |
| TestSmiMul(masm, &exit, 0x20, -1, 0); |
| TestSmiMul(masm, &exit, 0x30, 0, -1); |
| TestSmiMul(masm, &exit, 0x40, -1, -1); |
| TestSmiMul(masm, &exit, 0x50, 0x10000, 0x10000); |
| TestSmiMul(masm, &exit, 0x60, 0x10000, 0xffff); |
| TestSmiMul(masm, &exit, 0x70, 0x10000, 0xffff); |
| TestSmiMul(masm, &exit, 0x80, Smi::kMaxValue, -1); |
| TestSmiMul(masm, &exit, 0x90, Smi::kMaxValue, -2); |
| TestSmiMul(masm, &exit, 0xa0, Smi::kMaxValue, 2); |
| TestSmiMul(masm, &exit, 0xb0, (Smi::kMaxValue / 2), 2); |
| TestSmiMul(masm, &exit, 0xc0, (Smi::kMaxValue / 2) + 1, 2); |
| TestSmiMul(masm, &exit, 0xd0, (Smi::kMinValue / 2), 2); |
| TestSmiMul(masm, &exit, 0xe0, (Smi::kMinValue / 2) - 1, 2); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiDiv(MacroAssembler* masm, Label* exit, int id, int x, int y) { |
| bool division_by_zero = (y == 0); |
| bool negative_zero = (x == 0 && y < 0); |
| #ifdef V8_TARGET_ARCH_X64 |
| bool overflow = (x == Smi::kMinValue && y < 0); // Safe approx. used. |
| #else |
| bool overflow = (x == Smi::kMinValue && y == -1); |
| #endif |
| bool fraction = !division_by_zero && !overflow && (x % y != 0); |
| __ Move(r11, Smi::FromInt(x)); |
| __ Move(r14, Smi::FromInt(y)); |
| if (!fraction && !overflow && !negative_zero && !division_by_zero) { |
| // Division succeeds |
| __ movq(rcx, r11); |
| __ movq(r15, Immediate(id)); |
| int result = x / y; |
| __ Move(r8, Smi::FromInt(result)); |
| __ SmiDiv(r9, rcx, r14, exit); |
| // Might have destroyed rcx and r14. |
| __ incq(r15); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(r15); |
| __ movq(rcx, r11); |
| __ Move(r14, Smi::FromInt(y)); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| |
| __ incq(r15); |
| __ SmiDiv(rcx, rcx, r14, exit); |
| |
| __ incq(r15); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } else { |
| // Division fails. |
| __ movq(r15, Immediate(id + 8)); |
| |
| Label fail_ok, fail_ok2; |
| __ movq(rcx, r11); |
| __ SmiDiv(r9, rcx, r14, &fail_ok); |
| __ jmp(exit); |
| __ bind(&fail_ok); |
| |
| __ incq(r15); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| |
| __ incq(r15); |
| __ SmiDiv(rcx, rcx, r14, &fail_ok2); |
| __ jmp(exit); |
| __ bind(&fail_ok2); |
| |
| __ incq(r15); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| } |
| |
| |
| TEST(SmiDiv) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| __ push(r14); |
| __ push(r15); |
| TestSmiDiv(masm, &exit, 0x10, 1, 1); |
| TestSmiDiv(masm, &exit, 0x20, 1, 0); |
| TestSmiDiv(masm, &exit, 0x30, -1, 0); |
| TestSmiDiv(masm, &exit, 0x40, 0, 1); |
| TestSmiDiv(masm, &exit, 0x50, 0, -1); |
| TestSmiDiv(masm, &exit, 0x60, 4, 2); |
| TestSmiDiv(masm, &exit, 0x70, -4, 2); |
| TestSmiDiv(masm, &exit, 0x80, 4, -2); |
| TestSmiDiv(masm, &exit, 0x90, -4, -2); |
| TestSmiDiv(masm, &exit, 0xa0, 3, 2); |
| TestSmiDiv(masm, &exit, 0xb0, 3, 4); |
| TestSmiDiv(masm, &exit, 0xc0, 1, Smi::kMaxValue); |
| TestSmiDiv(masm, &exit, 0xd0, -1, Smi::kMaxValue); |
| TestSmiDiv(masm, &exit, 0xe0, Smi::kMaxValue, 1); |
| TestSmiDiv(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue); |
| TestSmiDiv(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue); |
| TestSmiDiv(masm, &exit, 0x110, Smi::kMaxValue, -1); |
| TestSmiDiv(masm, &exit, 0x120, Smi::kMinValue, 1); |
| TestSmiDiv(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue); |
| TestSmiDiv(masm, &exit, 0x140, Smi::kMinValue, -1); |
| |
| __ xor_(r15, r15); // Success. |
| __ bind(&exit); |
| __ movq(rax, r15); |
| __ pop(r15); |
| __ pop(r14); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiMod(MacroAssembler* masm, Label* exit, int id, int x, int y) { |
| bool division_by_zero = (y == 0); |
| bool division_overflow = (x == Smi::kMinValue) && (y == -1); |
| bool fraction = !division_by_zero && !division_overflow && ((x % y) != 0); |
| bool negative_zero = (!fraction && x < 0); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| __ Move(r14, Smi::FromInt(y)); |
| if (!division_overflow && !negative_zero && !division_by_zero) { |
| // Modulo succeeds |
| __ movq(r15, Immediate(id)); |
| int result = x % y; |
| __ Move(r8, Smi::FromInt(result)); |
| __ SmiMod(r9, rcx, r14, exit); |
| |
| __ incq(r15); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(r15); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| |
| __ incq(r15); |
| __ SmiMod(rcx, rcx, r14, exit); |
| |
| __ incq(r15); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } else { |
| // Modulo fails. |
| __ movq(r15, Immediate(id + 8)); |
| |
| Label fail_ok, fail_ok2; |
| __ SmiMod(r9, rcx, r14, &fail_ok); |
| __ jmp(exit); |
| __ bind(&fail_ok); |
| |
| __ incq(r15); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| |
| __ incq(r15); |
| __ SmiMod(rcx, rcx, r14, &fail_ok2); |
| __ jmp(exit); |
| __ bind(&fail_ok2); |
| |
| __ incq(r15); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| } |
| } |
| |
| |
| TEST(SmiMod) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| __ push(r14); |
| __ push(r15); |
| TestSmiMod(masm, &exit, 0x10, 1, 1); |
| TestSmiMod(masm, &exit, 0x20, 1, 0); |
| TestSmiMod(masm, &exit, 0x30, -1, 0); |
| TestSmiMod(masm, &exit, 0x40, 0, 1); |
| TestSmiMod(masm, &exit, 0x50, 0, -1); |
| TestSmiMod(masm, &exit, 0x60, 4, 2); |
| TestSmiMod(masm, &exit, 0x70, -4, 2); |
| TestSmiMod(masm, &exit, 0x80, 4, -2); |
| TestSmiMod(masm, &exit, 0x90, -4, -2); |
| TestSmiMod(masm, &exit, 0xa0, 3, 2); |
| TestSmiMod(masm, &exit, 0xb0, 3, 4); |
| TestSmiMod(masm, &exit, 0xc0, 1, Smi::kMaxValue); |
| TestSmiMod(masm, &exit, 0xd0, -1, Smi::kMaxValue); |
| TestSmiMod(masm, &exit, 0xe0, Smi::kMaxValue, 1); |
| TestSmiMod(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue); |
| TestSmiMod(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue); |
| TestSmiMod(masm, &exit, 0x110, Smi::kMaxValue, -1); |
| TestSmiMod(masm, &exit, 0x120, Smi::kMinValue, 1); |
| TestSmiMod(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue); |
| TestSmiMod(masm, &exit, 0x140, Smi::kMinValue, -1); |
| |
| __ xor_(r15, r15); // Success. |
| __ bind(&exit); |
| __ movq(rax, r15); |
| __ pop(r15); |
| __ pop(r14); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) { |
| __ movl(rax, Immediate(id)); |
| |
| for (int i = 0; i < 8; i++) { |
| __ Move(rcx, Smi::FromInt(x)); |
| SmiIndex index = masm->SmiToIndex(rdx, rcx, i); |
| ASSERT(index.reg.is(rcx) || index.reg.is(rdx)); |
| __ shl(index.reg, Immediate(index.scale)); |
| __ Set(r8, static_cast<intptr_t>(x) << i); |
| __ cmpq(index.reg, r8); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| __ Move(rcx, Smi::FromInt(x)); |
| index = masm->SmiToIndex(rcx, rcx, i); |
| ASSERT(index.reg.is(rcx)); |
| __ shl(rcx, Immediate(index.scale)); |
| __ Set(r8, static_cast<intptr_t>(x) << i); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| |
| __ Move(rcx, Smi::FromInt(x)); |
| index = masm->SmiToNegativeIndex(rdx, rcx, i); |
| ASSERT(index.reg.is(rcx) || index.reg.is(rdx)); |
| __ shl(index.reg, Immediate(index.scale)); |
| __ Set(r8, static_cast<intptr_t>(-x) << i); |
| __ cmpq(index.reg, r8); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| __ Move(rcx, Smi::FromInt(x)); |
| index = masm->SmiToNegativeIndex(rcx, rcx, i); |
| ASSERT(index.reg.is(rcx)); |
| __ shl(rcx, Immediate(index.scale)); |
| __ Set(r8, static_cast<intptr_t>(-x) << i); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| } |
| } |
| |
| TEST(SmiIndex) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 3, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiIndex(masm, &exit, 0x10, 0); |
| TestSmiIndex(masm, &exit, 0x20, 1); |
| TestSmiIndex(masm, &exit, 0x30, 100); |
| TestSmiIndex(masm, &exit, 0x40, 1000); |
| TestSmiIndex(masm, &exit, 0x50, Smi::kMaxValue); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSelectNonSmi(MacroAssembler* masm, Label* exit, int id, int x, int y) { |
| __ movl(rax, Immediate(id)); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ Move(rdx, Smi::FromInt(y)); |
| __ xor_(rdx, Immediate(kSmiTagMask)); |
| __ SelectNonSmi(r9, rcx, rdx, exit); |
| |
| __ incq(rax); |
| __ cmpq(r9, rdx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ Move(rdx, Smi::FromInt(y)); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| __ SelectNonSmi(r9, rcx, rdx, exit); |
| |
| __ incq(rax); |
| __ cmpq(r9, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| Label fail_ok; |
| __ Move(rcx, Smi::FromInt(x)); |
| __ Move(rdx, Smi::FromInt(y)); |
| __ xor_(rcx, Immediate(kSmiTagMask)); |
| __ xor_(rdx, Immediate(kSmiTagMask)); |
| __ SelectNonSmi(r9, rcx, rdx, &fail_ok); |
| __ jmp(exit); |
| __ bind(&fail_ok); |
| } |
| |
| |
| TEST(SmiSelectNonSmi) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); // Avoid inline checks. |
| EntryCode(masm); |
| Label exit; |
| |
| TestSelectNonSmi(masm, &exit, 0x10, 0, 0); |
| TestSelectNonSmi(masm, &exit, 0x20, 0, 1); |
| TestSelectNonSmi(masm, &exit, 0x30, 1, 0); |
| TestSelectNonSmi(masm, &exit, 0x40, 0, -1); |
| TestSelectNonSmi(masm, &exit, 0x50, -1, 0); |
| TestSelectNonSmi(masm, &exit, 0x60, -1, -1); |
| TestSelectNonSmi(masm, &exit, 0x70, 1, 1); |
| TestSelectNonSmi(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue); |
| TestSelectNonSmi(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiAnd(MacroAssembler* masm, Label* exit, int id, int x, int y) { |
| int result = x & y; |
| |
| __ movl(rax, Immediate(id)); |
| |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| __ Move(rdx, Smi::FromInt(y)); |
| __ Move(r8, Smi::FromInt(result)); |
| __ SmiAnd(r9, rcx, rdx); |
| __ cmpq(r8, r9); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiAnd(rcx, rcx, rdx); |
| __ cmpq(r8, rcx); |
| __ j(not_equal, exit); |
| |
| __ movq(rcx, r11); |
| __ incq(rax); |
| __ SmiAndConstant(r9, rcx, Smi::FromInt(y)); |
| __ cmpq(r8, r9); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiAndConstant(rcx, rcx, Smi::FromInt(y)); |
| __ cmpq(r8, rcx); |
| __ j(not_equal, exit); |
| } |
| |
| |
| TEST(SmiAnd) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiAnd(masm, &exit, 0x10, 0, 0); |
| TestSmiAnd(masm, &exit, 0x20, 0, 1); |
| TestSmiAnd(masm, &exit, 0x30, 1, 0); |
| TestSmiAnd(masm, &exit, 0x40, 0, -1); |
| TestSmiAnd(masm, &exit, 0x50, -1, 0); |
| TestSmiAnd(masm, &exit, 0x60, -1, -1); |
| TestSmiAnd(masm, &exit, 0x70, 1, 1); |
| TestSmiAnd(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue); |
| TestSmiAnd(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue); |
| TestSmiAnd(masm, &exit, 0xA0, Smi::kMinValue, -1); |
| TestSmiAnd(masm, &exit, 0xB0, Smi::kMinValue, -1); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiOr(MacroAssembler* masm, Label* exit, int id, int x, int y) { |
| int result = x | y; |
| |
| __ movl(rax, Immediate(id)); |
| |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| __ Move(rdx, Smi::FromInt(y)); |
| __ Move(r8, Smi::FromInt(result)); |
| __ SmiOr(r9, rcx, rdx); |
| __ cmpq(r8, r9); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiOr(rcx, rcx, rdx); |
| __ cmpq(r8, rcx); |
| __ j(not_equal, exit); |
| |
| __ movq(rcx, r11); |
| __ incq(rax); |
| __ SmiOrConstant(r9, rcx, Smi::FromInt(y)); |
| __ cmpq(r8, r9); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiOrConstant(rcx, rcx, Smi::FromInt(y)); |
| __ cmpq(r8, rcx); |
| __ j(not_equal, exit); |
| } |
| |
| |
| TEST(SmiOr) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiOr(masm, &exit, 0x10, 0, 0); |
| TestSmiOr(masm, &exit, 0x20, 0, 1); |
| TestSmiOr(masm, &exit, 0x30, 1, 0); |
| TestSmiOr(masm, &exit, 0x40, 0, -1); |
| TestSmiOr(masm, &exit, 0x50, -1, 0); |
| TestSmiOr(masm, &exit, 0x60, -1, -1); |
| TestSmiOr(masm, &exit, 0x70, 1, 1); |
| TestSmiOr(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue); |
| TestSmiOr(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue); |
| TestSmiOr(masm, &exit, 0xA0, Smi::kMinValue, -1); |
| TestSmiOr(masm, &exit, 0xB0, 0x05555555, 0x01234567); |
| TestSmiOr(masm, &exit, 0xC0, 0x05555555, 0x0fedcba9); |
| TestSmiOr(masm, &exit, 0xD0, Smi::kMinValue, -1); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiXor(MacroAssembler* masm, Label* exit, int id, int x, int y) { |
| int result = x ^ y; |
| |
| __ movl(rax, Immediate(id)); |
| |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| __ Move(rdx, Smi::FromInt(y)); |
| __ Move(r8, Smi::FromInt(result)); |
| __ SmiXor(r9, rcx, rdx); |
| __ cmpq(r8, r9); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiXor(rcx, rcx, rdx); |
| __ cmpq(r8, rcx); |
| __ j(not_equal, exit); |
| |
| __ movq(rcx, r11); |
| __ incq(rax); |
| __ SmiXorConstant(r9, rcx, Smi::FromInt(y)); |
| __ cmpq(r8, r9); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiXorConstant(rcx, rcx, Smi::FromInt(y)); |
| __ cmpq(r8, rcx); |
| __ j(not_equal, exit); |
| } |
| |
| |
| TEST(SmiXor) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiXor(masm, &exit, 0x10, 0, 0); |
| TestSmiXor(masm, &exit, 0x20, 0, 1); |
| TestSmiXor(masm, &exit, 0x30, 1, 0); |
| TestSmiXor(masm, &exit, 0x40, 0, -1); |
| TestSmiXor(masm, &exit, 0x50, -1, 0); |
| TestSmiXor(masm, &exit, 0x60, -1, -1); |
| TestSmiXor(masm, &exit, 0x70, 1, 1); |
| TestSmiXor(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue); |
| TestSmiXor(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue); |
| TestSmiXor(masm, &exit, 0xA0, Smi::kMinValue, -1); |
| TestSmiXor(masm, &exit, 0xB0, 0x5555555, 0x01234567); |
| TestSmiXor(masm, &exit, 0xC0, 0x5555555, 0x0fedcba9); |
| TestSmiXor(masm, &exit, 0xD0, Smi::kMinValue, -1); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiNot(MacroAssembler* masm, Label* exit, int id, int x) { |
| int result = ~x; |
| __ movl(rax, Immediate(id)); |
| |
| __ Move(r8, Smi::FromInt(result)); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| |
| __ SmiNot(r9, rcx); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ cmpq(r11, rcx); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ SmiNot(rcx, rcx); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| } |
| |
| |
| TEST(SmiNot) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiNot(masm, &exit, 0x10, 0); |
| TestSmiNot(masm, &exit, 0x20, 1); |
| TestSmiNot(masm, &exit, 0x30, -1); |
| TestSmiNot(masm, &exit, 0x40, 127); |
| TestSmiNot(masm, &exit, 0x50, 65535); |
| TestSmiNot(masm, &exit, 0x60, Smi::kMinValue); |
| TestSmiNot(masm, &exit, 0x70, Smi::kMaxValue); |
| TestSmiNot(masm, &exit, 0x80, 0x05555555); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) { |
| const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1}; |
| const int kNumShifts = 5; |
| __ movl(rax, Immediate(id)); |
| for (int i = 0; i < kNumShifts; i++) { |
| // rax == id + i * 10. |
| int shift = shifts[i]; |
| int result = x << shift; |
| CHECK(Smi::IsValid(result)); |
| __ Move(r8, Smi::FromInt(result)); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ SmiShiftLeftConstant(r9, rcx, shift); |
| |
| __ incq(rax); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ SmiShiftLeftConstant(rcx, rcx, shift); |
| |
| __ incq(rax); |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(rdx, Smi::FromInt(x)); |
| __ Move(rcx, Smi::FromInt(shift)); |
| __ SmiShiftLeft(r9, rdx, rcx); |
| |
| __ incq(rax); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(rdx, Smi::FromInt(x)); |
| __ Move(r11, Smi::FromInt(shift)); |
| __ SmiShiftLeft(r9, rdx, r11); |
| |
| __ incq(rax); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(rdx, Smi::FromInt(x)); |
| __ Move(r11, Smi::FromInt(shift)); |
| __ SmiShiftLeft(rdx, rdx, r11); |
| |
| __ incq(rax); |
| __ cmpq(rdx, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| } |
| } |
| |
| |
| TEST(SmiShiftLeft) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 4, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiShiftLeft(masm, &exit, 0x10, 0); |
| TestSmiShiftLeft(masm, &exit, 0x50, 1); |
| TestSmiShiftLeft(masm, &exit, 0x90, 127); |
| TestSmiShiftLeft(masm, &exit, 0xD0, 65535); |
| TestSmiShiftLeft(masm, &exit, 0x110, Smi::kMaxValue); |
| TestSmiShiftLeft(masm, &exit, 0x150, Smi::kMinValue); |
| TestSmiShiftLeft(masm, &exit, 0x190, -1); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiShiftLogicalRight(MacroAssembler* masm, |
| Label* exit, |
| int id, |
| int x) { |
| const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1}; |
| const int kNumShifts = 5; |
| __ movl(rax, Immediate(id)); |
| for (int i = 0; i < kNumShifts; i++) { |
| int shift = shifts[i]; |
| intptr_t result = static_cast<unsigned int>(x) >> shift; |
| if (Smi::IsValid(result)) { |
| __ Move(r8, Smi::FromInt(static_cast<int>(result))); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ SmiShiftLogicalRightConstant(r9, rcx, shift, exit); |
| |
| __ incq(rax); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(rdx, Smi::FromInt(x)); |
| __ Move(rcx, Smi::FromInt(shift)); |
| __ SmiShiftLogicalRight(r9, rdx, rcx, exit); |
| |
| __ incq(rax); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(rdx, Smi::FromInt(x)); |
| __ Move(r11, Smi::FromInt(shift)); |
| __ SmiShiftLogicalRight(r9, rdx, r11, exit); |
| |
| __ incq(rax); |
| __ cmpq(r9, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| } else { |
| // Cannot happen with long smis. |
| Label fail_ok; |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| __ SmiShiftLogicalRightConstant(r9, rcx, shift, &fail_ok); |
| __ jmp(exit); |
| __ bind(&fail_ok); |
| |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(r8, Smi::FromInt(shift)); |
| Label fail_ok3; |
| __ SmiShiftLogicalRight(r9, rcx, r8, &fail_ok3); |
| __ jmp(exit); |
| __ bind(&fail_ok3); |
| |
| __ incq(rax); |
| __ cmpq(rcx, r11); |
| __ j(not_equal, exit); |
| |
| __ addq(rax, Immediate(3)); |
| } |
| } |
| } |
| |
| |
| TEST(SmiShiftLogicalRight) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 3, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiShiftLogicalRight(masm, &exit, 0x10, 0); |
| TestSmiShiftLogicalRight(masm, &exit, 0x30, 1); |
| TestSmiShiftLogicalRight(masm, &exit, 0x50, 127); |
| TestSmiShiftLogicalRight(masm, &exit, 0x70, 65535); |
| TestSmiShiftLogicalRight(masm, &exit, 0x90, Smi::kMaxValue); |
| TestSmiShiftLogicalRight(masm, &exit, 0xB0, Smi::kMinValue); |
| TestSmiShiftLogicalRight(masm, &exit, 0xD0, -1); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestSmiShiftArithmeticRight(MacroAssembler* masm, |
| Label* exit, |
| int id, |
| int x) { |
| const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1}; |
| const int kNumShifts = 5; |
| __ movl(rax, Immediate(id)); |
| for (int i = 0; i < kNumShifts; i++) { |
| int shift = shifts[i]; |
| // Guaranteed arithmetic shift. |
| int result = (x < 0) ? ~((~x) >> shift) : (x >> shift); |
| __ Move(r8, Smi::FromInt(result)); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ SmiShiftArithmeticRightConstant(rcx, rcx, shift); |
| |
| __ cmpq(rcx, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| __ Move(rdx, Smi::FromInt(x)); |
| __ Move(r11, Smi::FromInt(shift)); |
| __ SmiShiftArithmeticRight(rdx, rdx, r11); |
| |
| __ cmpq(rdx, r8); |
| __ j(not_equal, exit); |
| |
| __ incq(rax); |
| } |
| } |
| |
| |
| TEST(SmiShiftArithmeticRight) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestSmiShiftArithmeticRight(masm, &exit, 0x10, 0); |
| TestSmiShiftArithmeticRight(masm, &exit, 0x20, 1); |
| TestSmiShiftArithmeticRight(masm, &exit, 0x30, 127); |
| TestSmiShiftArithmeticRight(masm, &exit, 0x40, 65535); |
| TestSmiShiftArithmeticRight(masm, &exit, 0x50, Smi::kMaxValue); |
| TestSmiShiftArithmeticRight(masm, &exit, 0x60, Smi::kMinValue); |
| TestSmiShiftArithmeticRight(masm, &exit, 0x70, -1); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| void TestPositiveSmiPowerUp(MacroAssembler* masm, Label* exit, int id, int x) { |
| ASSERT(x >= 0); |
| int powers[] = { 0, 1, 2, 3, 8, 16, 24, 31 }; |
| int power_count = 8; |
| __ movl(rax, Immediate(id)); |
| for (int i = 0; i < power_count; i++) { |
| int power = powers[i]; |
| intptr_t result = static_cast<intptr_t>(x) << power; |
| __ Set(r8, result); |
| __ Move(rcx, Smi::FromInt(x)); |
| __ movq(r11, rcx); |
| __ PositiveSmiTimesPowerOfTwoToInteger64(rdx, rcx, power); |
| __ cmpq(rdx, r8); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| __ cmpq(r11, rcx); // rcx unchanged. |
| __ j(not_equal, exit); |
| __ incq(rax); |
| __ PositiveSmiTimesPowerOfTwoToInteger64(rcx, rcx, power); |
| __ cmpq(rdx, r8); |
| __ j(not_equal, exit); |
| __ incq(rax); |
| } |
| } |
| |
| |
| TEST(PositiveSmiTimesPowerOfTwoToInteger64) { |
| v8::internal::V8::Initialize(NULL); |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 4, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| EntryCode(masm); |
| Label exit; |
| |
| TestPositiveSmiPowerUp(masm, &exit, 0x20, 0); |
| TestPositiveSmiPowerUp(masm, &exit, 0x40, 1); |
| TestPositiveSmiPowerUp(masm, &exit, 0x60, 127); |
| TestPositiveSmiPowerUp(masm, &exit, 0x80, 128); |
| TestPositiveSmiPowerUp(masm, &exit, 0xA0, 255); |
| TestPositiveSmiPowerUp(masm, &exit, 0xC0, 256); |
| TestPositiveSmiPowerUp(masm, &exit, 0x100, 65535); |
| TestPositiveSmiPowerUp(masm, &exit, 0x120, 65536); |
| TestPositiveSmiPowerUp(masm, &exit, 0x140, Smi::kMaxValue); |
| |
| __ xor_(rax, rax); // Success. |
| __ bind(&exit); |
| ExitCode(masm); |
| __ ret(0); |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| TEST(OperandOffset) { |
| v8::internal::V8::Initialize(NULL); |
| int data[256]; |
| for (int i = 0; i < 256; i++) { data[i] = i * 0x01010101; } |
| |
| // Allocate an executable page of memory. |
| size_t actual_size; |
| byte* buffer = |
| static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 2, |
| &actual_size, |
| true)); |
| CHECK(buffer); |
| HandleScope handles; |
| MacroAssembler assembler(Isolate::Current(), |
| buffer, |
| static_cast<int>(actual_size)); |
| |
| MacroAssembler* masm = &assembler; |
| masm->set_allow_stub_calls(false); |
| Label exit; |
| |
| EntryCode(masm); |
| __ push(r13); |
| __ push(r14); |
| __ push(rbx); |
| __ push(rbp); |
| __ push(Immediate(0x100)); // <-- rbp |
| __ movq(rbp, rsp); |
| __ push(Immediate(0x101)); |
| __ push(Immediate(0x102)); |
| __ push(Immediate(0x103)); |
| __ push(Immediate(0x104)); |
| __ push(Immediate(0x105)); // <-- rbx |
| __ push(Immediate(0x106)); |
| __ push(Immediate(0x107)); |
| __ push(Immediate(0x108)); |
| __ push(Immediate(0x109)); // <-- rsp |
| // rbp = rsp[9] |
| // r15 = rsp[3] |
| // rbx = rsp[5] |
| // r13 = rsp[7] |
| __ lea(r14, Operand(rsp, 3 * kPointerSize)); |
| __ lea(r13, Operand(rbp, -3 * kPointerSize)); |
| __ lea(rbx, Operand(rbp, -5 * kPointerSize)); |
| __ movl(rcx, Immediate(2)); |
| __ movq(r8, reinterpret_cast<uintptr_t>(&data[128]), RelocInfo::NONE64); |
| __ movl(rax, Immediate(1)); |
| |
| Operand sp0 = Operand(rsp, 0); |
| |
| // Test 1. |
| __ movl(rdx, sp0); // Sanity check. |
| __ cmpl(rdx, Immediate(0x109)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // Test 2. |
| // Zero to non-zero displacement. |
| __ movl(rdx, Operand(sp0, 2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x107)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand sp2 = Operand(rsp, 2 * kPointerSize); |
| |
| // Test 3. |
| __ movl(rdx, sp2); // Sanity check. |
| __ cmpl(rdx, Immediate(0x107)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(sp2, 2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x105)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // Non-zero to zero displacement. |
| __ movl(rdx, Operand(sp2, -2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x109)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand sp2c2 = Operand(rsp, rcx, times_pointer_size, 2 * kPointerSize); |
| |
| // Test 6. |
| __ movl(rdx, sp2c2); // Sanity check. |
| __ cmpl(rdx, Immediate(0x105)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(sp2c2, 2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x103)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // Non-zero to zero displacement. |
| __ movl(rdx, Operand(sp2c2, -2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x107)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| |
| Operand bp0 = Operand(rbp, 0); |
| |
| // Test 9. |
| __ movl(rdx, bp0); // Sanity check. |
| __ cmpl(rdx, Immediate(0x100)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // Zero to non-zero displacement. |
| __ movl(rdx, Operand(bp0, -2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x102)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand bp2 = Operand(rbp, -2 * kPointerSize); |
| |
| // Test 11. |
| __ movl(rdx, bp2); // Sanity check. |
| __ cmpl(rdx, Immediate(0x102)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // Non-zero to zero displacement. |
| __ movl(rdx, Operand(bp2, 2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x100)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(bp2, -2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x104)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand bp2c4 = Operand(rbp, rcx, times_pointer_size, -4 * kPointerSize); |
| |
| // Test 14: |
| __ movl(rdx, bp2c4); // Sanity check. |
| __ cmpl(rdx, Immediate(0x102)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(bp2c4, 2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x100)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(bp2c4, -2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x104)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand bx0 = Operand(rbx, 0); |
| |
| // Test 17. |
| __ movl(rdx, bx0); // Sanity check. |
| __ cmpl(rdx, Immediate(0x105)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(bx0, 5 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x100)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(bx0, -4 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x109)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand bx2 = Operand(rbx, 2 * kPointerSize); |
| |
| // Test 20. |
| __ movl(rdx, bx2); // Sanity check. |
| __ cmpl(rdx, Immediate(0x103)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(bx2, 2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x101)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // Non-zero to zero displacement. |
| __ movl(rdx, Operand(bx2, -2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x105)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand bx2c2 = Operand(rbx, rcx, times_pointer_size, -2 * kPointerSize); |
| |
| // Test 23. |
| __ movl(rdx, bx2c2); // Sanity check. |
| __ cmpl(rdx, Immediate(0x105)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(bx2c2, 2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x103)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(bx2c2, -2 * kPointerSize)); |
| __ cmpl(rdx, Immediate(0x107)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand r80 = Operand(r8, 0); |
| |
| // Test 26. |
| __ movl(rdx, r80); // Sanity check. |
| __ cmpl(rdx, Immediate(0x80808080)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, -8 * kIntSize)); |
| __ cmpl(rdx, Immediate(0x78787878)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, 8 * kIntSize)); |
| __ cmpl(rdx, Immediate(0x88888888)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, -64 * kIntSize)); |
| __ cmpl(rdx, Immediate(0x40404040)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, 64 * kIntSize)); |
| __ cmpl(rdx, Immediate(0xC0C0C0C0)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| Operand r88 = Operand(r8, 8 * kIntSize); |
| |
| // Test 31. |
| __ movl(rdx, r88); // Sanity check. |
| __ cmpl(rdx, Immediate(0x88888888)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r88, -8 * kIntSize)); |
| __ cmpl(rdx, Immediate(0x80808080)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r88, 8 * kIntSize)); |
| __ cmpl(rdx, Immediate(0x90909090)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r88, -64 * kIntSize)); |
| __ cmpl(rdx, Immediate(0x48484848)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r88, 64 * kIntSize)); |
| __ cmpl(rdx, Immediate(0xC8C8C8C8)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| |
| Operand r864 = Operand(r8, 64 * kIntSize); |
| |
| // Test 36. |
| __ movl(rdx, r864); // Sanity check. |
| __ cmpl(rdx, Immediate(0xC0C0C0C0)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r864, -8 * kIntSize)); |
| __ cmpl(rdx, Immediate(0xB8B8B8B8)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r864, 8 * kIntSize)); |
| __ cmpl(rdx, Immediate(0xC8C8C8C8)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r864, -64 * kIntSize)); |
| __ cmpl(rdx, Immediate(0x80808080)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r864, 32 * kIntSize)); |
| __ cmpl(rdx, Immediate(0xE0E0E0E0)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // 32-bit offset to 8-bit offset. |
| __ movl(rdx, Operand(r864, -60 * kIntSize)); |
| __ cmpl(rdx, Immediate(0x84848484)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r864, 60 * kIntSize)); |
| __ cmpl(rdx, Immediate(0xFCFCFCFC)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // Test unaligned offsets. |
| |
| // Test 43. |
| __ movl(rdx, Operand(r80, 2)); |
| __ cmpl(rdx, Immediate(0x81818080)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, -2)); |
| __ cmpl(rdx, Immediate(0x80807F7F)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, 126)); |
| __ cmpl(rdx, Immediate(0xA0A09F9F)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, -126)); |
| __ cmpl(rdx, Immediate(0x61616060)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, 254)); |
| __ cmpl(rdx, Immediate(0xC0C0BFBF)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| __ movl(rdx, Operand(r80, -254)); |
| __ cmpl(rdx, Immediate(0x41414040)); |
| __ j(not_equal, &exit); |
| __ incq(rax); |
| |
| // Success. |
| |
| __ movl(rax, Immediate(0)); |
| __ bind(&exit); |
| __ lea(rsp, Operand(rbp, kPointerSize)); |
| __ pop(rbp); |
| __ pop(rbx); |
| __ pop(r14); |
| __ pop(r13); |
| ExitCode(masm); |
| __ ret(0); |
| |
| |
| CodeDesc desc; |
| masm->GetCode(&desc); |
| // Call the function from C++. |
| int result = FUNCTION_CAST<F0>(buffer)(); |
| CHECK_EQ(0, result); |
| } |
| |
| |
| |
| #undef __ |