Changeset 39020 in webkit for trunk/JavaScriptCore/assembler


Ignore:
Timestamp:
Dec 4, 2008, 10:58:40 PM (16 years ago)
Author:
[email protected]
Message:

2008-12-04 Gavin Barraclough <​[email protected]>

Reviewed by Geoff Garen.

Start porting the JIT to use the MacroAssembler.

​https://bugs.webkit.org/show_bug.cgi?id=22671
No change in performance.

  • assembler/MacroAssembler.h: (JSC::MacroAssembler::Jump::operator X86Assembler::JmpSrc): (JSC::MacroAssembler::add32): (JSC::MacroAssembler::and32): (JSC::MacroAssembler::lshift32): (JSC::MacroAssembler::rshift32): (JSC::MacroAssembler::storePtr): (JSC::MacroAssembler::store32): (JSC::MacroAssembler::poke): (JSC::MacroAssembler::move): (JSC::MacroAssembler::compareImm32ForBranchEquality): (JSC::MacroAssembler::jnePtr): (JSC::MacroAssembler::jnset32): (JSC::MacroAssembler::jset32): (JSC::MacroAssembler::jzeroSub32): (JSC::MacroAssembler::joverAdd32): (JSC::MacroAssembler::call):
  • assembler/X86Assembler.h: (JSC::X86Assembler::shll_i8r):
  • jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompile): (JSC::JIT::privateCompileCTIMachineTrampolines):
  • jit/JIT.h:
  • jit/JITArithmetic.cpp: (JSC::JIT::compileBinaryArithOp):
  • jit/JITInlineMethods.h: (JSC::JIT::emitGetVirtualRegister): (JSC::JIT::emitPutCTIArg): (JSC::JIT::emitPutCTIArgConstant): (JSC::JIT::emitGetCTIArg): (JSC::JIT::emitPutCTIArgFromVirtualRegister): (JSC::JIT::emitPutCTIParam): (JSC::JIT::emitGetCTIParam): (JSC::JIT::emitPutToCallFrameHeader): (JSC::JIT::emitPutImmediateToCallFrameHeader): (JSC::JIT::emitGetFromCallFrameHeader): (JSC::JIT::emitPutVirtualRegister): (JSC::JIT::emitInitRegister): (JSC::JIT::emitNakedCall): (JSC::JIT::restoreArgumentReference): (JSC::JIT::restoreArgumentReferenceForTrampoline): (JSC::JIT::emitCTICall): (JSC::JIT::checkStructure): (JSC::JIT::emitJumpSlowCaseIfNotJSCell): (JSC::JIT::emitJumpSlowCaseIfNotImmNum): (JSC::JIT::emitJumpSlowCaseIfNotImmNums): (JSC::JIT::emitFastArithDeTagImmediate): (JSC::JIT::emitFastArithDeTagImmediateJumpIfZero): (JSC::JIT::emitFastArithReTagImmediate): (JSC::JIT::emitFastArithPotentiallyReTagImmediate): (JSC::JIT::emitFastArithImmToInt): (JSC::JIT::emitFastArithIntToImmOrSlowCase): (JSC::JIT::emitFastArithIntToImmNoCheck): (JSC::JIT::emitTagAsBoolImmediate):
  • jit/JITPropertyAccess.cpp: (JSC::JIT::privateCompilePutByIdTransition):
Location:
trunk/JavaScriptCore/assembler
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/MacroAssembler.h

    r38989 r39020  
    189189            m_assembler->link(m_jmp, label.m_label);
    190190        }
     191       
     192        // FIXME: transitionary method, while we replace JmpSrces with Jumps.
     193        operator X86Assembler::JmpSrc()
     194        {
     195            return m_jmp;
     196        }
    191197
    192198    private:
    … …  
    269275    }
    270276
     277    void add32(RegisterID src, RegisterID dest)
     278    {
     279        m_assembler.addl_rr(src, dest);
     280    }
     281
    271282    void add32(Imm32 imm, RegisterID dest)
    272283    {
    … …  
    282293    }
    283294   
     295    void and32(RegisterID src, RegisterID dest)
     296    {
     297        m_assembler.andl_rr(src, dest);
     298    }
     299
     300    void lshift32(Imm32 imm, RegisterID dest)
     301    {
     302        m_assembler.shll_i8r(imm.m_value, dest);
     303    }
     304   
    284305    void or32(Imm32 imm, RegisterID dest)
    285306    {
    … …  
    288309        else
    289310            m_assembler.orl_i32r(imm.m_value, dest);
     311    }
     312
     313    void rshift32(Imm32 imm, RegisterID dest)
     314    {
     315        m_assembler.sarl_i8r(imm.m_value, dest);
    290316    }
    291317
    … …  
    365391    }
    366392   
     393#if !PLATFORM(X86_64)
     394    void storePtr(void* value, ImplicitAddress address)
     395    {
     396        if (address.offset)
     397            m_assembler.movl_i32m(reinterpret_cast<unsigned>(value), address.offset, address.base);
     398        else
     399            m_assembler.movl_i32m(reinterpret_cast<unsigned>(value), address.base);
     400    }
     401#endif
     402   
    367403    void store32(RegisterID src, ImplicitAddress address)
    368404    {
    … …  
    375411    void store32(Imm32 imm, ImplicitAddress address)
    376412    {
    377         // FIXME: add a version that doesn't take an offset
    378         m_assembler.movl_i32m(imm.m_value, address.offset, address.base);
    379     }
     413        if (address.offset)
     414            m_assembler.movl_i32m(imm.m_value, address.offset, address.base);
     415        else
     416            m_assembler.movl_i32m(imm.m_value, address.base);
     417    }
     418   
     419#if !PLATFORM(X86_64)
     420    void store32(Imm32 imm, void* address)
     421    {
     422        m_assembler.movl_i32m(imm.m_value, address);
     423    }
     424#endif
    380425
    381426
    … …  
    421466    }
    422467
     468    void poke(Imm32 value, int index = 0)
     469    {
     470        store32(value, Address(X86::esp, (index * sizeof(void *))));
     471    }
     472
     473#if !PLATFORM(X86_64)
     474    void poke(void* value, int index = 0)
     475    {
     476        storePtr(value, Address(X86::esp, (index * sizeof(void *))));
     477    }
     478#endif
    423479
    424480    // Register move operations:
    … …  
    447503    }
    448504
     505#if !PLATFORM(X86_64)
     506    void move(void* value, RegisterID dest)
     507    {
     508        m_assembler.movl_i32r(reinterpret_cast<int32_t>(value), dest);
     509    }
     510#endif
     511
    449512
    450513    // Forwards / external control flow operations:
    … …  
    482545    }
    483546
     547    void compareImm32ForBranchEquality(Address address, int32_t imm)
     548    {
     549        if (CAN_SIGN_EXTEND_8_32(imm)) {
     550            if (address.offset)
     551                m_assembler.cmpl_i8m(imm, address.offset, address.base);
     552            else
     553                m_assembler.cmpl_i8m(imm, address.base);
     554        } else {
     555            if (address.offset)
     556                m_assembler.cmpl_i32m(imm, address.offset, address.base);
     557            else
     558                m_assembler.cmpl_i32m(imm, address.base);
     559        }
     560    }
     561
    484562public:
    485563    Jump jae32(RegisterID left, Imm32 right)
    … …  
    552630        return Jump(m_assembler, m_assembler.jle());
    553631    }
    554    
     632
     633#if !PLATFORM(X86_64)
     634    Jump jnePtr(void* ptr, Address address)
     635    {
     636        compareImm32ForBranchEquality(address, reinterpret_cast<uint32_t>(ptr));
     637        return Jump(m_assembler, m_assembler.jne());
     638    }
     639#endif
     640
    555641    Jump jne32(RegisterID op1, RegisterID op2)
    556642    {
    … …  
    562648    {
    563649        compareImm32ForBranchEquality(reg, imm.m_value);
     650        return Jump(m_assembler, m_assembler.jne());
     651    }
     652
     653    Jump jnset32(Imm32 imm, RegisterID reg)
     654    {
     655        // if we are only interested in the low seven bits, this can be tested with a testb
     656        if ((imm.m_value & ~0x7f) == 0)
     657            m_assembler.testb_i8r(imm.m_value, reg);
     658        else
     659            m_assembler.testl_i32r(imm.m_value, reg);
     660        return Jump(m_assembler, m_assembler.je());
     661    }
     662
     663    Jump jset32(Imm32 imm, RegisterID reg)
     664    {
     665        // if we are only interested in the low seven bits, this can be tested with a testb
     666        if ((imm.m_value & ~0x7f) == 0)
     667            m_assembler.testb_i8r(imm.m_value, reg);
     668        else
     669            m_assembler.testl_i32r(imm.m_value, reg);
    564670        return Jump(m_assembler, m_assembler.jne());
    565671    }
    … …  
    627733
    628734
     735    // Arithmetic control flow operations:
     736    //
     737    // This set of conditional branch operations branch based
     738    // on the result of an arithmetic operation.  The operation
     739    // is performed as normal, storing the result.
     740    //
     741    // * jz operations branch if the result is zero.
     742    // * jo operations branch if the (signed) arithmetic
     743    //   operation caused an overflow to occur.
     744
     745    Jump jzSub32(Imm32 imm, RegisterID dest)
     746    {
     747        if (CAN_SIGN_EXTEND_8_32(imm.m_value))
     748            m_assembler.subl_i8r(imm.m_value, dest);
     749        else
     750            m_assembler.subl_i32r(imm.m_value, dest);
     751        return Jump(m_assembler, m_assembler.je());
     752    }
     753   
     754    Jump joAdd32(RegisterID src, RegisterID dest)
     755    {
     756        m_assembler.addl_rr(src, dest);
     757        return Jump(m_assembler, m_assembler.jo());
     758    }
     759   
     760
    629761    // Miscellaneous operations:
    630762
    … …  
    634766    }
    635767
     768    Jump call()
     769    {
     770        return Jump(m_assembler, m_assembler.call());
     771    }
     772
     773    Jump call(RegisterID target)
     774    {
     775        return Jump(m_assembler, m_assembler.call(target));
     776    }
     777
    636778    void ret()
    637779    {

  • trunk/JavaScriptCore/assembler/X86Assembler.h

    r38989 r39020  
    115115        PRE_SSE_F2                      = 0xF2,
    116116        OP_HLT                          = 0xF4,
     117        OP_GROUP3_EbIb                  = 0xF6,
    117118        OP_GROUP3_Ev                    = 0xF7,
    118119        OP_GROUP3_EvIz                  = 0xF7, // OP_GROUP3_Ev has an immediate, when instruction is a test.
    … …  
    391392#endif
    392393
     394    void cmpl_i8m(int imm, RegisterID dst)
     395    {
     396        m_buffer.putByte(OP_GROUP1_EvIb);
     397        modRm_opm(GROUP1_OP_CMP, dst);
     398        m_buffer.putByte(imm);
     399    }
     400
     401    void cmpl_i8m(int imm, int offset, RegisterID dst)
     402    {
     403        m_buffer.putByte(OP_GROUP1_EvIb);
     404        modRm_opm(GROUP1_OP_CMP, dst, offset);
     405        m_buffer.putByte(imm);
     406    }
     407
    393408    void cmpl_i8m(int imm, int offset, RegisterID base, RegisterID index, int scale)
    394409    {
    … …  
    495510        m_buffer.putByte(OP_SUB_GvEv);
    496511        modRm_rm(dst, base, offset);
     512    }
     513
     514    void testb_i8r(int imm, RegisterID dst)
     515    {
     516        m_buffer.ensureSpace(maxInstructionSize);
     517        m_buffer.putByteUnchecked(OP_GROUP3_EbIb);
     518        modRm_opr_Unchecked(GROUP3_OP_TEST, dst);
     519        m_buffer.putByteUnchecked(imm);
    497520    }
    498521
    … …  
    556579    }
    557580
    558     void shl_i8r(int imm, RegisterID dst)
     581    void shll_i8r(int imm, RegisterID dst)
    559582    {
    560583        if (imm == 1) {
    … …  
    720743    }
    721744
     745    void movl_i32m(int imm, RegisterID base)
     746    {
     747        m_buffer.ensureSpace(maxInstructionSize);
     748        m_buffer.putByteUnchecked(OP_GROUP11_EvIz);
     749        modRm_opm_Unchecked(GROUP11_MOV, base);
     750        m_buffer.putIntUnchecked(imm);
     751    }
     752
    722753    void movl_i32m(int imm, int offset, RegisterID base)
    723754    {
    … …  
    10901121    }
    10911122
    1092 #if USE(CTI_ARGUMENT)
    1093     void restoreArgumentReference()
    1094     {
    1095 #if USE(FAST_CALL_CTI_ARGUMENT)
    1096         movl_rr(X86::esp, X86::ecx);
    1097 #else
    1098         movl_rm(X86::esp, 0, X86::esp);
    1099 #endif
    1100     }
    1101 
    1102     void restoreArgumentReferenceForTrampoline()
    1103     {
    1104 #if USE(FAST_CALL_CTI_ARGUMENT)
    1105         movl_rr(X86::esp, X86::ecx);
    1106         addl_i32r(4, X86::ecx);
    1107 #endif
    1108     }
    1109 #else
    1110     void restoreArgumentReference() {}
    1111     void restoreArgumentReferenceForTrampoline() {}
    1112 #endif
    1113 
    11141123private:
    11151124    void modRm_rr(RegisterID reg, RegisterID rm)
    … …  
    11311140    }
    11321141#endif
     1142
     1143    void modRm_rm_Unchecked(RegisterID reg, RegisterID base)
     1144    {
     1145        if (base == X86::esp) {
     1146            m_buffer.putByteUnchecked(MODRM(0, reg, X86::hasSib));
     1147            m_buffer.putByteUnchecked(SIB(0, X86::noScale, X86::esp));
     1148        } else {
     1149            m_buffer.putByteUnchecked(MODRM(0, reg, base));
     1150        }
     1151    }
    11331152
    11341153    void modRm_rm(RegisterID reg, RegisterID base)
    … …  
    12131232    }
    12141233
     1234    void modRm_opm_Unchecked(OpcodeID opcodeID, RegisterID base)
     1235    {
     1236        modRm_rm_Unchecked(static_cast<RegisterID>(opcodeID), base);
     1237    }
     1238
    12151239    void modRm_opm_Unchecked(OpcodeID opcodeID, RegisterID base, int offset)
    12161240    {
Note: See TracChangeset for help on using the changeset viewer.