⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 286020 in webkit


Ignore:
Timestamp:
Nov 18, 2021, 12:04:48 PM (5 years ago)
Author:
ysuzuki@apple.com
Message:

[JSC] Add branchTest16 operation
​https://bugs.webkit.org/show_bug.cgi?id=233275

Reviewed by Mark Lam.

This patch adds branchTest16 to all macro assemblers. And it also fixes the existing bug of
edge case of branchTest8: when we cannot represent the imm as ARM logical value, then we are
failing to emit the right instructions. Probably this bug does not appear since we are not using
such a value as an imm for branchTest8. We added tests to testmasm so that these code is stressed
now.

  • assembler/MacroAssembler.h:

(JSC::MacroAssembler::branchTest16):

  • assembler/MacroAssemblerARM64.h:

(JSC::MacroAssemblerARM64::load16SignedExtendTo32):
(JSC::MacroAssemblerARM64::branchTest32):
(JSC::MacroAssemblerARM64::branchTest8):
(JSC::MacroAssemblerARM64::branchTest16):

  • assembler/MacroAssemblerARMv7.h:

(JSC::MacroAssemblerARMv7::branchTest16):
(JSC::MacroAssemblerARMv7::test32):
(JSC::MacroAssemblerARMv7::test8):

  • assembler/MacroAssemblerHelpers.h:

(JSC::MacroAssemblerHelpers::mask16OnCondition):
(JSC::MacroAssemblerHelpers::load16OnCondition):

  • assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::load16):
(JSC::MacroAssemblerMIPS::load16SignedExtendTo32):
(JSC::MacroAssemblerMIPS::mask16OnTest):
(JSC::MacroAssemblerMIPS::branchTest16):

  • assembler/MacroAssemblerX86Common.h:

(JSC::MacroAssemblerX86Common::branchTest16):

  • assembler/MacroAssemblerX86_64.h:

(JSC::MacroAssemblerX86_64::branchTest16):

  • assembler/X86Assembler.h:

(JSC::X86Assembler::cmpw_im):
(JSC::X86Assembler::testw_im):

  • assembler/testmasm.cpp:

(JSC::testBranchTest8):
(JSC::testBranchTest16):

Location:
trunk/Source/JavaScriptCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r286018 r286020  
     12021-11-18  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        [JSC] Add branchTest16 operation
     4        https://bugs.webkit.org/show_bug.cgi?id=233275
     5
     6        Reviewed by Mark Lam.
     7
     8        This patch adds branchTest16 to all macro assemblers. And it also fixes the existing bug of
     9        edge case of branchTest8: when we cannot represent the imm as ARM logical value, then we are
     10        failing to emit the right instructions. Probably this bug does not appear since we are not using
     11        such a value as an imm for branchTest8. We added tests to testmasm so that these code is stressed
     12        now.
     13
     14        * assembler/MacroAssembler.h:
     15        (JSC::MacroAssembler::branchTest16):
     16        * assembler/MacroAssemblerARM64.h:
     17        (JSC::MacroAssemblerARM64::load16SignedExtendTo32):
     18        (JSC::MacroAssemblerARM64::branchTest32):
     19        (JSC::MacroAssemblerARM64::branchTest8):
     20        (JSC::MacroAssemblerARM64::branchTest16):
     21        * assembler/MacroAssemblerARMv7.h:
     22        (JSC::MacroAssemblerARMv7::branchTest16):
     23        (JSC::MacroAssemblerARMv7::test32):
     24        (JSC::MacroAssemblerARMv7::test8):
     25        * assembler/MacroAssemblerHelpers.h:
     26        (JSC::MacroAssemblerHelpers::mask16OnCondition):
     27        (JSC::MacroAssemblerHelpers::load16OnCondition):
     28        * assembler/MacroAssemblerMIPS.h:
     29        (JSC::MacroAssemblerMIPS::load16):
     30        (JSC::MacroAssemblerMIPS::load16SignedExtendTo32):
     31        (JSC::MacroAssemblerMIPS::mask16OnTest):
     32        (JSC::MacroAssemblerMIPS::branchTest16):
     33        * assembler/MacroAssemblerX86Common.h:
     34        (JSC::MacroAssemblerX86Common::branchTest16):
     35        * assembler/MacroAssemblerX86_64.h:
     36        (JSC::MacroAssemblerX86_64::branchTest16):
     37        * assembler/X86Assembler.h:
     38        (JSC::X86Assembler::cmpw_im):
     39        (JSC::X86Assembler::testw_im):
     40        * assembler/testmasm.cpp:
     41        (JSC::testBranchTest8):
     42        (JSC::testBranchTest16):
     43
    1442021-11-18  David Kilzer  <ddkilzer@apple.com>
    245

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

    r284330 r286020  
    879879    {
    880880        return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask);
     881    }
     882
     883    using MacroAssemblerBase::branchTest16;
     884    Jump branchTest16(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
     885    {
     886        return MacroAssemblerBase::branchTest16(cond, Address(address.base, address.offset), mask);
    881887    }
    882888

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

    r284330 r286020  
    18061806    }
    18071807
     1808    void load16SignedExtendTo32(const void* address, RegisterID dest)
     1809    {
     1810        moveToCachedReg(TrustedImmPtr(address), cachedMemoryTempRegister());
     1811        m_assembler.ldrsh<32>(dest, memoryTempRegister, ARM64Registers::zr);
     1812        if (dest == memoryTempRegister)
     1813            cachedMemoryTempRegister().invalidate();
     1814    }
     1815
    18081816    void zeroExtend16To32(RegisterID src, RegisterID dest)
    18091817    {
    … …  
    34113419            }
    34123420
     3421            ASSERT(reg != dataTempRegister);
    34133422            move(mask, getCachedDataTempRegisterIDAndInvalidate());
    34143423            m_assembler.tst<32>(reg, dataTempRegister);
    … …  
    35153524    {
    35163525        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    3517         MacroAssemblerHelpers::load8OnCondition(*this, cond, address, getCachedDataTempRegisterIDAndInvalidate());
    3518         return branchTest32(cond, dataTempRegister, mask8);
     3526        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, getCachedMemoryTempRegisterIDAndInvalidate());
     3527        return branchTest32(cond, memoryTempRegister, mask8);
    35193528    }
    35203529
    … …  
    35223531    {
    35233532        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    3524         MacroAssemblerHelpers::load8OnCondition(*this, cond, address.m_ptr, getCachedDataTempRegisterIDAndInvalidate());
    3525         return branchTest32(cond, dataTempRegister, mask8);
     3533        MacroAssemblerHelpers::load8OnCondition(*this, cond, address.m_ptr, getCachedMemoryTempRegisterIDAndInvalidate());
     3534        return branchTest32(cond, memoryTempRegister, mask8);
    35263535    }
    35273536
    … …  
    35293538    {
    35303539        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    3531         move(TrustedImmPtr(reinterpret_cast<void*>(address.offset)), getCachedDataTempRegisterIDAndInvalidate());
     3540        move(TrustedImmPtr(reinterpret_cast<void*>(address.offset)), getCachedMemoryTempRegisterIDAndInvalidate());
    35323541
    35333542        if (MacroAssemblerHelpers::isUnsigned<MacroAssemblerARM64>(cond))
    3534             m_assembler.ldrb(dataTempRegister, address.base, dataTempRegister);
     3543            m_assembler.ldrb(memoryTempRegister, address.base, memoryTempRegister);
    35353544        else
    3536             m_assembler.ldrsb<32>(dataTempRegister, address.base, dataTempRegister);
    3537 
    3538         return branchTest32(cond, dataTempRegister, mask8);
     3545            m_assembler.ldrsb<32>(memoryTempRegister, address.base, memoryTempRegister);
     3546
     3547        return branchTest32(cond, memoryTempRegister, mask8);
    35393548    }
    35403549
    … …  
    35423551    {
    35433552        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    3544         MacroAssemblerHelpers::load8OnCondition(*this, cond, address, getCachedDataTempRegisterIDAndInvalidate());
    3545         return branchTest32(cond, dataTempRegister, mask8);
     3553        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, getCachedMemoryTempRegisterIDAndInvalidate());
     3554        return branchTest32(cond, memoryTempRegister, mask8);
     3555    }
     3556
     3557    Jump branchTest16(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
     3558    {
     3559        TrustedImm32 mask16 = MacroAssemblerHelpers::mask16OnCondition(*this, cond, mask);
     3560        MacroAssemblerHelpers::load16OnCondition(*this, cond, address, getCachedMemoryTempRegisterIDAndInvalidate());
     3561        return branchTest32(cond, memoryTempRegister, mask16);
     3562    }
     3563
     3564    Jump branchTest16(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
     3565    {
     3566        TrustedImm32 mask16 = MacroAssemblerHelpers::mask16OnCondition(*this, cond, mask);
     3567        MacroAssemblerHelpers::load16OnCondition(*this, cond, address.m_ptr, getCachedMemoryTempRegisterIDAndInvalidate());
     3568        return branchTest32(cond, memoryTempRegister, mask16);
     3569    }
     3570
     3571    Jump branchTest16(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
     3572    {
     3573        TrustedImm32 mask16 = MacroAssemblerHelpers::mask16OnCondition(*this, cond, mask);
     3574        move(TrustedImmPtr(reinterpret_cast<void*>(address.offset)), getCachedMemoryTempRegisterIDAndInvalidate());
     3575
     3576        if (MacroAssemblerHelpers::isUnsigned<MacroAssemblerARM64>(cond))
     3577            m_assembler.ldrh(memoryTempRegister, address.base, memoryTempRegister);
     3578        else
     3579            m_assembler.ldrsh<32>(memoryTempRegister, address.base, memoryTempRegister);
     3580
     3581        return branchTest32(cond, memoryTempRegister, mask16);
     3582    }
     3583
     3584    Jump branchTest16(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
     3585    {
     3586        TrustedImm32 mask16 = MacroAssemblerHelpers::mask16OnCondition(*this, cond, mask);
     3587        MacroAssemblerHelpers::load16OnCondition(*this, cond, address, getCachedMemoryTempRegisterIDAndInvalidate());
     3588        return branchTest32(cond, memoryTempRegister, mask16);
    35463589    }
    35473590

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

    r284103 r286020  
    17731773    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    17741774    {
    1775         // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
     1775        // use addressTempRegister incase the branchTest32 we call uses dataTempRegister. :-/
    17761776        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    17771777        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, addressTempRegister);
    … …  
    17811781    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    17821782    {
    1783         // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
     1783        // use addressTempRegister incase the branchTest32 we call uses dataTempRegister. :-/
    17841784        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    17851785        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, addressTempRegister);
    … …  
    17891789    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    17901790    {
    1791         // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
     1791        // use addressTempRegister incase the branchTest32 we call uses dataTempRegister. :-/
    17921792        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    17931793        move(TrustedImmPtr(address.m_ptr), addressTempRegister);
    17941794        MacroAssemblerHelpers::load8OnCondition(*this, cond, Address(addressTempRegister), addressTempRegister);
    17951795        return branchTest32(cond, addressTempRegister, mask8);
     1796    }
     1797
     1798    Jump branchTest16(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
     1799    {
     1800        // use addressTempRegister incase the branchTest32 we call uses dataTempRegister. :-/
     1801        TrustedImm32 mask16 = MacroAssemblerHelpers::mask16OnCondition(*this, cond, mask);
     1802        MacroAssemblerHelpers::load16OnCondition(*this, cond, address, addressTempRegister);
     1803        return branchTest32(cond, addressTempRegister, mask16);
     1804    }
     1805
     1806    Jump branchTest16(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
     1807    {
     1808        // use addressTempRegister incase the branchTest32 we call uses dataTempRegister. :-/
     1809        TrustedImm32 mask16 = MacroAssemblerHelpers::mask16OnCondition(*this, cond, mask);
     1810        MacroAssemblerHelpers::load16OnCondition(*this, cond, address, addressTempRegister);
     1811        return branchTest32(cond, addressTempRegister, mask16);
     1812    }
     1813
     1814    Jump branchTest16(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
     1815    {
     1816        // use addressTempRegister incase the branchTest32 we call uses dataTempRegister. :-/
     1817        TrustedImm32 mask16 = MacroAssemblerHelpers::mask16OnCondition(*this, cond, mask);
     1818        move(TrustedImmPtr(address.m_ptr), addressTempRegister);
     1819        MacroAssemblerHelpers::load16OnCondition(*this, cond, Address(addressTempRegister), addressTempRegister);
     1820        return branchTest32(cond, addressTempRegister, mask16);
    17961821    }
    17971822
    … …  
    20422067    void test32(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
    20432068    {
    2044         load32(address, dataTempRegister);
    2045         test32(dataTempRegister, mask);
     2069        load32(address, addressTempRegister);
     2070        test32(addressTempRegister, mask);
    20462071        m_assembler.it(armV7Condition(cond), false);
    20472072        m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(1));
    … …  
    20522077    {
    20532078        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    2054         MacroAssemblerHelpers::load8OnCondition(*this, cond, address, dataTempRegister);
    2055         test32(dataTempRegister, mask8);
     2079        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, addressTempRegister);
     2080        test32(addressTempRegister, mask8);
    20562081        m_assembler.it(armV7Condition(cond), false);
    20572082        m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(1));

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

    r280508 r286020  
    127127}
    128128
     129template<typename MacroAssemblerType>
     130inline typename MacroAssemblerType::TrustedImm32 mask16OnCondition(MacroAssemblerType&, typename MacroAssemblerType::RelationalCondition cond, typename MacroAssemblerType::TrustedImm32 value)
     131{
     132    if (isUnsigned<MacroAssemblerType>(cond))
     133        return typename MacroAssemblerType::TrustedImm32(static_cast<uint16_t>(value.m_value));
     134    return typename MacroAssemblerType::TrustedImm32(static_cast<int16_t>(value.m_value));
     135}
     136
     137template<typename MacroAssemblerType>
     138inline typename MacroAssemblerType::TrustedImm32 mask16OnCondition(MacroAssemblerType&, typename MacroAssemblerType::ResultCondition cond, typename MacroAssemblerType::TrustedImm32 value)
     139{
     140    // If condition is Zero or NonZero, upper bits are unrelated.
     141    // Since branchTest32 handles -1 in an optimized manner, we keep -1 as is instead of converting it to 0xffff.
     142    if (cond == MacroAssemblerType::Zero || cond == MacroAssemblerType::NonZero) {
     143        if (value.m_value == -1)
     144            return value;
     145    }
     146    if (isUnsigned<MacroAssemblerType>(cond))
     147        return typename MacroAssemblerType::TrustedImm32(static_cast<uint16_t>(value.m_value));
     148    ASSERT_WITH_MESSAGE(cond != MacroAssemblerType::Overflow, "Overflow is not used for 16bit test operations.");
     149    ASSERT(isSigned<MacroAssemblerType>(cond));
     150    return typename MacroAssemblerType::TrustedImm32(static_cast<int16_t>(value.m_value));
     151}
     152
    129153template<typename MacroAssemblerType, typename Condition, typename ...Args>
    130154void load8OnCondition(MacroAssemblerType& jit, Condition cond, Args... args)
    … …  
    135159}
    136160
     161template<typename MacroAssemblerType, typename Condition, typename ...Args>
     162void load16OnCondition(MacroAssemblerType& jit, Condition cond, Args... args)
     163{
     164    if (isUnsigned<MacroAssemblerType>(cond))
     165        return jit.load16(std::forward<Args>(args)...);
     166    return jit.load16SignedExtendTo32(std::forward<Args>(args)...);
     167}
     168
    137169} } // namespace JSC

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

    r283970 r286020  
    12731273    }
    12741274
     1275    ALWAYS_INLINE void load16(AbsoluteAddress address, RegisterID dest)
     1276    {
     1277        load16(address.m_ptr, dest);
     1278    }
     1279
     1280    /* Need to use zero-extened load half-word for load16.  */
     1281    void load16SignedExtendTo32(Address address, RegisterID dest)
     1282    {
     1283        if (address.offset >= -32768 && address.offset <= 32767
     1284            && !m_fixedWidth)
     1285            m_assembler.lh(dest, address.base, address.offset);
     1286        else {
     1287            /*
     1288                lui     addrTemp, (offset + 0x8000) >> 16
     1289                addu    addrTemp, addrTemp, base
     1290                lh      dest, (offset & 0xffff)(addrTemp)
     1291              */
     1292            m_assembler.lui(addrTempRegister, (address.offset + 0x8000) >> 16);
     1293            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1294            m_assembler.lh(dest, addrTempRegister, address.offset);
     1295        }
     1296    }
     1297
    12751298    void load16SignedExtendTo32(BaseIndex address, RegisterID dest)
    12761299    {
    … …  
    12931316        }
    12941317    }
     1318
     1319    ALWAYS_INLINE void load16SignedExtendTo32(AbsoluteAddress address, RegisterID dest)
     1320    {
     1321        load16SignedExtendTo32(address.m_ptr, dest);
     1322    }
     1323
     1324    void load16SignedExtendTo32(const void* address, RegisterID dest)
     1325    {
     1326        if (m_fixedWidth) {
     1327            /*
     1328                li  addrTemp, address
     1329                lh dest, 0(addrTemp)
     1330            */
     1331            move(TrustedImmPtr(address), addrTempRegister);
     1332            m_assembler.lh(dest, addrTempRegister, 0);
     1333        } else {
     1334            uintptr_t adr = reinterpret_cast<uintptr_t>(address);
     1335            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     1336            m_assembler.lh(dest, addrTempRegister, adr & 0xffff);
     1337        }
     1338    }
     1339
    12951340
    12961341    void loadPair32(RegisterID src, RegisterID dest1, RegisterID dest2)
    … …  
    20422087        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, dataTempRegister);
    20432088        return branchTest32(cond, dataTempRegister, mask8);
     2089    }
     2090
     2091    TrustedImm32 mask16OnTest(ResultCondition cond, TrustedImm32 mask)
     2092    {
     2093        if (mask.m_value == -1 && !m_fixedWidth)
     2094            return TrustedImm32(-1);
     2095        return MacroAssemblerHelpers::mask16OnCondition(*this, cond, mask);
     2096    }
     2097
     2098    Jump branchTest16(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
     2099    {
     2100        TrustedImm32 mask16 = mask16OnTest(cond, mask);
     2101        MacroAssemblerHelpers::load16OnCondition(*this, cond, address, dataTempRegister);
     2102        return branchTest32(cond, dataTempRegister, mask16);
     2103    }
     2104
     2105    Jump branchTest16(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
     2106    {
     2107        TrustedImm32 mask16 = mask16OnTest(cond, mask);
     2108        MacroAssemblerHelpers::load16OnCondition(*this, cond, address, dataTempRegister);
     2109        return branchTest32(cond, dataTempRegister, mask16);
     2110    }
     2111
     2112    Jump branchTest16(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
     2113    {
     2114        TrustedImm32 mask16 = mask16OnTest(cond, mask);
     2115        MacroAssemblerHelpers::load16OnCondition(*this, cond, address, dataTempRegister);
     2116        return branchTest32(cond, dataTempRegister, mask16);
    20442117    }
    20452118

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

    r284330 r286020  
    27572757        else
    27582758            m_assembler.testb_im(mask8.m_value, address.offset, address.base, address.index, address.scale);
     2759        return Jump(m_assembler.jCC(x86Condition(cond)));
     2760    }
     2761
     2762    Jump branchTest16(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
     2763    {
     2764        TrustedImm32 mask16(static_cast<int16_t>(mask.m_value));
     2765        if (mask16.m_value == -1)
     2766            m_assembler.cmpw_im(0, address.offset, address.base);
     2767        else
     2768            m_assembler.testw_im(mask16.m_value, address.offset, address.base);
     2769        return Jump(m_assembler.jCC(x86Condition(cond)));
     2770    }
     2771
     2772    Jump branchTest16(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
     2773    {
     2774        TrustedImm32 mask16(static_cast<int16_t>(mask.m_value));
     2775        if (mask16.m_value == -1)
     2776            m_assembler.cmpw_im(0, address.offset, address.base, address.index, address.scale);
     2777        else
     2778            m_assembler.testw_im(mask16.m_value, address.offset, address.base, address.index, address.scale);
    27592779        return Jump(m_assembler.jCC(x86Condition(cond)));
    27602780    }

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

    r283970 r286020  
    15641564        return MacroAssemblerX86Common::branchTest8(cond, Address(scratchRegister()), mask8);
    15651565    }
    1566    
     1566
     1567    using MacroAssemblerX86Common::branchTest16;
     1568    Jump branchTest16(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
     1569    {
     1570        TrustedImm32 mask16(static_cast<int16_t>(mask.m_value));
     1571        TrustedImmPtr addr(reinterpret_cast<void*>(address.offset));
     1572        MacroAssemblerX86Common::move(addr, scratchRegister());
     1573        return MacroAssemblerX86Common::branchTest16(cond, BaseIndex(scratchRegister(), address.base, TimesOne), mask16);
     1574    }
     1575
     1576    Jump branchTest16(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
     1577    {
     1578        TrustedImm32 mask16(static_cast<int16_t>(mask.m_value));
     1579        MacroAssemblerX86Common::move(TrustedImmPtr(address.m_ptr), scratchRegister());
     1580        return MacroAssemblerX86Common::branchTest16(cond, Address(scratchRegister()), mask16);
     1581    }
     1582
    15671583    void xchg64(RegisterID reg, Address address)
    15681584    {

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

    r272191 r286020  
    20502050    }
    20512051
     2052    void cmpw_im(int imm, int offset, RegisterID base)
     2053    {
     2054        if (CAN_SIGN_EXTEND_8_32(imm)) {
     2055            m_formatter.prefix(PRE_OPERAND_SIZE);
     2056            m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, offset);
     2057            m_formatter.immediate8(imm);
     2058        } else {
     2059            m_formatter.prefix(PRE_OPERAND_SIZE);
     2060            m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, offset);
     2061            m_formatter.immediate16(imm);
     2062        }
     2063    }
     2064
    20522065    void cmpw_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
    20532066    {
    … …  
    21522165        m_formatter.oneByteOp(OP_TEST_EvGv, src, dst);
    21532166    }
    2154    
     2167
     2168    void testw_im(int imm, int offset, RegisterID base)
     2169    {
     2170        m_formatter.prefix(PRE_OPERAND_SIZE);
     2171        m_formatter.oneByteOp(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, offset);
     2172        m_formatter.immediate16(imm);
     2173    }
     2174
     2175    void testw_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
     2176    {
     2177        m_formatter.prefix(PRE_OPERAND_SIZE);
     2178        m_formatter.oneByteOp(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, index, scale, offset);
     2179        m_formatter.immediate16(imm);
     2180    }
     2181
    21552182    void testb_i8r(int imm, RegisterID dst)
    21562183    {

  • trunk/Source/JavaScriptCore/assembler/testmasm.cpp

    r283970 r286020  
    325325        jit.ret();
    326326    }), expected);
     327}
     328
     329void testBranchTest8()
     330{
     331    for (auto value : int32Operands()) {
     332        for (auto value2 : int32Operands()) {
     333            auto test1 = compile([=] (CCallHelpers& jit) {
     334                emitFunctionPrologue(jit);
     335
     336                auto branch = jit.branchTest8(MacroAssembler::NonZero, CCallHelpers::Address(GPRInfo::argumentGPR0, 1), CCallHelpers::TrustedImm32(value2));
     337                jit.move(CCallHelpers::TrustedImm32(0), GPRInfo::returnValueGPR);
     338                auto done = jit.jump();
     339                branch.link(&jit);
     340                jit.move(CCallHelpers::TrustedImm32(1), GPRInfo::returnValueGPR);
     341                done.link(&jit);
     342
     343                emitFunctionEpilogue(jit);
     344                jit.ret();
     345            });
     346
     347            auto test2 = compile([=] (CCallHelpers& jit) {
     348                emitFunctionPrologue(jit);
     349
     350                auto branch = jit.branchTest8(MacroAssembler::NonZero, CCallHelpers::BaseIndex(GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, CCallHelpers::TimesOne), CCallHelpers::TrustedImm32(value2));
     351                jit.move(CCallHelpers::TrustedImm32(0), GPRInfo::returnValueGPR);
     352                auto done = jit.jump();
     353                branch.link(&jit);
     354                jit.move(CCallHelpers::TrustedImm32(1), GPRInfo::returnValueGPR);
     355                done.link(&jit);
     356
     357                emitFunctionEpilogue(jit);
     358                jit.ret();
     359            });
     360
     361            int result = 0;
     362            if (static_cast<uint8_t>(value) & static_cast<uint8_t>(value2))
     363                result = 1;
     364
     365            uint8_t array[] = {
     366                0,
     367                static_cast<uint8_t>(value)
     368            };
     369            CHECK_EQ(invoke<int>(test1, array), result);
     370            CHECK_EQ(invoke<int>(test2, array, 1), result);
     371        }
     372    }
     373}
     374
     375void testBranchTest16()
     376{
     377    for (auto value : int32Operands()) {
     378        for (auto value2 : int32Operands()) {
     379            auto test1 = compile([=] (CCallHelpers& jit) {
     380                emitFunctionPrologue(jit);
     381
     382                auto branch = jit.branchTest16(MacroAssembler::NonZero, CCallHelpers::Address(GPRInfo::argumentGPR0, 2), CCallHelpers::TrustedImm32(value2));
     383                jit.move(CCallHelpers::TrustedImm32(0), GPRInfo::returnValueGPR);
     384                auto done = jit.jump();
     385                branch.link(&jit);
     386                jit.move(CCallHelpers::TrustedImm32(1), GPRInfo::returnValueGPR);
     387                done.link(&jit);
     388
     389                emitFunctionEpilogue(jit);
     390                jit.ret();
     391            });
     392
     393            auto test2 = compile([=] (CCallHelpers& jit) {
     394                emitFunctionPrologue(jit);
     395
     396                auto branch = jit.branchTest16(MacroAssembler::NonZero, CCallHelpers::BaseIndex(GPRInfo::argumentGPR0, GPRInfo::argumentGPR1, CCallHelpers::TimesTwo), CCallHelpers::TrustedImm32(value2));
     397                jit.move(CCallHelpers::TrustedImm32(0), GPRInfo::returnValueGPR);
     398                auto done = jit.jump();
     399                branch.link(&jit);
     400                jit.move(CCallHelpers::TrustedImm32(1), GPRInfo::returnValueGPR);
     401                done.link(&jit);
     402
     403                emitFunctionEpilogue(jit);
     404                jit.ret();
     405            });
     406
     407            int result = 0;
     408            if (static_cast<uint16_t>(value) & static_cast<uint16_t>(value2))
     409                result = 1;
     410
     411            uint16_t array[] = {
     412                0,
     413                static_cast<uint16_t>(value)
     414            };
     415            CHECK_EQ(invoke<int>(test1, array), result);
     416            CHECK_EQ(invoke<int>(test2, array, 1), result);
     417        }
     418    }
    327419}
    328420
    … …  
    56505742    RUN(testSub32ArgImm());
    56515743
     5744    RUN(testBranchTest8());
     5745    RUN(testBranchTest16());
     5746
    56525747#if CPU(X86_64)
    56535748    RUN(testBranchTestBit32RegReg());
Note: See TracChangeset for help on using the changeset viewer.