dd/dc8/test-assembler-ia32_8cc_source.html

 // Copyright 2011 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 "disassembler.h"

 #include "factory.h"

 #include "macro-assembler.h"

 #include "platform.h"

 #include "serialize.h"

 #include "cctest.h"


 using namespace v8::internal;


 typedef int (*F0)();

 typedef int (*F1)(int x);

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


 static v8::Persistent<v8::Context> env;


 static void InitializeVM() {

   if (env.IsEmpty()) {

     env = v8::Context::New();

   }

 }


 #define __ assm.


 TEST(AssemblerIa320) {

   InitializeVM();

   v8::HandleScope scope;


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

   Assembler assm(Isolate::Current(), buffer, sizeof buffer);


   __ mov(eax, Operand(esp, 4));

   __ add(eax, Operand(esp, 8));

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Object* code = HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();

   CHECK(code->IsCode());

 #ifdef OBJECT_PRINT

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

 #endif

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

   int res = f(3, 4);

   ::printf("f() = %d\n", res);

   CHECK_EQ(7, res);

 }


 TEST(AssemblerIa321) {

   InitializeVM();

   v8::HandleScope scope;


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

   Assembler assm(Isolate::Current(), buffer, sizeof buffer);

   Label L, C;


   __ mov(edx, Operand(esp, 4));

   __ xor_(eax, eax);  // clear eax

   __ jmp(&C);


   __ bind(&L);

   __ add(eax, edx);

   __ sub(edx, Immediate(1));


   __ bind(&C);

   __ test(edx, edx);

   __ j(not_zero, &L);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Object* code = HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();

   CHECK(code->IsCode());

 #ifdef OBJECT_PRINT

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

 #endif

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

   int res = f(100);

   ::printf("f() = %d\n", res);

   CHECK_EQ(5050, res);

 }


 TEST(AssemblerIa322) {

   InitializeVM();

   v8::HandleScope scope;


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

   Assembler assm(Isolate::Current(), buffer, sizeof buffer);

   Label L, C;


   __ mov(edx, Operand(esp, 4));

   __ mov(eax, 1);

   __ jmp(&C);


   __ bind(&L);

   __ imul(eax, edx);

   __ sub(edx, Immediate(1));


   __ bind(&C);

   __ test(edx, edx);

   __ j(not_zero, &L);

   __ ret(0);


   // some relocated stuff here, not executed

   __ mov(eax, FACTORY->true_value());

   __ jmp(NULL, RelocInfo::RUNTIME_ENTRY);


   CodeDesc desc;

   assm.GetCode(&desc);

   Object* code = HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked();

   CHECK(code->IsCode());

 #ifdef OBJECT_PRINT

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

 #endif

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

   int res = f(10);

   ::printf("f() = %d\n", res);

   CHECK_EQ(3628800, res);

 }


 typedef int (*F3)(float x);


 TEST(AssemblerIa323) {

   InitializeVM();

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


   v8::HandleScope scope;


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

   Assembler assm(Isolate::Current(), buffer, sizeof buffer);


   CHECK(CpuFeatures::IsSupported(SSE2));

   { CpuFeatures::Scope fscope(SSE2);

     __ cvttss2si(eax, Operand(esp, 4));

     __ ret(0);

   }


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked());

   // don't print the code - our disassembler can't handle cvttss2si

   // instead print bytes

   Disassembler::Dump(stdout,

                      code->instruction_start(),

                      code->instruction_start() + code->instruction_size());

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

   int res = f(static_cast<float>(-3.1415));

   ::printf("f() = %d\n", res);

   CHECK_EQ(-3, res);

 }


 typedef int (*F4)(double x);


 TEST(AssemblerIa324) {

   InitializeVM();

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


   v8::HandleScope scope;


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

   Assembler assm(Isolate::Current(), buffer, sizeof buffer);


   CHECK(CpuFeatures::IsSupported(SSE2));

   CpuFeatures::Scope fscope(SSE2);

   __ cvttsd2si(eax, Operand(esp, 4));

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked());

   // don't print the code - our disassembler can't handle cvttsd2si

   // instead print bytes

   Disassembler::Dump(stdout,

                      code->instruction_start(),

                      code->instruction_start() + code->instruction_size());

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

   int res = f(2.718281828);

   ::printf("f() = %d\n", res);

   CHECK_EQ(2, res);

 }


 static int baz = 42;

 TEST(AssemblerIa325) {

   InitializeVM();

   v8::HandleScope scope;


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

   Assembler assm(Isolate::Current(), buffer, sizeof buffer);


   __ mov(eax, Operand(reinterpret_cast<intptr_t>(&baz), RelocInfo::NONE));

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked());

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

   int res = f();

   CHECK_EQ(42, res);

 }


 typedef double (*F5)(double x, double y);


 TEST(AssemblerIa326) {

   InitializeVM();

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


   v8::HandleScope scope;

   CHECK(CpuFeatures::IsSupported(SSE2));

   CpuFeatures::Scope fscope(SSE2);

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

   Assembler assm(Isolate::Current(), buffer, sizeof buffer);


   __ movdbl(xmm0, Operand(esp, 1 * kPointerSize));

   __ movdbl(xmm1, Operand(esp, 3 * kPointerSize));

   __ addsd(xmm0, xmm1);

   __ mulsd(xmm0, xmm1);

   __ subsd(xmm0, xmm1);

   __ divsd(xmm0, xmm1);

   // Copy xmm0 to st(0) using eight bytes of stack.

   __ sub(esp, Immediate(8));

   __ movdbl(Operand(esp, 0), xmm0);

   __ fld_d(Operand(esp, 0));

   __ add(esp, Immediate(8));

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked());

 #ifdef DEBUG

   ::printf("\n---\n");

   // don't print the code - our disassembler can't handle SSE instructions

   // instead print bytes

   Disassembler::Dump(stdout,

                      code->instruction_start(),

                      code->instruction_start() + code->instruction_size());

 #endif

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

   double res = f(2.2, 1.1);

   ::printf("f() = %f\n", res);

   CHECK(2.29 < res && res < 2.31);

 }


 typedef double (*F6)(int x);


 TEST(AssemblerIa328) {

   InitializeVM();

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


   v8::HandleScope scope;

   CHECK(CpuFeatures::IsSupported(SSE2));

   CpuFeatures::Scope fscope(SSE2);

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

   Assembler assm(Isolate::Current(), buffer, sizeof buffer);

   __ mov(eax, Operand(esp, 4));

   __ cvtsi2sd(xmm0, eax);

   // Copy xmm0 to st(0) using eight bytes of stack.

   __ sub(esp, Immediate(8));

   __ movdbl(Operand(esp, 0), xmm0);

   __ fld_d(Operand(esp, 0));

   __ add(esp, Immediate(8));

   __ ret(0);

   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked());

   CHECK(code->IsCode());

 #ifdef OBJECT_PRINT

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

 #endif

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

   double res = f(12);


   ::printf("f() = %f\n", res);

   CHECK(11.99 < res && res < 12.001);

 }


 typedef int (*F7)(double x, double y);


 TEST(AssemblerIa329) {

   InitializeVM();

   v8::HandleScope scope;

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

   MacroAssembler assm(Isolate::Current(), buffer, sizeof buffer);

   enum { kEqual = 0, kGreater = 1, kLess = 2, kNaN = 3, kUndefined = 4 };

   Label equal_l, less_l, greater_l, nan_l;

   __ fld_d(Operand(esp, 3 * kPointerSize));

   __ fld_d(Operand(esp, 1 * kPointerSize));

   __ FCmp();

   __ j(parity_even, &nan_l);

   __ j(equal, &equal_l);

   __ j(below, &less_l);

   __ j(above, &greater_l);


   __ mov(eax, kUndefined);

   __ ret(0);


   __ bind(&equal_l);

   __ mov(eax, kEqual);

   __ ret(0);


   __ bind(&greater_l);

   __ mov(eax, kGreater);

   __ ret(0);


   __ bind(&less_l);

   __ mov(eax, kLess);

   __ ret(0);


   __ bind(&nan_l);

   __ mov(eax, kNaN);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked());

   CHECK(code->IsCode());

 #ifdef OBJECT_PRINT

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

 #endif


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

   CHECK_EQ(kLess, f(1.1, 2.2));

   CHECK_EQ(kEqual, f(2.2, 2.2));

   CHECK_EQ(kGreater, f(3.3, 2.2));

   CHECK_EQ(kNaN, f(OS::nan_value(), 1.1));

 }


 TEST(AssemblerIa3210) {

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

   InitializeVM();

   v8::HandleScope scope;

   Assembler assm(Isolate::Current(), NULL, 0);


   Label target;

   __ j(equal, &target);

   __ j(not_equal, &target);

   __ bind(&target);

   __ nop();

 }


 TEST(AssemblerMultiByteNop) {

   InitializeVM();

   v8::HandleScope scope;

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

   Assembler assm(Isolate::Current(), buffer, sizeof(buffer));

   __ push(ebx);

   __ push(ecx);

   __ push(edx);

   __ push(edi);

   __ push(esi);

   __ mov(eax, 1);

   __ mov(ebx, 2);

   __ mov(ecx, 3);

   __ mov(edx, 4);

   __ mov(edi, 5);

   __ mov(esi, 6);

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

     int before = assm.pc_offset();

     __ Nop(i);

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

   }


   Label fail;

   __ cmp(eax, 1);

   __ j(not_equal, &fail);

   __ cmp(ebx, 2);

   __ j(not_equal, &fail);

   __ cmp(ecx, 3);

   __ j(not_equal, &fail);

   __ cmp(edx, 4);

   __ j(not_equal, &fail);

   __ cmp(edi, 5);

   __ j(not_equal, &fail);

   __ cmp(esi, 6);

   __ j(not_equal, &fail);

   __ mov(eax, 42);

   __ pop(esi);

   __ pop(edi);

   __ pop(edx);

   __ pop(ecx);

   __ pop(ebx);

   __ ret(0);

   __ bind(&fail);

   __ mov(eax, 13);

   __ pop(esi);

   __ pop(edi);

   __ pop(edx);

   __ pop(ecx);

   __ pop(ebx);

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Code* code = Code::cast(HEAP->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Object>(HEAP->undefined_value()))->ToObjectChecked());

   CHECK(code->IsCode());


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

   int res = f();

   CHECK_EQ(42, res);

 }


 #undef __

v8::internal::Assembler::pc_offset
int pc_offset() const
Definition: assembler-arm.h:1285

F3
int(* F3)(float x)
Definition: test-assembler-ia32.cc:167

__
#define __
Definition: test-assembler-ia32.cc:57

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

v8::HandleScope
Definition: v8.h:446

v8::internal::Handle< Object >

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

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

v8::internal::esp
const Register esp
Definition: assembler-ia32.h:114

v8::internal::below
Definition: assembler-ia32.h:204

v8::internal::parity_even
Definition: assembler-ia32.h:212

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

v8::internal::Code::instruction_size
int instruction_size()

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

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

v8::internal::not_zero
Definition: assembler-ia32.h:223

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

platform.h

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

F1
int(* F1)(int x)
Definition: test-assembler-ia32.cc:43

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

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

v8::internal::Object
Definition: objects.h:879

cctest.h

v8::internal::edi
const Register edi
Definition: assembler-ia32.h:117

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

v8::internal::eax
const Register eax
Definition: assembler-ia32.h:110

serialize.h

F2
int(* F2)(int x, int y)
Definition: test-assembler-ia32.cc:44

NONE
Definition: property-details.h:37

v8::internal::xmm1
const XMMRegister xmm1
Definition: assembler-ia32.h:186

v8::internal::Code::instruction_start
byte * instruction_start()
Definition: objects-inl.h:4649

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

v8::internal::kPointerSize
const int kPointerSize
Definition: globals.h:220

v8::internal::ecx
const Register ecx
Definition: assembler-ia32.h:111

F0
int(* F0)()
Definition: test-assembler-ia32.cc:42

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

factory.h

F7
int(* F7)(double x, double y)
Definition: test-assembler-ia32.cc:342

v8::internal::L
Definition: constants-arm.h:224

v8::internal::above
Definition: assembler-ia32.h:209

v8::internal::OS::nan_value
static double nan_value()
Definition: platform-nullos.cc:212

v8::internal::ebx
const Register ebx
Definition: assembler-ia32.h:113

disassembler.h

F5
double(* F5)(double x, double y)
Definition: test-assembler-ia32.cc:259

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

baz
int baz
Definition: test-accessors.cc:85

macro-assembler.h

v8::Persistent< v8::Context >

HEAP
#define HEAP
Definition: isolate.h:1433

v8::internal::esi
const Register esi
Definition: assembler-ia32.h:116

v8::Handle::IsEmpty
bool IsEmpty() const
Definition: v8.h:209

FACTORY
#define FACTORY
Definition: isolate.h:1434

v8::internal::SSE2
Definition: v8globals.h:428

v8::internal::NULL
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if NULL
Definition: flags.cc:301

v8::Context::New
static Persistent< Context > New(ExtensionConfiguration *extensions=NULL, Handle< ObjectTemplate > global_template=Handle< ObjectTemplate >(), Handle< Value > global_object=Handle< Value >())
Definition: api.cc:4411

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

RUNTIME_ENTRY
#define RUNTIME_ENTRY(name, nargs, ressize)

v8::internal::code
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra code(assertions) for debugging") DEFINE_bool(code_comments

v8::internal::edx
const Register edx
Definition: assembler-ia32.h:112

v8::internal::Disassembler::Dump
static void Dump(FILE *f, byte *begin, byte *end)
Definition: disassembler.cc:342

F6
double(* F6)(int x)
Definition: test-assembler-ia32.cc:305

F4
int(* F4)(double x)
Definition: test-assembler-ia32.cc:202

v8::internal::xmm0
const XMMRegister xmm0
Definition: assembler-ia32.h:185