Ignore:
Timestamp:
Aug 14, 2013, 9:51:10 AM (12 years ago)
Author:
[email protected]
Message:

DFG_JIT implementation for sh4 architecture.
​https://bugs.webkit.org/show_bug.cgi?id=119737

Patch by Julien Brianceau <​[email protected]> on 2013-08-14
Reviewed by Oliver Hunt.

Source/JavaScriptCore:

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::invert):
(JSC::MacroAssemblerSH4::add32):
(JSC::MacroAssemblerSH4::and32):
(JSC::MacroAssemblerSH4::lshift32):
(JSC::MacroAssemblerSH4::mul32):
(JSC::MacroAssemblerSH4::or32):
(JSC::MacroAssemblerSH4::rshift32):
(JSC::MacroAssemblerSH4::sub32):
(JSC::MacroAssemblerSH4::xor32):
(JSC::MacroAssemblerSH4::store32):
(JSC::MacroAssemblerSH4::swapDouble):
(JSC::MacroAssemblerSH4::storeDouble):
(JSC::MacroAssemblerSH4::subDouble):
(JSC::MacroAssemblerSH4::mulDouble):
(JSC::MacroAssemblerSH4::divDouble):
(JSC::MacroAssemblerSH4::negateDouble):
(JSC::MacroAssemblerSH4::zeroExtend32ToPtr):
(JSC::MacroAssemblerSH4::branchTruncateDoubleToUint32):
(JSC::MacroAssemblerSH4::truncateDoubleToUint32):
(JSC::MacroAssemblerSH4::swap):
(JSC::MacroAssemblerSH4::jump):
(JSC::MacroAssemblerSH4::branchNeg32):
(JSC::MacroAssemblerSH4::branchAdd32):
(JSC::MacroAssemblerSH4::branchMul32):
(JSC::MacroAssemblerSH4::urshift32):

  • assembler/SH4Assembler.h:

(JSC::SH4Assembler::SH4Assembler):
(JSC::SH4Assembler::labelForWatchpoint):
(JSC::SH4Assembler::label):
(JSC::SH4Assembler::debugOffset):

  • dfg/DFGAssemblyHelpers.h:

(JSC::DFG::AssemblyHelpers::preserveReturnAddressAfterCall):
(JSC::DFG::AssemblyHelpers::restoreReturnAddressBeforeReturn):
(JSC::DFG::AssemblyHelpers::debugCall):

  • dfg/DFGCCallHelpers.h:

(JSC::DFG::CCallHelpers::setupArguments):
(JSC::DFG::CCallHelpers::setupArgumentsWithExecState):

  • dfg/DFGFPRInfo.h:

(JSC::DFG::FPRInfo::toRegister):
(JSC::DFG::FPRInfo::toIndex):
(JSC::DFG::FPRInfo::debugName):

  • dfg/DFGGPRInfo.h:

(JSC::DFG::GPRInfo::toRegister):
(JSC::DFG::GPRInfo::toIndex):
(JSC::DFG::GPRInfo::debugName):

  • dfg/DFGOperations.cpp:
  • dfg/DFGSpeculativeJIT.h:

(JSC::DFG::SpeculativeJIT::callOperation):

  • jit/JITStubs.h:
  • jit/JITStubsSH4.h:

Source/WTF:

  • wtf/Platform.h:
Location:
trunk/Source/JavaScriptCore/assembler
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h

    r154016 r154052  
    102102    }
    103103
     104    static RelationalCondition invert(RelationalCondition cond)
     105    {
     106        switch (cond) {
     107        case Equal:
     108            return NotEqual;
     109        case NotEqual:
     110            return Equal;
     111        case Above:
     112            return BelowOrEqual;
     113        case AboveOrEqual:
     114            return Below;
     115        case Below:
     116            return AboveOrEqual;
     117        case BelowOrEqual:
     118            return Above;
     119        case GreaterThan:
     120            return LessThanOrEqual;
     121        case GreaterThanOrEqual:
     122            return LessThan;
     123        case LessThan:
     124            return GreaterThanOrEqual;
     125        case LessThanOrEqual:
     126            return GreaterThan;
     127        default:
     128            RELEASE_ASSERT_NOT_REACHED();
     129        }
     130    }
     131
    104132    // Integer arithmetic operations
    105133
    … …  
    107135    {
    108136        m_assembler.addlRegReg(src, dest);
     137    }
     138
     139    void add32(RegisterID src1, RegisterID src2, RegisterID dest)
     140    {
     141        if (src1 == dest)
     142            add32(src2, dest);
     143        else {
     144            move(src2, dest);
     145            add32(src1, dest);
     146        }
    109147    }
    110148
    … …  
    162200    {
    163201        m_assembler.andlRegReg(src, dest);
     202    }
     203
     204    void and32(RegisterID src1, RegisterID src2, RegisterID dest)
     205    {
     206        if (src1 == dest)
     207            and32(src2, dest);
     208        else {
     209            move(src2, dest);
     210            and32(src1, dest);
     211        }
     212    }
     213
     214    void and32(Address src, RegisterID dest)
     215    {
     216        RegisterID scr = claimScratch();
     217        load32(src, scr);
     218        and32(scr, dest);
     219        releaseScratch(scr);
    164220    }
    165221
    … …  
    202258    }
    203259
     260    void lshift32(RegisterID src, RegisterID shiftAmount, RegisterID dest)
     261    {
     262        move(src, dest);
     263        lshift32(shiftAmount, dest);
     264    }
     265
    204266    void lshift32(TrustedImm32 imm, RegisterID dest)
    205267    {
    … …  
    227289    void mul32(RegisterID src, RegisterID dest)
    228290    {
    229         m_assembler.imullRegReg(src, dest);
     291        mul32(src, dest, dest);   
     292    }
     293
     294    void mul32(RegisterID src1, RegisterID src2, RegisterID dest)
     295    {
     296        m_assembler.imullRegReg(src1, src2);
    230297        m_assembler.stsmacl(dest);
    231298    }
    … …  
    285352    }
    286353
     354    void or32(RegisterID src, AbsoluteAddress address)
     355    {
     356        RegisterID destptr = claimScratch();
     357        move(TrustedImmPtr(address.m_ptr), destptr);
     358        RegisterID destval = claimScratch();
     359        m_assembler.movlMemReg(destptr, destval);
     360        m_assembler.orlRegReg(src, destval);
     361        m_assembler.movlRegMem(destval, destptr);
     362        releaseScratch(destval);
     363        releaseScratch(destptr);
     364    }
     365
    287366    void xor32(TrustedImm32 imm, RegisterID src, RegisterID dest)
    288367    {
    … …  
    306385    }
    307386
     387    void rshift32(RegisterID src, RegisterID shiftAmount, RegisterID dest)
     388    {
     389        move(src, dest);
     390        rshift32(shiftAmount, dest);
     391    }
     392
    308393    void rshift32(TrustedImm32 imm, RegisterID dest)
    309394    {
    … …  
    355440        releaseScratch(result);
    356441        releaseScratch(scratchReg);
     442    }
     443
     444    void sub32(TrustedImm32 imm, Address address)
     445    {
     446        add32(TrustedImm32(-imm.m_value), address);
    357447    }
    358448
    … …  
    433523    {
    434524        m_assembler.xorlRegReg(src, dest);
     525    }
     526
     527    void xor32(RegisterID src1, RegisterID src2, RegisterID dest)
     528    {
     529        if (src1 == dest)
     530            xor32(src2, dest);
     531        else {
     532            move(src2, dest);
     533            xor32(src1, dest);
     534        }
    435535    }
    436536
    … …  
    896996    }
    897997
     998    void store32(TrustedImm32 imm, BaseIndex address)
     999    {
     1000        RegisterID destptr = claimScratch();
     1001
     1002        loadEffectiveAddress(address, destptr);
     1003
     1004        RegisterID srcval = claimScratch();
     1005        move(imm, srcval);
     1006        m_assembler.movlRegMem(srcval, destptr);
     1007        releaseScratch(srcval);
     1008        releaseScratch(destptr);
     1009    }
     1010
    8981011    DataLabel32 load32WithAddressOffsetPatch(Address address, RegisterID dest)
    8991012    {
    … …  
    9671080            m_assembler.fmovsRegReg((FPRegisterID)(src + 1), (FPRegisterID)(dest + 1));
    9681081            m_assembler.fmovsRegReg(src, dest);
     1082        }
     1083    }
     1084
     1085    void swapDouble(FPRegisterID fr1, FPRegisterID fr2)
     1086    {
     1087        if (fr1 != fr2) {
     1088            m_assembler.fldsfpul((FPRegisterID)(fr1 + 1));
     1089            m_assembler.fmovsRegReg((FPRegisterID)(fr2 + 1), (FPRegisterID)(fr1 + 1));
     1090            m_assembler.fstsfpul((FPRegisterID)(fr2 + 1));
     1091            m_assembler.fldsfpul(fr1);
     1092            m_assembler.fmovsRegReg(fr2, fr1);
     1093            m_assembler.fstsfpul(fr2);
    9691094        }
    9701095    }
    … …  
    10591184    }
    10601185
     1186    void storeDouble(FPRegisterID src, const void* address)
     1187    {
     1188        RegisterID scr = claimScratch();
     1189        m_assembler.loadConstant(reinterpret_cast<uint32_t>(const_cast<void*>(address)) + 8, scr);
     1190        m_assembler.fmovsWriterndec(src, scr);
     1191        m_assembler.fmovsWriterndec((FPRegisterID)(src + 1), scr);
     1192        releaseScratch(scr);
     1193    }
     1194
    10611195    void addDouble(FPRegisterID src, FPRegisterID dest)
    10621196    {
    … …  
    10811215    }
    10821216
     1217    void subDouble(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1218    {
     1219        if (op2 == dest) {
     1220            moveDouble(op1, fscratch);
     1221            subDouble(op2, fscratch);
     1222            moveDouble(fscratch, dest);
     1223        } else {
     1224            moveDouble(op1, dest);
     1225            subDouble(op2, dest);
     1226        }
     1227    }
     1228
    10831229    void subDouble(Address address, FPRegisterID dest)
    10841230    {
    … …  
    10921238    }
    10931239
     1240    void mulDouble(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1241    {
     1242        if (op1 == dest)
     1243            mulDouble(op2, dest);
     1244        else {
     1245            moveDouble(op2, dest);
     1246            mulDouble(op1, dest);
     1247        }
     1248    }
     1249
    10941250    void mulDouble(Address address, FPRegisterID dest)
    10951251    {
    … …  
    11011257    {
    11021258        m_assembler.ddivRegReg(src, dest);
     1259    }
     1260
     1261    void divDouble(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1262    {
     1263        if (op2 == dest) {
     1264            moveDouble(op1, fscratch);
     1265            divDouble(op2, fscratch);
     1266            moveDouble(fscratch, dest);
     1267        } else {
     1268            moveDouble(op1, dest);
     1269            divDouble(op2, dest);
     1270        }
     1271    }
     1272
     1273    void negateDouble(FPRegisterID src, FPRegisterID dest)
     1274    {
     1275        moveDouble(src, dest);
     1276        m_assembler.dneg(dest);
    11031277    }
    11041278
    … …  
    13961570    }
    13971571
     1572    void zeroExtend32ToPtr(RegisterID src, RegisterID dest)
     1573    {
     1574        move(src, dest);
     1575    }
     1576
    13981577    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    13991578    {
    … …  
    14381617    }
    14391618
     1619    Jump branchTruncateDoubleToUint32(FPRegisterID src, RegisterID dest, BranchTruncateType branchType = BranchIfTruncateFailed)
     1620    {
     1621        Jump result;
     1622        RegisterID intscr = claimScratch();
     1623        m_assembler.loadConstant(0x80000000, intscr);
     1624        convertInt32ToDouble(intscr, fscratch);
     1625        addDouble(src, fscratch);
     1626        truncateDoubleToInt32(fscratch, dest);
     1627        m_assembler.cmplRegReg(dest, intscr, SH4Condition(Equal));
     1628        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 16, sizeof(uint32_t));
     1629        if (branchType == BranchIfTruncateFailed) {
     1630            m_assembler.branch(BT_OPCODE, 4);
     1631            m_assembler.addlImm8r(-1, intscr);
     1632            m_assembler.cmplRegReg(dest, intscr, SH4Condition(Equal));
     1633            m_assembler.addlImm8r(1, intscr);
     1634            m_assembler.sublRegReg(intscr, dest);
     1635            result = branchTrue();
     1636        } else {
     1637            Jump out = Jump(m_assembler.je(), SH4Assembler::JumpNear);
     1638            m_assembler.addlImm8r(-1, intscr);
     1639            m_assembler.cmplRegReg(dest, intscr, SH4Condition(Equal));
     1640            m_assembler.addlImm8r(1, intscr);
     1641            m_assembler.sublRegReg(intscr, dest);
     1642            result = branchFalse();
     1643            out.link(this);
     1644        }
     1645        releaseScratch(intscr);
     1646        return result;
     1647    }
     1648
    14401649    void truncateDoubleToInt32(FPRegisterID src, RegisterID dest)
    14411650    {
    14421651        m_assembler.ftrcdrmfpul(src);
    14431652        m_assembler.stsfpulReg(dest);
     1653    }
     1654
     1655    void truncateDoubleToUint32(FPRegisterID src, RegisterID dest)
     1656    {
     1657        RegisterID intscr = claimScratch();
     1658        m_assembler.loadConstant(0x80000000, intscr);
     1659        convertInt32ToDouble(intscr, fscratch);
     1660        addDouble(src, fscratch);
     1661        m_assembler.ftrcdrmfpul(fscratch);
     1662        m_assembler.stsfpulReg(dest);
     1663        m_assembler.sublRegReg(intscr, dest);
     1664        releaseScratch(intscr);
    14441665    }
    14451666
    … …  
    14881709    {
    14891710        m_assembler.loadConstant(imm.asIntptr(), dest);
     1711    }
     1712
     1713    void swap(RegisterID reg1, RegisterID reg2)
     1714    {
     1715        if (reg1 != reg2) {
     1716            xor32(reg1, reg2);
     1717            xor32(reg2, reg1);
     1718            xor32(reg1, reg2);
     1719        }
    14901720    }
    14911721
    … …  
    17191949    }
    17201950
     1951    void jump(AbsoluteAddress address)
     1952    {
     1953        RegisterID scr = claimScratch();
     1954
     1955        move(TrustedImmPtr(address.m_ptr), scr);
     1956        m_assembler.movlMemReg(scr, scr);
     1957        m_assembler.jmpReg(scr);
     1958        releaseScratch(scr);
     1959    }
     1960
    17211961    // Arithmetic control flow operations
     1962
     1963    Jump branchNeg32(ResultCondition cond, RegisterID srcDest)
     1964    {
     1965        ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
     1966
     1967        if (cond == Overflow)
     1968            return branchMul32(cond, TrustedImm32(-1), srcDest, srcDest);
     1969
     1970        neg32(srcDest);
     1971
     1972        if (cond == Signed) {
     1973            m_assembler.cmppz(srcDest);
     1974            return branchFalse();
     1975        }
     1976
     1977        compare32(0, srcDest, Equal);
     1978        return (cond == NonZero) ? branchFalse() : branchTrue();
     1979    }
    17221980
    17231981    Jump branchAdd32(ResultCondition cond, RegisterID src, RegisterID dest)
    … …  
    17311989
    17321990        m_assembler.addlRegReg(src, dest);
     1991
     1992        if ((cond == Signed) || (cond == PositiveOrZero)) {
     1993            m_assembler.cmppz(dest);
     1994            return (cond == Signed) ? branchFalse() : branchTrue();
     1995        }
     1996
     1997        compare32(0, dest, Equal);
     1998        return (cond == NonZero) ? branchFalse() : branchTrue();
     1999    }
     2000
     2001    Jump branchAdd32(ResultCondition cond, RegisterID src1, RegisterID src2, RegisterID dest)
     2002    {
     2003        ASSERT((cond == Overflow) || (cond == Signed) || (cond == PositiveOrZero) || (cond == Zero) || (cond == NonZero));
     2004
     2005        if (cond == Overflow) {
     2006            if (src1 == dest)
     2007                m_assembler.addvlRegReg(src2, dest);
     2008            else {
     2009                move(src2, dest);
     2010                m_assembler.addvlRegReg(src1, dest);
     2011            }
     2012            return branchTrue();
     2013        }
     2014
     2015        add32(src1, src2, dest);
    17332016
    17342017        if ((cond == Signed) || (cond == PositiveOrZero)) {
    … …  
    18342117    }
    18352118
     2119    Jump branchMul32(ResultCondition cond, RegisterID src1, RegisterID src2, RegisterID dest)
     2120    {
     2121        ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
     2122
     2123        if (cond == Overflow) {
     2124            RegisterID scrsign = claimScratch();
     2125            RegisterID msbres = claimScratch();
     2126            m_assembler.dmulslRegReg(src1, src2);
     2127            m_assembler.stsmacl(dest);
     2128            m_assembler.cmppz(dest);
     2129            m_assembler.movt(scrsign);
     2130            m_assembler.addlImm8r(-1, scrsign);
     2131            m_assembler.stsmach(msbres);
     2132            m_assembler.cmplRegReg(msbres, scrsign, SH4Condition(Equal));
     2133            releaseScratch(msbres);
     2134            releaseScratch(scrsign);
     2135            return branchFalse();
     2136        }
     2137
     2138        mul32(src1, src2, dest);
     2139
     2140        if (cond == Signed) {
     2141            m_assembler.cmppz(dest);
     2142            return branchFalse();
     2143        }
     2144
     2145        compare32(0, dest, Equal);
     2146        return (cond == NonZero) ? branchFalse() : branchTrue();
     2147    }
     2148
    18362149    Jump branchMul32(ResultCondition cond, TrustedImm32 imm, RegisterID src, RegisterID dest)
    18372150    {
    … …  
    19592272    }
    19602273
     2274    void urshift32(RegisterID src, RegisterID shiftAmount, RegisterID dest)
     2275    {
     2276        move(src, dest);
     2277        urshift32(shiftAmount, dest);
     2278    }
     2279
    19612280    void urshift32(TrustedImm32 imm, RegisterID dest)
    19622281    {

  • trunk/Source/JavaScriptCore/assembler/SH4Assembler.h

    r154016 r154052  
    339339    SH4Assembler()
    340340        : m_claimscratchReg(0x0)
     341        , m_indexOfLastWatchpoint(INT_MIN)
     342        , m_indexOfTailOfLastWatchpoint(INT_MIN)
    341343    {
    342344    }
    … …  
    13011303    }
    13021304
     1305    AssemblerLabel labelForWatchpoint()
     1306    {
     1307        m_buffer.ensureSpaceForAnyInstruction();
     1308        AssemblerLabel result = m_buffer.label();
     1309        if (static_cast<int>(result.m_offset) != m_indexOfLastWatchpoint)
     1310            result = label();
     1311        m_indexOfLastWatchpoint = result.m_offset;
     1312        m_indexOfTailOfLastWatchpoint = result.m_offset + maxJumpReplacementSize();
     1313        return result;
     1314    }
     1315
    13031316    AssemblerLabel label()
    13041317    {
    1305         m_buffer.ensureSpaceForAnyInstruction();
    1306         return m_buffer.label();
     1318        AssemblerLabel result = labelIgnoringWatchpoints();
     1319        while (UNLIKELY(static_cast<int>(result.m_offset) < m_indexOfTailOfLastWatchpoint)) {
     1320            nop();
     1321            result = labelIgnoringWatchpoints();
     1322        }
     1323        return result;
    13071324    }
    13081325
    … …  
    16911708    size_t codeSize() const { return m_buffer.codeSize(); }
    16921709
     1710    unsigned debugOffset() { return m_buffer.debugOffset(); }
     1711
    16931712#ifdef SH4_ASSEMBLER_TRACING
    16941713    static void printInstr(uint16_t opc, unsigned size, bool isdoubleInst = true)
    … …  
    22242243    SH4Buffer m_buffer;
    22252244    int m_claimscratchReg;
     2245    int m_indexOfLastWatchpoint;
     2246    int m_indexOfTailOfLastWatchpoint;
    22262247};
    22272248
Note: See TracChangeset for help on using the changeset viewer.