Ignore:
Timestamp:
Aug 13, 2013, 11:59:14 AM (12 years ago)
Author:
[email protected]
Message:

[sh4] Prepare baseline JIT for DFG_JIT implementation.
​https://bugs.webkit.org/show_bug.cgi?id=119758

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

  • assembler/MacroAssemblerSH4.h:
    • Introduce a loadEffectiveAddress function to avoid code duplication.
    • Add ASSERTs and clean code.
  • assembler/SH4Assembler.h:
    • Prepare DFG_JIT implementation.
    • Add ASSERTs.
  • jit/JITStubs.cpp:
    • Add SH4 specific call for assertions.
  • jit/JITStubs.h:
    • Cosmetic change.
  • jit/JITStubsSH4.h:
    • Use constants to be more flexible with sh4 JIT stack frame.
  • jit/JSInterfaceJIT.h:
    • Cosmetic change.
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r153324 r154016  
    4242
    4343    static const Scale ScalePtr = TimesFour;
    44     static const FPRegisterID fscratch = SH4Registers::fr10;
     44    static const FPRegisterID fscratch = SH4Registers::dr10;
    4545    static const RegisterID stackPointerRegister = SH4Registers::sp;
    4646    static const RegisterID linkRegister = SH4Registers::pr;
    … …  
    5151    static bool isCompactPtrAlignedAddressOffset(ptrdiff_t value)
    5252    {
    53         return (value >= 0) && (value <= MaximumCompactPtrAlignedAddressOffset);
     53        return (value >= 0) && (value <= MaximumCompactPtrAlignedAddressOffset) && (!(value & 3));
    5454    }
    5555
    … …  
    127127    void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)
    128128    {
    129         if (src != dest)
    130             m_assembler.movlRegReg(src, dest);
     129        move(src, dest);
    131130        add32(imm, dest);
    132131    }
    … …  
    167166    void and32(TrustedImm32 imm, RegisterID dest)
    168167    {
     168        if (!imm.m_value) {
     169            m_assembler.movImm8(0, dest);
     170            return;
     171        }
     172
    169173        if ((imm.m_value <= 255) && (imm.m_value >= 0) && (dest == SH4Registers::r0)) {
    170174            m_assembler.andlImm8r(imm.m_value, dest);
    … …  
    217221    void lshift32(RegisterID src, TrustedImm32 shiftamount, RegisterID dest)
    218222    {
    219         if (src != dest)
    220             move(src, dest);
    221 
     223        move(src, dest);
    222224        lshift32(shiftamount, dest);
    223225    }
    … …  
    231233    void mul32(TrustedImm32 imm, RegisterID src, RegisterID dest)
    232234    {
    233         RegisterID scr = claimScratch();
    234         move(imm, scr);
    235         if (src != dest)
    236             move(src, dest);
    237         mul32(scr, dest);
    238         releaseScratch(scr);
     235        if (src == dest) {
     236            RegisterID immval = claimScratch();
     237            move(imm, immval);
     238            mul32(immval, dest);
     239            releaseScratch(immval);
     240        } else {
     241            move(imm, dest);
     242            mul32(src, dest);
     243        }
    239244    }
    240245
    … …  
    320325    void rshift32(RegisterID src, TrustedImm32 imm, RegisterID dest)
    321326    {
    322         if (src != dest)
    323             move(src, dest);
     327        move(src, dest);
    324328        rshift32(imm, dest);
    325329    }
    … …  
    338342        RegisterID scratchReg = claimScratch();
    339343
    340         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address.m_ptr), scratchReg);
     344        move(TrustedImmPtr(address.m_ptr), scratchReg);
    341345        m_assembler.movlMemReg(scratchReg, result);
    342346
    … …  
    361365        RegisterID scratchReg = claimScratch();
    362366
    363         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address.m_ptr), scratchReg);
     367        move(TrustedImmPtr(address.m_ptr), scratchReg);
    364368        m_assembler.movlMemReg(scratchReg, result);
    365369
    … …  
    382386
    383387        // Add 32-bit LSB first.
    384         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address.m_ptr), scr1);
    385         m_assembler.movlMemReg(scr1, scr1); // scr1 = 32-bit LSB of int64 @ address
     388        move(TrustedImmPtr(address.m_ptr), scratchReg3);
     389        m_assembler.movlMemReg(scratchReg3, scr1); // scr1 = 32-bit LSB of int64 @ address
    386390        m_assembler.loadConstant(imm.m_value, scr2);
    387391        m_assembler.clrt();
    388392        m_assembler.addclRegReg(scr1, scr2);
    389         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address.m_ptr), scr1);
    390         m_assembler.movlRegMem(scr2, scr1); // Update address with 32-bit LSB result.
     393        m_assembler.movlRegMem(scr2, scratchReg3); // Update address with 32-bit LSB result.
    391394
    392395        // Then add 32-bit MSB.
    393         m_assembler.addlImm8r(4, scr1);
    394         m_assembler.movlMemReg(scr1, scr1); // scr1 = 32-bit MSB of int64 @ address
     396        m_assembler.addlImm8r(4, scratchReg3);
     397        m_assembler.movlMemReg(scratchReg3, scr1); // scr1 = 32-bit MSB of int64 @ address
    395398        m_assembler.movt(scr2);
    396399        if (imm.m_value < 0)
    397400            m_assembler.addlImm8r(-1, scr2); // Sign extend imm value if needed.
    398401        m_assembler.addvlRegReg(scr2, scr1);
    399         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address.m_ptr) + 4, scr2);
    400         m_assembler.movlRegMem(scr1, scr2); // Update (address + 4) with 32-bit MSB result.
     402        m_assembler.movlRegMem(scr1, scratchReg3); // Update (address + 4) with 32-bit MSB result.
    401403
    402404        releaseScratch(scr2);
    … …  
    455457        if (((cond == Equal) || (cond == NotEqual)) && (dst == SH4Registers::r0) && m_assembler.isImmediate(imm)) {
    456458            m_assembler.cmpEqImmR0(imm, dst);
     459            return;
     460        }
     461
     462        if (((cond == Equal) || (cond == NotEqual)) && !imm) {
     463            m_assembler.testlRegReg(dst, dst);
    457464            return;
    458465        }
    … …  
    491498    {
    492499        RegisterID scr = claimScratch();
     500        load32(base, offset, scr);
     501
    493502        RegisterID scr1 = claimScratch();
    494 
    495         if ((offset < 0) || (offset >= 64)) {
    496             m_assembler.loadConstant(offset, scr);
    497             m_assembler.addlRegReg(base, scr);
    498             m_assembler.movlMemReg(scr, scr);
    499         } else if (offset)
    500             m_assembler.movlMemReg(offset >> 2, base, scr);
    501         else
    502             m_assembler.movlMemReg(base, scr);
    503         if (m_assembler.isImmediate(imm))
    504             m_assembler.movImm8(imm, scr1);
    505         else
    506             m_assembler.loadConstant(imm, scr1);
     503        move(TrustedImm32(imm), scr1);
    507504
    508505        m_assembler.testlRegReg(scr, scr1);
    … …  
    552549    void compare32(int imm, int offset, RegisterID base, RelationalCondition cond)
    553550    {
    554         if (!offset) {
    555             RegisterID scr = claimScratch();
    556             RegisterID scr1 = claimScratch();
    557             m_assembler.movlMemReg(base, scr);
    558             m_assembler.loadConstant(imm, scr1);
    559             m_assembler.cmplRegReg(scr1, scr, SH4Condition(cond));
    560             releaseScratch(scr1);
    561             releaseScratch(scr);
    562             return;
    563         }
    564 
    565         if ((offset < 0) || (offset >= 64)) {
    566             RegisterID scr = claimScratch();
    567             RegisterID scr1 = claimScratch();
    568             m_assembler.loadConstant(offset, scr);
    569             m_assembler.addlRegReg(base, scr);
    570             m_assembler.movlMemReg(scr, scr);
    571             m_assembler.loadConstant(imm, scr1);
    572             m_assembler.cmplRegReg(scr1, scr, SH4Condition(cond));
    573             releaseScratch(scr1);
    574             releaseScratch(scr);
    575             return;
    576         }
    577 
    578         RegisterID scr = claimScratch();
     551        RegisterID scr = claimScratch();
     552        load32(base, offset, scr);
     553
    579554        RegisterID scr1 = claimScratch();
    580         m_assembler.movlMemReg(offset >> 2, base, scr);
    581         m_assembler.loadConstant(imm, scr1);
     555        move(TrustedImm32(imm), scr1);
     556
    582557        m_assembler.cmplRegReg(scr1, scr, SH4Condition(cond));
     558
    583559        releaseScratch(scr1);
    584560        releaseScratch(scr);
    … …  
    586562
    587563    // Memory access operation
     564
     565    ALWAYS_INLINE void loadEffectiveAddress(BaseIndex address, RegisterID dest, int extraoffset = 0)
     566    {
     567        if (dest == address.base) {
     568            RegisterID scaledIndex = claimScratch();
     569            move(address.index, scaledIndex);
     570            lshift32(TrustedImm32(address.scale), scaledIndex);
     571            add32(scaledIndex, dest);
     572            releaseScratch(scaledIndex);
     573        } else {
     574            move(address.index, dest);
     575            lshift32(TrustedImm32(address.scale), dest);
     576            add32(address.base, dest);
     577        }
     578
     579        add32(TrustedImm32(address.offset + extraoffset), dest);
     580    }
    588581
    589582    void load32(ImplicitAddress address, RegisterID dest)
    … …  
    635628    void load32(const void* address, RegisterID dest)
    636629    {
    637         m_assembler.loadConstant(reinterpret_cast<uint32_t>(const_cast<void*>(address)), dest);
     630        move(TrustedImmPtr(address), dest);
    638631        m_assembler.movlMemReg(dest, dest);
    639632    }
    … …  
    734727    {
    735728        RegisterID scr = claimScratch();
     729
     730        loadEffectiveAddress(address, scr);
     731
    736732        RegisterID scr1 = claimScratch();
    737 
    738         move(address.index, scr);
    739         lshift32(TrustedImm32(address.scale), scr);
    740 
    741         if (address.offset)
    742             add32(TrustedImm32(address.offset), scr);
    743 
    744         add32(address.base, scr);
    745733        load8PostInc(scr, scr1);
    746734        load8(scr, dest);
    … …  
    781769        move(address.index, scr);
    782770        lshift32(TrustedImm32(address.scale), scr);
    783 
    784         if (address.offset)
    785             add32(TrustedImm32(address.offset), scr);
     771        add32(TrustedImm32(address.offset), scr);
    786772
    787773        if (address.base == SH4Registers::r0)
    … …  
    815801    void store8(TrustedImm32 imm, void* address)
    816802    {
     803        ASSERT((imm.m_value >= -128) && (imm.m_value <= 127));
     804        RegisterID dstptr = claimScratch();
     805        move(TrustedImmPtr(address), dstptr);
    817806        RegisterID srcval = claimScratch();
    818         RegisterID dstptr = claimScratch();
    819807        move(imm, srcval);
    820         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address), dstptr);
    821808        m_assembler.movbRegMem(srcval, dstptr);
    822809        releaseScratch(dstptr);
    … …  
    895882        RegisterID scr1 = claimScratch();
    896883        m_assembler.loadConstant(imm.m_value, scr);
    897         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address), scr1);
     884        move(TrustedImmPtr(address), scr1);
    898885        m_assembler.movlRegMem(scr, scr1);
    899886        releaseScratch(scr);
    … …  
    904891    {
    905892        RegisterID scr = claimScratch();
    906         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address), scr);
     893        move(TrustedImmPtr(address), scr);
    907894        m_assembler.movlRegMem(src, scr);
    908895        releaseScratch(scr);
    … …  
    934921    {
    935922        DataLabelCompact dataLabel(this);
    936         ASSERT(address.offset <= MaximumCompactPtrAlignedAddressOffset);
    937         ASSERT(address.offset >= 0);
     923        ASSERT(isCompactPtrAlignedAddressOffset(address.offset));
    938924        m_assembler.movlMemRegCompact(address.offset >> 2, address.base, dest);
    939925        return dataLabel;
    … …  
    968954    }
    969955
    970     void moveIntsToDouble(RegisterID src1, RegisterID src2, FPRegisterID dest, FPRegisterID scratch)
    971     {
    972         UNUSED_PARAM(scratch);
     956    void moveIntsToDouble(RegisterID src1, RegisterID src2, FPRegisterID dest, FPRegisterID)
     957    {
    973958        m_assembler.ldsrmfpul(src1);
    974959        m_assembler.fstsfpul((FPRegisterID)(dest + 1));
    … …  
    989974        RegisterID scr = claimScratch();
    990975
    991         move(address.index, scr);
    992         lshift32(TrustedImm32(address.scale), scr);
    993         add32(address.base, scr);
    994         if (address.offset)
    995             add32(TrustedImm32(address.offset), scr);
     976        loadEffectiveAddress(address, scr);
    996977
    997978        m_assembler.fmovsReadrm(scr, dest);
    … …  
    1003984        RegisterID scr = claimScratch();
    1004985
    1005         move(address.index, scr);
    1006         lshift32(TrustedImm32(address.scale), scr);
    1007         add32(address.base, scr);
    1008         if (address.offset)
    1009             add32(TrustedImm32(address.offset), scr);
     986        loadEffectiveAddress(address, scr);
    1010987
    1011988        m_assembler.fmovsReadrminc(scr, (FPRegisterID)(dest + 1));
    … …  
    10361013    {
    10371014        RegisterID scr = claimScratch();
    1038         m_assembler.loadConstant(reinterpret_cast<uint32_t>(address), scr);
     1015        move(TrustedImmPtr(address), scr);
    10391016        m_assembler.fmovsReadrminc(scr, (FPRegisterID)(dest + 1));
    10401017        m_assembler.fmovsReadrm(scr, dest);
    … …  
    10451022    {
    10461023        RegisterID scr = claimScratch();
    1047 
    1048         move(address.index, scr);
    1049         lshift32(TrustedImm32(address.scale), scr);
    1050         add32(address.base, scr);
    1051         if (address.offset)
    1052             add32(TrustedImm32(address.offset), scr);
    1053 
     1024        loadEffectiveAddress(address, scr);
    10541025        m_assembler.fmovsWriterm(src, scr);
    1055 
    10561026        releaseScratch(scr);
    10571027    }
    … …  
    10711041        RegisterID scr = claimScratch();
    10721042
    1073         move(address.index, scr);
    1074         lshift32(TrustedImm32(address.scale), scr);
    1075         add32(address.base, scr);
    1076         add32(TrustedImm32(address.offset + 8), scr);
     1043        loadEffectiveAddress(address, scr, 8);
    10771044
    10781045        m_assembler.fmovsWriterndec(src, scr);
    … …  
    11801147            move(SH4Registers::r0, scr1);
    11811148
    1182         move(address.index, scr);
    1183         lshift32(TrustedImm32(address.scale), scr);
    1184         add32(address.base, scr);
    1185 
    1186         if (address.offset)
    1187             add32(TrustedImm32(address.offset), scr);
     1149        loadEffectiveAddress(address, scr);
    11881150
    11891151        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 58, sizeof(uint32_t));
    … …  
    14311393    void signExtend32ToPtr(RegisterID src, RegisterID dest)
    14321394    {
    1433         if (src != dest)
    1434             move(src, dest);
     1395        move(src, dest);
    14351396    }
    14361397
    … …  
    14551416    Jump branchTruncateDoubleToInt32(FPRegisterID src, RegisterID dest, BranchTruncateType branchType = BranchIfTruncateFailed)
    14561417    {
     1418        Jump result;
     1419        truncateDoubleToInt32(src, dest);
     1420        RegisterID intscr = claimScratch();
     1421        m_assembler.loadConstant(0x7fffffff, intscr);
     1422        m_assembler.cmplRegReg(dest, intscr, SH4Condition(Equal));
     1423        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 12, sizeof(uint32_t));
     1424        if (branchType == BranchIfTruncateFailed) {
     1425            m_assembler.branch(BT_OPCODE, 2);
     1426            m_assembler.addlImm8r(1, intscr);
     1427            m_assembler.cmplRegReg(dest, intscr, SH4Condition(Equal));
     1428            result = branchTrue();
     1429        } else {
     1430            Jump out = Jump(m_assembler.je(), SH4Assembler::JumpNear);
     1431            m_assembler.addlImm8r(1, intscr);
     1432            m_assembler.cmplRegReg(dest, intscr, SH4Condition(Equal));
     1433            result = branchFalse();
     1434            out.link(this);
     1435        }
     1436        releaseScratch(intscr);
     1437        return result;
     1438    }
     1439
     1440    void truncateDoubleToInt32(FPRegisterID src, RegisterID dest)
     1441    {
    14571442        m_assembler.ftrcdrmfpul(src);
    14581443        m_assembler.stsfpulReg(dest);
    1459         m_assembler.loadConstant(0x7fffffff, scratchReg3);
    1460         m_assembler.cmplRegReg(dest, scratchReg3, SH4Condition(Equal));
    1461         m_assembler.ensureSpace(m_assembler.maxInstructionSize + 14, sizeof(uint32_t));
    1462         m_assembler.branch(BT_OPCODE, 2);
    1463         m_assembler.addlImm8r(1, scratchReg3);
    1464         m_assembler.cmplRegReg(dest, scratchReg3, SH4Condition(Equal));
    1465         return (branchType == BranchIfTruncateFailed) ? branchTrue() : branchFalse();
    14661444    }
    14671445
    … …  
    16341612        RegisterID addressTempRegister = claimScratch();
    16351613
    1636         m_assembler.loadConstant(reinterpret_cast<uint32_t>(left.m_ptr), addressTempRegister);
     1614        move(TrustedImmPtr(left.m_ptr), addressTempRegister);
    16371615        m_assembler.movlMemReg(addressTempRegister, addressTempRegister);
    16381616        compare32(right.m_value, addressTempRegister, cond);
    … …  
    16471625    {
    16481626        ASSERT(!(right.m_value & 0xFFFFFF00));
    1649         RegisterID scr = claimScratch();
    1650 
    1651         move(left.index, scr);
    1652         lshift32(TrustedImm32(left.scale), scr);
    1653 
    1654         if (left.offset)
    1655             add32(TrustedImm32(left.offset), scr);
    1656         add32(left.base, scr);
    1657         load8(scr, scr);
    1658         RegisterID scr1 = claimScratch();
    1659         m_assembler.loadConstant(right.m_value, scr1);
    1660         releaseScratch(scr);
    1661         releaseScratch(scr1);
    1662 
    1663         return branch32(cond, scr, scr1);
     1627        RegisterID lefttmp = claimScratch();
     1628
     1629        loadEffectiveAddress(left, lefttmp);
     1630
     1631        load8(lefttmp, lefttmp);
     1632        RegisterID righttmp = claimScratch();
     1633        m_assembler.loadConstant(right.m_value, righttmp);
     1634
     1635        Jump result = branch32(cond, lefttmp, righttmp);
     1636        releaseScratch(lefttmp);
     1637        releaseScratch(righttmp);
     1638        return result;
    16641639    }
    16651640
    … …  
    17051680    Jump branchTest32(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    17061681    {
     1682        ASSERT((cond == Zero) || (cond == NonZero));
     1683
    17071684        RegisterID scr = claimScratch();
    17081685
    … …  
    17371714    {
    17381715        RegisterID scr = claimScratch();
    1739 
    1740         if ((address.offset < 0) || (address.offset >= 64)) {
    1741             m_assembler.loadConstant(address.offset, scr);
    1742             m_assembler.addlRegReg(address.base, scr);
    1743             m_assembler.movlMemReg(scr, scr);
    1744         } else if (address.offset)
    1745             m_assembler.movlMemReg(address.offset >> 2, address.base, scr);
    1746         else
    1747             m_assembler.movlMemReg(address.base, scr);
     1716        load32(address, scr);
    17481717        m_assembler.jmpReg(scr);
    1749 
    17501718        releaseScratch(scr);
    17511719    }
    … …  
    17621730        }
    17631731
    1764         if (cond == Signed) {
    1765             m_assembler.addlRegReg(src, dest);
    1766             // Check if dest is negative
     1732        m_assembler.addlRegReg(src, dest);
     1733
     1734        if ((cond == Signed) || (cond == PositiveOrZero)) {
    17671735            m_assembler.cmppz(dest);
    1768             return branchFalse();
    1769         }
    1770 
    1771         if (cond == PositiveOrZero) {
    1772             m_assembler.addlRegReg(src, dest);
    1773             m_assembler.cmppz(dest);
    1774             return branchTrue();
    1775         }
    1776 
    1777         m_assembler.addlRegReg(src, dest);
     1736            return (cond == Signed) ? branchFalse() : branchTrue();
     1737        }
     1738
    17781739        compare32(0, dest, Equal);
    1779 
    1780         if (cond == NonZero) // NotEqual
    1781             return branchFalse();
    1782         return branchTrue();
     1740        return (cond == NonZero) ? branchFalse() : branchTrue();
    17831741    }
    17841742
    … …  
    17871745        ASSERT((cond == Overflow) || (cond == Signed) || (cond == PositiveOrZero) || (cond == Zero) || (cond == NonZero));
    17881746
    1789         move(imm, scratchReg3);
    1790         return branchAdd32(cond, scratchReg3, dest);
     1747        RegisterID immval = claimScratch();
     1748        move(imm, immval);
     1749        Jump result = branchAdd32(cond, immval, dest);
     1750        releaseScratch(immval);
     1751        return result;
    17911752    }
    17921753
    … …  
    17951756        ASSERT((cond == Overflow) || (cond == Signed) || (cond == PositiveOrZero) || (cond == Zero) || (cond == NonZero));
    17961757
    1797         if (src != dest)
    1798             move(src, dest);
     1758        move(src, dest);
    17991759
    18001760        if (cond == Overflow) {
    … …  
    18061766        add32(imm, dest);
    18071767
    1808         if (cond == Signed) {
     1768        if ((cond == Signed) || (cond == PositiveOrZero)) {
    18091769            m_assembler.cmppz(dest);
    1810             return branchFalse();
    1811         }
    1812 
    1813         if (cond == PositiveOrZero) {
    1814             m_assembler.cmppz(dest);
    1815             return branchTrue();
     1770            return (cond == Signed) ? branchFalse() : branchTrue();
    18161771        }
    18171772
    18181773        compare32(0, dest, Equal);
    1819 
    1820         if (cond == NonZero) // NotEqual
    1821             return branchFalse();
    1822         return branchTrue();
     1774        return (cond == NonZero) ? branchFalse() : branchTrue();
    18231775    }
    18241776
    … …  
    18311783        RegisterID destptr = claimScratch();
    18321784        RegisterID destval = claimScratch();
    1833         m_assembler.loadConstant(reinterpret_cast<uint32_t>(dest.m_ptr), destptr);
     1785        move(TrustedImmPtr(dest.m_ptr), destptr);
    18341786        m_assembler.movlMemReg(destptr, destval);
    18351787        if (cond == Overflow) {
    … …  
    18381790        } else {
    18391791            m_assembler.addlRegReg(scratchReg3, destval);
    1840             if (cond == Signed) {
     1792            if ((cond == Signed) || (cond == PositiveOrZero)) {
    18411793                m_assembler.cmppz(destval);
    1842                 result = false;
    1843             } else if (cond == PositiveOrZero) {
    1844                 m_assembler.cmppz(destval);
    1845                 result = true;
     1794                result = (cond == PositiveOrZero);
    18461795            } else {
    1847                 m_assembler.movImm8(0, scratchReg3);
    1848                 m_assembler.cmplRegReg(scratchReg3, destval, SH4Condition(cond));
    1849                 result = (cond == Zero);
     1796                m_assembler.testlRegReg(destval, destval);
     1797                result = (cond != NonZero);
    18501798            }
    18511799        }
    … …  
    18751823        }
    18761824
    1877         m_assembler.imullRegReg(src, dest);
    1878         m_assembler.stsmacl(dest);
     1825        mul32(src, dest);
     1826
    18791827        if (cond == Signed) {
    1880             // Check if dest is negative
    18811828            m_assembler.cmppz(dest);
    18821829            return branchFalse();
    … …  
    18841831
    18851832        compare32(0, dest, static_cast<RelationalCondition>(cond));
    1886 
    1887         if (cond == NonZero) // NotEqual
    1888             return branchFalse();
    1889         return branchTrue();
     1833        return (cond == NonZero) ? branchFalse() : branchTrue();
    18901834    }
    18911835
    … …  
    18941838        ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
    18951839
    1896         move(imm, scratchReg3);
    1897         if (src != dest)
    1898             move(src, dest);
    1899 
    1900         return branchMul32(cond, scratchReg3, dest);
     1840        if (src == dest) {
     1841            move(imm, scratchReg3);
     1842            return branchMul32(cond, scratchReg3, dest);
     1843        }
     1844
     1845        move(imm, dest);
     1846        return branchMul32(cond, src, dest);
    19011847    }
    19021848
    … …  
    19101856        }
    19111857
     1858        sub32(src, dest);
     1859
    19121860        if (cond == Signed) {
    1913             // Check if dest is negative
    1914             m_assembler.sublRegReg(src, dest);
    1915             compare32(0, dest, LessThan);
     1861            m_assembler.cmppz(dest);
     1862            return branchFalse();
     1863        }
     1864
     1865        compare32(0, dest, static_cast<RelationalCondition>(cond));
     1866        return (cond == NonZero) ? branchFalse() : branchTrue();
     1867    }
     1868
     1869    Jump branchSub32(ResultCondition cond, TrustedImm32 imm, RegisterID dest)
     1870    {
     1871        ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
     1872
     1873        RegisterID immval = claimScratch();
     1874        move(imm, immval);
     1875        Jump result = branchSub32(cond, immval, dest);
     1876        releaseScratch(immval);
     1877        return result;
     1878    }
     1879
     1880    Jump branchSub32(ResultCondition cond, RegisterID src, TrustedImm32 imm, RegisterID dest)
     1881    {
     1882        ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
     1883
     1884        move(src, dest);
     1885        return branchSub32(cond, imm, dest);
     1886    }
     1887
     1888    Jump branchSub32(ResultCondition cond, RegisterID src1, RegisterID src2, RegisterID dest)
     1889    {
     1890        ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
     1891
     1892        if (src2 != dest) {
     1893            move(src1, dest);
     1894            return branchSub32(cond, src2, dest);
     1895        }
     1896
     1897        if (cond == Overflow) {
     1898            RegisterID tmpval = claimScratch();
     1899            move(src1, tmpval);
     1900            m_assembler.subvlRegReg(src2, tmpval);
     1901            move(tmpval, dest);
     1902            releaseScratch(tmpval);
    19161903            return branchTrue();
    19171904        }
    19181905
    1919         sub32(src, dest);
     1906        RegisterID tmpval = claimScratch();
     1907        move(src1, tmpval);
     1908        sub32(src2, tmpval);
     1909        move(tmpval, dest);
     1910        releaseScratch(tmpval);
     1911
     1912        if (cond == Signed) {
     1913            m_assembler.cmppz(dest);
     1914            return branchFalse();
     1915        }
     1916
    19201917        compare32(0, dest, static_cast<RelationalCondition>(cond));
    1921 
    1922         if (cond == NonZero) // NotEqual
     1918        return (cond == NonZero) ? branchFalse() : branchTrue();
     1919    }
     1920
     1921    Jump branchOr32(ResultCondition cond, RegisterID src, RegisterID dest)
     1922    {
     1923        ASSERT((cond == Signed) || (cond == Zero) || (cond == NonZero));
     1924
     1925        or32(src, dest);
     1926
     1927        if (cond == Signed) {
     1928            m_assembler.cmppz(dest);
    19231929            return branchFalse();
    1924         return branchTrue();
    1925     }
    1926 
    1927     Jump branchSub32(ResultCondition cond, TrustedImm32 imm, RegisterID dest)
    1928     {
    1929         ASSERT((cond == Overflow) || (cond == Signed) || (cond == Zero) || (cond == NonZero));
    1930 
    1931         move(imm, scratchReg3);
    1932         return branchSub32(cond, scratchReg3, dest);
    1933     }
    1934 
    1935     Jump branchSub32(ResultCondition cond, RegisterID src, TrustedImm32 imm, RegisterID dest)
    1936     {
    1937         move(imm, scratchReg3);
    1938         if (src != dest)
    1939             move(src, dest);
    1940         return branchSub32(cond, scratchReg3, dest);
    1941     }
    1942 
    1943     Jump branchSub32(ResultCondition cond, RegisterID src1, RegisterID src2, RegisterID dest)
    1944     {
    1945         if (src1 != dest)
    1946             move(src1, dest);
    1947         return branchSub32(cond, src2, dest);
    1948     }
    1949 
    1950     Jump branchOr32(ResultCondition cond, RegisterID src, RegisterID dest)
    1951     {
    1952         ASSERT((cond == Signed) || (cond == Zero) || (cond == NonZero));
    1953 
    1954         if (cond == Signed) {
    1955             or32(src, dest);
    1956             compare32(0, dest, static_cast<RelationalCondition>(LessThan));
    1957             return branchTrue();
    1958         }
    1959 
    1960         or32(src, dest);
     1930        }
     1931
    19611932        compare32(0, dest, static_cast<RelationalCondition>(cond));
    1962 
    1963         if (cond == NonZero) // NotEqual
    1964             return branchFalse();
    1965         return branchTrue();
    1966     }
    1967 
    1968     void branchConvertDoubleToInt32(FPRegisterID src, RegisterID dest, JumpList& failureCases, FPRegisterID fpTemp, bool negZeroCheck = true)
    1969     {
    1970         m_assembler.ftrcdrmfpul(src);
    1971         m_assembler.stsfpulReg(dest);
     1933        return (cond == NonZero) ? branchFalse() : branchTrue();
     1934    }
     1935
     1936    void branchConvertDoubleToInt32(FPRegisterID src, RegisterID dest, JumpList& failureCases, FPRegisterID, bool negZeroCheck = true)
     1937    {
     1938        truncateDoubleToInt32(src, dest);
    19721939        convertInt32ToDouble(dest, fscratch);
    19731940        failureCases.append(branchDouble(DoubleNotEqualOrUnordered, fscratch, src));
    19741941
    1975         if (negZeroCheck) {
    1976             if (dest == SH4Registers::r0)
    1977                 m_assembler.cmpEqImmR0(0, dest);
    1978             else {
    1979                 m_assembler.movImm8(0, scratchReg3);
    1980                 m_assembler.cmplRegReg(scratchReg3, dest, SH4Condition(Equal));
    1981             }
    1982             failureCases.append(branchTrue());
    1983         }
     1942        if (negZeroCheck)
     1943            failureCases.append(branch32(Equal, dest, TrustedImm32(0)));
    19841944    }
    19851945
    … …  
    20181978    void urshift32(RegisterID src, TrustedImm32 shiftamount, RegisterID dest)
    20191979    {
    2020         if (src != dest)
    2021             move(src, dest);
    2022 
     1980        move(src, dest);
    20231981        urshift32(shiftamount, dest);
    20241982    }
    … …  
    20492007    void breakpoint()
    20502008    {
     2009        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 2);
    20512010        m_assembler.bkpt();
    20522011        m_assembler.nop();
    … …  
    21502109    }
    21512110
    2152     static void revertJumpReplacementToBranchPtrWithPatch(CodeLocationLabel instructionStart, RegisterID, void* initialValue)
    2153     {
    2154         SH4Assembler::revertJump(instructionStart.dataLocation(), initialValue);
     2111    static void revertJumpReplacementToBranchPtrWithPatch(CodeLocationLabel instructionStart, RegisterID rd, void* initialValue)
     2112    {
     2113        SH4Assembler::revertJumpToMove(instructionStart.dataLocation(), rd, reinterpret_cast<int>(initialValue));
    21552114    }
    21562115
Note: See TracChangeset for help on using the changeset viewer.