Changeset 102389 in webkit


Ignore:
Timestamp:
Dec 8, 2011 3:16:54 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

​https://bugs.webkit.org/show_bug.cgi?id=74005
fix unaligned access memory in generatePatternCharacterOnce function
for SH4 platforms.

Patch by Thouraya ANDOLSI <​thouraya.andolsi@st.com> on 2011-12-08
Reviewed by Gavin Barraclough.

  • assembler/MacroAssemblerARM.h:

(JSC::MacroAssemblerARM::load16Unaligned):

  • assembler/MacroAssemblerARMv7.h:

(JSC::MacroAssemblerARMv7::load16Unaligned):

  • assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::load16Unaligned):

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::lshift32):
(JSC::MacroAssemblerSH4::load8):
(JSC::MacroAssemblerSH4::load16):
(JSC::MacroAssemblerSH4::load16Unaligned):
(JSC::MacroAssemblerSH4::branch8):

  • assembler/MacroAssemblerX86Common.h:

(JSC::MacroAssemblerX86Common::load16Unaligned):

  • jit/JIT.h:
  • yarr/YarrJIT.cpp:

(JSC::Yarr::YarrGenerator::generatePatternCharacterOnce):

Location:
trunk/Source/JavaScriptCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r102380 r102389  
     12011-12-08  Thouraya ANDOLSI  <thouraya.andolsi@st.com>
     2
     3        https://bugs.webkit.org/show_bug.cgi?id=74005
     4        fix unaligned access memory in generatePatternCharacterOnce function
     5        for SH4 platforms.
     6
     7        Reviewed by Gavin Barraclough.
     8
     9        * assembler/MacroAssemblerARM.h:
     10        (JSC::MacroAssemblerARM::load16Unaligned):
     11        * assembler/MacroAssemblerARMv7.h:
     12        (JSC::MacroAssemblerARMv7::load16Unaligned):
     13        * assembler/MacroAssemblerMIPS.h:
     14        (JSC::MacroAssemblerMIPS::load16Unaligned):
     15        * assembler/MacroAssemblerSH4.h:
     16        (JSC::MacroAssemblerSH4::lshift32):
     17        (JSC::MacroAssemblerSH4::load8):
     18        (JSC::MacroAssemblerSH4::load16):
     19        (JSC::MacroAssemblerSH4::load16Unaligned):
     20        (JSC::MacroAssemblerSH4::branch8):
     21        * assembler/MacroAssemblerX86Common.h:
     22        (JSC::MacroAssemblerX86Common::load16Unaligned):
     23        * jit/JIT.h:
     24        * yarr/YarrJIT.cpp:
     25        (JSC::Yarr::YarrGenerator::generatePatternCharacterOnce):
     26
    1272011-12-08  Michael Saboff  <msaboff@apple.com>
    228

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

    r101473 r102389  
    282282    }
    283283#endif
     284
     285    void load16Unaligned(BaseIndex address, RegisterID dest)
     286    {
     287        load16(address, dest);
     288    }
    284289
    285290    DataLabel32 load32WithAddressOffsetPatch(Address address, RegisterID dest)

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

    r102038 r102389  
    576576    }
    577577
     578    void load16Unaligned(BaseIndex address, RegisterID dest)
     579    {
     580        load16(setupArmAddress(address), dest);
     581    }
     582
    578583    void load32(const void* address, RegisterID dest)
    579584    {

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

    r101658 r102389  
    575575            m_assembler.lw(dest, addrTempRegister, address.offset);
    576576        }
     577    }
     578
     579    void load16Unaligned(BaseIndex address, RegisterID dest)
     580    {
     581        load16(address, dest);
    577582    }
    578583

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

    r101980 r102389  
    159159    void lshift32(RegisterID shiftamount, RegisterID dest)
    160160    {
     161        if (shiftamount == SH4Registers::r0)
     162            m_assembler.andlImm8r(0x1f, shiftamount);
     163        else {
     164            RegisterID scr = claimScratch();
     165            m_assembler.loadConstant(0x1f, scr);
     166            m_assembler.andlRegReg(scr, shiftamount);
     167            releaseScratch(scr);
     168        }
    161169        m_assembler.shllRegReg(dest, shiftamount);
    162170    }
    … …  
    172180    void lshift32(TrustedImm32 imm, RegisterID dest)
    173181    {
     182        if (!imm.m_value)
     183            return;
     184
    174185        if ((imm.m_value == 1) || (imm.m_value == 2) || (imm.m_value == 8) || (imm.m_value == 16)) {
    175186            m_assembler.shllImm8r(imm.m_value, dest);
    … …  
    178189
    179190        RegisterID scr = claimScratch();
    180         m_assembler.loadConstant(imm.m_value, scr);
     191        m_assembler.loadConstant((imm.m_value & 0x1f) , scr);
    181192        m_assembler.shllRegReg(dest, scr);
    182193        releaseScratch(scr);
    … …  
    236247    void rshift32(RegisterID shiftamount, RegisterID dest)
    237248    {
    238         compare32(32, shiftamount, Equal);
    239         m_assembler.ensureSpace(m_assembler.maxInstructionSize + 4);
    240         m_assembler.branch(BT_OPCODE, 1);
     249        if (shiftamount == SH4Registers::r0)
     250            m_assembler.andlImm8r(0x1f, shiftamount);
     251        else {
     252            RegisterID scr = claimScratch();
     253            m_assembler.loadConstant(0x1f, scr);
     254            m_assembler.andlRegReg(scr, shiftamount);
     255            releaseScratch(scr);
     256        }
    241257        m_assembler.neg(shiftamount, shiftamount);
    242258        m_assembler.shaRegReg(dest, shiftamount);
    … …  
    583599        if (!offset) {
    584600            m_assembler.movbMemReg(base, dest);
     601            m_assembler.extub(dest, dest);
    585602            return;
    586603        }
    … …  
    588605        if ((offset > 0) && (offset < 64) && (dest == SH4Registers::r0)) {
    589606            m_assembler.movbMemReg(offset, base, dest);
     607            m_assembler.extub(dest, dest);
    590608            return;
    591609        }
    … …  
    595613            m_assembler.addlRegReg(base, dest);
    596614            m_assembler.movbMemReg(dest, dest);
     615            m_assembler.extub(dest, dest);
    597616            return;
    598617        }
    … …  
    602621        m_assembler.addlRegReg(base, scr);
    603622        m_assembler.movbMemReg(scr, dest);
     623        m_assembler.extub(dest, dest);
    604624        releaseScratch(scr);
    605625    }
    … …  
    620640        if (!address.offset) {
    621641            m_assembler.movwMemReg(address.base, dest);
     642            extuw(dest, dest);
    622643            return;
    623644        }
    … …  
    625646        if ((address.offset > 0) && (address.offset < 64) && (dest == SH4Registers::r0)) {
    626647            m_assembler.movwMemReg(address.offset, address.base, dest);
     648            extuw(dest, dest);
    627649            return;
    628650        }
    … …  
    632654            m_assembler.addlRegReg(address.base, dest);
    633655            m_assembler.movwMemReg(dest, dest);
     656            extuw(dest, dest);
    634657            return;
    635658        }
    … …  
    639662        m_assembler.addlRegReg(address.base, scr);
    640663        m_assembler.movwMemReg(scr, dest);
    641         releaseScratch(scr);
     664        extuw(dest, dest);
     665        releaseScratch(scr);
     666    }
     667
     668    void load16Unaligned(BaseIndex address, RegisterID dest)
     669    {
     670
     671        RegisterID scr = claimScratch();
     672        RegisterID scr1 = claimScratch();
     673
     674        move(address.index, scr);
     675        lshift32(TrustedImm32(address.scale), scr);
     676
     677        if (address.offset)
     678            add32(TrustedImm32(address.offset), scr);
     679
     680        add32(address.base, scr);
     681        load8(scr, scr1);
     682        add32(TrustedImm32(1), scr);
     683        load8(scr, dest);
     684        move(TrustedImm32(8), scr);
     685        m_assembler.shllRegReg(dest, scr);
     686        or32(scr1, dest);
     687
     688        releaseScratch(scr);
     689        releaseScratch(scr1);
    642690    }
    643691
    … …  
    645693    {
    646694        m_assembler.movwMemReg(src, dest);
     695        extuw(dest, dest);
    647696    }
    648697
    … …  
    651700        ASSERT(r0 == SH4Registers::r0);
    652701        m_assembler.movwR0mr(src, dest);
     702        extuw(dest, dest);
    653703    }
    654704
    … …  
    662712        if (address.offset)
    663713            add32(TrustedImm32(address.offset), scr);
    664         if (scr == SH4Registers::r0)
    665             m_assembler.movwR0mr(address.base, scr);
     714        if (address.base == SH4Registers::r0)
     715            load16(address.base, scr, dest);
    666716        else {
    667717            add32(address.base, scr);
    668             load16(scr, scr);
    669         }
    670 
    671         extuw(scr, dest);
     718            load16(scr, dest);
     719        }
     720
    672721        releaseScratch(scr);
    673722    }
    … …  
    12301279    void move(RegisterID src, RegisterID dest)
    12311280    {
    1232         m_assembler.movlRegReg(src, dest);
     1281        if (src != dest)
     1282            m_assembler.movlRegReg(src, dest);
    12331283    }
    12341284
    … …  
    13871437        add32(left.base, scr);
    13881438        load8(scr, scr);
    1389         m_assembler.extub(scr, scr);
    13901439        RegisterID scr1 = claimScratch();
    13911440        m_assembler.loadConstant(right.m_value, scr1);
    … …  
    16401689    void urshift32(RegisterID shiftamount, RegisterID dest)
    16411690    {
    1642         compare32(32, shiftamount, Equal);
    1643         m_assembler.ensureSpace(m_assembler.maxInstructionSize + 4);
    1644         m_assembler.branch(BT_OPCODE, 1);
     1691        if (shiftamount == SH4Registers::r0)
     1692            m_assembler.andlImm8r(0x1f, shiftamount);
     1693        else {
     1694            RegisterID scr = claimScratch();
     1695            m_assembler.loadConstant(0x1f, scr);
     1696            m_assembler.andlRegReg(scr, shiftamount);
     1697            releaseScratch(scr);
     1698        }
    16451699        m_assembler.neg(shiftamount, shiftamount);
    16461700        m_assembler.shllRegReg(dest, shiftamount);
    … …  
    16501704    {
    16511705        RegisterID scr = claimScratch();
    1652         m_assembler.loadConstant(-(imm.m_value), scr);
     1706        m_assembler.loadConstant(-(imm.m_value & 0x1f), scr);
    16531707        m_assembler.shaRegReg(dest, scr);
    16541708        releaseScratch(scr);

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

    r101886 r102389  
    445445    {
    446446        load32(address, dest);
     447    }
     448
     449    void load16Unaligned(BaseIndex address, RegisterID dest)
     450    {
     451        load16(address, dest);
    447452    }
    448453

  • trunk/Source/JavaScriptCore/yarr/YarrJIT.cpp

    r98624 r102389  
    700700                if (m_charSize == Char8) {
    701701                    BaseIndex address(input, index, TimesOne, (term->inputPosition - m_checked) * sizeof(char));
    702                     load16(address, character);
     702                    load16Unaligned(address, character);
    703703                } else {
    704704                    BaseIndex address(input, index, TimesTwo, (term->inputPosition - m_checked) * sizeof(UChar));
Note: See TracChangeset for help on using the changeset viewer.