Changeset 149634 in webkit


Ignore:
Timestamp:
May 6, 2013 1:28:31 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Misc bugfix and cleaning in sh4 base JIT.
​https://bugs.webkit.org/show_bug.cgi?id=115627

Patch by Julien Brianceau <​jbrianceau@nds.com> on 2013-05-06
Reviewed by Oliver Hunt.

Get rid of loadX(RegisterID r0, RegisterID src, RegisterID dest) functions.
Remove misplaced extuw() implementation from MacroAssemblerSH4.
Add movbRegMemr0 and movwRegMemr0 functions in SH4Assembler.

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::add32): Skip operation when first operand is a zero immediate.
(JSC::MacroAssemblerSH4::sub32): Skip operation when first operand is a zero immediate.
(JSC::MacroAssemblerSH4::load32): Fix wrong usage of r0 register.
(JSC::MacroAssemblerSH4::load8Signed): Handle "base == r0" case.
(MacroAssemblerSH4):
(JSC::MacroAssemblerSH4::load16): Handle "base == r0" case.
(JSC::MacroAssemblerSH4::load16Unaligned): Use extuw() implementation from SH4Assembler.
(JSC::MacroAssemblerSH4::load16Signed): Cosmetic change.
(JSC::MacroAssemblerSH4::store8): Fix unhandled BaseIndex offset and handle (base == r0) case.
(JSC::MacroAssemblerSH4::store16): Fix unhandled BaseIndex offset and handle (base == r0) case.
(JSC::MacroAssemblerSH4::store32):

  • assembler/SH4Assembler.h:

(JSC::SH4Assembler::movwRegMemr0):
(SH4Assembler):
(JSC::SH4Assembler::movbRegMemr0):
(JSC::SH4Assembler::placeConstantPoolBarrier): Cosmetic change.
(JSC::SH4Assembler::maxJumpReplacementSize):
(JSC::SH4Assembler::replaceWithJump): Correct branch range and save an opcode.
(JSC::SH4Assembler::printInstr):

Location:
trunk/Source/JavaScriptCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r149633 r149634  
     12013-05-06  Julien Brianceau  <jbrianceau@nds.com>
     2
     3        Misc bugfix and cleaning in sh4 base JIT.
     4        https://bugs.webkit.org/show_bug.cgi?id=115627
     5
     6        Reviewed by Oliver Hunt.
     7
     8        Get rid of loadX(RegisterID r0, RegisterID src, RegisterID dest) functions.
     9        Remove misplaced extuw() implementation from MacroAssemblerSH4.
     10        Add movbRegMemr0 and movwRegMemr0 functions in SH4Assembler.
     11
     12        * assembler/MacroAssemblerSH4.h:
     13        (JSC::MacroAssemblerSH4::add32): Skip operation when first operand is a zero immediate.
     14        (JSC::MacroAssemblerSH4::sub32): Skip operation when first operand is a zero immediate.
     15        (JSC::MacroAssemblerSH4::load32): Fix wrong usage of r0 register.
     16        (JSC::MacroAssemblerSH4::load8Signed): Handle "base == r0" case.
     17        (MacroAssemblerSH4):
     18        (JSC::MacroAssemblerSH4::load16): Handle "base == r0" case.
     19        (JSC::MacroAssemblerSH4::load16Unaligned): Use extuw() implementation from SH4Assembler.
     20        (JSC::MacroAssemblerSH4::load16Signed): Cosmetic change.
     21        (JSC::MacroAssemblerSH4::store8): Fix unhandled BaseIndex offset and handle (base == r0) case.
     22        (JSC::MacroAssemblerSH4::store16): Fix unhandled BaseIndex offset and handle (base == r0) case.
     23        (JSC::MacroAssemblerSH4::store32):
     24        * assembler/SH4Assembler.h:
     25        (JSC::SH4Assembler::movwRegMemr0):
     26        (SH4Assembler):
     27        (JSC::SH4Assembler::movbRegMemr0):
     28        (JSC::SH4Assembler::placeConstantPoolBarrier): Cosmetic change.
     29        (JSC::SH4Assembler::maxJumpReplacementSize):
     30        (JSC::SH4Assembler::replaceWithJump): Correct branch range and save an opcode.
     31        (JSC::SH4Assembler::printInstr):
     32
    1332013-05-06  Anders Carlsson  <andersca@apple.com>
    234

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

    r149403 r149634  
    111111    void add32(TrustedImm32 imm, RegisterID dest)
    112112    {
     113        if (!imm.m_value)
     114            return;
     115
    113116        if (m_assembler.isImmediate(imm.m_value)) {
    114117            m_assembler.addlImm8r(imm.m_value, dest);
    … …  
    131134    void add32(TrustedImm32 imm, Address address)
    132135    {
     136        if (!imm.m_value)
     137            return;
     138
    133139        RegisterID scr = claimScratch();
    134140        load32(address, scr);
    … …  
    326332    void sub32(TrustedImm32 imm, AbsoluteAddress address)
    327333    {
     334        if (!imm.m_value)
     335            return;
     336
    328337        RegisterID result = claimScratch();
    329338        RegisterID scratchReg = claimScratch();
    … …  
    346355    void add32(TrustedImm32 imm, AbsoluteAddress address)
    347356    {
     357        if (!imm.m_value)
     358            return;
     359
    348360        RegisterID result = claimScratch();
    349361        RegisterID scratchReg = claimScratch();
    … …  
    394406    void sub32(TrustedImm32 imm, RegisterID dest)
    395407    {
     408        if (!imm.m_value)
     409            return;
     410
    396411        if (m_assembler.isImmediate(-imm.m_value)) {
    397412            m_assembler.addlImm8r(-imm.m_value, dest);
    … …  
    630645        }
    631646
    632         if ((dest == SH4Registers::r0) && (dest != base)) {
    633             m_assembler.loadConstant((offset), dest);
    634             m_assembler.movlR0mr(base, dest);
    635             return;
    636         }
    637 
    638         RegisterID scr;
    639         if (dest == base)
    640             scr = claimScratch();
    641         else
    642             scr = dest;
     647        RegisterID scr = (dest == base) ? claimScratch() : dest;
     648
    643649        m_assembler.loadConstant(offset, scr);
    644         m_assembler.addlRegReg(base, scr);
    645         m_assembler.movlMemReg(scr, dest);
     650        if (base == SH4Registers::r0)
     651            m_assembler.movlR0mr(scr, dest);
     652        else {
     653            m_assembler.addlRegReg(base, scr);
     654            m_assembler.movlMemReg(scr, dest);
     655        }
    646656
    647657        if (dest == base)
    … …  
    661671        }
    662672
    663         if (base != dest) {
    664             m_assembler.loadConstant(offset, dest);
    665             m_assembler.addlRegReg(base, dest);
    666             m_assembler.movbMemReg(dest, dest);
    667             return;
    668         }
    669 
    670         RegisterID scr = claimScratch();
     673        RegisterID scr = (dest == base) ? claimScratch() : dest;
     674
    671675        m_assembler.loadConstant(offset, scr);
    672         m_assembler.addlRegReg(base, scr);
    673         m_assembler.movbMemReg(scr, dest);
    674         releaseScratch(scr);
     676        if (base == SH4Registers::r0)
     677            m_assembler.movbR0mr(scr, dest);
     678        else {
     679            m_assembler.addlRegReg(base, scr);
     680            m_assembler.movbMemReg(scr, dest);
     681        }
     682
     683        if (dest == base)
     684            releaseScratch(scr);
    675685    }
    676686
    … …  
    681691    }
    682692
    683     void load32(RegisterID r0, RegisterID src, RegisterID dst)
    684     {
    685         ASSERT(r0 == SH4Registers::r0);
    686         m_assembler.movlR0mr(src, dst);
    687     }
    688 
    689693    void load32(RegisterID src, RegisterID dst)
    690694    {
    … …  
    696700        if (!address.offset) {
    697701            m_assembler.movwMemReg(address.base, dest);
    698             extuw(dest, dest);
     702            m_assembler.extuw(dest, dest);
    699703            return;
    700704        }
    … …  
    702706        if ((address.offset > 0) && (address.offset <= 30) && (dest == SH4Registers::r0)) {
    703707            m_assembler.movwMemReg(address.offset >> 1, address.base, dest);
    704             extuw(dest, dest);
    705             return;
    706         }
    707 
    708         if (address.base != dest) {
    709             m_assembler.loadConstant(address.offset, dest);
    710             m_assembler.addlRegReg(address.base, dest);
    711             m_assembler.movwMemReg(dest, dest);
    712             extuw(dest, dest);
    713             return;
    714         }
    715 
    716         RegisterID scr = claimScratch();
     708            m_assembler.extuw(dest, dest);
     709            return;
     710        }
     711
     712        RegisterID scr = (dest == address.base) ? claimScratch() : dest;
     713
    717714        m_assembler.loadConstant(address.offset, scr);
    718         m_assembler.addlRegReg(address.base, scr);
    719         m_assembler.movwMemReg(scr, dest);
    720         extuw(dest, dest);
    721         releaseScratch(scr);
     715        if (address.base == SH4Registers::r0)
     716            m_assembler.movwR0mr(scr, dest);
     717        else {
     718            m_assembler.addlRegReg(address.base, scr);
     719            m_assembler.movwMemReg(scr, dest);
     720        }
     721        m_assembler.extuw(dest, dest);
     722
     723        if (dest == address.base)
     724            releaseScratch(scr);
    722725    }
    723726
    724727    void load16Unaligned(BaseIndex address, RegisterID dest)
    725728    {
    726 
    727729        RegisterID scr = claimScratch();
    728730        RegisterID scr1 = claimScratch();
    … …  
    748750    {
    749751        m_assembler.movwMemReg(src, dest);
    750         extuw(dest, dest);
     752        m_assembler.extuw(dest, dest);
    751753    }
    752754
    … …  
    756758    }
    757759
    758     void load16(RegisterID r0, RegisterID src, RegisterID dest)
    759     {
    760         ASSERT(r0 == SH4Registers::r0);
    761         m_assembler.movwR0mr(src, dest);
    762         extuw(dest, dest);
    763     }
    764 
    765     void load16Signed(RegisterID r0, RegisterID src, RegisterID dest)
    766     {
    767         ASSERT(r0 == SH4Registers::r0);
    768         m_assembler.movwR0mr(src, dest);
    769     }
    770 
    771760    void load16(BaseIndex address, RegisterID dest)
     761    {
     762        load16Signed(address, dest);
     763        m_assembler.extuw(dest, dest);
     764    }
     765
     766    void load16Signed(BaseIndex address, RegisterID dest)
    772767    {
    773768        RegisterID scr = claimScratch();
    … …  
    778773        if (address.offset)
    779774            add32(TrustedImm32(address.offset), scr);
     775
    780776        if (address.base == SH4Registers::r0)
    781             load16(address.base, scr, dest);
    782         else {
    783             add32(address.base, scr);
    784             load16(scr, dest);
    785         }
    786 
    787         releaseScratch(scr);
    788     }
    789 
    790     void load16Signed(BaseIndex address, RegisterID dest)
    791     {
    792         RegisterID scr = claimScratch();
    793 
    794         move(address.index, scr);
    795         lshift32(TrustedImm32(address.scale), scr);
    796 
    797         if (address.offset)
    798             add32(TrustedImm32(address.offset), scr);
    799         if (address.base == SH4Registers::r0)
    800             load16Signed(address.base, scr, dest);
     777            m_assembler.movwR0mr(scr, dest);
    801778        else {
    802779            add32(address.base, scr);
    … …  
    813790        move(address.index, scr);
    814791        lshift32(TrustedImm32(address.scale), scr);
    815         add32(address.base, scr);
    816 
    817         m_assembler.movbRegMem(src, scr);
     792        add32(TrustedImm32(address.offset), scr);
     793
     794        if (address.base == SH4Registers::r0)
     795            m_assembler.movbRegMemr0(src, scr);
     796        else {
     797            add32(address.base, scr);
     798            m_assembler.movbRegMem(src, scr);
     799        }
    818800
    819801        releaseScratch(scr);
    … …  
    826808        move(address.index, scr);
    827809        lshift32(TrustedImm32(address.scale), scr);
    828         add32(address.base, scr);
    829 
    830         m_assembler.movwRegMem(src, scr);
     810        add32(TrustedImm32(address.offset), scr);
     811
     812        if (address.base == SH4Registers::r0)
     813            m_assembler.movwRegMemr0(src, scr);
     814        else {
     815            add32(address.base, scr);
     816            m_assembler.movwRegMem(src, scr);
     817        }
    831818
    832819        releaseScratch(scr);
    … …  
    835822    void store32(RegisterID src, ImplicitAddress address)
    836823    {
    837         RegisterID scr = claimScratch();
    838         store32(src, address.offset, address.base, scr);
    839         releaseScratch(scr);
    840     }
    841 
    842     void store32(RegisterID src, int offset, RegisterID base, RegisterID scr)
    843     {
    844         if (!offset) {
    845             m_assembler.movlRegMem(src, base);
    846             return;
    847         }
    848 
    849         if ((offset >= 0) && (offset < 64)) {
    850             m_assembler.movlRegMem(src, offset >> 2, base);
    851             return;
    852         }
    853 
    854         m_assembler.loadConstant(offset, scr);
    855         if (scr == SH4Registers::r0) {
    856             m_assembler.movlRegMemr0(src, base);
    857             return;
    858         }
    859 
    860         m_assembler.addlRegReg(base, scr);
    861         m_assembler.movlRegMem(src, scr);
    862     }
    863 
    864     void store32(RegisterID src, RegisterID offset, RegisterID base)
    865     {
    866         ASSERT(offset == SH4Registers::r0);
    867         m_assembler.movlRegMemr0(src, base);
     824        if (!address.offset) {
     825            m_assembler.movlRegMem(src, address.base);
     826            return;
     827        }
     828
     829        if ((address.offset >= 0) && (address.offset < 64)) {
     830            m_assembler.movlRegMem(src, address.offset >> 2, address.base);
     831            return;
     832        }
     833
     834        RegisterID scr = claimScratch();
     835        m_assembler.loadConstant(address.offset, scr);
     836        if (address.base == SH4Registers::r0)
     837            m_assembler.movlRegMemr0(src, scr);
     838        else {
     839            m_assembler.addlRegReg(address.base, scr);
     840            m_assembler.movlRegMem(src, scr);
     841        }
     842        releaseScratch(scr);
    868843    }
    869844
    … …  
    876851    {
    877852        RegisterID scr = claimScratch();
    878         RegisterID scr1 = claimScratch();
    879853        m_assembler.loadConstant(imm.m_value, scr);
    880         store32(scr, address.offset, address.base, scr1);
    881         releaseScratch(scr);
    882         releaseScratch(scr1);
     854        store32(scr, address);
     855        releaseScratch(scr);
    883856    }
    884857
    … …  
    15741547    {
    15751548        m_assembler.loadConstant(imm.asIntptr(), dest);
    1576     }
    1577 
    1578     void extuw(RegisterID src, RegisterID dst)
    1579     {
    1580         m_assembler.extuw(src, dst);
    15811549    }
    15821550

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

    r149403 r149634  
    116116    MOVL_READ_OFFRM_OPCODE = 0x5000,
    117117    MOVW_WRITE_RN_OPCODE = 0x2001,
     118    MOVW_WRITE_R0RN_OPCODE = 0x0005,
    118119    MOVW_READ_RM_OPCODE = 0x6001,
    119120    MOVW_READ_R0RM_OPCODE = 0x000d,
    … …  
    10611062    }
    10621063
     1064    void movwRegMemr0(RegisterID src, RegisterID dst)
     1065    {
     1066        uint16_t opc = getOpcodeGroup1(MOVW_WRITE_R0RN_OPCODE, dst, src);
     1067        oneShortOp(opc);
     1068    }
     1069
    10631070    void movlRegMem(RegisterID src, int offset, RegisterID base)
    10641071    {
    … …  
    11241131    {
    11251132        uint16_t opc = getOpcodeGroup1(MOVB_READ_RM_OPCODE, dst, src);
     1133        oneShortOp(opc);
     1134    }
     1135
     1136    void movbRegMemr0(RegisterID src, RegisterID dst)
     1137    {
     1138        uint16_t opc = getOpcodeGroup1(MOVB_WRITE_R0RN_OPCODE, dst, src);
    11261139        oneShortOp(opc);
    11271140    }
    … …  
    13811394    static SH4Buffer::TwoShorts placeConstantPoolBarrier(int offset)
    13821395    {
    1383         ASSERT(((offset >> 1) <=2047) && ((offset >> 1) >= -2048));
     1396        ASSERT(((offset >> 1) <= 2047) && ((offset >> 1) >= -2048));
    13841397
    13851398        SH4Buffer::TwoShorts m_barrier;
    … …  
    14751488    static ptrdiff_t maxJumpReplacementSize()
    14761489    {
    1477         return sizeof(SH4Word) * 7;
     1490        return sizeof(SH4Word) * 6;
    14781491    }
    14791492
    … …  
    14841497        int nbinst = 0;
    14851498
    1486         if ((difference >= -2048) && (difference <= 2047)) {
     1499        if ((difference >= -4096) && (difference <= 4094)) {
    14871500            instruction[0] = getOpcodeGroup6(BRA_OPCODE, difference >> 1);
    14881501            instruction[1] = NOP_OPCODE;
    … …  
    14911504        }
    14921505
    1493         if (reinterpret_cast<unsigned>(instruction) & 3)
    1494             instruction[nbinst++] = NOP_OPCODE;
    1495 
    14961506        instruction[nbinst++] = getOpcodeGroup3(MOVL_READ_OFFPC_OPCODE, scratchReg2, 1);
    14971507        instruction[nbinst++] = getOpcodeGroup2(JMP_OPCODE, scratchReg2);
    14981508        instruction[nbinst++] = NOP_OPCODE;
    1499         instruction[nbinst++] = NOP_OPCODE;
     1509
     1510        if (!(reinterpret_cast<unsigned>(instruction) & 3))
     1511            instruction[nbinst++] = NOP_OPCODE;
     1512
    15001513        instruction[nbinst++] = reinterpret_cast<unsigned>(to) & 0xffff;
    15011514        instruction[nbinst++] = reinterpret_cast<unsigned>(to) >> 16;
    … …  
    19491962            format = "    MOV.W @(R0, R%d), R%d\n";
    19501963            break;
     1964        case MOVW_WRITE_R0RN_OPCODE:
     1965            format = "    MOV.W R%d, @(R0, R%d)\n";
     1966            break;
    19511967        case EXTUB_OPCODE:
    19521968            format = "    EXTU.B R%d, R%d\n";
Note: See TracChangeset for help on using the changeset viewer.