blob: 3b8905bb7ceb3fbe1f7d63a4ac1ff5dd39eb8123 [file] [log] [blame]
// 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::byte;
using v8::internal::OS;
using v8::internal::Assembler;
using v8::internal::Condition;
using v8::internal::MacroAssembler;
using v8::internal::HandleScope;
using v8::internal::Operand;
using v8::internal::Immediate;
using v8::internal::SmiIndex;
using v8::internal::Label;
using v8::internal::RelocInfo;
using v8::internal::rax;
using v8::internal::rbx;
using v8::internal::rsi;
using v8::internal::rdi;
using v8::internal::rcx;
using v8::internal::rdx;
using v8::internal::rbp;
using v8::internal::rsp;
using v8::internal::r8;
using v8::internal::r9;
using v8::internal::r11;
using v8::internal::r12; // Remember: r12..r15 are callee save!
using v8::internal::r13;
using v8::internal::r14;
using v8::internal::r15;
using v8::internal::FUNCTION_CAST;
using v8::internal::CodeDesc;
using v8::internal::less_equal;
using v8::internal::not_equal;
using v8::internal::not_zero;
using v8::internal::greater;
using v8::internal::greater_equal;
using v8::internal::carry;
using v8::internal::not_carry;
using v8::internal::negative;
using v8::internal::positive;
using v8::internal::Smi;
using v8::internal::kSmiTagMask;
using v8::internal::kSmiValueSize;
// 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->
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) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler; // Create a pointer for the __ macro.
masm->set_allow_stub_calls(false);
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);
__ 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 {
__ SmiCompare(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) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ ret(0);
CodeDesc desc;
masm->GetCode(&desc);
// Call the function from C++.
int result = FUNCTION_CAST<F0>(buffer)();
CHECK_EQ(0, result);
}
TEST(Integer32ToSmi) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
Label exit;
__ movq(rax, Immediate(1)); // Test number.
__ movl(rcx, Immediate(0));
__ Integer32ToSmi(rcx, rcx);
__ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
__ SmiCompare(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)));
__ SmiCompare(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)));
__ SmiCompare(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)));
__ SmiCompare(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)));
__ SmiCompare(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)));
__ SmiCompare(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)));
__ SmiCompare(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)));
__ SmiCompare(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)));
__ SmiCompare(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)));
__ SmiCompare(r8, rdx);
__ j(not_equal, &exit);
__ xor_(rax, rax); // Success.
__ bind(&exit);
__ 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::NONE);
__ movq(r11, rcx);
__ Integer64PlusConstantToSmi(rdx, rcx, y);
__ SmiCompare(rdx, r8);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ Integer64PlusConstantToSmi(rcx, rcx, y);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
}
TEST(Integer64PlusConstantToSmi) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ ret(0);
CodeDesc desc;
masm->GetCode(&desc);
// Call the function from C++.
int result = FUNCTION_CAST<F0>(buffer)();
CHECK_EQ(0, result);
}
TEST(SmiCheck) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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->CheckPositiveSmi(rcx); // Zero counts as positive.
__ j(NegateCondition(cond), &exit);
__ incq(rax);
__ xor_(rcx, Immediate(kSmiTagMask));
cond = masm->CheckPositiveSmi(rcx); // "zero" non-smi.
__ j(cond, &exit);
__ incq(rax);
__ movq(rcx, Immediate(-1));
__ Integer32ToSmi(rcx, rcx);
cond = masm->CheckPositiveSmi(rcx); // Negative smis are not positive.
__ j(cond, &exit);
__ incq(rax);
__ movq(rcx, Immediate(Smi::kMinValue));
__ Integer32ToSmi(rcx, rcx);
cond = masm->CheckPositiveSmi(rcx); // Most negative smi is not positive.
__ j(cond, &exit);
__ incq(rax);
__ xor_(rcx, Immediate(kSmiTagMask));
cond = masm->CheckPositiveSmi(rcx); // "Negative" non-smi.
__ j(cond, &exit);
__ incq(rax);
__ movq(rcx, Immediate(Smi::kMaxValue));
__ Integer32ToSmi(rcx, rcx);
cond = masm->CheckPositiveSmi(rcx); // Most positive smi is positive.
__ j(NegateCondition(cond), &exit);
__ incq(rax);
__ xor_(rcx, Immediate(kSmiTagMask));
cond = masm->CheckPositiveSmi(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);
__ 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);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiNeg(rcx, rcx, exit);
__ incq(rax);
__ SmiCompare(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);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiNeg(rcx, rcx, &smi_ok2);
__ jmp(exit);
__ bind(&smi_ok2);
__ incq(rax);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
}
}
TEST(SmiNeg) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax);
__ SmiAdd(rcx, rcx, rdx, exit); \
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
__ movl(rcx, Immediate(first));
__ Integer32ToSmi(rcx, rcx);
__ incq(rax);
__ SmiAddConstant(r9, rcx, Smi::FromInt(second));
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ SmiAddConstant(rcx, rcx, Smi::FromInt(second));
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
__ movl(rcx, Immediate(first));
__ Integer32ToSmi(rcx, rcx);
__ incq(rax);
__ SmiAddConstant(r9, rcx, Smi::FromInt(second), exit);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax);
__ SmiAddConstant(rcx, rcx, Smi::FromInt(second), exit);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
}
TEST(SmiAdd) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax); // Test 1.
__ SmiSub(rcx, rcx, rdx, exit);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
__ Move(rcx, Smi::FromInt(first));
__ incq(rax); // Test 2.
__ SmiSubConstant(r9, rcx, Smi::FromInt(second));
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax); // Test 3.
__ SmiSubConstant(rcx, rcx, Smi::FromInt(second));
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
__ Move(rcx, Smi::FromInt(first));
__ incq(rax); // Test 4.
__ SmiSubConstant(r9, rcx, Smi::FromInt(second), exit);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax); // Test 5.
__ SmiSubConstant(rcx, rcx, Smi::FromInt(second), exit);
__ SmiCompare(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);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
}
{
Label overflow_ok;
__ incq(rax);
__ SmiSub(rcx, rcx, rdx, &overflow_ok);
__ jmp(exit);
__ bind(&overflow_ok);
__ incq(rax);
__ SmiCompare(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);
__ SmiCompare(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);
__ SmiCompare(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);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
}
{
Label overflow_ok;
__ incq(rax);
__ SmiSub(rcx, rcx, rdx, &overflow_ok);
__ jmp(exit);
__ bind(&overflow_ok);
__ incq(rax);
__ SmiCompare(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);
__ SmiCompare(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);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
}
}
TEST(SmiSub) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax);
__ SmiMul(rcx, rcx, rdx, exit);
__ SmiCompare(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);
__ SmiCompare(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);
// __ SmiCompare(r11, rcx);
// __ j(not_equal, exit);
}
}
TEST(SmiMul) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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(r12, 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, r12, exit);
// Might have destroyed rcx and r12.
__ incq(r15);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(r15);
__ movq(rcx, r11);
__ Move(r12, Smi::FromInt(y));
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
__ incq(r15);
__ SmiDiv(rcx, rcx, r12, exit);
__ incq(r15);
__ SmiCompare(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, r12, &fail_ok);
__ jmp(exit);
__ bind(&fail_ok);
__ incq(r15);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
__ incq(r15);
__ SmiDiv(rcx, rcx, r12, &fail_ok2);
__ jmp(exit);
__ bind(&fail_ok2);
__ incq(r15);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
}
}
TEST(SmiDiv) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
Label exit;
__ push(r12);
__ 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(r12);
__ 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(r12, 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, r12, exit);
__ incq(r15);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(r15);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
__ incq(r15);
__ SmiMod(rcx, rcx, r12, exit);
__ incq(r15);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
} else {
// Modulo fails.
__ movq(r15, Immediate(id + 8));
Label fail_ok, fail_ok2;
__ SmiMod(r9, rcx, r12, &fail_ok);
__ jmp(exit);
__ bind(&fail_ok);
__ incq(r15);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
__ incq(r15);
__ SmiMod(rcx, rcx, r12, &fail_ok2);
__ jmp(exit);
__ bind(&fail_ok2);
__ incq(r15);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
}
}
TEST(SmiMod) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
Label exit;
__ push(r12);
__ 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(r12);
__ 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);
__ SmiCompare(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);
__ SmiCompare(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);
__ SmiCompare(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);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
__ incq(rax);
}
}
TEST(SmiIndex) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(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);
__ SmiCompare(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) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false); // Avoid inline checks.
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);
__ 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);
__ SmiCompare(r8, r9);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiAnd(rcx, rcx, rdx);
__ SmiCompare(r8, rcx);
__ j(not_equal, exit);
__ movq(rcx, r11);
__ incq(rax);
__ SmiAndConstant(r9, rcx, Smi::FromInt(y));
__ SmiCompare(r8, r9);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiAndConstant(rcx, rcx, Smi::FromInt(y));
__ SmiCompare(r8, rcx);
__ j(not_equal, exit);
}
TEST(SmiAnd) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(r8, r9);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiOr(rcx, rcx, rdx);
__ SmiCompare(r8, rcx);
__ j(not_equal, exit);
__ movq(rcx, r11);
__ incq(rax);
__ SmiOrConstant(r9, rcx, Smi::FromInt(y));
__ SmiCompare(r8, r9);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiOrConstant(rcx, rcx, Smi::FromInt(y));
__ SmiCompare(r8, rcx);
__ j(not_equal, exit);
}
TEST(SmiOr) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(r8, r9);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiXor(rcx, rcx, rdx);
__ SmiCompare(r8, rcx);
__ j(not_equal, exit);
__ movq(rcx, r11);
__ incq(rax);
__ SmiXorConstant(r9, rcx, Smi::FromInt(y));
__ SmiCompare(r8, r9);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiXorConstant(rcx, rcx, Smi::FromInt(y));
__ SmiCompare(r8, rcx);
__ j(not_equal, exit);
}
TEST(SmiXor) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx);
__ j(not_equal, exit);
__ incq(rax);
__ SmiNot(rcx, rcx);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
}
TEST(SmiNot) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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;
if (Smi::IsValid(result)) {
__ Move(r8, Smi::FromInt(result));
__ Move(rcx, Smi::FromInt(x));
__ SmiShiftLeftConstant(r9, rcx, shift, exit);
__ incq(rax);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax);
__ Move(rcx, Smi::FromInt(x));
__ SmiShiftLeftConstant(rcx, rcx, shift, exit);
__ incq(rax);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
__ incq(rax);
__ Move(rdx, Smi::FromInt(x));
__ Move(rcx, Smi::FromInt(shift));
__ SmiShiftLeft(r9, rdx, rcx, exit);
__ incq(rax);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax);
__ Move(rdx, Smi::FromInt(x));
__ Move(r11, Smi::FromInt(shift));
__ SmiShiftLeft(r9, rdx, r11, exit);
__ incq(rax);
__ SmiCompare(r9, r8);
__ j(not_equal, exit);
__ incq(rax);
__ Move(rdx, Smi::FromInt(x));
__ Move(r11, Smi::FromInt(shift));
__ SmiShiftLeft(rdx, rdx, r11, exit);
__ incq(rax);
__ SmiCompare(rdx, r8);
__ j(not_equal, exit);
__ incq(rax);
} else {
// Cannot happen with long smis.
Label fail_ok;
__ Move(rcx, Smi::FromInt(x));
__ movq(r11, rcx);
__ SmiShiftLeftConstant(r9, rcx, shift, &fail_ok);
__ jmp(exit);
__ bind(&fail_ok);
__ incq(rax);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
__ incq(rax);
Label fail_ok2;
__ SmiShiftLeftConstant(rcx, rcx, shift, &fail_ok2);
__ jmp(exit);
__ bind(&fail_ok2);
__ incq(rax);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
__ incq(rax);
__ Move(r8, Smi::FromInt(shift));
Label fail_ok3;
__ SmiShiftLeft(r9, rcx, r8, &fail_ok3);
__ jmp(exit);
__ bind(&fail_ok3);
__ incq(rax);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
__ incq(rax);
__ Move(r8, Smi::FromInt(shift));
__ movq(rdx, r11);
Label fail_ok4;
__ SmiShiftLeft(rdx, rdx, r8, &fail_ok4);
__ jmp(exit);
__ bind(&fail_ok4);
__ incq(rax);
__ SmiCompare(rdx, r11);
__ j(not_equal, exit);
__ addq(rax, Immediate(3));
}
}
}
TEST(SmiShiftLeft) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(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);
__ SmiCompare(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);
__ SmiCompare(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);
__ SmiCompare(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);
__ SmiCompare(rcx, r11);
__ j(not_equal, exit);
__ addq(rax, Immediate(3));
}
}
}
TEST(SmiShiftLogicalRight) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(rcx, r8);
__ j(not_equal, exit);
__ incq(rax);
__ Move(rdx, Smi::FromInt(x));
__ Move(r11, Smi::FromInt(shift));
__ SmiShiftArithmeticRight(rdx, rdx, r11);
__ SmiCompare(rdx, r8);
__ j(not_equal, exit);
__ incq(rax);
}
}
TEST(SmiShiftArithmeticRight) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ 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);
__ SmiCompare(rdx, r8);
__ j(not_equal, exit);
__ incq(rax);
__ SmiCompare(r11, rcx); // rcx unchanged.
__ j(not_equal, exit);
__ incq(rax);
__ PositiveSmiTimesPowerOfTwoToInteger64(rcx, rcx, power);
__ SmiCompare(rdx, r8);
__ j(not_equal, exit);
__ incq(rax);
}
}
TEST(PositiveSmiTimesPowerOfTwoToInteger64) {
// 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(buffer, static_cast<int>(actual_size));
MacroAssembler* masm = &assembler;
masm->set_allow_stub_calls(false);
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);
__ ret(0);
CodeDesc desc;
masm->GetCode(&desc);
// Call the function from C++.
int result = FUNCTION_CAST<F0>(buffer)();
CHECK_EQ(0, result);
}
#undef __