d8/da5/test-disasm-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 "debug.h"

 #include "disasm.h"

 #include "disassembler.h"

 #include "macro-assembler.h"

 #include "serialize.h"

 #include "cctest.h"


 using namespace v8::internal;


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


 static void InitializeVM() {

   if (env.IsEmpty()) {

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

   }

 }


 #define __ assm.


 static void DummyStaticFunction(Object* result) {

 }


 TEST(DisasmIa320) {

   InitializeVM();

   v8::HandleScope scope;

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

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

   DummyStaticFunction(NULL);  // just bloody use it (DELETE; debugging)


   // Short immediate instructions

   __ adc(eax, 12345678);

   __ add(eax, Immediate(12345678));

   __ or_(eax, 12345678);

   __ sub(eax, Immediate(12345678));

   __ xor_(eax, 12345678);

   __ and_(eax, 12345678);

   Handle<FixedArray> foo = FACTORY->NewFixedArray(10, TENURED);

   __ cmp(eax, foo);


   // ---- This one caused crash

   __ mov(ebx,  Operand(esp, ecx, times_2, 0));  // [esp+ecx*4]


   // ---- All instructions that I can think of

   __ add(edx, ebx);

   __ add(edx, Operand(12, RelocInfo::NONE));

   __ add(edx, Operand(ebx, 0));

   __ add(edx, Operand(ebx, 16));

   __ add(edx, Operand(ebx, 1999));

   __ add(edx, Operand(esp, 0));

   __ add(edx, Operand(esp, 16));

   __ add(edx, Operand(esp, 1999));

   __ nop();

   __ add(edi, Operand(ebp, ecx, times_4, 0));

   __ add(edi, Operand(ebp, ecx, times_4, 12));

   __ add(Operand(ebp, ecx, times_4, 12), Immediate(12));


   __ nop();

   __ add(ebx, Immediate(12));

   __ nop();

   __ adc(ecx, 12);

   __ adc(ecx, 1000);

   __ nop();

   __ and_(edx, 3);

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

   __ cmp(edx, 3);

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

   __ cmp(Operand(ebp, ecx, times_4, 0), Immediate(1000));

   Handle<FixedArray> foo2 = FACTORY->NewFixedArray(10, TENURED);

   __ cmp(ebx, foo2);

   __ cmpb(ebx, Operand(ebp, ecx, times_2, 0));

   __ cmpb(Operand(ebp, ecx, times_2, 0), ebx);

   __ or_(edx, 3);

   __ xor_(edx, 3);

   __ nop();

   {

     CHECK(CpuFeatures::IsSupported(CPUID));

     CpuFeatures::Scope fscope(CPUID);

     __ cpuid();

   }

   {

     CHECK(CpuFeatures::IsSupported(RDTSC));

     CpuFeatures::Scope fscope(RDTSC);

     __ rdtsc();

   }

   __ movsx_b(edx, ecx);

   __ movsx_w(edx, ecx);

   __ movzx_b(edx, ecx);

   __ movzx_w(edx, ecx);


   __ nop();

   __ imul(edx, ecx);

   __ shld(edx, ecx);

   __ shrd(edx, ecx);

   __ bts(edx, ecx);

   __ bts(Operand(ebx, ecx, times_4, 0), ecx);

   __ nop();

   __ pushad();

   __ popad();

   __ pushfd();

   __ popfd();

   __ push(Immediate(12));

   __ push(Immediate(23456));

   __ push(ecx);

   __ push(esi);

   __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));

   __ push(Operand(ebx, ecx, times_4, 0));

   __ push(Operand(ebx, ecx, times_4, 0));

   __ push(Operand(ebx, ecx, times_4, 10000));

   __ pop(edx);

   __ pop(eax);

   __ pop(Operand(ebx, ecx, times_4, 0));

   __ nop();


   __ add(edx, Operand(esp, 16));

   __ add(edx, ecx);

   __ mov_b(edx, ecx);

   __ mov_b(ecx, 6);

   __ mov_b(Operand(ebx, ecx, times_4, 10000), 6);

   __ mov_b(Operand(esp, 16), edx);

   __ mov_w(edx, Operand(esp, 16));

   __ mov_w(Operand(esp, 16), edx);

   __ nop();

   __ movsx_w(edx, Operand(esp, 12));

   __ movsx_b(edx, Operand(esp, 12));

   __ movzx_w(edx, Operand(esp, 12));

   __ movzx_b(edx, Operand(esp, 12));

   __ nop();

   __ mov(edx, 1234567);

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

   __ mov(Operand(ebx, ecx, times_4, 10000), Immediate(12345));

   __ mov(Operand(ebx, ecx, times_4, 10000), edx);

   __ nop();

   __ dec_b(edx);

   __ dec_b(Operand(eax, 10));

   __ dec_b(Operand(ebx, ecx, times_4, 10000));

   __ dec(edx);

   __ cdq();


   __ nop();

   __ idiv(edx);

   __ mul(edx);

   __ neg(edx);

   __ not_(edx);

   __ test(Operand(ebx, ecx, times_4, 10000), Immediate(123456));


   __ imul(edx, Operand(ebx, ecx, times_4, 10000));

   __ imul(edx, ecx, 12);

   __ imul(edx, ecx, 1000);


   __ inc(edx);

   __ inc(Operand(ebx, ecx, times_4, 10000));

   __ push(Operand(ebx, ecx, times_4, 10000));

   __ pop(Operand(ebx, ecx, times_4, 10000));

   __ call(Operand(ebx, ecx, times_4, 10000));

   __ jmp(Operand(ebx, ecx, times_4, 10000));


   __ lea(edx, Operand(ebx, ecx, times_4, 10000));

   __ or_(edx, 12345);

   __ or_(edx, Operand(ebx, ecx, times_4, 10000));


   __ nop();


   __ rcl(edx, 1);

   __ rcl(edx, 7);

   __ rcr(edx, 1);

   __ rcr(edx, 7);

   __ sar(edx, 1);

   __ sar(edx, 6);

   __ sar_cl(edx);

   __ sbb(edx, Operand(ebx, ecx, times_4, 10000));

   __ shld(edx, Operand(ebx, ecx, times_4, 10000));

   __ shl(edx, 1);

   __ shl(edx, 6);

   __ shl_cl(edx);

   __ shrd(edx, Operand(ebx, ecx, times_4, 10000));

   __ shr(edx, 1);

   __ shr(edx, 7);

   __ shr_cl(edx);


   // Immediates


   __ adc(edx, 12345);


   __ add(ebx, Immediate(12));

   __ add(Operand(edx, ecx, times_4, 10000), Immediate(12));


   __ and_(ebx, 12345);


   __ cmp(ebx, 12345);

   __ cmp(ebx, Immediate(12));

   __ cmp(Operand(edx, ecx, times_4, 10000), Immediate(12));

   __ cmpb(eax, 100);


   __ or_(ebx, 12345);


   __ sub(ebx, Immediate(12));

   __ sub(Operand(edx, ecx, times_4, 10000), Immediate(12));


   __ xor_(ebx, 12345);


   __ imul(edx, ecx, 12);

   __ imul(edx, ecx, 1000);


   __ cld();

   __ rep_movs();

   __ rep_stos();

   __ stos();


   __ sub(edx, Operand(ebx, ecx, times_4, 10000));

   __ sub(edx, ebx);


   __ test(edx, Immediate(12345));

   __ test(edx, Operand(ebx, ecx, times_8, 10000));

   __ test(Operand(esi, edi, times_1, -20000000), Immediate(300000000));

   __ test_b(edx, Operand(ecx, ebx, times_2, 1000));

   __ test_b(Operand(eax, -20), 0x9A);

   __ nop();


   __ xor_(edx, 12345);

   __ xor_(edx, Operand(ebx, ecx, times_8, 10000));

   __ bts(Operand(ebx, ecx, times_8, 10000), edx);

   __ hlt();

   __ int3();

   __ ret(0);

   __ ret(8);


   // Calls


   Label L1, L2;

   __ bind(&L1);

   __ nop();

   __ call(&L1);

   __ call(&L2);

   __ nop();

   __ bind(&L2);

   __ call(Operand(ebx, ecx, times_4, 10000));

   __ nop();

   Handle<Code> ic(Isolate::Current()->builtins()->builtin(

       Builtins::kLoadIC_Initialize));

   __ call(ic, RelocInfo::CODE_TARGET);

   __ nop();

   __ call(FUNCTION_ADDR(DummyStaticFunction), RelocInfo::RUNTIME_ENTRY);

   __ nop();


   __ jmp(&L1);

   __ jmp(Operand(ebx, ecx, times_4, 10000));

 #ifdef ENABLE_DEBUGGER_SUPPORT

   ExternalReference after_break_target =

       ExternalReference(Debug_Address::AfterBreakTarget(),

                         assm.isolate());

   __ jmp(Operand::StaticVariable(after_break_target));

 #endif  // ENABLE_DEBUGGER_SUPPORT

   __ jmp(ic, RelocInfo::CODE_TARGET);

   __ nop();


   Label Ljcc;

   __ nop();

   // long jumps

   __ j(overflow, &Ljcc);

   __ j(no_overflow, &Ljcc);

   __ j(below, &Ljcc);

   __ j(above_equal, &Ljcc);

   __ j(equal, &Ljcc);

   __ j(not_equal, &Ljcc);

   __ j(below_equal, &Ljcc);

   __ j(above, &Ljcc);

   __ j(sign, &Ljcc);

   __ j(not_sign, &Ljcc);

   __ j(parity_even, &Ljcc);

   __ j(parity_odd, &Ljcc);

   __ j(less, &Ljcc);

   __ j(greater_equal, &Ljcc);

   __ j(less_equal, &Ljcc);

   __ j(greater, &Ljcc);

   __ nop();

   __ bind(&Ljcc);

   // short jumps

   __ j(overflow, &Ljcc);

   __ j(no_overflow, &Ljcc);

   __ j(below, &Ljcc);

   __ j(above_equal, &Ljcc);

   __ j(equal, &Ljcc);

   __ j(not_equal, &Ljcc);

   __ j(below_equal, &Ljcc);

   __ j(above, &Ljcc);

   __ j(sign, &Ljcc);

   __ j(not_sign, &Ljcc);

   __ j(parity_even, &Ljcc);

   __ j(parity_odd, &Ljcc);

   __ j(less, &Ljcc);

   __ j(greater_equal, &Ljcc);

   __ j(less_equal, &Ljcc);

   __ j(greater, &Ljcc);


   // 0xD9 instructions

   __ nop();


   __ fld(1);

   __ fld1();

   __ fldz();

   __ fldpi();

   __ fabs();

   __ fchs();

   __ fprem();

   __ fprem1();

   __ fincstp();

   __ ftst();

   __ fxch(3);

   __ fld_s(Operand(ebx, ecx, times_4, 10000));

   __ fstp_s(Operand(ebx, ecx, times_4, 10000));

   __ ffree(3);

   __ fld_d(Operand(ebx, ecx, times_4, 10000));

   __ fstp_d(Operand(ebx, ecx, times_4, 10000));

   __ nop();


   __ fild_s(Operand(ebx, ecx, times_4, 10000));

   __ fistp_s(Operand(ebx, ecx, times_4, 10000));

   __ fild_d(Operand(ebx, ecx, times_4, 10000));

   __ fistp_d(Operand(ebx, ecx, times_4, 10000));

   __ fnstsw_ax();

   __ nop();

   __ fadd(3);

   __ fsub(3);

   __ fmul(3);

   __ fdiv(3);


   __ faddp(3);

   __ fsubp(3);

   __ fmulp(3);

   __ fdivp(3);

   __ fcompp();

   __ fwait();

   __ nop();

   {

     if (CpuFeatures::IsSupported(SSE2)) {

       CpuFeatures::Scope fscope(SSE2);

       __ cvttss2si(edx, Operand(ebx, ecx, times_4, 10000));

       __ cvtsi2sd(xmm1, Operand(ebx, ecx, times_4, 10000));

       __ addsd(xmm1, xmm0);

       __ mulsd(xmm1, xmm0);

       __ subsd(xmm1, xmm0);

       __ divsd(xmm1, xmm0);

       __ movdbl(xmm1, Operand(ebx, ecx, times_4, 10000));

       __ movdbl(Operand(ebx, ecx, times_4, 10000), xmm1);

       __ ucomisd(xmm0, xmm1);


       // 128 bit move instructions.

       __ movdqa(xmm0, Operand(ebx, ecx, times_4, 10000));

       __ movdqa(Operand(ebx, ecx, times_4, 10000), xmm0);

       __ movdqu(xmm0, Operand(ebx, ecx, times_4, 10000));

       __ movdqu(Operand(ebx, ecx, times_4, 10000), xmm0);

     }

   }


   // cmov.

   {

     if (CpuFeatures::IsSupported(CMOV)) {

       CpuFeatures::Scope use_cmov(CMOV);

       __ cmov(overflow, eax, Operand(eax, 0));

       __ cmov(no_overflow, eax, Operand(eax, 1));

       __ cmov(below, eax, Operand(eax, 2));

       __ cmov(above_equal, eax, Operand(eax, 3));

       __ cmov(equal, eax, Operand(ebx, 0));

       __ cmov(not_equal, eax, Operand(ebx, 1));

       __ cmov(below_equal, eax, Operand(ebx, 2));

       __ cmov(above, eax, Operand(ebx, 3));

       __ cmov(sign, eax, Operand(ecx, 0));

       __ cmov(not_sign, eax, Operand(ecx, 1));

       __ cmov(parity_even, eax, Operand(ecx, 2));

       __ cmov(parity_odd, eax, Operand(ecx, 3));

       __ cmov(less, eax, Operand(edx, 0));

       __ cmov(greater_equal, eax, Operand(edx, 1));

       __ cmov(less_equal, eax, Operand(edx, 2));

       __ cmov(greater, eax, Operand(edx, 3));

     }

   }


   // andpd, cmpltsd, movaps, psllq, psrlq, por.

   {

     if (CpuFeatures::IsSupported(SSE2)) {

       CpuFeatures::Scope fscope(SSE2);

       __ andpd(xmm0, xmm1);

       __ andpd(xmm1, xmm2);


       __ cmpltsd(xmm0, xmm1);

       __ cmpltsd(xmm1, xmm2);


       __ movaps(xmm0, xmm1);

       __ movaps(xmm1, xmm2);


       __ psllq(xmm0, 17);

       __ psllq(xmm1, 42);


       __ psllq(xmm0, xmm1);

       __ psllq(xmm1, xmm2);


       __ psrlq(xmm0, 17);

       __ psrlq(xmm1, 42);


       __ psrlq(xmm0, xmm1);

       __ psrlq(xmm1, xmm2);


       __ por(xmm0, xmm1);

       __ por(xmm1, xmm2);

     }

   }


   {

     if (CpuFeatures::IsSupported(SSE4_1)) {

       CpuFeatures::Scope scope(SSE4_1);

       __ pextrd(eax, xmm0, 1);

       __ pinsrd(xmm1, eax, 0);

     }

   }


   // Nop instructions

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

     __ Nop(i);

   }


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

   byte* begin = Code::cast(code)->instruction_start();

   byte* end = begin + Code::cast(code)->instruction_size();

   disasm::Disassembler::Disassemble(stdout, begin, end);

 #endif

 }


 #undef __

disasm::Disassembler::Disassemble
static void Disassemble(FILE *f, byte *begin, byte *end)

v8::internal::no_overflow
Definition: assembler-ia32.h:203

v8::internal::AssemblerBase::isolate
Isolate * isolate() const
Definition: assembler.h:61

v8::internal::times_2
Definition: assembler-ia32.h:302

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

v8::internal::not_sign
Definition: assembler-ia32.h:225

v8::internal::overflow
Definition: assembler-ia32.h:202

v8::internal::less
Definition: assembler-ia32.h:214

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

v8::HandleScope
Definition: v8.h:446

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

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

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

v8::internal::CMOV
Definition: v8globals.h:429

debug.h

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::less_equal
Definition: assembler-ia32.h:216

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

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

disasm.h

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

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

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

v8::internal::sign
Definition: assembler-ia32.h:224

v8::internal::TENURED
Definition: v8globals.h:196

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

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

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

cctest.h

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

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

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

v8::internal::CPUID
Definition: v8globals.h:431

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

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

serialize.h

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::above_equal
Definition: assembler-ia32.h:205

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

v8::internal::RDTSC
Definition: v8globals.h:430

__
#define __
Definition: test-disasm-ia32.cc:50

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

v8::internal::times_8
Definition: assembler-ia32.h:304

v8::internal::parity_odd
Definition: assembler-ia32.h:213

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

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

disassembler.h

v8::internal::JavaScriptFrameConstants::kFunctionOffset
static const int kFunctionOffset
Definition: frames-arm.h:156

v8::internal::below_equal
Definition: assembler-ia32.h:208

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

macro-assembler.h

v8::internal::times_4
Definition: assembler-ia32.h:303

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

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::xmm2
const XMMRegister xmm2
Definition: assembler-ia32.h:187

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

FUNCTION_ADDR
#define FUNCTION_ADDR(f)
Definition: globals.h:293

v8::internal::greater_equal
Definition: assembler-ia32.h:215

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