d1/d12/test-assembler-x64_8cc_source.html

 // 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 namespace v8::internal;


 // 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 six arguments

 // in RDI, RSI, 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,

 // where the first four integer arguments are passed in RCX, RDX, R8 and R9.


 typedef int (*F0)();

 typedef int (*F1)(int64_t x);

 typedef int (*F2)(int64_t x, int64_t y);

 typedef int (*F3)(double x);

 typedef int64_t (*F4)(int64_t* x, int64_t* y);

 typedef int64_t (*F5)(int64_t x);


 #ifdef _WIN64

 static const Register arg1 = rcx;

 static const Register arg2 = rdx;

 #else

 static const Register arg1 = rdi;

 static const Register arg2 = rsi;

 #endif


 #define __ assm.


 TEST(AssemblerX64ReturnOperation) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   // Assemble a simple function that copies argument 2 and returns it.

   __ movq(rax, arg2);

   __ nop();

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);

   CHECK_EQ(2, result);

 }


 TEST(AssemblerX64StackOperations) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   // Assemble a simple function that copies argument 2 and returns it.

   // We compile without stack frame pointers, so the gdb debugger shows

   // incorrect stack frames when debugging this function (which has them).

   __ pushq(rbp);

   __ movq(rbp, rsp);

   __ pushq(arg2);  // Value at (rbp - 8)

   __ pushq(arg2);  // Value at (rbp - 16)

   __ pushq(arg1);  // Value at (rbp - 24)

   __ popq(rax);

   __ popq(rax);

   __ popq(rax);

   __ popq(rbp);

   __ nop();

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);

   CHECK_EQ(2, result);

 }


 TEST(AssemblerX64ArithmeticOperations) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   // Assemble a simple function that adds arguments returning the sum.

   __ movq(rax, arg2);

   __ addq(rax, arg1);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);

   CHECK_EQ(5, result);

 }


 TEST(AssemblerX64ImulOperation) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   // Assemble a simple function that multiplies arguments returning the high

   // word.

   __ movq(rax, arg2);

   __ imulq(arg1);

   __ movq(rax, rdx);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);

   CHECK_EQ(0, result);

   result =  FUNCTION_CAST<F2>(buffer)(0x100000000l, 0x100000000l);

   CHECK_EQ(1, result);

   result =  FUNCTION_CAST<F2>(buffer)(-0x100000000l, 0x100000000l);

   CHECK_EQ(-1, result);

 }


 TEST(AssemblerX64XchglOperations) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   __ movq(rax, Operand(arg1, 0));

   __ movq(r11, Operand(arg2, 0));

   __ xchgl(rax, r11);

   __ movq(Operand(arg1, 0), rax);

   __ movq(Operand(arg2, 0), r11);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);

   int64_t right  = V8_2PART_UINT64_C(0x30000000, 40000000);

   int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);

   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 40000000), left);

   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 20000000), right);

   USE(result);

 }


 TEST(AssemblerX64OrlOperations) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   __ movq(rax, Operand(arg2, 0));

   __ orl(Operand(arg1, 0), rax);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);

   int64_t right  = V8_2PART_UINT64_C(0x30000000, 40000000);

   int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);

   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, 60000000), left);

   USE(result);

 }


 TEST(AssemblerX64RollOperations) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   __ movq(rax, arg1);

   __ roll(rax, Immediate(1));

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int64_t src    = V8_2PART_UINT64_C(0x10000000, C0000000);

   int64_t result = FUNCTION_CAST<F5>(buffer)(src);

   CHECK_EQ(V8_2PART_UINT64_C(0x00000000, 80000001), result);

 }


 TEST(AssemblerX64SublOperations) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   __ movq(rax, Operand(arg2, 0));

   __ subl(Operand(arg1, 0), rax);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);

   int64_t right  = V8_2PART_UINT64_C(0x30000000, 40000000);

   int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);

   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, e0000000), left);

   USE(result);

 }


 TEST(AssemblerX64TestlOperations) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   // Set rax with the ZF flag of the testl instruction.

   Label done;

   __ movq(rax, Immediate(1));

   __ movq(r11, Operand(arg2, 0));

   __ testl(Operand(arg1, 0), r11);

   __ j(zero, &done, Label::kNear);

   __ movq(rax, Immediate(0));

   __ bind(&done);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);

   int64_t right  = V8_2PART_UINT64_C(0x30000000, 00000000);

   int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);

   CHECK_EQ(static_cast<int64_t>(1), result);

 }


 TEST(AssemblerX64XorlOperations) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   __ movq(rax, Operand(arg2, 0));

   __ xorl(Operand(arg1, 0), rax);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int64_t left   = V8_2PART_UINT64_C(0x10000000, 20000000);

   int64_t right  = V8_2PART_UINT64_C(0x30000000, 60000000);

   int64_t result = FUNCTION_CAST<F4>(buffer)(&left, &right);

   CHECK_EQ(V8_2PART_UINT64_C(0x10000000, 40000000), left);

   USE(result);

 }


 TEST(AssemblerX64MemoryOperands) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   // Assemble a simple function that copies argument 2 and returns it.

   __ pushq(rbp);

   __ movq(rbp, rsp);


   __ pushq(arg2);  // Value at (rbp - 8)

   __ pushq(arg2);  // Value at (rbp - 16)

   __ pushq(arg1);  // Value at (rbp - 24)


   const int kStackElementSize = 8;

   __ movq(rax, Operand(rbp, -3 * kStackElementSize));

   __ popq(arg2);

   __ popq(arg2);

   __ popq(arg2);

   __ popq(rbp);

   __ nop();

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);

   CHECK_EQ(3, result);

 }


 TEST(AssemblerX64ControlFlow) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));


   // Assemble a simple function that copies argument 1 and returns it.

   __ pushq(rbp);


   __ movq(rbp, rsp);

   __ movq(rax, arg1);

   Label target;

   __ jmp(&target);

   __ movq(rax, arg2);

   __ bind(&target);

   __ popq(rbp);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int result =  FUNCTION_CAST<F2>(buffer)(3, 2);

   CHECK_EQ(3, result);

 }


 TEST(AssemblerX64LoopImmediates) {

   // Allocate an executable page of memory.

   size_t actual_size;

   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,

                                                  &actual_size,

                                                  true));

   CHECK(buffer);

   Assembler assm(CcTest::i_isolate(), buffer, static_cast<int>(actual_size));

   // Assemble two loops using rax as counter, and verify the ending counts.

   Label Fail;

   __ movq(rax, Immediate(-3));

   Label Loop1_test;

   Label Loop1_body;

   __ jmp(&Loop1_test);

   __ bind(&Loop1_body);

   __ addq(rax, Immediate(7));

   __ bind(&Loop1_test);

   __ cmpq(rax, Immediate(20));

   __ j(less_equal, &Loop1_body);

   // Did the loop terminate with the expected value?

   __ cmpq(rax, Immediate(25));

   __ j(not_equal, &Fail);


   Label Loop2_test;

   Label Loop2_body;

   __ movq(rax, Immediate(0x11FEED00));

   __ jmp(&Loop2_test);

   __ bind(&Loop2_body);

   __ addq(rax, Immediate(-0x1100));

   __ bind(&Loop2_test);

   __ cmpq(rax, Immediate(0x11FE8000));

   __ j(greater, &Loop2_body);

   // Did the loop terminate with the expected value?

   __ cmpq(rax, Immediate(0x11FE7600));

   __ j(not_equal, &Fail);


   __ movq(rax, Immediate(1));

   __ ret(0);

   __ bind(&Fail);

   __ movq(rax, Immediate(0));

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   // Call the function from C++.

   int result =  FUNCTION_CAST<F0>(buffer)();

   CHECK_EQ(1, result);

 }


 TEST(OperandRegisterDependency) {

   int offsets[4] = {0, 1, 0xfed, 0xbeefcad};

   for (int i = 0; i < 4; i++) {

     int offset = offsets[i];

     CHECK(Operand(rax, offset).AddressUsesRegister(rax));

     CHECK(!Operand(rax, offset).AddressUsesRegister(r8));

     CHECK(!Operand(rax, offset).AddressUsesRegister(rcx));


     CHECK(Operand(rax, rax, times_1, offset).AddressUsesRegister(rax));

     CHECK(!Operand(rax, rax, times_1, offset).AddressUsesRegister(r8));

     CHECK(!Operand(rax, rax, times_1, offset).AddressUsesRegister(rcx));


     CHECK(Operand(rax, rcx, times_1, offset).AddressUsesRegister(rax));

     CHECK(Operand(rax, rcx, times_1, offset).AddressUsesRegister(rcx));

     CHECK(!Operand(rax, rcx, times_1, offset).AddressUsesRegister(r8));

     CHECK(!Operand(rax, rcx, times_1, offset).AddressUsesRegister(r9));

     CHECK(!Operand(rax, rcx, times_1, offset).AddressUsesRegister(rdx));

     CHECK(!Operand(rax, rcx, times_1, offset).AddressUsesRegister(rsp));


     CHECK(Operand(rsp, offset).AddressUsesRegister(rsp));

     CHECK(!Operand(rsp, offset).AddressUsesRegister(rax));

     CHECK(!Operand(rsp, offset).AddressUsesRegister(r15));


     CHECK(Operand(rbp, offset).AddressUsesRegister(rbp));

     CHECK(!Operand(rbp, offset).AddressUsesRegister(rax));

     CHECK(!Operand(rbp, offset).AddressUsesRegister(r13));


     CHECK(Operand(rbp, rax, times_1, offset).AddressUsesRegister(rbp));

     CHECK(Operand(rbp, rax, times_1, offset).AddressUsesRegister(rax));

     CHECK(!Operand(rbp, rax, times_1, offset).AddressUsesRegister(rcx));

     CHECK(!Operand(rbp, rax, times_1, offset).AddressUsesRegister(r13));

     CHECK(!Operand(rbp, rax, times_1, offset).AddressUsesRegister(r8));

     CHECK(!Operand(rbp, rax, times_1, offset).AddressUsesRegister(rsp));


     CHECK(Operand(rsp, rbp, times_1, offset).AddressUsesRegister(rsp));

     CHECK(Operand(rsp, rbp, times_1, offset).AddressUsesRegister(rbp));

     CHECK(!Operand(rsp, rbp, times_1, offset).AddressUsesRegister(rax));

     CHECK(!Operand(rsp, rbp, times_1, offset).AddressUsesRegister(r15));

     CHECK(!Operand(rsp, rbp, times_1, offset).AddressUsesRegister(r13));

   }

 }


 TEST(AssemblerX64LabelChaining) {

   // Test chaining of label usages within instructions (issue 1644).

   CcTest::InitializeVM();

   v8::HandleScope scope(CcTest::isolate());

   Assembler assm(CcTest::i_isolate(), NULL, 0);


   Label target;

   __ j(equal, &target);

   __ j(not_equal, &target);

   __ bind(&target);

   __ nop();

 }


 TEST(AssemblerMultiByteNop) {

   CcTest::InitializeVM();

   v8::HandleScope scope(CcTest::isolate());

   byte buffer[1024];

   Isolate* isolate = CcTest::i_isolate();

   Assembler assm(isolate, buffer, sizeof(buffer));

   __ pushq(rbx);

   __ pushq(rcx);

   __ pushq(rdx);

   __ pushq(rdi);

   __ pushq(rsi);

   __ movq(rax, Immediate(1));

   __ movq(rbx, Immediate(2));

   __ movq(rcx, Immediate(3));

   __ movq(rdx, Immediate(4));

   __ movq(rdi, Immediate(5));

   __ movq(rsi, Immediate(6));

   for (int i = 0; i < 16; i++) {

     int before = assm.pc_offset();

     __ Nop(i);

     CHECK_EQ(assm.pc_offset() - before, i);

   }


   Label fail;

   __ cmpq(rax, Immediate(1));

   __ j(not_equal, &fail);

   __ cmpq(rbx, Immediate(2));

   __ j(not_equal, &fail);

   __ cmpq(rcx, Immediate(3));

   __ j(not_equal, &fail);

   __ cmpq(rdx, Immediate(4));

   __ j(not_equal, &fail);

   __ cmpq(rdi, Immediate(5));

   __ j(not_equal, &fail);

   __ cmpq(rsi, Immediate(6));

   __ j(not_equal, &fail);

   __ movq(rax, Immediate(42));

   __ popq(rsi);

   __ popq(rdi);

   __ popq(rdx);

   __ popq(rcx);

   __ popq(rbx);

   __ ret(0);

   __ bind(&fail);

   __ movq(rax, Immediate(13));

   __ popq(rsi);

   __ popq(rdi);

   __ popq(rdx);

   __ popq(rcx);

   __ popq(rbx);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->ToObjectChecked());

   CHECK(code->IsCode());


   F0 f = FUNCTION_CAST<F0>(code->entry());

   int res = f();

   CHECK_EQ(42, res);

 }


 #ifdef __GNUC__

 #define ELEMENT_COUNT 4


 void DoSSE2(const v8::FunctionCallbackInfo<v8::Value>& args) {

   v8::HandleScope scope(CcTest::isolate());

   byte buffer[1024];


   CHECK(args[0]->IsArray());

   v8::Local<v8::Array> vec = v8::Local<v8::Array>::Cast(args[0]);

   CHECK_EQ(ELEMENT_COUNT, vec->Length());


   Isolate* isolate = CcTest::i_isolate();

   Assembler assm(isolate, buffer, sizeof(buffer));


   // Remove return address from the stack for fix stack frame alignment.

   __ popq(rcx);


   // Store input vector on the stack.

   for (int i = 0; i < ELEMENT_COUNT; i++) {

     __ movl(rax, Immediate(vec->Get(i)->Int32Value()));

     __ shl(rax, Immediate(0x20));

     __ orq(rax, Immediate(vec->Get(++i)->Int32Value()));

     __ pushq(rax);

   }


   // Read vector into a xmm register.

   __ xorps(xmm0, xmm0);

   __ movdqa(xmm0, Operand(rsp, 0));

   // Create mask and store it in the return register.

   __ movmskps(rax, xmm0);


   // Remove unused data from the stack.

   __ addq(rsp, Immediate(ELEMENT_COUNT * sizeof(int32_t)));

   // Restore return address.

   __ pushq(rcx);


   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->ToObjectChecked());

   CHECK(code->IsCode());


   F0 f = FUNCTION_CAST<F0>(code->entry());

   int res = f();

   args.GetReturnValue().Set(v8::Integer::New(CcTest::isolate(), res));

 }


 TEST(StackAlignmentForSSE2) {

   CcTest::InitializeVM();

   CHECK_EQ(0, OS::ActivationFrameAlignment() % 16);


   v8::Isolate* isolate = CcTest::isolate();

   v8::HandleScope handle_scope(isolate);

   v8::Handle<v8::ObjectTemplate> global_template =

       v8::ObjectTemplate::New(isolate);

   global_template->Set(v8_str("do_sse2"),

                        v8::FunctionTemplate::New(isolate, DoSSE2));


   LocalContext env(NULL, global_template);

   CompileRun(

       "function foo(vec) {"

       "  return do_sse2(vec);"

       "}");


   v8::Local<v8::Object> global_object = env->Global();

   v8::Local<v8::Function> foo =

       v8::Local<v8::Function>::Cast(global_object->Get(v8_str("foo")));


   int32_t vec[ELEMENT_COUNT] = { -1, 1, 1, 1 };

   v8::Local<v8::Array> v8_vec = v8::Array::New(isolate, ELEMENT_COUNT);

   for (int i = 0; i < ELEMENT_COUNT; i++) {

     v8_vec->Set(i, v8_num(vec[i]));

   }


   v8::Local<v8::Value> args[] = { v8_vec };

   v8::Local<v8::Value> result = foo->Call(global_object, 1, args);


   // The mask should be 0b1000.

   CHECK_EQ(8, result->Int32Value());

 }


 #undef ELEMENT_COUNT

 #endif  // __GNUC__


 TEST(AssemblerX64Extractps) {

   CcTest::InitializeVM();

   if (!CpuFeatures::IsSupported(SSE4_1)) return;


   v8::HandleScope scope(CcTest::isolate());

   byte buffer[256];

   Isolate* isolate = CcTest::i_isolate();

   Assembler assm(isolate, buffer, sizeof(buffer));

   { CpuFeatureScope fscope2(&assm, SSE4_1);

     __ extractps(rax, xmm0, 0x1);

     __ ret(0);

   }


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->ToObjectChecked());

   CHECK(code->IsCode());

 #ifdef OBJECT_PRINT

   Code::cast(code)->Print();

 #endif


   F3 f = FUNCTION_CAST<F3>(Code::cast(code)->entry());

   uint64_t value1 = V8_2PART_UINT64_C(0x12345678, 87654321);

   CHECK_EQ(0x12345678, f(uint64_to_double(value1)));

   uint64_t value2 = V8_2PART_UINT64_C(0x87654321, 12345678);

   CHECK_EQ(0x87654321, f(uint64_to_double(value2)));

 }


 typedef int (*F6)(float x, float y);

 TEST(AssemblerX64SSE) {

   CcTest::InitializeVM();


   Isolate* isolate = reinterpret_cast<Isolate*>(CcTest::isolate());

   HandleScope scope(isolate);

   v8::internal::byte buffer[256];

   MacroAssembler assm(isolate, buffer, sizeof buffer);

   {

     __ shufps(xmm0, xmm0, 0x0);  // brocast first argument

     __ shufps(xmm1, xmm1, 0x0);  // brocast second argument

     __ movaps(xmm2, xmm1);

     __ addps(xmm2, xmm0);

     __ mulps(xmm2, xmm1);

     __ subps(xmm2, xmm0);

     __ divps(xmm2, xmm1);

     __ cvttss2si(rax, xmm2);

     __ ret(0);

   }


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->ToObjectChecked());

   CHECK(code->IsCode());

 #ifdef OBJECT_PRINT

   Code::cast(code)->Print();

 #endif


   F6 f = FUNCTION_CAST<F6>(Code::cast(code)->entry());

   CHECK_EQ(2, f(1.0, 2.0));

 }

 #undef __

v8::internal::rdx
const Register rdx
Definition: assembler-x64.h:166

v8::internal::NULL
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter NULL
Definition: flags.cc:269

Fail
void Fail(const v8::FunctionCallbackInfo< v8::Value > &args)
Definition: test-thread-termination.cc:47

CHECK_EQ
#define CHECK_EQ(expected, value)
Definition: checks.h:252

v8::internal::SSE4_1
Definition: v8globals.h:420

v8::internal::AssemblerBase::pc_offset
int pc_offset() const
Definition: assembler.h:83

v8::Function::Call
Local< Value > Call(Handle< Value > recv, int argc, Handle< Value > argv[])
Definition: api.cc:3996

v8::internal::greater
Definition: assembler-ia32.h:292

v8::HandleScope
Definition: v8.h:829

v8::internal::r11
const Register r11
Definition: assembler-x64.h:175

v8::internal::Handle
Definition: handles.h:44

v8::internal::TEST
Definition: natives.h:39

v8::Object::Get
Local< Value > Get(Handle< Value > key)
Definition: api.cc:3139

v8::internal::CodeDesc
Definition: v8globals.h:237

v8::internal::rbp
const Register rbp
Definition: assembler-x64.h:169

v8::FunctionCallbackInfo::GetReturnValue
V8_INLINE ReturnValue< T > GetReturnValue() const
Definition: v8.h:6067

v8::internal::STUB
Definition: hydrogen.h:560

v8::internal::less_equal
Definition: assembler-ia32.h:291

v8::internal::rsi
const Register rsi
Definition: assembler-x64.h:170

v8::internal::not_equal
Definition: assembler-ia32.h:282

unibrow::int32_t
int int32_t
Definition: unicode.cc:47

v8::internal::AssemblerBase::kMinimalBufferSize
static const int kMinimalBufferSize
Definition: assembler.h:89

v8::internal::CpuFeatures::IsSupported
static bool IsSupported(CpuFeature f)
Definition: assembler-arm.h:68

v8::internal::Assembler
Definition: assembler-arm.h:771

v8::internal::times_1
Definition: assembler-ia32.h:376

v8::internal::MacroAssembler
Definition: macro-assembler-arm.h:90

v8::Integer::New
static Local< Integer > New(Isolate *isolate, int32_t value)
Definition: api.cc:6233

platform.h

CHECK
#define CHECK(condition)
Definition: checks.h:75

v8::Template::Set
void Set(Handle< String > name, Handle< Data > value, PropertyAttribute attributes=None)
Definition: api.cc:841

F1
int(* F1)(int64_t x)
Definition: test-assembler-x64.cc:51

v8::internal::Code::cast
static Code * cast(Object *obj)

v8::internal::Code::entry
byte * entry()
Definition: objects-inl.h:5887

v8::internal::Register
Definition: assembler-arm.h:161

cctest.h

foo
int foo
Definition: test-accessors.cc:118

v8::internal::byte
uint8_t byte
Definition: globals.h:185

v8::ObjectTemplate::New
static Local< ObjectTemplate > New()
Definition: api.cc:1286

serialize.h

v8::FunctionCallbackInfo
Definition: v8.h:136

v8::internal::xmm1
const XMMRegister xmm1
Definition: assembler-x64.h:264

v8::internal::Assembler::GetCode
void GetCode(CodeDesc *desc)

v8::internal::r9
const Register r9
Definition: assembler-arm.h:237

v8::internal::Operand
Definition: assembler-arm64.h:624

v8::internal::rbx
const Register rbx
Definition: assembler-x64.h:167

v8::FunctionTemplate::New
static Local< FunctionTemplate > New(Isolate *isolate, FunctionCallback callback=0, Handle< Value > data=Handle< Value >(), Handle< Signature > signature=Handle< Signature >(), int length=0)
Definition: api.cc:942

v8::internal::rsp
const Register rsp
Definition: assembler-x64.h:168

v8::internal::code
enable upcoming ES6 features enable harmony block scoping enable harmony enable harmony proxies enable harmony generators enable harmony numeric enable harmony string enable harmony math functions harmony_scoping harmony_symbols harmony_collections harmony_iteration harmony_strings harmony_scoping harmony_maths tracks arrays with only smi values Optimize object Array DOM strings and string pretenure call new trace pretenuring decisions of HAllocate instructions track fields with only smi values track fields with heap values track_fields track_fields Enables optimizations which favor memory size over execution speed use string slices optimization filter maximum number of GVN fix point iterations use function inlining use allocation folding eliminate write barriers targeting allocations in optimized code maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining crankshaft harvests type feedback from stub cache trace check elimination phase hydrogen tracing filter trace hydrogen to given file name trace inlining decisions trace store elimination trace all use positions trace global value numbering trace hydrogen escape analysis trace the tracking of allocation sites trace map generalization environment for every instruction deoptimize every n garbage collections put a break point before deoptimizing deoptimize uncommon cases use on stack replacement trace array bounds check elimination perform array index dehoisting use load elimination use store elimination use constant folding eliminate unreachable code number of stress runs when picking a function to watch for shared function not JSFunction itself flushes the cache of optimized code for closures on every GC functions with arguments object maximum number of escape analysis fix point iterations allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms concurrent on stack replacement do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes number of stack frames inspected by the profiler percentage of ICs that must have type info to allow optimization extra verbose compilation tracing generate extra code(assertions) for debugging") DEFINE_bool(code_comments

v8::internal::uint64_to_double
double uint64_to_double(uint64_t d64)
Definition: double.h:38

F2
int(* F2)(int64_t x, int64_t y)
Definition: test-assembler-x64.cc:52

CcTest::i_isolate
static i::Isolate * i_isolate()
Definition: cctest.h:102

v8::internal::rax
const Register rax
Definition: assembler-x64.h:164

v8::internal::r13
const Register r13
Definition: assembler-x64.h:177

v8::internal::rdi
const Register rdi
Definition: assembler-x64.h:171

V8_2PART_UINT64_C
#define V8_2PART_UINT64_C(a, b)
Definition: globals.h:226

v8::Handle
Definition: v8.h:123

F4
int64_t(* F4)(int64_t *x, int64_t *y)
Definition: test-assembler-x64.cc:54

v8::Array::New
static Local< Array > New(Isolate *isolate, int length=0)
Definition: api.cc:5786

factory.h

v8::Local::Cast
static V8_INLINE Local< T > Cast(Local< S > that)
Definition: v8.h:372

v8::internal::Heap::CreateCode
MUST_USE_RESULT MaybeObject * CreateCode(const CodeDesc &desc, Code::Flags flags, Handle< Object > self_reference, bool immovable=false, bool crankshafted=false, int prologue_offset=Code::kPrologueOffsetNotSet)
Definition: heap.cc:4119

__
#define __
Definition: test-assembler-x64.cc:65

CcTest::InitializeVM
static void InitializeVM()
Definition: cctest.h:116

v8::internal::Code::ComputeFlags
static Flags ComputeFlags(Kind kind, InlineCacheState ic_state=UNINITIALIZED, ExtraICState extra_ic_state=kNoExtraICState, StubType type=NORMAL, InlineCacheHolderFlag holder=OWN_MAP)
Definition: objects-inl.h:4601

v8::internal::OS::Allocate
static void * Allocate(const size_t requested, size_t *allocated, bool is_executable)
Definition: platform-cygwin.cc:75

v8::internal::equal
Definition: assembler-ia32.h:281

macro-assembler.h

F5
int64_t(* F5)(int64_t x)
Definition: test-assembler-x64.cc:55

v8::internal::r8
const Register r8
Definition: assembler-arm.h:235

v8::internal::rcx
const Register rcx
Definition: assembler-x64.h:165

v8::internal::USE
void USE(T)
Definition: globals.h:341

v8::internal::zero
Definition: assembler-ia32.h:297

v8::internal::OS::ActivationFrameAlignment
static int ActivationFrameAlignment()
Definition: platform-posix.cc:152

v8::internal::Isolate::heap
Heap * heap()
Definition: isolate.h:875

v8::Isolate
Definition: v8.h:4124

v8::internal::HandleScope
Definition: handles.h:131

v8::internal::Code
Definition: objects.h:5180

F6
int(* F6)(float x, float y)
Definition: test-assembler-x64.cc:681

v8::Array::Length
uint32_t Length() const
Definition: api.cc:5800

v8::internal::xmm2
const XMMRegister xmm2
Definition: assembler-x64.h:265

F3
int(* F3)(double x)
Definition: test-assembler-x64.cc:53

v8::internal::Isolate
Definition: isolate.h:389

LocalContext
Definition: cctest.h:243

v8::Local
Definition: v8.h:124

v8::internal::r15
const Register r15
Definition: assembler-x64.h:179

v8::Object::Set
bool Set(Handle< Value > key, Handle< Value > value, PropertyAttribute attribs=None)
Definition: api.cc:3044

CcTest::isolate
static v8::Isolate * isolate()
Definition: cctest.h:96

v8::internal::xmm0
const XMMRegister xmm0
Definition: assembler-x64.h:263

F0
F0Type * F0
Definition: test-macro-assembler-ia32.cc:47