Ignore:
Timestamp:
Nov 23, 2012, 5:11:28 AM (13 years ago)
Author:
[email protected]
Message:

[sh4] JavaScriptCore JIT build is broken since r130839
Add missing implementation for sh4 arch.
​https://bugs.webkit.org/show_bug.cgi?id=101479

Patch by Julien BRIANCEAU <​[email protected]> on 2012-11-23
Reviewed by Filip Pizlo.

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::load8Signed):
(MacroAssemblerSH4):
(JSC::MacroAssemblerSH4::load16Signed):
(JSC::MacroAssemblerSH4::store8):
(JSC::MacroAssemblerSH4::store16):
(JSC::MacroAssemblerSH4::moveDoubleToInts):
(JSC::MacroAssemblerSH4::moveIntsToDouble):
(JSC::MacroAssemblerSH4::loadFloat):
(JSC::MacroAssemblerSH4::loadDouble):
(JSC::MacroAssemblerSH4::storeFloat):
(JSC::MacroAssemblerSH4::storeDouble):
(JSC::MacroAssemblerSH4::addDouble):
(JSC::MacroAssemblerSH4::convertFloatToDouble):
(JSC::MacroAssemblerSH4::convertDoubleToFloat):
(JSC::MacroAssemblerSH4::urshift32):

  • assembler/SH4Assembler.h:

(JSC::SH4Assembler::sublRegReg):
(JSC::SH4Assembler::subvlRegReg):
(JSC::SH4Assembler::floatfpulfrn):
(JSC::SH4Assembler::fldsfpul):
(JSC::SH4Assembler::fstsfpul):
(JSC::SH4Assembler::dcnvsd):
(SH4Assembler):
(JSC::SH4Assembler::movbRegMem):
(JSC::SH4Assembler::sizeOfConstantPool):
(JSC::SH4Assembler::linkJump):
(JSC::SH4Assembler::printInstr):
(JSC::SH4Assembler::printBlockInstr):

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r127148 r135597  
    603603    }
    604604
     605    void load8Signed(BaseIndex address, RegisterID dest)
     606    {
     607        RegisterID scr = claimScratch();
     608        move(address.index, scr);
     609        lshift32(TrustedImm32(address.scale), scr);
     610        add32(address.base, scr);
     611        load8Signed(scr, address.offset, dest);
     612        releaseScratch(scr);
     613    }
     614
    605615    void load32(BaseIndex address, RegisterID dest)
    606616    {
    … …  
    650660    }
    651661
     662    void load8Signed(RegisterID base, int offset, RegisterID dest)
     663    {
     664        if (!offset) {
     665            m_assembler.movbMemReg(base, dest);
     666            return;
     667        }
     668
     669        if ((offset > 0) && (offset < 64) && (dest == SH4Registers::r0)) {
     670            m_assembler.movbMemReg(offset, base, dest);
     671            return;
     672        }
     673
     674        if (base != dest) {
     675            m_assembler.loadConstant((offset), dest);
     676            m_assembler.addlRegReg(base, dest);
     677            m_assembler.movbMemReg(dest, dest);
     678            return;
     679        }
     680
     681        RegisterID scr = claimScratch();
     682        m_assembler.loadConstant((offset), scr);
     683        m_assembler.addlRegReg(base, scr);
     684        m_assembler.movbMemReg(scr, dest);
     685        releaseScratch(scr);
     686    }
     687
    652688    void load8(RegisterID base, int offset, RegisterID dest)
    653689    {
    … …  
    750786    }
    751787
     788    void load16Signed(RegisterID src, RegisterID dest)
     789    {
     790        m_assembler.movwMemReg(src, dest);
     791    }
     792
    752793    void load16(RegisterID r0, RegisterID src, RegisterID dest)
    753794    {
    … …  
    755796        m_assembler.movwR0mr(src, dest);
    756797        extuw(dest, dest);
     798    }
     799
     800    void load16Signed(RegisterID r0, RegisterID src, RegisterID dest)
     801    {
     802        ASSERT(r0 == SH4Registers::r0);
     803        m_assembler.movwR0mr(src, dest);
    757804    }
    758805
    … …  
    776823    }
    777824
     825    void load16Signed(BaseIndex address, RegisterID dest)
     826    {
     827        RegisterID scr = claimScratch();
     828
     829        move(address.index, scr);
     830        lshift32(TrustedImm32(address.scale), scr);
     831
     832        if (address.offset)
     833            add32(TrustedImm32(address.offset), scr);
     834        if (address.base == SH4Registers::r0)
     835            load16Signed(address.base, scr, dest);
     836        else {
     837            add32(address.base, scr);
     838            load16Signed(scr, dest);
     839        }
     840
     841        releaseScratch(scr);
     842    }
     843
     844    void store8(RegisterID src, BaseIndex address)
     845    {
     846        RegisterID scr = claimScratch();
     847
     848        move(address.index, scr);
     849        lshift32(TrustedImm32(address.scale), scr);
     850        add32(address.base, scr);
     851
     852        m_assembler.movbRegMem(src, scr);
     853
     854        releaseScratch(scr);
     855    }
     856
     857    void store16(RegisterID src, BaseIndex address)
     858    {
     859        RegisterID scr = claimScratch();
     860
     861        move(address.index, scr);
     862        lshift32(TrustedImm32(address.scale), scr);
     863        add32(address.base, scr);
     864
     865        m_assembler.movwRegMem(src, scr);
     866
     867        releaseScratch(scr);
     868    }
     869
    778870    void store32(RegisterID src, ImplicitAddress address)
    779871    {
    … …  
    901993    }
    902994
    903      // Floating-point operations
     995    // Floating-point operations
    904996
    905997    static bool supportsFloatingPoint() { return true; }
    … …  
    907999    static bool supportsFloatingPointSqrt() { return true; }
    9081000    static bool supportsFloatingPointAbs() { return false; }
     1001
     1002    void moveDoubleToInts(FPRegisterID src, RegisterID dest1, RegisterID dest2)
     1003    {
     1004        m_assembler.fldsfpul((FPRegisterID)(src + 1));
     1005        m_assembler.stsfpulReg(dest1);
     1006        m_assembler.fldsfpul(src);
     1007        m_assembler.stsfpulReg(dest2);
     1008    }
     1009
     1010    void moveIntsToDouble(RegisterID src1, RegisterID src2, FPRegisterID dest, FPRegisterID scratch)
     1011    {
     1012        UNUSED_PARAM(scratch);
     1013        m_assembler.ldsrmfpul(src1);
     1014        m_assembler.fstsfpul((FPRegisterID)(dest + 1));
     1015        m_assembler.ldsrmfpul(src2);
     1016        m_assembler.fstsfpul(dest);
     1017    }
     1018
     1019    void loadFloat(BaseIndex address, FPRegisterID dest)
     1020    {
     1021        RegisterID scr = claimScratch();
     1022
     1023        move(address.index, scr);
     1024        lshift32(TrustedImm32(address.scale), scr);
     1025        add32(address.base, scr);
     1026        if (address.offset)
     1027            add32(TrustedImm32(address.offset), scr);
     1028
     1029        m_assembler.fmovsReadrm(scr, dest);
     1030        releaseScratch(scr);
     1031    }
     1032
     1033    void loadDouble(BaseIndex address, FPRegisterID dest)
     1034    {
     1035        RegisterID scr = claimScratch();
     1036
     1037        move(address.index, scr);
     1038        lshift32(TrustedImm32(address.scale), scr);
     1039        add32(address.base, scr);
     1040        if (address.offset)
     1041            add32(TrustedImm32(address.offset), scr);
     1042
     1043        m_assembler.fmovsReadrminc(scr, (FPRegisterID)(dest + 1));
     1044        m_assembler.fmovsReadrm(scr, dest);
     1045        releaseScratch(scr);
     1046    }
    9091047
    9101048    void loadDouble(ImplicitAddress address, FPRegisterID dest)
    … …  
    9361074    }
    9371075
     1076    void storeFloat(FPRegisterID src, BaseIndex address)
     1077    {
     1078        RegisterID scr = claimScratch();
     1079
     1080        move(address.index, scr);
     1081        lshift32(TrustedImm32(address.scale), scr);
     1082        add32(address.base, scr);
     1083        if (address.offset)
     1084            add32(TrustedImm32(address.offset), scr);
     1085
     1086        m_assembler.fmovsWriterm(src, scr);
     1087
     1088        releaseScratch(scr);
     1089    }
     1090
    9381091    void storeDouble(FPRegisterID src, ImplicitAddress address)
    9391092    {
    … …  
    9471100    }
    9481101
     1102    void storeDouble(FPRegisterID src, BaseIndex address)
     1103    {
     1104        RegisterID scr = claimScratch();
     1105
     1106        move(address.index, scr);
     1107        lshift32(TrustedImm32(address.scale), scr);
     1108        add32(address.base, scr);
     1109        if (address.offset)
     1110            add32(TrustedImm32(address.offset), scr);
     1111
     1112        m_assembler.fmovsWriterm((FPRegisterID)(src + 1), scr);
     1113        m_assembler.addlImm8r(4, scr);
     1114        m_assembler.fmovsWriterm(src, scr);
     1115
     1116        releaseScratch(scr);
     1117    }
     1118
     1119    void addDouble(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1120    {
     1121        if (op1 == dest)
     1122            m_assembler.daddRegReg(op2, dest);
     1123        else {
     1124            m_assembler.dmovRegReg(op1, dest);
     1125            m_assembler.daddRegReg(op2, dest);
     1126        }
     1127    }
     1128
    9491129    void addDouble(FPRegisterID src, FPRegisterID dest)
    9501130    {
    9511131        m_assembler.daddRegReg(src, dest);
     1132    }
     1133
     1134    void addDouble(AbsoluteAddress address, FPRegisterID dest)
     1135    {
     1136        loadDouble(address.m_ptr, fscratch);
     1137        addDouble(fscratch, dest);
    9521138    }
    9531139
    … …  
    9831169    {
    9841170        m_assembler.ddivRegReg(src, dest);
     1171    }
     1172
     1173    void convertFloatToDouble(FPRegisterID src, FPRegisterID dst)
     1174    {
     1175        m_assembler.fldsfpul(src);
     1176        m_assembler.dcnvsd(dst);
     1177    }
     1178
     1179    void convertDoubleToFloat(FPRegisterID src, FPRegisterID dst)
     1180    {
     1181        m_assembler.dcnvds(src);
     1182        m_assembler.fstsfpul(dst);
    9851183    }
    9861184
    … …  
    18942092    {
    18952093        if (src != dest)
    1896            move(src, dest);
     2094            move(src, dest);
    18972095
    18982096        urshift32(shiftamount, dest);
Note: See TracChangeset for help on using the changeset viewer.