CSE2410 Fall 2014 Bounce

// 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::Representation;

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, value);

  __ Set(rdx, reinterpret_cast<intptr_t>(value));

  __ 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

}

static void SmiAddOverflowTest(MacroAssembler* masm,

                               Label* exit,

                               int id,

                               int x) {

  // Adds a Smi to x so that the addition overflows.

  ASSERT(x != 0);  // Can't overflow by adding a Smi.

  int y_max = (x > 0) ? (Smi::kMaxValue + 0) : (Smi::kMinValue - x - 1);

  int y_min = (x > 0) ? (Smi::kMaxValue - x + 1) : (Smi::kMinValue + 0);

  __ 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;

    __ SmiAdd(r9, rcx, rdx, &overflow_ok);

    __ jmp(exit);

    __ bind(&overflow_ok);

    __ incq(rax);

    __ cmpq(rcx, r11);

    __ j(not_equal, exit);

  }

  {

    Label overflow_ok;

    __ incq(rax);

    __ SmiAdd(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);

    __ SmiAddConstant(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);

    __ SmiAddConstant(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);

    __ SmiAdd(r9, rcx, rdx, &overflow_ok);

    __ jmp(exit);

    __ bind(&overflow_ok);

    __ incq(rax);

    __ cmpq(rcx, r11);

    __ j(not_equal, exit);

  }

  {

    Label overflow_ok;

    __ incq(rax);

    __ SmiAdd(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);

    __ SmiAddConstant(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);

    __ SmiAddConstant(rcx, rcx, Smi::FromInt(y_max), &overflow_ok);

    __ jmp(exit);

    __ bind(&overflow_ok);

    __ incq(rax);

    __ cmpq(rcx, r11);

    __ 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 * 2,

                                      &actual_size,

                                      true));

  CHECK(buffer);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

  SmiAddOverflowTest(masm, &exit, 0x90, -1);

  SmiAddOverflowTest(masm, &exit, 0xA0, 1);

  SmiAddOverflowTest(masm, &exit, 0xB0, 1024);

  SmiAddOverflowTest(masm, &exit, 0xC0, Smi::kMaxValue);

  SmiAddOverflowTest(masm, &exit, 0xD0, -2);

  SmiAddOverflowTest(masm, &exit, 0xE0, -42000);

  SmiAddOverflowTest(masm, &exit, 0xF0, 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

#if 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, 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);

  Isolate* isolate = CcTest::i_isolate();

  HandleScope handles(isolate);

  MacroAssembler assembler(isolate, buffer, static_cast<int>(actual_size));

  MacroAssembler* masm = &assembler;

  masm->set_allow_stub_calls(false);

  EntryCode(masm);

  Label exit;