Changeset 203331 in webkit


Ignore:
Timestamp:
Jul 17, 2016 7:33:26 AM (8 years ago)
Author:
Yusuke Suzuki
Message:

[JSC] Mask TrustedImm32 to 8bit in MacroAssembler for 8bit operations
https://bugs.webkit.org/show_bug.cgi?id=159334

Reviewed by Filip Pizlo.

Previously, in 8bit operations (like add8, compare8, test8, branch8, branchTest8 etc.),
we require that the given TrustedImm32 is in range of 8bit. While achieving this in
the manual MacroAssembler calling is easy, in Air, we don't guarantee that the higher bit
of the 8bit argument is cleared. So the current assertions are invalid.

This patch relaxes the above restriction. By removing this assertion,
8bit operations can take arbitrary 32bit imms. And only lower 8bit are effective when
emitting the code in these methods.

  • assembler/MacroAssembler.h:

(JSC::MacroAssembler::branchTest8):

  • assembler/MacroAssemblerARM.h:

(JSC::MacroAssemblerARM::store8):
(JSC::MacroAssemblerARM::branch8):
(JSC::MacroAssemblerARM::branchTest8):
(JSC::MacroAssemblerARM::compare8):
(JSC::MacroAssemblerARM::test8):

  • assembler/MacroAssemblerARM64.h:

(JSC::MacroAssemblerARM64::store8):
(JSC::MacroAssemblerARM64::branch8):
(JSC::MacroAssemblerARM64::branchTest8):
(JSC::MacroAssemblerARM64::compare8):
(JSC::MacroAssemblerARM64::test8):

  • assembler/MacroAssemblerARMv7.h:

(JSC::MacroAssemblerARMv7::store8):
(JSC::MacroAssemblerARMv7::branch8):
(JSC::MacroAssemblerARMv7::branchTest8):
(JSC::MacroAssemblerARMv7::compare8):
(JSC::MacroAssemblerARMv7::test8):

  • assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::store8):
(JSC::MacroAssemblerMIPS::branch8):
(JSC::MacroAssemblerMIPS::compare8):
(JSC::MacroAssemblerMIPS::branchTest8):
(JSC::MacroAssemblerMIPS::test8):

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::store8):
(JSC::MacroAssemblerSH4::branchTest8):
(JSC::MacroAssemblerSH4::branch8):
(JSC::MacroAssemblerSH4::compare8):
(JSC::MacroAssemblerSH4::test8):

  • assembler/MacroAssemblerX86.h:

(JSC::MacroAssemblerX86::store8):
(JSC::MacroAssemblerX86::branch8):
(JSC::MacroAssemblerX86::branchTest8):

  • assembler/MacroAssemblerX86Common.h:

(JSC::MacroAssemblerX86Common::add8):
(JSC::MacroAssemblerX86Common::store8):
(JSC::MacroAssemblerX86Common::branch8):
(JSC::MacroAssemblerX86Common::branchTest8):
(JSC::MacroAssemblerX86Common::compare8):
(JSC::MacroAssemblerX86Common::test8):

  • assembler/MacroAssemblerX86_64.h:

(JSC::MacroAssemblerX86_64::store8):
(JSC::MacroAssemblerX86_64::branch8):
(JSC::MacroAssemblerX86_64::branchTest8):

Location:
trunk/Source/JavaScriptCore
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r203329 r203331  
     12016-07-17  Yusuke Suzuki  <utatane.tea@gmail.com>
     2
     3        [JSC] Mask TrustedImm32 to 8bit in MacroAssembler for 8bit operations
     4        https://bugs.webkit.org/show_bug.cgi?id=159334
     5
     6        Reviewed by Filip Pizlo.
     7
     8        Previously, in 8bit operations (like add8, compare8, test8, branch8, branchTest8 etc.),
     9        we require that the given TrustedImm32 is in range of 8bit. While achieving this in
     10        the manual MacroAssembler calling is easy, in Air, we don't guarantee that the higher bit
     11        of the 8bit argument is cleared. So the current assertions are invalid.
     12
     13        This patch relaxes the above restriction. By removing this assertion,
     14        8bit operations can take arbitrary 32bit imms. And only lower 8bit are effective when
     15        emitting the code in these methods.
     16
     17        * assembler/MacroAssembler.h:
     18        (JSC::MacroAssembler::branchTest8):
     19        * assembler/MacroAssemblerARM.h:
     20        (JSC::MacroAssemblerARM::store8):
     21        (JSC::MacroAssemblerARM::branch8):
     22        (JSC::MacroAssemblerARM::branchTest8):
     23        (JSC::MacroAssemblerARM::compare8):
     24        (JSC::MacroAssemblerARM::test8):
     25        * assembler/MacroAssemblerARM64.h:
     26        (JSC::MacroAssemblerARM64::store8):
     27        (JSC::MacroAssemblerARM64::branch8):
     28        (JSC::MacroAssemblerARM64::branchTest8):
     29        (JSC::MacroAssemblerARM64::compare8):
     30        (JSC::MacroAssemblerARM64::test8):
     31        * assembler/MacroAssemblerARMv7.h:
     32        (JSC::MacroAssemblerARMv7::store8):
     33        (JSC::MacroAssemblerARMv7::branch8):
     34        (JSC::MacroAssemblerARMv7::branchTest8):
     35        (JSC::MacroAssemblerARMv7::compare8):
     36        (JSC::MacroAssemblerARMv7::test8):
     37        * assembler/MacroAssemblerMIPS.h:
     38        (JSC::MacroAssemblerMIPS::store8):
     39        (JSC::MacroAssemblerMIPS::branch8):
     40        (JSC::MacroAssemblerMIPS::compare8):
     41        (JSC::MacroAssemblerMIPS::branchTest8):
     42        (JSC::MacroAssemblerMIPS::test8):
     43        * assembler/MacroAssemblerSH4.h:
     44        (JSC::MacroAssemblerSH4::store8):
     45        (JSC::MacroAssemblerSH4::branchTest8):
     46        (JSC::MacroAssemblerSH4::branch8):
     47        (JSC::MacroAssemblerSH4::compare8):
     48        (JSC::MacroAssemblerSH4::test8):
     49        * assembler/MacroAssemblerX86.h:
     50        (JSC::MacroAssemblerX86::store8):
     51        (JSC::MacroAssemblerX86::branch8):
     52        (JSC::MacroAssemblerX86::branchTest8):
     53        * assembler/MacroAssemblerX86Common.h:
     54        (JSC::MacroAssemblerX86Common::add8):
     55        (JSC::MacroAssemblerX86Common::store8):
     56        (JSC::MacroAssemblerX86Common::branch8):
     57        (JSC::MacroAssemblerX86Common::branchTest8):
     58        (JSC::MacroAssemblerX86Common::compare8):
     59        (JSC::MacroAssemblerX86Common::test8):
     60        * assembler/MacroAssemblerX86_64.h:
     61        (JSC::MacroAssemblerX86_64::store8):
     62        (JSC::MacroAssemblerX86_64::branch8):
     63        (JSC::MacroAssemblerX86_64::branchTest8):
     64
    1652016-07-16  Chris Dumez  <cdumez@apple.com>
    266
  • trunk/Source/JavaScriptCore/assembler/MacroAssembler.h

    r200970 r203331  
    791791    Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
    792792    {
    793         return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask);
     793        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     794        return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask8);
    794795    }
    795796
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h

    r203293 r203331  
    502502    void store8(TrustedImm32 imm, ImplicitAddress address)
    503503    {
    504         move(imm, ARMRegisters::S1);
     504        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     505        move(imm8, ARMRegisters::S1);
    505506        store8(ARMRegisters::S1, address);
    506507    }
     
    508509    void store8(TrustedImm32 imm, const void* address)
    509510    {
     511        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
    510512        move(TrustedImm32(reinterpret_cast<ARMWord>(address)), ARMRegisters::S0);
    511         move(imm, ARMRegisters::S1);
     513        move(imm8, ARMRegisters::S1);
    512514        m_assembler.dtrUp(ARMAssembler::StoreUint8, ARMRegisters::S1, ARMRegisters::S0, 0);
    513515    }
     
    624626    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    625627    {
     628        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    626629        load8(left, ARMRegisters::S1);
    627         return branch32(cond, ARMRegisters::S1, right);
     630        return branch32(cond, ARMRegisters::S1, right8);
    628631    }
    629632
    630633    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    631634    {
    632         ASSERT(!(right.m_value & 0xFFFFFF00));
     635        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    633636        load8(left, ARMRegisters::S1);
    634         return branch32(cond, ARMRegisters::S1, right);
     637        return branch32(cond, ARMRegisters::S1, right8);
    635638    }
    636639
    637640    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    638641    {
     642        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    639643        move(TrustedImmPtr(left.m_ptr), ARMRegisters::S1);
    640644        load8(Address(ARMRegisters::S1), ARMRegisters::S1);
    641         return branch32(cond, ARMRegisters::S1, right);
     645        return branch32(cond, ARMRegisters::S1, right8);
    642646    }
    643647
     
    686690    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    687691    {
     692        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    688693        load8(address, ARMRegisters::S1);
    689         return branchTest32(cond, ARMRegisters::S1, mask);
     694        return branchTest32(cond, ARMRegisters::S1, mask8);
    690695    }
    691696
    692697    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    693698    {
     699        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    694700        load8(address, ARMRegisters::S1);
    695         return branchTest32(cond, ARMRegisters::S1, mask);
     701        return branchTest32(cond, ARMRegisters::S1, mask8);
    696702    }
    697703
    698704    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    699705    {
     706        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    700707        move(TrustedImmPtr(address.m_ptr), ARMRegisters::S1);
    701708        load8(Address(ARMRegisters::S1), ARMRegisters::S1);
    702         return branchTest32(cond, ARMRegisters::S1, mask);
     709        return branchTest32(cond, ARMRegisters::S1, mask8);
    703710    }
    704711
     
    966973    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    967974    {
     975        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    968976        load8(left, ARMRegisters::S1);
    969         compare32(cond, ARMRegisters::S1, right, dest);
     977        compare32(cond, ARMRegisters::S1, right8, dest);
    970978    }
    971979
     
    988996    void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
    989997    {
     998        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    990999        load8(address, ARMRegisters::S1);
    991         test32(cond, ARMRegisters::S1, mask, dest);
     1000        test32(cond, ARMRegisters::S1, mask8, dest);
    9921001    }
    9931002
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h

    r202214 r203331  
    14091409    void store8(TrustedImm32 imm, void* address)
    14101410    {
    1411         if (!imm.m_value) {
     1411        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     1412        if (!imm8.m_value) {
    14121413            store8(ARM64Registers::zr, address);
    14131414            return;
    14141415        }
    14151416
    1416         move(imm, getCachedDataTempRegisterIDAndInvalidate());
     1417        move(imm8, getCachedDataTempRegisterIDAndInvalidate());
    14171418        store8(dataTempRegister, address);
    14181419    }
     
    14201421    void store8(TrustedImm32 imm, ImplicitAddress address)
    14211422    {
    1422         if (!imm.m_value) {
     1423        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     1424        if (!imm8.m_value) {
    14231425            store8(ARM64Registers::zr, address);
    14241426            return;
    14251427        }
    14261428
    1427         move(imm, getCachedDataTempRegisterIDAndInvalidate());
     1429        move(imm8, getCachedDataTempRegisterIDAndInvalidate());
    14281430        store8(dataTempRegister, address);
    14291431    }
     
    24032405    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    24042406    {
    2405         ASSERT(!(0xffffff00 & right.m_value));
     2407        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    24062408        load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
    2407         return branch32(cond, memoryTempRegister, right);
     2409        return branch32(cond, memoryTempRegister, right8);
    24082410    }
    24092411
    24102412    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    24112413    {
    2412         ASSERT(!(0xffffff00 & right.m_value));
     2414        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    24132415        load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
    2414         return branch32(cond, memoryTempRegister, right);
     2416        return branch32(cond, memoryTempRegister, right8);
    24152417    }
    24162418   
    24172419    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    24182420    {
    2419         ASSERT(!(0xffffff00 & right.m_value));
     2421        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    24202422        load8(left.m_ptr, getCachedMemoryTempRegisterIDAndInvalidate());
    2421         return branch32(cond, memoryTempRegister, right);
     2423        return branch32(cond, memoryTempRegister, right8);
    24222424    }
    24232425   
     
    25462548    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    25472549    {
     2550        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    25482551        load8(address, getCachedDataTempRegisterIDAndInvalidate());
    2549         return branchTest32(cond, dataTempRegister, mask);
     2552        return branchTest32(cond, dataTempRegister, mask8);
    25502553    }
    25512554
    25522555    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    25532556    {
     2557        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    25542558        load8(address.m_ptr, getCachedDataTempRegisterIDAndInvalidate());
    2555         return branchTest32(cond, dataTempRegister, mask);
     2559        return branchTest32(cond, dataTempRegister, mask8);
    25562560    }
    25572561
    25582562    Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
    25592563    {
     2564        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    25602565        move(TrustedImmPtr(reinterpret_cast<void*>(address.offset)), getCachedDataTempRegisterIDAndInvalidate());
    25612566        m_assembler.ldrb(dataTempRegister, address.base, dataTempRegister);
    2562         return branchTest32(cond, dataTempRegister, mask);
     2567        return branchTest32(cond, dataTempRegister, mask8);
    25632568    }
    25642569
    25652570    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    25662571    {
     2572        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    25672573        load8(address, getCachedDataTempRegisterIDAndInvalidate());
    2568         return branchTest32(cond, dataTempRegister, mask);
     2574        return branchTest32(cond, dataTempRegister, mask8);
    25692575    }
    25702576
     
    29762982    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    29772983    {
     2984        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    29782985        load8(left, getCachedMemoryTempRegisterIDAndInvalidate());
    2979         move(right, getCachedDataTempRegisterIDAndInvalidate());
     2986        move(right8, getCachedDataTempRegisterIDAndInvalidate());
    29802987        compare32(cond, memoryTempRegister, dataTempRegister, dest);
    29812988    }
     
    30013008    void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
    30023009    {
     3010        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    30033011        load8(address, getCachedMemoryTempRegisterIDAndInvalidate());
    3004         test32(cond, memoryTempRegister, mask, dest);
     3012        test32(cond, memoryTempRegister, mask8, dest);
    30053013    }
    30063014
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h

    r202899 r203331  
    830830    void store8(TrustedImm32 imm, void* address)
    831831    {
    832         move(imm, dataTempRegister);
     832        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     833        move(imm8, dataTempRegister);
    833834        store8(dataTempRegister, address);
    834835    }
     
    836837    void store8(TrustedImm32 imm, Address address)
    837838    {
    838         move(imm, dataTempRegister);
     839        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     840        move(imm8, dataTempRegister);
    839841        store8(dataTempRegister, address);
    840842    }
     
    14771479    Jump branch8(RelationalCondition cond, RegisterID left, TrustedImm32 right)
    14781480    {
    1479         compare32AndSetFlags(left, right);
     1481        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     1482        compare32AndSetFlags(left, right8);
    14801483        return Jump(makeBranch(cond));
    14811484    }
     
    14831486    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    14841487    {
    1485         ASSERT(!(0xffffff00 & right.m_value));
    14861488        // use addressTempRegister incase the branch8 we call uses dataTempRegister. :-/
     1489        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    14871490        load8(left, addressTempRegister);
    1488         return branch8(cond, addressTempRegister, right);
     1491        return branch8(cond, addressTempRegister, right8);
    14891492    }
    14901493
    14911494    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    14921495    {
    1493         ASSERT(!(0xffffff00 & right.m_value));
    14941496        // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/
     1497        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    14951498        load8(left, addressTempRegister);
    1496         return branch32(cond, addressTempRegister, right);
     1499        return branch32(cond, addressTempRegister, right8);
    14971500    }
    14981501   
     
    15001503    {
    15011504        // Use addressTempRegister instead of dataTempRegister, since branch32 uses dataTempRegister.
     1505        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    15021506        move(TrustedImmPtr(address.m_ptr), addressTempRegister);
    15031507        load8(Address(addressTempRegister), addressTempRegister);
    1504         return branch32(cond, addressTempRegister, right);
     1508        return branch32(cond, addressTempRegister, right8);
    15051509    }
    15061510   
     
    15361540    {
    15371541        // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
     1542        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    15381543        load8(address, addressTempRegister);
    1539         return branchTest32(cond, addressTempRegister, mask);
     1544        return branchTest32(cond, addressTempRegister, mask8);
    15401545    }
    15411546
     
    15431548    {
    15441549        // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
     1550        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    15451551        load8(address, addressTempRegister);
    1546         return branchTest32(cond, addressTempRegister, mask);
     1552        return branchTest32(cond, addressTempRegister, mask8);
    15471553    }
    15481554
     
    15501556    {
    15511557        // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/
     1558        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    15521559        move(TrustedImmPtr(address.m_ptr), addressTempRegister);
    15531560        load8(Address(addressTempRegister), addressTempRegister);
    1554         return branchTest32(cond, addressTempRegister, mask);
     1561        return branchTest32(cond, addressTempRegister, mask8);
    15551562    }
    15561563
     
    17791786    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    17801787    {
     1788        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    17811789        load8(left, addressTempRegister);
    1782         compare32(cond, addressTempRegister, right, dest);
     1790        compare32(cond, addressTempRegister, right8, dest);
    17831791    }
    17841792
     
    18061814    void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
    18071815    {
     1816        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    18081817        load8(address, dataTempRegister);
    1809         test32(dataTempRegister, mask);
     1818        test32(dataTempRegister, mask8);
    18101819        m_assembler.it(armV7Condition(cond), false);
    18111820        m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(1));
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h

    r203226 r203331  
    10921092            sb  src, 0(addrTemp)
    10931093        */
    1094         if (!imm.m_value && !m_fixedWidth) {
     1094        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     1095        if (!imm8.m_value && !m_fixedWidth) {
    10951096            move(TrustedImmPtr(address), addrTempRegister);
    10961097            m_assembler.sb(MIPSRegisters::zero, addrTempRegister, 0);
    10971098        } else {
    1098             move(imm, immTempRegister);
     1099            move(imm8, immTempRegister);
    10991100            move(TrustedImmPtr(address), addrTempRegister);
    11001101            m_assembler.sb(immTempRegister, addrTempRegister, 0);
     
    11041105    void store8(TrustedImm32 imm, ImplicitAddress address)
    11051106    {
     1107        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
    11061108        if (address.offset >= -32768 && address.offset <= 32767
    11071109            && !m_fixedWidth) {
    1108             if (!imm.m_value)
     1110            if (!imm8.m_value)
    11091111                m_assembler.sb(MIPSRegisters::zero, address.base, address.offset);
    11101112            else {
    1111                 move(imm, immTempRegister);
     1113                move(imm8, immTempRegister);
    11121114                m_assembler.sb(immTempRegister, address.base, address.offset);
    11131115            }
     
    11201122            m_assembler.lui(addrTempRegister, (address.offset + 0x8000) >> 16);
    11211123            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    1122             if (!imm.m_value && !m_fixedWidth)
     1124            if (!imm8.m_value && !m_fixedWidth)
    11231125                m_assembler.sb(MIPSRegisters::zero, addrTempRegister, address.offset);
    11241126            else {
    1125                 move(imm, immTempRegister);
     1127                move(imm8, immTempRegister);
    11261128                m_assembler.sb(immTempRegister, addrTempRegister, address.offset);
    11271129            }
     
    14451447    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    14461448    {
    1447         // Make sure the immediate value is unsigned 8 bits.
    1448         ASSERT(!(right.m_value & 0xFFFFFF00));
     1449        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    14491450        load8(left, dataTempRegister);
    1450         move(right, immTempRegister);
     1451        move(right8, immTempRegister);
    14511452        return branch32(cond, dataTempRegister, immTempRegister);
    14521453    }
     
    14541455    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    14551456    {
    1456         // Make sure the immediate value is unsigned 8 bits.
    1457         ASSERT(!(right.m_value & 0xFFFFFF00));
     1457        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    14581458        load8(left, dataTempRegister);
    1459         move(right, immTempRegister);
     1459        move(right8, immTempRegister);
    14601460        return branch32(cond, dataTempRegister, immTempRegister);
    14611461    }
     
    14631463    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    14641464    {
    1465         // Make sure the immediate value is unsigned 8 bits.
    1466         ASSERT(!(right.m_value & 0xFFFFFF00));
     1465        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    14671466        load8(left, dataTempRegister);
    1468         move(right, immTempRegister);
     1467        move(right8, immTempRegister);
    14691468        compare32(cond, dataTempRegister, immTempRegister, dest);
    14701469    }
     
    14721471    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    14731472    {
    1474         ASSERT(!(right.m_value & 0xFFFFFF00));
     1473        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    14751474        load8(left, dataTempRegister);
    14761475        // Be careful that the previous load8() uses immTempRegister.
    14771476        // So, we need to put move() after load8().
    1478         move(right, immTempRegister);
     1477        move(right8, immTempRegister);
    14791478        return branch32(cond, dataTempRegister, immTempRegister);
    14801479    }
     
    16311630    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    16321631    {
     1632        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    16331633        load8(address, dataTempRegister);
    1634         return branchTest32(cond, dataTempRegister, mask);
     1634        return branchTest32(cond, dataTempRegister, mask8);
    16351635    }
    16361636
    16371637    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    16381638    {
     1639        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    16391640        load8(address, dataTempRegister);
    1640         return branchTest32(cond, dataTempRegister, mask);
     1641        return branchTest32(cond, dataTempRegister, mask8);
    16411642    }
    16421643
    16431644    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    16441645    {
     1646        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    16451647        move(TrustedImmPtr(address.m_ptr), dataTempRegister);
    16461648        load8(Address(dataTempRegister), dataTempRegister);
    1647         return branchTest32(cond, dataTempRegister, mask);
     1649        return branchTest32(cond, dataTempRegister, mask8);
    16481650    }
    16491651
     
    22182220    {
    22192221        ASSERT((cond == Zero) || (cond == NonZero));
     2222        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    22202223        load8(address, dataTempRegister);
    2221         if (mask.m_value == -1 && !m_fixedWidth) {
     2224        if (mask8.m_value == -1 && !m_fixedWidth) {
    22222225            if (cond == Zero)
    22232226                m_assembler.sltiu(dest, dataTempRegister, 1);
     
    22252228                m_assembler.sltu(dest, MIPSRegisters::zero, dataTempRegister);
    22262229        } else {
    2227             move(mask, immTempRegister);
     2230            move(mask8, immTempRegister);
    22282231            m_assembler.andInsn(cmpTempRegister, dataTempRegister, immTempRegister);
    22292232            if (cond == Zero)
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h

    r198981 r203331  
    922922    void store8(TrustedImm32 imm, void* address)
    923923    {
    924         ASSERT((imm.m_value >= -128) && (imm.m_value <= 127));
     924        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
    925925        RegisterID dstptr = claimScratch();
    926926        move(TrustedImmPtr(address), dstptr);
    927927        RegisterID srcval = claimScratch();
    928         move(imm, srcval);
     928        move(imm8, srcval);
    929929        m_assembler.movbRegMem(srcval, dstptr);
    930930        releaseScratch(dstptr);
     
    934934    void store8(TrustedImm32 imm, Address address)
    935935    {
    936         ASSERT((imm.m_value >= -128) && (imm.m_value <= 127));
     936        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
    937937        RegisterID dstptr = claimScratch();
    938938        move(address.base, dstptr);
    939939        add32(TrustedImm32(address.offset), dstptr);
    940940        RegisterID srcval = claimScratch();
    941         move(imm, srcval);
     941        move(imm8, srcval);
    942942        m_assembler.movbRegMem(srcval, dstptr);
    943943        releaseScratch(dstptr);
     
    15961596    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    15971597    {
     1598        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    15981599        RegisterID addressTempRegister = claimScratch();
    15991600        load8(address, addressTempRegister);
    1600         Jump jmp = branchTest32(cond, addressTempRegister, mask);
     1601        Jump jmp = branchTest32(cond, addressTempRegister, mask8);
    16011602        releaseScratch(addressTempRegister);
    16021603        return jmp;
     
    16051606    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    16061607    {
     1608        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    16071609        RegisterID addressTempRegister = claimScratch();
    16081610        load8(address, addressTempRegister);
    1609         Jump jmp = branchTest32(cond, addressTempRegister, mask);
     1611        Jump jmp = branchTest32(cond, addressTempRegister, mask8);
    16101612        releaseScratch(addressTempRegister);
    16111613        return jmp;
     
    16141616    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    16151617    {
     1618        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    16161619        RegisterID addressTempRegister = claimScratch();
    16171620        move(TrustedImmPtr(address.m_ptr), addressTempRegister);
    16181621        load8(Address(addressTempRegister), addressTempRegister);
    1619         Jump jmp = branchTest32(cond, addressTempRegister, mask);
     1622        Jump jmp = branchTest32(cond, addressTempRegister, mask8);
    16201623        releaseScratch(addressTempRegister);
    16211624        return jmp;
     
    16341637    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    16351638    {
     1639        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    16361640        RegisterID addressTempRegister = claimScratch();
    16371641        load8(left, addressTempRegister);
    1638         Jump jmp = branch32(cond, addressTempRegister, right);
     1642        Jump jmp = branch32(cond, addressTempRegister, right8);
    16391643        releaseScratch(addressTempRegister);
    16401644        return jmp;
     
    16431647    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    16441648    {
     1649        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    16451650        RegisterID addressTempRegister = claimScratch();
    16461651        load8(left, addressTempRegister);
    1647         Jump jmp = branch32(cond, addressTempRegister, right);
     1652        Jump jmp = branch32(cond, addressTempRegister, right8);
    16481653        releaseScratch(addressTempRegister);
    16491654        return jmp;
     
    16521657    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    16531658    {
     1659        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    16541660        RegisterID addressTempRegister = claimScratch();
    16551661        load8(left, addressTempRegister);
    1656         compare32(cond, addressTempRegister, right, dest);
     1662        compare32(cond, addressTempRegister, right8, dest);
    16571663        releaseScratch(addressTempRegister);
    16581664    }
     
    18261832        ASSERT((cond == Zero) || (cond == NonZero));
    18271833
     1834        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     1835
    18281836        load8(address, dest);
    1829         if (mask.m_value == -1)
     1837        if (mask8.m_value == -1)
    18301838            compare32(0, dest, static_cast<RelationalCondition>(cond));
    18311839        else
    1832             testlImm(mask.m_value, dest);
     1840            testlImm(mask8.m_value, dest);
    18331841        if (cond != NonZero) {
    18341842            m_assembler.movt(dest);
     
    19481956    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    19491957    {
    1950         ASSERT(!(right.m_value & 0xFFFFFF00));
     1958        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    19511959        RegisterID lefttmp = claimScratch();
    19521960
     
    19551963        load8(lefttmp, lefttmp);
    19561964        RegisterID righttmp = claimScratch();
    1957         m_assembler.loadConstant(right.m_value, righttmp);
     1965        m_assembler.loadConstant(right8.m_value, righttmp);
    19581966
    19591967        Jump result = branch32(cond, lefttmp, righttmp);
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h

    r196152 r203331  
    161161    void store8(TrustedImm32 imm, void* address)
    162162    {
    163         ASSERT(-128 <= imm.m_value && imm.m_value < 128);
    164         m_assembler.movb_i8m(imm.m_value, address);
     163        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     164        m_assembler.movb_i8m(imm8.m_value, address);
    165165    }
    166166   
     
    238238    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    239239    {
    240         m_assembler.cmpb_im(right.m_value, left.m_ptr);
     240        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     241        m_assembler.cmpb_im(right8.m_value, left.m_ptr);
    241242        return Jump(m_assembler.jCC(x86Condition(cond)));
    242243    }
     
    244245    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    245246    {
    246         ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
    247         if (mask.m_value == -1)
     247        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     248        if (mask8.m_value == -1)
    248249            m_assembler.cmpb_im(0, address.m_ptr);
    249250        else
    250             m_assembler.testb_im(mask.m_value, address.m_ptr);
     251            m_assembler.testb_im(mask8.m_value, address.m_ptr);
    251252        return Jump(m_assembler.jCC(x86Condition(cond)));
    252253    }
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

    r202797 r203331  
    136136    void add8(TrustedImm32 imm, Address address)
    137137    {
    138         m_assembler.addb_im(imm.m_value, address.offset, address.base);
     138        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     139        m_assembler.addb_im(imm8.m_value, address.offset, address.base);
    139140    }
    140141
    141142    void add8(TrustedImm32 imm, BaseIndex address)
    142143    {
    143         m_assembler.addb_im(imm.m_value, address.offset, address.base, address.index, address.scale);
     144        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     145        m_assembler.addb_im(imm8.m_value, address.offset, address.base, address.index, address.scale);
    144146    }
    145147
     
    909911    void store8(TrustedImm32 imm, Address address)
    910912    {
    911         m_assembler.movb_i8m(static_cast<int8_t>(imm.m_value), address.offset, address.base);
     913        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     914        m_assembler.movb_i8m(imm8.m_value, address.offset, address.base);
    912915    }
    913916
    914917    void store8(TrustedImm32 imm, BaseIndex address)
    915918    {
    916         m_assembler.movb_i8m(static_cast<int8_t>(imm.m_value), address.offset, address.base, address.index, address.scale);
     919        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     920        m_assembler.movb_i8m(imm8.m_value, address.offset, address.base, address.index, address.scale);
    917921    }
    918922
     
    21222126    Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right)
    21232127    {
    2124         m_assembler.cmpb_im(right.m_value, left.offset, left.base);
     2128        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     2129        m_assembler.cmpb_im(right8.m_value, left.offset, left.base);
    21252130        return Jump(m_assembler.jCC(x86Condition(cond)));
    21262131    }
     
    22192224    Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
    22202225    {
    2221         // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values.
    2222         ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
    2223         if (mask.m_value == -1)
     2226        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     2227        if (mask8.m_value == -1)
    22242228            m_assembler.cmpb_im(0, address.offset, address.base);
    22252229        else
    2226             m_assembler.testb_im(mask.m_value, address.offset, address.base);
     2230            m_assembler.testb_im(mask8.m_value, address.offset, address.base);
    22272231        return Jump(m_assembler.jCC(x86Condition(cond)));
    22282232    }
     
    22302234    Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
    22312235    {
    2232         // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values.
    2233         ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
    2234         if (mask.m_value == -1)
     2236        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     2237        if (mask8.m_value == -1)
    22352238            m_assembler.cmpb_im(0, address.offset, address.base, address.index, address.scale);
    22362239        else
    2237             m_assembler.testb_im(mask.m_value, address.offset, address.base, address.index, address.scale);
     2240            m_assembler.testb_im(mask8.m_value, address.offset, address.base, address.index, address.scale);
    22382241        return Jump(m_assembler.jCC(x86Condition(cond)));
    22392242    }
     
    22412244    Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right)
    22422245    {
    2243         // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values.
    2244         ASSERT(right.m_value >= -128 && right.m_value <= 255);
    2245 
    2246         m_assembler.cmpb_im(right.m_value, left.offset, left.base, left.index, left.scale);
     2246        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     2247        m_assembler.cmpb_im(right8.m_value, left.offset, left.base, left.index, left.scale);
    22472248        return Jump(m_assembler.jCC(x86Condition(cond)));
    22482249    }
     
    24602461    void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest)
    24612462    {
    2462         m_assembler.cmpb_im(right.m_value, left.offset, left.base);
     2463        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
     2464        m_assembler.cmpb_im(right8.m_value, left.offset, left.base);
    24632465        set32(x86Condition(cond), dest);
    24642466    }
     
    24902492    void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
    24912493    {
    2492         if (mask.m_value == -1)
     2494        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
     2495        if (mask8.m_value == -1)
    24932496            m_assembler.cmpb_im(0, address.offset, address.base);
    24942497        else
    2495             m_assembler.testb_im(mask.m_value, address.offset, address.base);
     2498            m_assembler.testb_im(mask8.m_value, address.offset, address.base);
    24962499        set32(x86Condition(cond), dest);
    24972500    }
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h

    r201208 r203331  
    138138    void store8(TrustedImm32 imm, void* address)
    139139    {
     140        TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
    140141        move(TrustedImmPtr(address), scratchRegister());
    141         store8(imm, Address(scratchRegister()));
     142        store8(imm8, Address(scratchRegister()));
    142143    }
    143144
     
    12111212    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
    12121213    {
     1214        TrustedImm32 right8(static_cast<int8_t>(right.m_value));
    12131215        MacroAssemblerX86Common::move(TrustedImmPtr(left.m_ptr), scratchRegister());
    1214         return MacroAssemblerX86Common::branch8(cond, Address(scratchRegister()), right);
     1216        return MacroAssemblerX86Common::branch8(cond, Address(scratchRegister()), right8);
    12151217    }
    12161218   
     
    12181220    Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
    12191221    {
     1222        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    12201223        TrustedImmPtr addr(reinterpret_cast<void*>(address.offset));
    12211224        MacroAssemblerX86Common::move(addr, scratchRegister());
    1222         return MacroAssemblerX86Common::branchTest8(cond, BaseIndex(scratchRegister(), address.base, TimesOne), mask);
     1225        return MacroAssemblerX86Common::branchTest8(cond, BaseIndex(scratchRegister(), address.base, TimesOne), mask8);
    12231226    }
    12241227   
    12251228    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
    12261229    {
     1230        TrustedImm32 mask8(static_cast<int8_t>(mask.m_value));
    12271231        MacroAssemblerX86Common::move(TrustedImmPtr(address.m_ptr), scratchRegister());
    1228         return MacroAssemblerX86Common::branchTest8(cond, Address(scratchRegister()), mask);
     1232        return MacroAssemblerX86Common::branchTest8(cond, Address(scratchRegister()), mask8);
    12291233    }
    12301234
Note: See TracChangeset for help on using the changeset viewer.