Changeset 112192 in webkit for trunk/Source/JavaScriptCore


Ignore:
Timestamp:
Mar 26, 2012, 7:03:47 PM (13 years ago)
Author:
[email protected]
Message:

Unaligned userspace access for SH4 platforms
​https://bugs.webkit.org/show_bug.cgi?id=79104

Patch by Thouraya ANDOLSI <​[email protected]> on 2012-03-26
Reviewed by Gavin Barraclough.

  • assembler/AbstractMacroAssembler.h:

(Jump):
(JSC::AbstractMacroAssembler::Jump::Jump):
(JSC::AbstractMacroAssembler::Jump::link):

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::load16Unaligned):
(JSC::MacroAssemblerSH4::load32WithUnalignedHalfWords):
(JSC::MacroAssemblerSH4::branchDouble):
(JSC::MacroAssemblerSH4::branchTrue):
(JSC::MacroAssemblerSH4::branchFalse):

  • assembler/SH4Assembler.h:

(JSC::SH4Assembler::extraInstrForBranch):
(SH4Assembler):
(JSC::SH4Assembler::bra):
(JSC::SH4Assembler::linkJump):

  • jit/JIT.h:

(JIT):

  • yarr/YarrJIT.cpp:

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

Location:
trunk/Source/JavaScriptCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r112177 r112192  
     12012-03-26  Thouraya ANDOLSI  <[email protected]>
     2
     3        Unaligned userspace access for SH4 platforms
     4        https://bugs.webkit.org/show_bug.cgi?id=79104
     5
     6        Reviewed by Gavin Barraclough.
     7
     8        * assembler/AbstractMacroAssembler.h:
     9        (Jump):
     10        (JSC::AbstractMacroAssembler::Jump::Jump):
     11        (JSC::AbstractMacroAssembler::Jump::link):
     12        * assembler/MacroAssemblerSH4.h:
     13        (JSC::MacroAssemblerSH4::load16Unaligned):
     14        (JSC::MacroAssemblerSH4::load32WithUnalignedHalfWords):
     15        (JSC::MacroAssemblerSH4::branchDouble):
     16        (JSC::MacroAssemblerSH4::branchTrue):
     17        (JSC::MacroAssemblerSH4::branchFalse):
     18        * assembler/SH4Assembler.h:
     19        (JSC::SH4Assembler::extraInstrForBranch):
     20        (SH4Assembler):
     21        (JSC::SH4Assembler::bra):
     22        (JSC::SH4Assembler::linkJump):
     23        * jit/JIT.h:
     24        (JIT):
     25        * yarr/YarrJIT.cpp:
     26        (JSC::Yarr::YarrGenerator::generatePatternCharacterOnce):
     27
    1282012-03-26  Ryosuke Niwa  <[email protected]>
    229

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

    r110206 r112192  
    451451        {
    452452        }
     453#elif CPU(SH4)
     454        Jump(AssemblerLabel jmp, SH4Assembler::JumpType type = SH4Assembler::JumpFar)
     455            : m_label(jmp)
     456            , m_type(type)
     457        {
     458        }
    453459#else
    454460        Jump(AssemblerLabel jmp)   
    … …  
    462468#if CPU(ARM_THUMB2)
    463469            masm->m_assembler.linkJump(m_label, masm->m_assembler.label(), m_type, m_condition);
     470#elif CPU(SH4)
     471            masm->m_assembler.linkJump(m_label, masm->m_assembler.label(), m_type);
    464472#else
    465473            masm->m_assembler.linkJump(m_label, masm->m_assembler.label());
    … …  
    483491        ARMv7Assembler::JumpType m_type;
    484492        ARMv7Assembler::Condition m_condition;
     493#endif
     494#if CPU(SH4)
     495        SH4Assembler::JumpType m_type;
    485496#endif
    486497    };

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

    r110289 r112192  
    682682        add32(TrustedImm32(1), scr);
    683683        load8(scr, dest);
    684         move(TrustedImm32(8), scr);
    685         m_assembler.shllRegReg(dest, scr);
     684        m_assembler.shllImm8r(8, dest);
    686685        or32(scr1, dest);
    687686
    … …  
    943942    {
    944943        RegisterID scr = claimScratch();
     944        RegisterID scr1 = claimScratch();
     945        Jump m_jump;
     946        JumpList end;
     947
     948        if (dest != SH4Registers::r0)
     949            move(SH4Registers::r0, scr1);
    945950
    946951        move(address.index, scr);
    … …  
    951956            add32(TrustedImm32(address.offset), scr);
    952957
    953         RegisterID scr1 = claimScratch();
     958        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 68, sizeof(uint32_t));
     959        move(scr, SH4Registers::r0);
     960        m_assembler.andlImm8r(0x3, SH4Registers::r0);
     961        m_assembler.cmpEqImmR0(0x0, SH4Registers::r0);
     962        m_jump = Jump(m_assembler.jne(), SH4Assembler::JumpNear);
     963        if (dest != SH4Registers::r0)
     964            move(scr1, SH4Registers::r0);
     965
     966        load32(scr, dest);
     967        end.append(Jump(m_assembler.bra(), SH4Assembler::JumpNear));
     968        m_assembler.nop();
     969        m_jump.link(this);
     970        m_assembler.andlImm8r(0x1, SH4Registers::r0);
     971        m_assembler.cmpEqImmR0(0x0, SH4Registers::r0);
     972
     973        if (dest != SH4Registers::r0)
     974            move(scr1, SH4Registers::r0);
     975
     976        m_jump = Jump(m_assembler.jne(), SH4Assembler::JumpNear);
    954977        load16(scr, scr1);
    955978        add32(TrustedImm32(2), scr);
    956979        load16(scr, dest);
    957         move(TrustedImm32(16), scr);
    958         m_assembler.shllRegReg(dest, scr);
     980        m_assembler.shllImm8r(16, dest);
    959981        or32(scr1, dest);
     982        end.append(Jump(m_assembler.bra(), SH4Assembler::JumpNear));
     983        m_assembler.nop();
     984        m_jump.link(this);
     985        load8(scr, scr1);
     986        add32(TrustedImm32(1), scr);
     987        load16(scr, dest);
     988        m_assembler.shllImm8r(8, dest);
     989        or32(dest, scr1);
     990        add32(TrustedImm32(2), scr);
     991        load8(scr, dest);
     992        m_assembler.shllImm8r(8, dest);
     993        m_assembler.shllImm8r(16, dest);
     994        or32(scr1, dest);
     995        end.link(this);
    960996
    961997        releaseScratch(scr);
    … …  
    10001036        if (cond == DoubleNotEqual) {
    10011037            RegisterID scr = claimScratch();
     1038            JumpList end;
    10021039            m_assembler.loadConstant(0x7fbfffff, scratchReg3);
    10031040            m_assembler.dcnvds(right);
    … …  
    10051042            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    10061043            m_assembler.ensureSpace(m_assembler.maxInstructionSize + 22, sizeof(uint32_t));
    1007             m_assembler.branch(BT_OPCODE, 8);
     1044            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10081045            m_assembler.dcnvds(left);
    10091046            m_assembler.stsfpulReg(scr);
    10101047            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    1011             m_assembler.branch(BT_OPCODE, 4);
     1048            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10121049            m_assembler.dcmppeq(right, left);
    10131050            releaseScratch(scr);
    1014             return branchFalse();
     1051            Jump m_jump = branchFalse();
     1052            end.link(this);
     1053            return m_jump;
    10151054        }
    10161055
    … …  
    10371076        if (cond == DoubleEqualOrUnordered) {
    10381077            RegisterID scr = claimScratch();
     1078            JumpList end;
    10391079            m_assembler.loadConstant(0x7fbfffff, scratchReg3);
    10401080            m_assembler.dcnvds(right);
    … …  
    10421082            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    10431083            m_assembler.ensureSpace(m_assembler.maxInstructionSize + 22, sizeof(uint32_t));
    1044             m_assembler.branch(BT_OPCODE, 5);
     1084            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10451085            m_assembler.dcnvds(left);
    10461086            m_assembler.stsfpulReg(scr);
    10471087            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    1048             m_assembler.branch(BT_OPCODE, 1);
     1088            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10491089            m_assembler.dcmppeq(left, right);
     1090            Jump m_jump = Jump(m_assembler.je());
     1091            end.link(this);
     1092            m_assembler.extraInstrForBranch(scr);
    10501093            releaseScratch(scr);
    1051             return branchTrue();
     1094            return m_jump;
    10521095        }
    10531096
    10541097        if (cond == DoubleGreaterThanOrUnordered) {
    10551098            RegisterID scr = claimScratch();
     1099            JumpList end;
    10561100            m_assembler.loadConstant(0x7fbfffff, scratchReg3);
    10571101            m_assembler.dcnvds(right);
    … …  
    10591103            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    10601104            m_assembler.ensureSpace(m_assembler.maxInstructionSize + 22, sizeof(uint32_t));
    1061             m_assembler.branch(BT_OPCODE, 5);
     1105            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10621106            m_assembler.dcnvds(left);
    10631107            m_assembler.stsfpulReg(scr);
    10641108            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    1065             m_assembler.branch(BT_OPCODE, 1);
     1109            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10661110            m_assembler.dcmppgt(right, left);
     1111            Jump m_jump = Jump(m_assembler.je());
     1112            end.link(this);
     1113            m_assembler.extraInstrForBranch(scr);
    10671114            releaseScratch(scr);
    1068             return branchTrue();
     1115            return m_jump;
    10691116        }
    10701117
    10711118        if (cond == DoubleGreaterThanOrEqualOrUnordered) {
    10721119            RegisterID scr = claimScratch();
     1120            JumpList end;
    10731121            m_assembler.loadConstant(0x7fbfffff, scratchReg3);
    10741122            m_assembler.dcnvds(right);
    … …  
    10761124            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    10771125            m_assembler.ensureSpace(m_assembler.maxInstructionSize + 22, sizeof(uint32_t));
    1078             m_assembler.branch(BT_OPCODE, 5);
     1126            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10791127            m_assembler.dcnvds(left);
    10801128            m_assembler.stsfpulReg(scr);
    10811129            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    1082             m_assembler.branch(BT_OPCODE, 1);
     1130            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10831131            m_assembler.dcmppgt(left, right);
     1132            Jump m_jump = Jump(m_assembler.jne());
     1133            end.link(this);
     1134            m_assembler.extraInstrForBranch(scr);
    10841135            releaseScratch(scr);
    1085             return branchFalse();
     1136            return m_jump;
    10861137        }
    10871138
    10881139        if (cond == DoubleLessThanOrUnordered) {
    10891140            RegisterID scr = claimScratch();
     1141            JumpList end;
    10901142            m_assembler.loadConstant(0x7fbfffff, scratchReg3);
    10911143            m_assembler.dcnvds(right);
    … …  
    10931145            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    10941146            m_assembler.ensureSpace(m_assembler.maxInstructionSize + 22, sizeof(uint32_t));
    1095             m_assembler.branch(BT_OPCODE, 5);
     1147            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    10961148            m_assembler.dcnvds(left);
    10971149            m_assembler.stsfpulReg(scr);
    10981150            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    1099             m_assembler.branch(BT_OPCODE, 1);
     1151            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    11001152            m_assembler.dcmppgt(left, right);
     1153            Jump m_jump = Jump(m_assembler.je());
     1154            end.link(this);
     1155            m_assembler.extraInstrForBranch(scr);
    11011156            releaseScratch(scr);
    1102             return branchTrue();
     1157            return m_jump;
    11031158        }
    11041159
    11051160        if (cond == DoubleLessThanOrEqualOrUnordered) {
    11061161            RegisterID scr = claimScratch();
     1162            JumpList end;
    11071163            m_assembler.loadConstant(0x7fbfffff, scratchReg3);
    11081164            m_assembler.dcnvds(right);
    … …  
    11101166            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    11111167            m_assembler.ensureSpace(m_assembler.maxInstructionSize + 22, sizeof(uint32_t));
    1112             m_assembler.branch(BT_OPCODE, 5);
     1168            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    11131169            m_assembler.dcnvds(left);
    11141170            m_assembler.stsfpulReg(scr);
    11151171            m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    1116             m_assembler.branch(BT_OPCODE, 1);
     1172            end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    11171173            m_assembler.dcmppgt(right, left);
     1174            Jump m_jump = Jump(m_assembler.jne());
     1175            end.link(this);
     1176            m_assembler.extraInstrForBranch(scr);
    11181177            releaseScratch(scr);
    1119             return branchFalse();
     1178            return m_jump;
    11201179        }
    11211180
    11221181        ASSERT(cond == DoubleNotEqualOrUnordered);
    11231182        RegisterID scr = claimScratch();
     1183        JumpList end;
    11241184        m_assembler.loadConstant(0x7fbfffff, scratchReg3);
    11251185        m_assembler.dcnvds(right);
    … …  
    11271187        m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    11281188        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 22, sizeof(uint32_t));
    1129         m_assembler.branch(BT_OPCODE, 5);
     1189        end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    11301190        m_assembler.dcnvds(left);
    11311191        m_assembler.stsfpulReg(scr);
    11321192        m_assembler.cmplRegReg(scratchReg3, scr, SH4Condition(Equal));
    1133         m_assembler.branch(BT_OPCODE, 1);
     1193        end.append(Jump(m_assembler.je(), SH4Assembler::JumpNear));
    11341194        m_assembler.dcmppeq(right, left);
    1135         releaseScratch(scr);
    1136         return branchFalse();
     1195        Jump m_jump = Jump(m_assembler.jne());
     1196        end.link(this);
     1197        m_assembler.extraInstrForBranch(scr);
     1198        releaseScratch(scr);
     1199        return m_jump;
    11371200    }
    11381201
    … …  
    11411204        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 6, sizeof(uint32_t));
    11421205        Jump m_jump = Jump(m_assembler.je());
    1143         m_assembler.loadConstantUnReusable(0x0, scratchReg3);
    1144         m_assembler.nop();
    1145         m_assembler.nop();
     1206        m_assembler.extraInstrForBranch(scratchReg3);
    11461207        return m_jump;
    11471208    }
    … …  
    11511212        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 6, sizeof(uint32_t));
    11521213        Jump m_jump = Jump(m_assembler.jne());
    1153         m_assembler.loadConstantUnReusable(0x0, scratchReg3);
    1154         m_assembler.nop();
    1155         m_assembler.nop();
     1214        m_assembler.extraInstrForBranch(scratchReg3);
    11561215        return m_jump;
    11571216    }

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

    r109307 r112192  
    327327    };
    328328
     329    enum JumpType { JumpFar,
     330                    JumpNear
     331    };
     332
    329333    SH4Assembler()
    330334    {
    … …  
    11891193    }
    11901194
     1195    void extraInstrForBranch(RegisterID dst)
     1196    {
     1197        loadConstantUnReusable(0x0, dst);
     1198        nop();
     1199        nop();
     1200    }
     1201
    11911202    AssemblerLabel jmp(RegisterID dst)
    11921203    {
    … …  
    12131224        AssemblerLabel label = m_buffer.label();
    12141225        branch(BT_OPCODE, 0);
     1226        return label;
     1227    }
     1228
     1229    AssemblerLabel bra()
     1230    {
     1231        AssemblerLabel label = m_buffer.label();
     1232        branch(BRA_OPCODE, 0);
    12151233        return label;
    12161234    }
    … …  
    14251443    // Linking & patching
    14261444
    1427     void linkJump(AssemblerLabel from, AssemblerLabel to)
     1445    void linkJump(AssemblerLabel from, AssemblerLabel to, JumpType type = JumpFar)
    14281446    {
    14291447        ASSERT(to.isSet());
    … …  
    14331451        uint16_t instruction = *instructionPtr;
    14341452        int offsetBits;
     1453
     1454        if (type == JumpNear) {
     1455            ASSERT((instruction ==  BT_OPCODE) || (instruction == BF_OPCODE) || (instruction == BRA_OPCODE));
     1456            int offset = (codeSize() - from.m_offset) - 4;
     1457            *instructionPtr++ = instruction | (offset >> 1);
     1458            printInstr(*instructionPtr, from.m_offset + 2);
     1459            return;
     1460        }
    14351461
    14361462        if (((instruction & 0xff00) == BT_OPCODE) || ((instruction & 0xff00) == BF_OPCODE)) {

  • trunk/Source/JavaScriptCore/jit/JIT.h

    r112011 r112192  
    553553        static const int sequenceGetByIdHotPathConstantSpace = 5;
    554554        // sequenceGetByIdSlowCase
    555         static const int sequenceGetByIdSlowCaseInstructionSpace = 30;
    556         static const int sequenceGetByIdSlowCaseConstantSpace = 3;
     555        static const int sequenceGetByIdSlowCaseInstructionSpace = 38;
     556        static const int sequenceGetByIdSlowCaseConstantSpace = 4;
    557557        // sequencePutById
    558558        static const int sequencePutByIdInstructionSpace = 36;
    … …  
    568568        static const int patchOffsetGetByIdSlowCaseCall = 0; // FIMXE
    569569#else
    570         static const int patchOffsetGetByIdSlowCaseCall = 26;
     570        static const int patchOffsetGetByIdSlowCaseCall = 34;
    571571#endif
    572572        static const int patchOffsetOpCallCompareToJump = 4;

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

    r112143 r112192  
    730730            case 2: {
    731731                BaseIndex address(input, index, TimesOne, (startTermPosition - m_checked) * sizeof(LChar));
    732                 load16(address, character);
     732                load16Unaligned(address, character);
    733733                break;
    734734            }
    735735            case 3: {
    736736                BaseIndex highAddress(input, index, TimesOne, (startTermPosition - m_checked) * sizeof(LChar));
    737                 load16(highAddress, character);
     737                load16Unaligned(highAddress, character);
    738738                if (ignoreCaseMask)
    739739                    or32(Imm32(ignoreCaseMask), character);
Note: See TracChangeset for help on using the changeset viewer.