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


 #define __ assm.


 TEST(AssemblerIa320) {

   CcTest::InitializeVM();

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

   HandleScope scope(isolate);


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

   Assembler assm(isolate, buffer, sizeof buffer);


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

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

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

   Object* code = isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->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) {

   CcTest::InitializeVM();

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

   HandleScope scope(isolate);


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

   Assembler assm(isolate, 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 = isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->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) {

   CcTest::InitializeVM();

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

   HandleScope scope(isolate);


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

   Assembler assm(isolate, 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, isolate->factory()->true_value());

   __ jmp(NULL, RelocInfo::RUNTIME_ENTRY);


   CodeDesc desc;

   assm.GetCode(&desc);

   Object* code = isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->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) {

   CcTest::InitializeVM();

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


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

   HandleScope scope(isolate);


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

   Assembler assm(isolate, buffer, sizeof buffer);


   CHECK(CpuFeatures::IsSupported(SSE2));

   { CpuFeatureScope fscope(&assm, SSE2);

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

     __ ret(0);

   }


   CodeDesc desc;

   assm.GetCode(&desc);

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

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->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) {

   CcTest::InitializeVM();

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


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

   HandleScope scope(isolate);


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

   Assembler assm(isolate, buffer, sizeof buffer);


   CHECK(CpuFeatures::IsSupported(SSE2));

   CpuFeatureScope fscope(&assm, SSE2);

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

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

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

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->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) {

   CcTest::InitializeVM();

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

   HandleScope scope(isolate);


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

   Assembler assm(isolate, buffer, sizeof buffer);


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

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

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

       desc,

       Code::ComputeFlags(Code::STUB),

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

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

   int res = f();

   CHECK_EQ(42, res);

 }


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


 TEST(AssemblerIa326) {

   CcTest::InitializeVM();

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


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

   HandleScope scope(isolate);

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

   Assembler assm(isolate, buffer, sizeof buffer);


   CpuFeatureScope fscope(&assm, SSE2);

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

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

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

   __ fld_d(Operand(esp, 0));

   __ add(esp, Immediate(8));

   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);

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

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->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) {

   CcTest::InitializeVM();

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


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

   HandleScope scope(isolate);

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

   Assembler assm(isolate, buffer, sizeof buffer);

   CpuFeatureScope fscope(&assm, SSE2);

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

   __ cvtsi2sd(xmm0, eax);

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

   __ sub(esp, Immediate(8));

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

   __ fld_d(Operand(esp, 0));

   __ add(esp, Immediate(8));

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

   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) {

   CcTest::InitializeVM();

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

   HandleScope scope(isolate);

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

   MacroAssembler assm(isolate, 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(isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

       Handle<Code>())->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).

   CcTest::InitializeVM();

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

   HandleScope scope(isolate);

   Assembler assm(isolate, NULL, 0);


   Label target;

   __ j(equal, &target);

   __ j(not_equal, &target);

   __ bind(&target);

   __ nop();

 }


 TEST(AssemblerMultiByteNop) {

   CcTest::InitializeVM();

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

   HandleScope scope(isolate);

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

   Assembler assm(isolate, 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(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) {

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

   HandleScope scope(isolate);


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

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

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


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

   Assembler assm(isolate, buffer, sizeof buffer);


   ASSERT(CpuFeatures::IsSupported(SSE2));

   CpuFeatureScope fscope(&assm, SSE2);


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

   __ pop(ecx);


   // Store input vector on the stack.

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

     __ push(Immediate(vec->Get(i)->Int32Value()));

   }


   // Read vector into a xmm register.

   __ pxor(xmm0, xmm0);

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

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

   __ movmskps(eax, xmm0);


   // Remove unused data from the stack.

   __ add(esp, Immediate(ELEMENT_COUNT * sizeof(int32_t)));

   // Restore return address.

   __ push(ecx);


   __ ret(0);


   CodeDesc desc;

   assm.GetCode(&desc);


   Object* code = isolate->heap()->CreateCode(

       desc,

       Code::ComputeFlags(Code::STUB),

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

   CHECK(code->IsCode());


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

   int res = f();

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

 }


 TEST(StackAlignmentForSSE2) {

   CcTest::InitializeVM();

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


   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(AssemblerIa32Extractps) {

   CcTest::InitializeVM();

   if (!CpuFeatures::IsSupported(SSE2) ||

       !CpuFeatures::IsSupported(SSE4_1)) return;


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

   HandleScope scope(isolate);

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

   MacroAssembler assm(isolate, buffer, sizeof buffer);

   { CpuFeatureScope fscope2(&assm, SSE2);

     CpuFeatureScope fscope41(&assm, SSE4_1);

     __ movsd(xmm1, Operand(esp, 4));

     __ extractps(eax, xmm1, 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


   F4 f = FUNCTION_CAST<F4>(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 (*F8)(float x, float y);

 TEST(AssemblerIa32SSE) {

   CcTest::InitializeVM();

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


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

   HandleScope scope(isolate);

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

   MacroAssembler assm(isolate, buffer, sizeof buffer);

   {

     CpuFeatureScope fscope(&assm, SSE2);

     __ movss(xmm0, Operand(esp, kPointerSize));

     __ movss(xmm1, Operand(esp, 2 * kPointerSize));

     __ shufps(xmm0, xmm0, 0x0);

     __ shufps(xmm1, xmm1, 0x0);

     __ movaps(xmm2, xmm1);

     __ addps(xmm2, xmm0);

     __ mulps(xmm2, xmm1);

     __ subps(xmm2, xmm0);

     __ divps(xmm2, xmm1);

     __ cvttss2si(eax, 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


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

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

 }


 #undef __

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

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

__
#define __
Definition: test-assembler-ia32.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::HandleScope
Definition: v8.h:829

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::FunctionCallbackInfo::GetReturnValue
V8_INLINE ReturnValue< T > GetReturnValue() const
Definition: v8.h:6067

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

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

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

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

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

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

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

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

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

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

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

ASSERT
#define ASSERT(condition)
Definition: checks.h:329

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

F8
int(* F8)(float x, float y)
Definition: test-assembler-ia32.cc:604

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)(int x)
Definition: test-assembler-ia32.cc:43

v8::internal::Isolate::factory
Factory * factory()
Definition: isolate.h:995

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

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

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

cctest.h

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

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

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

serialize.h

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

v8::FunctionCallbackInfo
Definition: v8.h:136

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

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

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

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

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

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

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::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

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

v8::Handle
Definition: v8.h:123

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

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

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

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

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

v8::internal::OS::nan_value
static double nan_value()
Definition: platform-posix.cc:327

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

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

disassembler.h

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

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::equal
Definition: assembler-ia32.h:281

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

macro-assembler.h

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

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::SSE2
Definition: v8globals.h:422

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

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

RUNTIME_ENTRY
#define RUNTIME_ENTRY(name, nargs, ressize)

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

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

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

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

LocalContext
Definition: cctest.h:243

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

v8::Local
Definition: v8.h:124

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

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