Ignore:
Timestamp:
Nov 19, 2008, 11:16:30 AM (17 years ago)
Author:
[email protected]
Message:

2008-11-19 Geoffrey Garen <​[email protected]>

Reviewed by Sam Weinig.


A little more refactoring.


Removed the "emit" and "emitUnlinked" prefixes from the assembler.


Moved the JmpSrc and JmpDst class definitions to the top of the X86
assembler class, in accordance with WebKit style guidelines.

  • assembler/X86Assembler.h: (JSC::X86Assembler::JmpSrc::JmpSrc): (JSC::X86Assembler::JmpDst::JmpDst): (JSC::X86Assembler::int3): (JSC::X86Assembler::pushl_m): (JSC::X86Assembler::popl_m): (JSC::X86Assembler::movl_rr): (JSC::X86Assembler::addl_rr): (JSC::X86Assembler::addl_i8r): (JSC::X86Assembler::addl_i8m): (JSC::X86Assembler::addl_i32r): (JSC::X86Assembler::addl_mr): (JSC::X86Assembler::andl_rr): (JSC::X86Assembler::andl_i32r): (JSC::X86Assembler::cmpl_i8r): (JSC::X86Assembler::cmpl_rr): (JSC::X86Assembler::cmpl_rm): (JSC::X86Assembler::cmpl_mr): (JSC::X86Assembler::cmpl_i32r): (JSC::X86Assembler::cmpl_i32m): (JSC::X86Assembler::cmpl_i8m): (JSC::X86Assembler::cmpw_rm): (JSC::X86Assembler::orl_rr): (JSC::X86Assembler::orl_mr): (JSC::X86Assembler::orl_i32r): (JSC::X86Assembler::subl_rr): (JSC::X86Assembler::subl_i8r): (JSC::X86Assembler::subl_i8m): (JSC::X86Assembler::subl_i32r): (JSC::X86Assembler::subl_mr): (JSC::X86Assembler::testl_i32r): (JSC::X86Assembler::testl_i32m): (JSC::X86Assembler::testl_rr): (JSC::X86Assembler::xorl_i8r): (JSC::X86Assembler::xorl_rr): (JSC::X86Assembler::sarl_i8r): (JSC::X86Assembler::sarl_CLr): (JSC::X86Assembler::shl_i8r): (JSC::X86Assembler::shll_CLr): (JSC::X86Assembler::imull_rr): (JSC::X86Assembler::imull_i32r): (JSC::X86Assembler::idivl_r): (JSC::X86Assembler::negl_r): (JSC::X86Assembler::movl_mr): (JSC::X86Assembler::movzbl_rr): (JSC::X86Assembler::movzwl_mr): (JSC::X86Assembler::movl_rm): (JSC::X86Assembler::movl_i32r): (JSC::X86Assembler::movl_i32m): (JSC::X86Assembler::leal_mr): (JSC::X86Assembler::jmp_r): (JSC::X86Assembler::jmp_m): (JSC::X86Assembler::movsd_mr): (JSC::X86Assembler::xorpd_mr): (JSC::X86Assembler::movsd_rm): (JSC::X86Assembler::movd_rr): (JSC::X86Assembler::cvtsi2sd_rr): (JSC::X86Assembler::cvttsd2si_rr): (JSC::X86Assembler::addsd_mr): (JSC::X86Assembler::subsd_mr): (JSC::X86Assembler::mulsd_mr): (JSC::X86Assembler::addsd_rr): (JSC::X86Assembler::subsd_rr): (JSC::X86Assembler::mulsd_rr): (JSC::X86Assembler::ucomis_rr): (JSC::X86Assembler::pextrw_irr): (JSC::X86Assembler::call): (JSC::X86Assembler::jmp): (JSC::X86Assembler::jne): (JSC::X86Assembler::jnz): (JSC::X86Assembler::je): (JSC::X86Assembler::jl): (JSC::X86Assembler::jb): (JSC::X86Assembler::jle): (JSC::X86Assembler::jbe): (JSC::X86Assembler::jge): (JSC::X86Assembler::jg): (JSC::X86Assembler::ja): (JSC::X86Assembler::jae): (JSC::X86Assembler::jo): (JSC::X86Assembler::jp): (JSC::X86Assembler::js): (JSC::X86Assembler::predictNotTaken): (JSC::X86Assembler::convertToFastCall): (JSC::X86Assembler::restoreArgumentReference): (JSC::X86Assembler::restoreArgumentReferenceForTrampoline): (JSC::X86Assembler::modRm_rr): (JSC::X86Assembler::modRm_rr_Unchecked): (JSC::X86Assembler::modRm_rm): (JSC::X86Assembler::modRm_rm_Unchecked): (JSC::X86Assembler::modRm_rmsib): (JSC::X86Assembler::modRm_opr): (JSC::X86Assembler::modRm_opr_Unchecked): (JSC::X86Assembler::modRm_opm): (JSC::X86Assembler::modRm_opm_Unchecked): (JSC::X86Assembler::modRm_opmsib):
  • jit/JIT.cpp: (JSC::JIT::emitNakedCall): (JSC::JIT::emitNakedFastCall): (JSC::JIT::emitCTICall): (JSC::JIT::emitJumpSlowCaseIfNotJSCell): (JSC::JIT::emitJumpSlowCaseIfNotImmNum): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero): (JSC::JIT::emitFastArithIntToImmOrSlowCase): (JSC::JIT::emitArithIntToImmWithJump): (JSC::JIT::compileOpCall): (JSC::JIT::compileOpStrictEq): (JSC::JIT::emitSlowScriptCheck): (JSC::JIT::putDoubleResultToJSNumberCellOrJSImmediate): (JSC::JIT::compileBinaryArithOp): (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): (JSC::JIT::privateCompile): (JSC::JIT::privateCompileGetByIdSelf): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdChain): (JSC::JIT::privateCompilePutByIdReplace): (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::privateCompileCTIMachineTrampolines): (JSC::JIT::privateCompilePatchGetArrayLength):
  • wrec/WREC.cpp: (JSC::WREC::compileRegExp):
  • wrec/WRECGenerator.cpp: (JSC::WREC::Generator::generateBackreferenceQuantifier): (JSC::WREC::Generator::generateNonGreedyQuantifier): (JSC::WREC::Generator::generateGreedyQuantifier): (JSC::WREC::Generator::generatePatternCharacter): (JSC::WREC::Generator::generateCharacterClassInvertedRange): (JSC::WREC::Generator::generateCharacterClassInverted): (JSC::WREC::Generator::generateCharacterClass): (JSC::WREC::Generator::generateParentheses): (JSC::WREC::Generator::generateParenthesesNonGreedy): (JSC::WREC::Generator::generateParenthesesResetTrampoline): (JSC::WREC::Generator::generateAssertionBOL): (JSC::WREC::Generator::generateAssertionEOL): (JSC::WREC::Generator::generateAssertionWordBoundary): (JSC::WREC::Generator::generateBackreference): (JSC::WREC::Generator::generateDisjunction):
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/X86Assembler.h

    r38548 r38600  
    169169    } OpcodeID;
    170170   
    171     static const int maxInstructionSize = 16;
    172 
    173     X86Assembler(AssemblerBuffer* m_buffer)
    174         : m_buffer(m_buffer)
    175     {
    176         m_buffer->reset();
    177     }
    178 
    179     void emitInt3()
    180     {
    181         m_buffer->putByte(OP_INT3);
    182     }
    183    
    184     void pushl_r(RegisterID reg)
    185     {
    186         m_buffer->putByte(OP_PUSH_EAX + reg);
    187     }
    188    
    189     void pushl_m(int offset, RegisterID base)
    190     {
    191         m_buffer->putByte(OP_GROUP5_Ev);
    192         emitModRm_opm(GROUP5_OP_PUSH, base, offset);
    193     }
    194 
    195     void pushl_i32(int imm)
    196     {
    197         m_buffer->putByte(OP_PUSH_Iz);
    198         m_buffer->putInt(imm);
    199     }
    200    
    201     void popl_r(RegisterID reg)
    202     {
    203         m_buffer->putByte(OP_POP_EAX + reg);
    204     }
    205 
    206     void popl_m(int offset, RegisterID base)
    207     {
    208         m_buffer->putByte(OP_GROUP1A_Ev);
    209         emitModRm_opm(GROUP1A_OP_POP, base, offset);
    210     }
    211    
    212     void movl_rr(RegisterID src, RegisterID dst)
    213     {
    214         m_buffer->putByte(OP_MOV_EvGv);
    215         emitModRm_rr(src, dst);
    216     }
    217    
    218     void addl_rr(RegisterID src, RegisterID dst)
    219     {
    220         m_buffer->putByte(OP_ADD_EvGv);
    221         emitModRm_rr(src, dst);
    222     }
    223 
    224     void addl_i8r(int imm, RegisterID dst)
    225     {
    226         m_buffer->putByte(OP_GROUP1_EvIb);
    227         emitModRm_opr(GROUP1_OP_ADD, dst);
    228         m_buffer->putByte(imm);
    229     }
    230 
    231     void addl_i8m(int imm, void* addr)
    232     {
    233         m_buffer->putByte(OP_GROUP1_EvIb);
    234         emitModRm_opm(GROUP1_OP_ADD, addr);
    235         m_buffer->putByte(imm);
    236     }
    237 
    238     void addl_i32r(int imm, RegisterID dst)
    239     {
    240         m_buffer->putByte(OP_GROUP1_EvIz);
    241         emitModRm_opr(GROUP1_OP_ADD, dst);
    242         m_buffer->putInt(imm);
    243     }
    244 
    245     void addl_mr(int offset, RegisterID base, RegisterID dst)
    246     {
    247         m_buffer->putByte(OP_ADD_GvEv);
    248         emitModRm_rm(dst, base, offset);
    249     }
    250 
    251     void andl_rr(RegisterID src, RegisterID dst)
    252     {
    253         m_buffer->putByte(OP_AND_EvGv);
    254         emitModRm_rr(src, dst);
    255     }
    256 
    257     void andl_i32r(int imm, RegisterID dst)
    258     {
    259         m_buffer->putByte(OP_GROUP1_EvIz);
    260         emitModRm_opr(GROUP1_OP_AND, dst);
    261         m_buffer->putInt(imm);
    262     }
    263 
    264     void cmpl_i8r(int imm, RegisterID dst)
    265     {
    266         m_buffer->putByte(OP_GROUP1_EvIb);
    267         emitModRm_opr(GROUP1_OP_CMP, dst);
    268         m_buffer->putByte(imm);
    269     }
    270 
    271     void cmpl_rr(RegisterID src, RegisterID dst)
    272     {
    273         m_buffer->putByte(OP_CMP_EvGv);
    274         emitModRm_rr(src, dst);
    275     }
    276 
    277     void cmpl_rm(RegisterID src, int offset, RegisterID base)
    278     {
    279         m_buffer->putByte(OP_CMP_EvGv);
    280         emitModRm_rm(src, base, offset);
    281     }
    282 
    283     void cmpl_mr(int offset, RegisterID base, RegisterID dst)
    284     {
    285         m_buffer->putByte(OP_CMP_GvEv);
    286         emitModRm_rm(dst, base, offset);
    287     }
    288 
    289     void cmpl_i32r(int imm, RegisterID dst)
    290     {
    291         m_buffer->putByte(OP_GROUP1_EvIz);
    292         emitModRm_opr(GROUP1_OP_CMP, dst);
    293         m_buffer->putInt(imm);
    294     }
    295 
    296     void cmpl_i32m(int imm, RegisterID dst)
    297     {
    298         m_buffer->putByte(OP_GROUP1_EvIz);
    299         emitModRm_opm(GROUP1_OP_CMP, dst);
    300         m_buffer->putInt(imm);
    301     }
    302 
    303     void cmpl_i32m(int imm, int offset, RegisterID dst)
    304     {
    305         m_buffer->putByte(OP_GROUP1_EvIz);
    306         emitModRm_opm(GROUP1_OP_CMP, dst, offset);
    307         m_buffer->putInt(imm);
    308     }
    309 
    310     void cmpl_i32m(int imm, void* addr)
    311     {
    312         m_buffer->putByte(OP_GROUP1_EvIz);
    313         emitModRm_opm(GROUP1_OP_CMP, addr);
    314         m_buffer->putInt(imm);
    315     }
    316 
    317     void cmpl_i8m(int imm, int offset, RegisterID base, RegisterID index, int scale)
    318     {
    319         m_buffer->putByte(OP_GROUP1_EvIb);
    320         emitModRm_opmsib(GROUP1_OP_CMP, base, index, scale, offset);
    321         m_buffer->putByte(imm);
    322     }
    323 
    324     void cmpw_rm(RegisterID src, RegisterID base, RegisterID index, int scale)
    325     {
    326         m_buffer->putByte(PRE_OPERAND_SIZE);
    327         m_buffer->putByte(OP_CMP_EvGv);
    328         emitModRm_rmsib(src, base, index, scale);
    329     }
    330 
    331     void sete_r(RegisterID dst)
    332     {
    333         m_buffer->putByte(OP_2BYTE_ESCAPE);
    334         m_buffer->putByte(OP_SETE);
    335         m_buffer->putByte(MODRM(3, 0, dst));
    336     }
    337 
    338     void setz_r(RegisterID dst)
    339     {
    340         sete_r(dst);
    341     }
    342 
    343     void setne_r(RegisterID dst)
    344     {
    345         m_buffer->putByte(OP_2BYTE_ESCAPE);
    346         m_buffer->putByte(OP_SETNE);
    347         m_buffer->putByte(MODRM(3, 0, dst));
    348     }
    349 
    350     void setnz_r(RegisterID dst)
    351     {
    352         setne_r(dst);
    353     }
    354 
    355     void orl_rr(RegisterID src, RegisterID dst)
    356     {
    357         m_buffer->putByte(OP_OR_EvGv);
    358         emitModRm_rr(src, dst);
    359     }
    360 
    361     void orl_mr(int offset, RegisterID base, RegisterID dst)
    362     {
    363         m_buffer->putByte(OP_OR_GvEv);
    364         emitModRm_rm(dst, base, offset);
    365     }
    366 
    367     void orl_i32r(int imm, RegisterID dst)
    368     {
    369         m_buffer->putByte(OP_GROUP1_EvIb);
    370         emitModRm_opr(GROUP1_OP_OR, dst);
    371         m_buffer->putByte(imm);
    372     }
    373 
    374     void subl_rr(RegisterID src, RegisterID dst)
    375     {
    376         m_buffer->putByte(OP_SUB_EvGv);
    377         emitModRm_rr(src, dst);
    378     }
    379 
    380     void subl_i8r(int imm, RegisterID dst)
    381     {
    382         m_buffer->putByte(OP_GROUP1_EvIb);
    383         emitModRm_opr(GROUP1_OP_SUB, dst);
    384         m_buffer->putByte(imm);
    385     }
    386    
    387     void subl_i8m(int imm, void* addr)
    388     {
    389         m_buffer->putByte(OP_GROUP1_EvIb);
    390         emitModRm_opm(GROUP1_OP_SUB, addr);
    391         m_buffer->putByte(imm);
    392     }
    393 
    394     void subl_i32r(int imm, RegisterID dst)
    395     {
    396         m_buffer->putByte(OP_GROUP1_EvIz);
    397         emitModRm_opr(GROUP1_OP_SUB, dst);
    398         m_buffer->putInt(imm);
    399     }
    400 
    401     void subl_mr(int offset, RegisterID base, RegisterID dst)
    402     {
    403         m_buffer->putByte(OP_SUB_GvEv);
    404         emitModRm_rm(dst, base, offset);
    405     }
    406 
    407     void testl_i32r(int imm, RegisterID dst)
    408     {
    409         m_buffer->ensureSpace(maxInstructionSize);
    410         m_buffer->putByteUnchecked(OP_GROUP3_EvIz);
    411         emitModRm_opr_Unchecked(GROUP3_OP_TEST, dst);
    412         m_buffer->putIntUnchecked(imm);
    413     }
    414 
    415     void testl_i32m(int imm, RegisterID dst)
    416     {
    417         m_buffer->putByte(OP_GROUP3_EvIz);
    418         emitModRm_opm(GROUP3_OP_TEST, dst);
    419         m_buffer->putInt(imm);
    420     }
    421 
    422     void testl_i32m(int imm, int offset, RegisterID dst)
    423     {
    424         m_buffer->putByte(OP_GROUP3_EvIz);
    425         emitModRm_opm(GROUP3_OP_TEST, dst, offset);
    426         m_buffer->putInt(imm);
    427     }
    428 
    429     void testl_rr(RegisterID src, RegisterID dst)
    430     {
    431         m_buffer->putByte(OP_TEST_EvGv);
    432         emitModRm_rr(src, dst);
    433     }
    434    
    435     void xorl_i8r(int imm, RegisterID dst)
    436     {
    437         m_buffer->putByte(OP_GROUP1_EvIb);
    438         emitModRm_opr(GROUP1_OP_XOR, dst);
    439         m_buffer->putByte(imm);
    440     }
    441 
    442     void xorl_rr(RegisterID src, RegisterID dst)
    443     {
    444         m_buffer->putByte(OP_XOR_EvGv);
    445         emitModRm_rr(src, dst);
    446     }
    447 
    448     void sarl_i8r(int imm, RegisterID dst)
    449     {
    450         if (imm == 1) {
    451             m_buffer->putByte(OP_GROUP2_Ev1);
    452             emitModRm_opr(GROUP2_OP_SAR, dst);
    453         } else {
    454             m_buffer->putByte(OP_GROUP2_EvIb);
    455             emitModRm_opr(GROUP2_OP_SAR, dst);
    456             m_buffer->putByte(imm);
    457         }
    458     }
    459 
    460     void sarl_CLr(RegisterID dst)
    461     {
    462         m_buffer->putByte(OP_GROUP2_EvCL);
    463         emitModRm_opr(GROUP2_OP_SAR, dst);
    464     }
    465 
    466     void shl_i8r(int imm, RegisterID dst)
    467     {
    468         if (imm == 1) {
    469             m_buffer->putByte(OP_GROUP2_Ev1);
    470             emitModRm_opr(GROUP2_OP_SHL, dst);
    471         } else {
    472             m_buffer->putByte(OP_GROUP2_EvIb);
    473             emitModRm_opr(GROUP2_OP_SHL, dst);
    474             m_buffer->putByte(imm);
    475         }
    476     }
    477 
    478     void shll_CLr(RegisterID dst)
    479     {
    480         m_buffer->putByte(OP_GROUP2_EvCL);
    481         emitModRm_opr(GROUP2_OP_SHL, dst);
    482     }
    483 
    484     void imull_rr(RegisterID src, RegisterID dst)
    485     {
    486         m_buffer->putByte(OP_2BYTE_ESCAPE);
    487         m_buffer->putByte(OP2_IMUL_GvEv);
    488         emitModRm_rr(dst, src);
    489     }
    490    
    491     void imull_i32r(RegisterID src, int32_t value, RegisterID dst)
    492     {
    493         m_buffer->putByte(OP_IMUL_GvEvIz);
    494         emitModRm_rr(dst, src);
    495         m_buffer->putInt(value);
    496     }
    497 
    498     void idivl_r(RegisterID dst)
    499     {
    500         m_buffer->putByte(OP_GROUP3_Ev);
    501         emitModRm_opr(GROUP3_OP_IDIV, dst);
    502     }
    503 
    504     void negl_r(RegisterID dst)
    505     {
    506         m_buffer->putByte(OP_GROUP3_Ev);
    507         emitModRm_opr(GROUP3_OP_NEG, dst);
    508     }
    509 
    510     void cdq()
    511     {
    512         m_buffer->putByte(OP_CDQ);
    513     }
    514 
    515     void movl_mr(RegisterID base, RegisterID dst)
    516     {
    517         m_buffer->putByte(OP_MOV_GvEv);
    518         emitModRm_rm(dst, base);
    519     }
    520 
    521     void movl_mr(int offset, RegisterID base, RegisterID dst)
    522     {
    523         m_buffer->ensureSpace(maxInstructionSize);
    524         m_buffer->putByteUnchecked(OP_MOV_GvEv);
    525         emitModRm_rm_Unchecked(dst, base, offset);
    526     }
    527 
    528     void movl_mr(void* addr, RegisterID dst)
    529     {
    530         m_buffer->putByte(OP_MOV_GvEv);
    531         emitModRm_rm(dst, addr);
    532     }
    533 
    534     void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
    535     {
    536         m_buffer->putByte(OP_MOV_GvEv);
    537         emitModRm_rmsib(dst, base, index, scale, offset);
    538     }
    539 
    540     void movzbl_rr(RegisterID src, RegisterID dst)
    541     {
    542         m_buffer->putByte(OP_2BYTE_ESCAPE);
    543         m_buffer->putByte(OP2_MOVZX_GvEb);
    544         emitModRm_rr(dst, src);
    545     }
    546 
    547     void movzwl_mr(int offset, RegisterID base, RegisterID dst)
    548     {
    549         m_buffer->putByte(OP_2BYTE_ESCAPE);
    550         m_buffer->putByte(OP2_MOVZX_GvEw);
    551         emitModRm_rm(dst, base, offset);
    552     }
    553 
    554     void movzwl_mr(RegisterID base, RegisterID index, int scale, RegisterID dst)
    555     {
    556         m_buffer->putByte(OP_2BYTE_ESCAPE);
    557         m_buffer->putByte(OP2_MOVZX_GvEw);
    558         emitModRm_rmsib(dst, base, index, scale);
    559     }
    560 
    561     void movzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
    562     {
    563         m_buffer->putByte(OP_2BYTE_ESCAPE);
    564         m_buffer->putByte(OP2_MOVZX_GvEw);
    565         emitModRm_rmsib(dst, base, index, scale, offset);
    566     }
    567 
    568     void movl_rm(RegisterID src, RegisterID base)
    569     {
    570         m_buffer->putByte(OP_MOV_EvGv);
    571         emitModRm_rm(src, base);
    572     }
    573 
    574     void movl_rm(RegisterID src, int offset, RegisterID base)
    575     {
    576         m_buffer->ensureSpace(maxInstructionSize);
    577         m_buffer->putByteUnchecked(OP_MOV_EvGv);
    578         emitModRm_rm_Unchecked(src, base, offset);
    579     }
    580    
    581     void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
    582     {
    583         m_buffer->putByte(OP_MOV_EvGv);
    584         emitModRm_rmsib(src, base, index, scale, offset);
    585     }
    586    
    587     void movl_i32r(int imm, RegisterID dst)
    588     {
    589         m_buffer->putByte(OP_GROUP11_EvIz);
    590         emitModRm_opr(GROUP11_MOV, dst);
    591         m_buffer->putInt(imm);
    592     }
    593 
    594     void movl_i32m(int imm, int offset, RegisterID base)
    595     {
    596         m_buffer->ensureSpace(maxInstructionSize);
    597         m_buffer->putByteUnchecked(OP_GROUP11_EvIz);
    598         emitModRm_opm_Unchecked(GROUP11_MOV, base, offset);
    599         m_buffer->putIntUnchecked(imm);
    600     }
    601 
    602     void movl_i32m(int imm, void* addr)
    603     {
    604         m_buffer->putByte(OP_GROUP11_EvIz);
    605         emitModRm_opm(GROUP11_MOV, addr);
    606         m_buffer->putInt(imm);
    607     }
    608 
    609     void leal_mr(int offset, RegisterID base, RegisterID dst)
    610     {
    611         m_buffer->putByte(OP_LEA);
    612         emitModRm_rm(dst, base, offset);
    613     }
    614 
    615     void leal_mr(int offset, RegisterID index, int scale, RegisterID dst)
    616     {
    617         m_buffer->putByte(OP_LEA);
    618         emitModRm_rmsib(dst, X86::noBase, index, scale, offset);
    619     }
    620 
    621     void ret()
    622     {
    623         m_buffer->putByte(OP_RET);
    624     }
    625    
    626     void jmp_r(RegisterID dst)
    627     {
    628         m_buffer->putByte(OP_GROUP5_Ev);
    629         emitModRm_opr(GROUP5_OP_JMPN, dst);
    630     }
    631    
    632     void jmp_m(int offset, RegisterID base)
    633     {
    634         m_buffer->putByte(OP_GROUP5_Ev);
    635         emitModRm_opm(GROUP5_OP_JMPN, base, offset);
    636     }
    637    
    638     void movsd_mr(int offset, RegisterID base, XMMRegisterID dst)
    639     {
    640         m_buffer->putByte(PRE_SSE_F2);
    641         m_buffer->putByte(OP_2BYTE_ESCAPE);
    642         m_buffer->putByte(OP2_MOVSD_VsdWsd);
    643         emitModRm_rm((RegisterID)dst, base, offset);
    644     }
    645 
    646     void xorpd_mr(void* addr, XMMRegisterID dst)
    647     {
    648         m_buffer->putByte(PRE_SSE_66);
    649         m_buffer->putByte(OP_2BYTE_ESCAPE);
    650         m_buffer->putByte(OP2_XORPD_VsdWsd);
    651         emitModRm_rm((RegisterID)dst, addr);
    652     }
    653 
    654     void movsd_rm(XMMRegisterID src, int offset, RegisterID base)
    655     {
    656         m_buffer->putByte(PRE_SSE_F2);
    657         m_buffer->putByte(OP_2BYTE_ESCAPE);
    658         m_buffer->putByte(OP2_MOVSD_WsdVsd);
    659         emitModRm_rm((RegisterID)src, base, offset);
    660     }
    661 
    662     void movd_rr(XMMRegisterID src, RegisterID dst)
    663     {
    664         m_buffer->putByte(PRE_SSE_66);
    665         m_buffer->putByte(OP_2BYTE_ESCAPE);
    666         m_buffer->putByte(OP2_MOVD_EdVd);
    667         emitModRm_rr((RegisterID)src, dst);
    668     }
    669 
    670     void cvtsi2sd_rr(RegisterID src, XMMRegisterID dst)
    671     {
    672         m_buffer->putByte(PRE_SSE_F2);
    673         m_buffer->putByte(OP_2BYTE_ESCAPE);
    674         m_buffer->putByte(OP2_CVTSI2SD_VsdEd);
    675         emitModRm_rr((RegisterID)dst, src);
    676     }
    677 
    678     void cvttsd2si_rr(XMMRegisterID src, RegisterID dst)
    679     {
    680         m_buffer->putByte(PRE_SSE_F2);
    681         m_buffer->putByte(OP_2BYTE_ESCAPE);
    682         m_buffer->putByte(OP2_CVTTSD2SI_GdWsd);
    683         emitModRm_rr(dst, (RegisterID)src);
    684     }
    685 
    686     void addsd_mr(int offset, RegisterID base, XMMRegisterID dst)
    687     {
    688         m_buffer->putByte(PRE_SSE_F2);
    689         m_buffer->putByte(OP_2BYTE_ESCAPE);
    690         m_buffer->putByte(OP2_ADDSD_VsdWsd);
    691         emitModRm_rm((RegisterID)dst, base, offset);
    692     }
    693 
    694     void subsd_mr(int offset, RegisterID base, XMMRegisterID dst)
    695     {
    696         m_buffer->putByte(PRE_SSE_F2);
    697         m_buffer->putByte(OP_2BYTE_ESCAPE);
    698         m_buffer->putByte(OP2_SUBSD_VsdWsd);
    699         emitModRm_rm((RegisterID)dst, base, offset);
    700     }
    701 
    702     void mulsd_mr(int offset, RegisterID base, XMMRegisterID dst)
    703     {
    704         m_buffer->putByte(PRE_SSE_F2);
    705         m_buffer->putByte(OP_2BYTE_ESCAPE);
    706         m_buffer->putByte(OP2_MULSD_VsdWsd);
    707         emitModRm_rm((RegisterID)dst, base, offset);
    708     }
    709 
    710     void addsd_rr(XMMRegisterID src, XMMRegisterID dst)
    711     {
    712         m_buffer->putByte(PRE_SSE_F2);
    713         m_buffer->putByte(OP_2BYTE_ESCAPE);
    714         m_buffer->putByte(OP2_ADDSD_VsdWsd);
    715         emitModRm_rr((RegisterID)dst, (RegisterID)src);
    716     }
    717 
    718     void subsd_rr(XMMRegisterID src, XMMRegisterID dst)
    719     {
    720         m_buffer->putByte(PRE_SSE_F2);
    721         m_buffer->putByte(OP_2BYTE_ESCAPE);
    722         m_buffer->putByte(OP2_SUBSD_VsdWsd);
    723         emitModRm_rr((RegisterID)dst, (RegisterID)src);
    724     }
    725 
    726     void mulsd_rr(XMMRegisterID src, XMMRegisterID dst)
    727     {
    728         m_buffer->putByte(PRE_SSE_F2);
    729         m_buffer->putByte(OP_2BYTE_ESCAPE);
    730         m_buffer->putByte(OP2_MULSD_VsdWsd);
    731         emitModRm_rr((RegisterID)dst, (RegisterID)src);
    732     }
    733 
    734     void ucomis_rr(XMMRegisterID src, XMMRegisterID dst)
    735     {
    736         m_buffer->putByte(PRE_SSE_66);
    737         m_buffer->putByte(OP_2BYTE_ESCAPE);
    738         m_buffer->putByte(OP2_UCOMISD_VsdWsd);
    739         emitModRm_rr((RegisterID)dst, (RegisterID)src);
    740     }
    741 
    742     void pextrw_irr(int whichWord, XMMRegisterID src, RegisterID dst)
    743     {
    744         m_buffer->putByte(PRE_SSE_66);
    745         m_buffer->putByte(OP_2BYTE_ESCAPE);
    746         m_buffer->putByte(OP2_PEXTRW_GdUdIb);
    747         emitModRm_rr(dst, (RegisterID)src);
    748         m_buffer->putByte(whichWord);
    749     }
    750 
    751171    // Opaque label types
    752172   
    … …  
    785205    };
    786206
    787     // FIXME: make this point to a global label, linked later.
    788     JmpSrc emitCall()
     207    static const int maxInstructionSize = 16;
     208
     209    X86Assembler(AssemblerBuffer* m_buffer)
     210        : m_buffer(m_buffer)
     211    {
     212        m_buffer->reset();
     213    }
     214
     215    void int3()
     216    {
     217        m_buffer->putByte(OP_INT3);
     218    }
     219   
     220    void pushl_r(RegisterID reg)
     221    {
     222        m_buffer->putByte(OP_PUSH_EAX + reg);
     223    }
     224   
     225    void pushl_m(int offset, RegisterID base)
     226    {
     227        m_buffer->putByte(OP_GROUP5_Ev);
     228        modRm_opm(GROUP5_OP_PUSH, base, offset);
     229    }
     230
     231    void pushl_i32(int imm)
     232    {
     233        m_buffer->putByte(OP_PUSH_Iz);
     234        m_buffer->putInt(imm);
     235    }
     236   
     237    void popl_r(RegisterID reg)
     238    {
     239        m_buffer->putByte(OP_POP_EAX + reg);
     240    }
     241
     242    void popl_m(int offset, RegisterID base)
     243    {
     244        m_buffer->putByte(OP_GROUP1A_Ev);
     245        modRm_opm(GROUP1A_OP_POP, base, offset);
     246    }
     247   
     248    void movl_rr(RegisterID src, RegisterID dst)
     249    {
     250        m_buffer->putByte(OP_MOV_EvGv);
     251        modRm_rr(src, dst);
     252    }
     253   
     254    void addl_rr(RegisterID src, RegisterID dst)
     255    {
     256        m_buffer->putByte(OP_ADD_EvGv);
     257        modRm_rr(src, dst);
     258    }
     259
     260    void addl_i8r(int imm, RegisterID dst)
     261    {
     262        m_buffer->putByte(OP_GROUP1_EvIb);
     263        modRm_opr(GROUP1_OP_ADD, dst);
     264        m_buffer->putByte(imm);
     265    }
     266
     267    void addl_i8m(int imm, void* addr)
     268    {
     269        m_buffer->putByte(OP_GROUP1_EvIb);
     270        modRm_opm(GROUP1_OP_ADD, addr);
     271        m_buffer->putByte(imm);
     272    }
     273
     274    void addl_i32r(int imm, RegisterID dst)
     275    {
     276        m_buffer->putByte(OP_GROUP1_EvIz);
     277        modRm_opr(GROUP1_OP_ADD, dst);
     278        m_buffer->putInt(imm);
     279    }
     280
     281    void addl_mr(int offset, RegisterID base, RegisterID dst)
     282    {
     283        m_buffer->putByte(OP_ADD_GvEv);
     284        modRm_rm(dst, base, offset);
     285    }
     286
     287    void andl_rr(RegisterID src, RegisterID dst)
     288    {
     289        m_buffer->putByte(OP_AND_EvGv);
     290        modRm_rr(src, dst);
     291    }
     292
     293    void andl_i32r(int imm, RegisterID dst)
     294    {
     295        m_buffer->putByte(OP_GROUP1_EvIz);
     296        modRm_opr(GROUP1_OP_AND, dst);
     297        m_buffer->putInt(imm);
     298    }
     299
     300    void cmpl_i8r(int imm, RegisterID dst)
     301    {
     302        m_buffer->putByte(OP_GROUP1_EvIb);
     303        modRm_opr(GROUP1_OP_CMP, dst);
     304        m_buffer->putByte(imm);
     305    }
     306
     307    void cmpl_rr(RegisterID src, RegisterID dst)
     308    {
     309        m_buffer->putByte(OP_CMP_EvGv);
     310        modRm_rr(src, dst);
     311    }
     312
     313    void cmpl_rm(RegisterID src, int offset, RegisterID base)
     314    {
     315        m_buffer->putByte(OP_CMP_EvGv);
     316        modRm_rm(src, base, offset);
     317    }
     318
     319    void cmpl_mr(int offset, RegisterID base, RegisterID dst)
     320    {
     321        m_buffer->putByte(OP_CMP_GvEv);
     322        modRm_rm(dst, base, offset);
     323    }
     324
     325    void cmpl_i32r(int imm, RegisterID dst)
     326    {
     327        m_buffer->putByte(OP_GROUP1_EvIz);
     328        modRm_opr(GROUP1_OP_CMP, dst);
     329        m_buffer->putInt(imm);
     330    }
     331
     332    void cmpl_i32m(int imm, RegisterID dst)
     333    {
     334        m_buffer->putByte(OP_GROUP1_EvIz);
     335        modRm_opm(GROUP1_OP_CMP, dst);
     336        m_buffer->putInt(imm);
     337    }
     338
     339    void cmpl_i32m(int imm, int offset, RegisterID dst)
     340    {
     341        m_buffer->putByte(OP_GROUP1_EvIz);
     342        modRm_opm(GROUP1_OP_CMP, dst, offset);
     343        m_buffer->putInt(imm);
     344    }
     345
     346    void cmpl_i32m(int imm, void* addr)
     347    {
     348        m_buffer->putByte(OP_GROUP1_EvIz);
     349        modRm_opm(GROUP1_OP_CMP, addr);
     350        m_buffer->putInt(imm);
     351    }
     352
     353    void cmpl_i8m(int imm, int offset, RegisterID base, RegisterID index, int scale)
     354    {
     355        m_buffer->putByte(OP_GROUP1_EvIb);
     356        modRm_opmsib(GROUP1_OP_CMP, base, index, scale, offset);
     357        m_buffer->putByte(imm);
     358    }
     359
     360    void cmpw_rm(RegisterID src, RegisterID base, RegisterID index, int scale)
     361    {
     362        m_buffer->putByte(PRE_OPERAND_SIZE);
     363        m_buffer->putByte(OP_CMP_EvGv);
     364        modRm_rmsib(src, base, index, scale);
     365    }
     366
     367    void sete_r(RegisterID dst)
     368    {
     369        m_buffer->putByte(OP_2BYTE_ESCAPE);
     370        m_buffer->putByte(OP_SETE);
     371        m_buffer->putByte(MODRM(3, 0, dst));
     372    }
     373
     374    void setz_r(RegisterID dst)
     375    {
     376        sete_r(dst);
     377    }
     378
     379    void setne_r(RegisterID dst)
     380    {
     381        m_buffer->putByte(OP_2BYTE_ESCAPE);
     382        m_buffer->putByte(OP_SETNE);
     383        m_buffer->putByte(MODRM(3, 0, dst));
     384    }
     385
     386    void setnz_r(RegisterID dst)
     387    {
     388        setne_r(dst);
     389    }
     390
     391    void orl_rr(RegisterID src, RegisterID dst)
     392    {
     393        m_buffer->putByte(OP_OR_EvGv);
     394        modRm_rr(src, dst);
     395    }
     396
     397    void orl_mr(int offset, RegisterID base, RegisterID dst)
     398    {
     399        m_buffer->putByte(OP_OR_GvEv);
     400        modRm_rm(dst, base, offset);
     401    }
     402
     403    void orl_i32r(int imm, RegisterID dst)
     404    {
     405        m_buffer->putByte(OP_GROUP1_EvIb);
     406        modRm_opr(GROUP1_OP_OR, dst);
     407        m_buffer->putByte(imm);
     408    }
     409
     410    void subl_rr(RegisterID src, RegisterID dst)
     411    {
     412        m_buffer->putByte(OP_SUB_EvGv);
     413        modRm_rr(src, dst);
     414    }
     415
     416    void subl_i8r(int imm, RegisterID dst)
     417    {
     418        m_buffer->putByte(OP_GROUP1_EvIb);
     419        modRm_opr(GROUP1_OP_SUB, dst);
     420        m_buffer->putByte(imm);
     421    }
     422   
     423    void subl_i8m(int imm, void* addr)
     424    {
     425        m_buffer->putByte(OP_GROUP1_EvIb);
     426        modRm_opm(GROUP1_OP_SUB, addr);
     427        m_buffer->putByte(imm);
     428    }
     429
     430    void subl_i32r(int imm, RegisterID dst)
     431    {
     432        m_buffer->putByte(OP_GROUP1_EvIz);
     433        modRm_opr(GROUP1_OP_SUB, dst);
     434        m_buffer->putInt(imm);
     435    }
     436
     437    void subl_mr(int offset, RegisterID base, RegisterID dst)
     438    {
     439        m_buffer->putByte(OP_SUB_GvEv);
     440        modRm_rm(dst, base, offset);
     441    }
     442
     443    void testl_i32r(int imm, RegisterID dst)
     444    {
     445        m_buffer->ensureSpace(maxInstructionSize);
     446        m_buffer->putByteUnchecked(OP_GROUP3_EvIz);
     447        modRm_opr_Unchecked(GROUP3_OP_TEST, dst);
     448        m_buffer->putIntUnchecked(imm);
     449    }
     450
     451    void testl_i32m(int imm, RegisterID dst)
     452    {
     453        m_buffer->putByte(OP_GROUP3_EvIz);
     454        modRm_opm(GROUP3_OP_TEST, dst);
     455        m_buffer->putInt(imm);
     456    }
     457
     458    void testl_i32m(int imm, int offset, RegisterID dst)
     459    {
     460        m_buffer->putByte(OP_GROUP3_EvIz);
     461        modRm_opm(GROUP3_OP_TEST, dst, offset);
     462        m_buffer->putInt(imm);
     463    }
     464
     465    void testl_rr(RegisterID src, RegisterID dst)
     466    {
     467        m_buffer->putByte(OP_TEST_EvGv);
     468        modRm_rr(src, dst);
     469    }
     470   
     471    void xorl_i8r(int imm, RegisterID dst)
     472    {
     473        m_buffer->putByte(OP_GROUP1_EvIb);
     474        modRm_opr(GROUP1_OP_XOR, dst);
     475        m_buffer->putByte(imm);
     476    }
     477
     478    void xorl_rr(RegisterID src, RegisterID dst)
     479    {
     480        m_buffer->putByte(OP_XOR_EvGv);
     481        modRm_rr(src, dst);
     482    }
     483
     484    void sarl_i8r(int imm, RegisterID dst)
     485    {
     486        if (imm == 1) {
     487            m_buffer->putByte(OP_GROUP2_Ev1);
     488            modRm_opr(GROUP2_OP_SAR, dst);
     489        } else {
     490            m_buffer->putByte(OP_GROUP2_EvIb);
     491            modRm_opr(GROUP2_OP_SAR, dst);
     492            m_buffer->putByte(imm);
     493        }
     494    }
     495
     496    void sarl_CLr(RegisterID dst)
     497    {
     498        m_buffer->putByte(OP_GROUP2_EvCL);
     499        modRm_opr(GROUP2_OP_SAR, dst);
     500    }
     501
     502    void shl_i8r(int imm, RegisterID dst)
     503    {
     504        if (imm == 1) {
     505            m_buffer->putByte(OP_GROUP2_Ev1);
     506            modRm_opr(GROUP2_OP_SHL, dst);
     507        } else {
     508            m_buffer->putByte(OP_GROUP2_EvIb);
     509            modRm_opr(GROUP2_OP_SHL, dst);
     510            m_buffer->putByte(imm);
     511        }
     512    }
     513
     514    void shll_CLr(RegisterID dst)
     515    {
     516        m_buffer->putByte(OP_GROUP2_EvCL);
     517        modRm_opr(GROUP2_OP_SHL, dst);
     518    }
     519
     520    void imull_rr(RegisterID src, RegisterID dst)
     521    {
     522        m_buffer->putByte(OP_2BYTE_ESCAPE);
     523        m_buffer->putByte(OP2_IMUL_GvEv);
     524        modRm_rr(dst, src);
     525    }
     526   
     527    void imull_i32r(RegisterID src, int32_t value, RegisterID dst)
     528    {
     529        m_buffer->putByte(OP_IMUL_GvEvIz);
     530        modRm_rr(dst, src);
     531        m_buffer->putInt(value);
     532    }
     533
     534    void idivl_r(RegisterID dst)
     535    {
     536        m_buffer->putByte(OP_GROUP3_Ev);
     537        modRm_opr(GROUP3_OP_IDIV, dst);
     538    }
     539
     540    void negl_r(RegisterID dst)
     541    {
     542        m_buffer->putByte(OP_GROUP3_Ev);
     543        modRm_opr(GROUP3_OP_NEG, dst);
     544    }
     545
     546    void cdq()
     547    {
     548        m_buffer->putByte(OP_CDQ);
     549    }
     550
     551    void movl_mr(RegisterID base, RegisterID dst)
     552    {
     553        m_buffer->putByte(OP_MOV_GvEv);
     554        modRm_rm(dst, base);
     555    }
     556
     557    void movl_mr(int offset, RegisterID base, RegisterID dst)
     558    {
     559        m_buffer->ensureSpace(maxInstructionSize);
     560        m_buffer->putByteUnchecked(OP_MOV_GvEv);
     561        modRm_rm_Unchecked(dst, base, offset);
     562    }
     563
     564    void movl_mr(void* addr, RegisterID dst)
     565    {
     566        m_buffer->putByte(OP_MOV_GvEv);
     567        modRm_rm(dst, addr);
     568    }
     569
     570    void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     571    {
     572        m_buffer->putByte(OP_MOV_GvEv);
     573        modRm_rmsib(dst, base, index, scale, offset);
     574    }
     575
     576    void movzbl_rr(RegisterID src, RegisterID dst)
     577    {
     578        m_buffer->putByte(OP_2BYTE_ESCAPE);
     579        m_buffer->putByte(OP2_MOVZX_GvEb);
     580        modRm_rr(dst, src);
     581    }
     582
     583    void movzwl_mr(int offset, RegisterID base, RegisterID dst)
     584    {
     585        m_buffer->putByte(OP_2BYTE_ESCAPE);
     586        m_buffer->putByte(OP2_MOVZX_GvEw);
     587        modRm_rm(dst, base, offset);
     588    }
     589
     590    void movzwl_mr(RegisterID base, RegisterID index, int scale, RegisterID dst)
     591    {
     592        m_buffer->putByte(OP_2BYTE_ESCAPE);
     593        m_buffer->putByte(OP2_MOVZX_GvEw);
     594        modRm_rmsib(dst, base, index, scale);
     595    }
     596
     597    void movzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
     598    {
     599        m_buffer->putByte(OP_2BYTE_ESCAPE);
     600        m_buffer->putByte(OP2_MOVZX_GvEw);
     601        modRm_rmsib(dst, base, index, scale, offset);
     602    }
     603
     604    void movl_rm(RegisterID src, RegisterID base)
     605    {
     606        m_buffer->putByte(OP_MOV_EvGv);
     607        modRm_rm(src, base);
     608    }
     609
     610    void movl_rm(RegisterID src, int offset, RegisterID base)
     611    {
     612        m_buffer->ensureSpace(maxInstructionSize);
     613        m_buffer->putByteUnchecked(OP_MOV_EvGv);
     614        modRm_rm_Unchecked(src, base, offset);
     615    }
     616   
     617    void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
     618    {
     619        m_buffer->putByte(OP_MOV_EvGv);
     620        modRm_rmsib(src, base, index, scale, offset);
     621    }
     622   
     623    void movl_i32r(int imm, RegisterID dst)
     624    {
     625        m_buffer->putByte(OP_GROUP11_EvIz);
     626        modRm_opr(GROUP11_MOV, dst);
     627        m_buffer->putInt(imm);
     628    }
     629
     630    void movl_i32m(int imm, int offset, RegisterID base)
     631    {
     632        m_buffer->ensureSpace(maxInstructionSize);
     633        m_buffer->putByteUnchecked(OP_GROUP11_EvIz);
     634        modRm_opm_Unchecked(GROUP11_MOV, base, offset);
     635        m_buffer->putIntUnchecked(imm);
     636    }
     637
     638    void movl_i32m(int imm, void* addr)
     639    {
     640        m_buffer->putByte(OP_GROUP11_EvIz);
     641        modRm_opm(GROUP11_MOV, addr);
     642        m_buffer->putInt(imm);
     643    }
     644
     645    void leal_mr(int offset, RegisterID base, RegisterID dst)
     646    {
     647        m_buffer->putByte(OP_LEA);
     648        modRm_rm(dst, base, offset);
     649    }
     650
     651    void leal_mr(int offset, RegisterID index, int scale, RegisterID dst)
     652    {
     653        m_buffer->putByte(OP_LEA);
     654        modRm_rmsib(dst, X86::noBase, index, scale, offset);
     655    }
     656
     657    void ret()
     658    {
     659        m_buffer->putByte(OP_RET);
     660    }
     661   
     662    void jmp_r(RegisterID dst)
     663    {
     664        m_buffer->putByte(OP_GROUP5_Ev);
     665        modRm_opr(GROUP5_OP_JMPN, dst);
     666    }
     667   
     668    void jmp_m(int offset, RegisterID base)
     669    {
     670        m_buffer->putByte(OP_GROUP5_Ev);
     671        modRm_opm(GROUP5_OP_JMPN, base, offset);
     672    }
     673   
     674    void movsd_mr(int offset, RegisterID base, XMMRegisterID dst)
     675    {
     676        m_buffer->putByte(PRE_SSE_F2);
     677        m_buffer->putByte(OP_2BYTE_ESCAPE);
     678        m_buffer->putByte(OP2_MOVSD_VsdWsd);
     679        modRm_rm((RegisterID)dst, base, offset);
     680    }
     681
     682    void xorpd_mr(void* addr, XMMRegisterID dst)
     683    {
     684        m_buffer->putByte(PRE_SSE_66);
     685        m_buffer->putByte(OP_2BYTE_ESCAPE);
     686        m_buffer->putByte(OP2_XORPD_VsdWsd);
     687        modRm_rm((RegisterID)dst, addr);
     688    }
     689
     690    void movsd_rm(XMMRegisterID src, int offset, RegisterID base)
     691    {
     692        m_buffer->putByte(PRE_SSE_F2);
     693        m_buffer->putByte(OP_2BYTE_ESCAPE);
     694        m_buffer->putByte(OP2_MOVSD_WsdVsd);
     695        modRm_rm((RegisterID)src, base, offset);
     696    }
     697
     698    void movd_rr(XMMRegisterID src, RegisterID dst)
     699    {
     700        m_buffer->putByte(PRE_SSE_66);
     701        m_buffer->putByte(OP_2BYTE_ESCAPE);
     702        m_buffer->putByte(OP2_MOVD_EdVd);
     703        modRm_rr((RegisterID)src, dst);
     704    }
     705
     706    void cvtsi2sd_rr(RegisterID src, XMMRegisterID dst)
     707    {
     708        m_buffer->putByte(PRE_SSE_F2);
     709        m_buffer->putByte(OP_2BYTE_ESCAPE);
     710        m_buffer->putByte(OP2_CVTSI2SD_VsdEd);
     711        modRm_rr((RegisterID)dst, src);
     712    }
     713
     714    void cvttsd2si_rr(XMMRegisterID src, RegisterID dst)
     715    {
     716        m_buffer->putByte(PRE_SSE_F2);
     717        m_buffer->putByte(OP_2BYTE_ESCAPE);
     718        m_buffer->putByte(OP2_CVTTSD2SI_GdWsd);
     719        modRm_rr(dst, (RegisterID)src);
     720    }
     721
     722    void addsd_mr(int offset, RegisterID base, XMMRegisterID dst)
     723    {
     724        m_buffer->putByte(PRE_SSE_F2);
     725        m_buffer->putByte(OP_2BYTE_ESCAPE);
     726        m_buffer->putByte(OP2_ADDSD_VsdWsd);
     727        modRm_rm((RegisterID)dst, base, offset);
     728    }
     729
     730    void subsd_mr(int offset, RegisterID base, XMMRegisterID dst)
     731    {
     732        m_buffer->putByte(PRE_SSE_F2);
     733        m_buffer->putByte(OP_2BYTE_ESCAPE);
     734        m_buffer->putByte(OP2_SUBSD_VsdWsd);
     735        modRm_rm((RegisterID)dst, base, offset);
     736    }
     737
     738    void mulsd_mr(int offset, RegisterID base, XMMRegisterID dst)
     739    {
     740        m_buffer->putByte(PRE_SSE_F2);
     741        m_buffer->putByte(OP_2BYTE_ESCAPE);
     742        m_buffer->putByte(OP2_MULSD_VsdWsd);
     743        modRm_rm((RegisterID)dst, base, offset);
     744    }
     745
     746    void addsd_rr(XMMRegisterID src, XMMRegisterID dst)
     747    {
     748        m_buffer->putByte(PRE_SSE_F2);
     749        m_buffer->putByte(OP_2BYTE_ESCAPE);
     750        m_buffer->putByte(OP2_ADDSD_VsdWsd);
     751        modRm_rr((RegisterID)dst, (RegisterID)src);
     752    }
     753
     754    void subsd_rr(XMMRegisterID src, XMMRegisterID dst)
     755    {
     756        m_buffer->putByte(PRE_SSE_F2);
     757        m_buffer->putByte(OP_2BYTE_ESCAPE);
     758        m_buffer->putByte(OP2_SUBSD_VsdWsd);
     759        modRm_rr((RegisterID)dst, (RegisterID)src);
     760    }
     761
     762    void mulsd_rr(XMMRegisterID src, XMMRegisterID dst)
     763    {
     764        m_buffer->putByte(PRE_SSE_F2);
     765        m_buffer->putByte(OP_2BYTE_ESCAPE);
     766        m_buffer->putByte(OP2_MULSD_VsdWsd);
     767        modRm_rr((RegisterID)dst, (RegisterID)src);
     768    }
     769
     770    void ucomis_rr(XMMRegisterID src, XMMRegisterID dst)
     771    {
     772        m_buffer->putByte(PRE_SSE_66);
     773        m_buffer->putByte(OP_2BYTE_ESCAPE);
     774        m_buffer->putByte(OP2_UCOMISD_VsdWsd);
     775        modRm_rr((RegisterID)dst, (RegisterID)src);
     776    }
     777
     778    void pextrw_irr(int whichWord, XMMRegisterID src, RegisterID dst)
     779    {
     780        m_buffer->putByte(PRE_SSE_66);
     781        m_buffer->putByte(OP_2BYTE_ESCAPE);
     782        m_buffer->putByte(OP2_PEXTRW_GdUdIb);
     783        modRm_rr(dst, (RegisterID)src);
     784        m_buffer->putByte(whichWord);
     785    }
     786
     787    JmpSrc call()
    789788    {
    790789        m_buffer->putByte(OP_CALL_rel32);
    791         m_buffer->putInt(0);
    792         return JmpSrc(m_buffer->size());
    793     }
    794    
    795     JmpSrc emitCall(RegisterID dst)
     790        m_buffer->putInt(0); // FIXME: make this point to a global label, linked later.
     791        return JmpSrc(m_buffer->size());
     792    }
     793   
     794    JmpSrc call(RegisterID dst)
    796795    {
    797796        m_buffer->putByte(OP_GROUP5_Ev);
    798         emitModRm_opr(GROUP5_OP_CALLN, dst);
     797        modRm_opr(GROUP5_OP_CALLN, dst);
    799798        return JmpSrc(m_buffer->size());
    800799    }
    … …  
    813812    }
    814813
    815     JmpSrc emitUnlinkedJmp()
     814    JmpSrc jmp()
    816815    {
    817816        m_buffer->putByte(OP_JMP_rel32);
    … …  
    820819    }
    821820   
    822     JmpSrc emitUnlinkedJne()
     821    JmpSrc jne()
    823822    {
    824823        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    828827    }
    829828   
    830     JmpSrc emitUnlinkedJnz()
    831     {
    832         return emitUnlinkedJne();
    833     }
    834 
    835     JmpSrc emitUnlinkedJe()
     829    JmpSrc jnz()
     830    {
     831        return jne();
     832    }
     833
     834    JmpSrc je()
    836835    {
    837836        m_buffer->ensureSpace(maxInstructionSize);
    … …  
    842841    }
    843842   
    844     JmpSrc emitUnlinkedJl()
     843    JmpSrc jl()
    845844    {
    846845        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    850849    }
    851850   
    852     JmpSrc emitUnlinkedJb()
     851    JmpSrc jb()
    853852    {
    854853        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    858857    }
    859858   
    860     JmpSrc emitUnlinkedJle()
     859    JmpSrc jle()
    861860    {
    862861        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    866865    }
    867866   
    868     JmpSrc emitUnlinkedJbe()
     867    JmpSrc jbe()
    869868    {
    870869        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    874873    }
    875874   
    876     JmpSrc emitUnlinkedJge()
     875    JmpSrc jge()
    877876    {
    878877        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    882881    }
    883882
    884     JmpSrc emitUnlinkedJg()
     883    JmpSrc jg()
    885884    {
    886885        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    890889    }
    891890
    892     JmpSrc emitUnlinkedJa()
     891    JmpSrc ja()
    893892    {
    894893        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    898897    }
    899898   
    900     JmpSrc emitUnlinkedJae()
     899    JmpSrc jae()
    901900    {
    902901        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    906905    }
    907906   
    908     JmpSrc emitUnlinkedJo()
     907    JmpSrc jo()
    909908    {
    910909        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    914913    }
    915914
    916     JmpSrc emitUnlinkedJp()
     915    JmpSrc jp()
    917916    {
    918917        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    922921    }
    923922   
    924     JmpSrc emitUnlinkedJs()
     923    JmpSrc js()
    925924    {
    926925        m_buffer->putByte(OP_2BYTE_ESCAPE);
    … …  
    930929    }
    931930   
    932     void emitPredictionNotTaken()
     931    void predictNotTaken()
    933932    {
    934933        m_buffer->putByte(PRE_PREDICT_BRANCH_NOT_TAKEN);
    … …  
    10041003
    10051004#if COMPILER(MSVC)
    1006     void emitConvertToFastCall()
     1005    void convertToFastCall()
    10071006    {
    10081007        movl_mr(4, X86::esp, X86::eax);
    … …  
    10111010    }
    10121011#else
    1013     void emitConvertToFastCall() {}
     1012    void convertToFastCall() {}
    10141013#endif
    10151014
    10161015#if USE(CTI_ARGUMENT)
    1017     void emitRestoreArgumentReference()
     1016    void restoreArgumentReference()
    10181017    {
    10191018#if USE(FAST_CALL_CTI_ARGUMENT)
    … …  
    10241023    }
    10251024
    1026     void emitRestoreArgumentReferenceForTrampoline()
     1025    void restoreArgumentReferenceForTrampoline()
    10271026    {
    10281027#if USE(FAST_CALL_CTI_ARGUMENT)
    … …  
    10321031    }
    10331032#else
    1034     void emitRestoreArgumentReference() {}
    1035     void emitRestoreArgumentReferenceForTrampoline() {}
     1033    void restoreArgumentReference() {}
     1034    void restoreArgumentReferenceForTrampoline() {}
    10361035#endif
    10371036
    10381037private:
    1039     void emitModRm_rr(RegisterID reg, RegisterID rm)
     1038    void modRm_rr(RegisterID reg, RegisterID rm)
    10401039    {
    10411040        m_buffer->ensureSpace(maxInstructionSize);
    1042         emitModRm_rr_Unchecked(reg, rm);
    1043     }
    1044 
    1045     void emitModRm_rr_Unchecked(RegisterID reg, RegisterID rm)
     1041        modRm_rr_Unchecked(reg, rm);
     1042    }
     1043
     1044    void modRm_rr_Unchecked(RegisterID reg, RegisterID rm)
    10461045    {
    10471046        m_buffer->putByteUnchecked(MODRM(3, reg, rm));
    10481047    }
    10491048
    1050     void emitModRm_rm(RegisterID reg, void* addr)
     1049    void modRm_rm(RegisterID reg, void* addr)
    10511050    {
    10521051        m_buffer->putByte(MODRM(0, reg, X86::noBase));
    … …  
    10541053    }
    10551054
    1056     void emitModRm_rm(RegisterID reg, RegisterID base)
     1055    void modRm_rm(RegisterID reg, RegisterID base)
    10571056    {
    10581057        if (base == X86::esp) {
    … …  
    10631062    }
    10641063
    1065     void emitModRm_rm_Unchecked(RegisterID reg, RegisterID base, int offset)
     1064    void modRm_rm_Unchecked(RegisterID reg, RegisterID base, int offset)
    10661065    {
    10671066        if (base == X86::esp) {
    … …  
    10861085    }
    10871086
    1088     void emitModRm_rm(RegisterID reg, RegisterID base, int offset)
     1087    void modRm_rm(RegisterID reg, RegisterID base, int offset)
    10891088    {
    10901089        m_buffer->ensureSpace(maxInstructionSize);
    1091         emitModRm_rm_Unchecked(reg, base, offset);
    1092     }
    1093 
    1094     void emitModRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale)
     1090        modRm_rm_Unchecked(reg, base, offset);
     1091    }
     1092
     1093    void modRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale)
    10951094    {
    10961095        int shift = 0;
    … …  
    11021101    }
    11031102
    1104     void emitModRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale, int offset)
     1103    void modRm_rmsib(RegisterID reg, RegisterID base, RegisterID index, int scale, int offset)
    11051104    {
    11061105        int shift = 0;
    … …  
    11191118    }
    11201119
    1121     void emitModRm_opr(OpcodeID opcodeID, RegisterID rm)
     1120    void modRm_opr(OpcodeID opcodeID, RegisterID rm)
    11221121    {
    11231122        m_buffer->ensureSpace(maxInstructionSize);
    1124         emitModRm_opr_Unchecked(opcodeID, rm);
    1125     }
    1126 
    1127     void emitModRm_opr_Unchecked(OpcodeID opcodeID, RegisterID rm)
    1128     {
    1129         emitModRm_rr_Unchecked(static_cast<RegisterID>(opcodeID), rm);
    1130     }
    1131 
    1132     void emitModRm_opm(OpcodeID opcodeID, RegisterID base)
    1133     {
    1134         emitModRm_rm(static_cast<RegisterID>(opcodeID), base);
    1135     }
    1136 
    1137     void emitModRm_opm_Unchecked(OpcodeID opcodeID, RegisterID base, int offset)
    1138     {
    1139         emitModRm_rm_Unchecked(static_cast<RegisterID>(opcodeID), base, offset);
    1140     }
    1141 
    1142     void emitModRm_opm(OpcodeID opcodeID, RegisterID base, int offset)
    1143     {
    1144         emitModRm_rm(static_cast<RegisterID>(opcodeID), base, offset);
    1145     }
    1146 
    1147     void emitModRm_opm(OpcodeID opcodeID, void* addr)
    1148     {
    1149         emitModRm_rm(static_cast<RegisterID>(opcodeID), addr);
    1150     }
    1151 
    1152     void emitModRm_opmsib(OpcodeID opcodeID, RegisterID base, RegisterID index, int scale, int offset)
    1153     {
    1154         emitModRm_rmsib(static_cast<RegisterID>(opcodeID), base, index, scale, offset);
     1123        modRm_opr_Unchecked(opcodeID, rm);
     1124    }
     1125
     1126    void modRm_opr_Unchecked(OpcodeID opcodeID, RegisterID rm)
     1127    {
     1128        modRm_rr_Unchecked(static_cast<RegisterID>(opcodeID), rm);
     1129    }
     1130
     1131    void modRm_opm(OpcodeID opcodeID, RegisterID base)
     1132    {
     1133        modRm_rm(static_cast<RegisterID>(opcodeID), base);
     1134    }
     1135
     1136    void modRm_opm_Unchecked(OpcodeID opcodeID, RegisterID base, int offset)
     1137    {
     1138        modRm_rm_Unchecked(static_cast<RegisterID>(opcodeID), base, offset);
     1139    }
     1140
     1141    void modRm_opm(OpcodeID opcodeID, RegisterID base, int offset)
     1142    {
     1143        modRm_rm(static_cast<RegisterID>(opcodeID), base, offset);
     1144    }
     1145
     1146    void modRm_opm(OpcodeID opcodeID, void* addr)
     1147    {
     1148        modRm_rm(static_cast<RegisterID>(opcodeID), addr);
     1149    }
     1150
     1151    void modRm_opmsib(OpcodeID opcodeID, RegisterID base, RegisterID index, int scale, int offset)
     1152    {
     1153        modRm_rmsib(static_cast<RegisterID>(opcodeID), base, index, scale, offset);
    11551154    }
    11561155
Note: See TracChangeset for help on using the changeset viewer.