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):

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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    }
Note: See TracChangeset for help on using the changeset viewer.