Changeset 229766 in webkit


Ignore:
Timestamp:
Mar 20, 2018 10:53:59 AM (6 years ago)
Author:
commit-queue@webkit.org
Message:

[MIPS] Optimize generated JIT code for loads/stores
​https://bugs.webkit.org/show_bug.cgi?id=183243

Patch by Stanislav Ocovaj <​stanislav.ocovaj@rt-rk.com> on 2018-03-20
Reviewed by Yusuke Suzuki.

JIT generates three MIPS instructions for a load/store from/to an absolute address:

lui adrTmpReg, address >> 16
ori adrTmpReg, address & 0xffff
lw dataReg, 0(adrTmpReg)

Since load/store instructions on MIPS have a 16-bit offset, lower 16 bits of the address can
be encoded into the load/store and ori instruction can be removed:

lui adrTmpReg, (address + 0x8000) >> 16
lw dataReg, (address & 0xffff)(adrTmpReg)

Also, in loads/stores with BaseIndex address, the left shift can be omitted if address.scale is 0.

  • assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::add32):
(JSC::MacroAssemblerMIPS::add64):
(JSC::MacroAssemblerMIPS::or32):
(JSC::MacroAssemblerMIPS::sub32):
(JSC::MacroAssemblerMIPS::convertibleLoadPtr):
(JSC::MacroAssemblerMIPS::load8):
(JSC::MacroAssemblerMIPS::load8SignedExtendTo32):
(JSC::MacroAssemblerMIPS::load32):
(JSC::MacroAssemblerMIPS::store8):
(JSC::MacroAssemblerMIPS::store32):
(JSC::MacroAssemblerMIPS::branchTest8):
(JSC::MacroAssemblerMIPS::branchAdd32):
(JSC::MacroAssemblerMIPS::loadDouble):
(JSC::MacroAssemblerMIPS::storeDouble):

Location:
trunk/Source/JavaScriptCore
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r229743 r229766  
     12018-03-20  Stanislav Ocovaj  <stanislav.ocovaj@rt-rk.com>
     2
     3        [MIPS] Optimize generated JIT code for loads/stores
     4        https://bugs.webkit.org/show_bug.cgi?id=183243
     5
     6        Reviewed by Yusuke Suzuki.
     7
     8        JIT generates three MIPS instructions for a load/store from/to an absolute address:
     9
     10          lui adrTmpReg, address >> 16
     11          ori adrTmpReg, address & 0xffff
     12          lw dataReg, 0(adrTmpReg)
     13
     14        Since load/store instructions on MIPS have a 16-bit offset, lower 16 bits of the address can
     15        be encoded into the load/store and ori instruction can be removed:
     16
     17          lui adrTmpReg, (address + 0x8000) >> 16
     18          lw dataReg, (address & 0xffff)(adrTmpReg)
     19
     20        Also, in loads/stores with BaseIndex address, the left shift can be omitted if address.scale is 0.
     21
     22        * assembler/MacroAssemblerMIPS.h:
     23        (JSC::MacroAssemblerMIPS::add32):
     24        (JSC::MacroAssemblerMIPS::add64):
     25        (JSC::MacroAssemblerMIPS::or32):
     26        (JSC::MacroAssemblerMIPS::sub32):
     27        (JSC::MacroAssemblerMIPS::convertibleLoadPtr):
     28        (JSC::MacroAssemblerMIPS::load8):
     29        (JSC::MacroAssemblerMIPS::load8SignedExtendTo32):
     30        (JSC::MacroAssemblerMIPS::load32):
     31        (JSC::MacroAssemblerMIPS::store8):
     32        (JSC::MacroAssemblerMIPS::store32):
     33        (JSC::MacroAssemblerMIPS::branchTest8):
     34        (JSC::MacroAssemblerMIPS::branchAdd32):
     35        (JSC::MacroAssemblerMIPS::loadDouble):
     36        (JSC::MacroAssemblerMIPS::storeDouble):
     37
    1382018-03-16  Yusuke Suzuki  <utatane.tea@gmail.com>
    239

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

    r229609 r229766  
    236236    void add32(TrustedImm32 imm, AbsoluteAddress address)
    237237    {
     238        if (!m_fixedWidth) {
     239            uintptr_t adr = reinterpret_cast<uintptr_t>(address.m_ptr);
     240            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     241            m_assembler.lw(cmpTempRegister, addrTempRegister, adr & 0xffff);
     242            if (imm.m_value >= -32768 && imm.m_value <= 32767)
     243                m_assembler.addiu(dataTempRegister, cmpTempRegister, imm.m_value);
     244            else {
     245                move(imm, immTempRegister);
     246                m_assembler.addu(dataTempRegister, cmpTempRegister, immTempRegister);
     247            }
     248            m_assembler.sw(dataTempRegister, addrTempRegister, adr & 0xffff);
     249        } else {
     250            /*
     251               li   addrTemp, address
     252               li   immTemp, imm
     253               lw   cmpTemp, 0(addrTemp)
     254               addu dataTemp, cmpTemp, immTemp
     255               sw   dataTemp, 0(addrTemp)
     256            */
     257            move(TrustedImmPtr(address.m_ptr), addrTempRegister);
     258            m_assembler.lw(cmpTempRegister, addrTempRegister, 0);
     259            move(imm, immTempRegister);
     260            m_assembler.addu(dataTempRegister, cmpTempRegister, immTempRegister);
     261            m_assembler.sw(dataTempRegister, addrTempRegister, 0);
     262        }
     263    }
     264
     265    void add64(TrustedImm32 imm, AbsoluteAddress address)
     266    {
     267        if (!m_fixedWidth) {
     268            uintptr_t adr = reinterpret_cast<uintptr_t>(address.m_ptr);
     269            if ((adr >> 15) == ((adr + 4) >> 15)) {
     270                m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     271                m_assembler.lw(cmpTempRegister, addrTempRegister, adr & 0xffff);
     272                if (imm.m_value >= -32768 && imm.m_value <= 32767)
     273                    m_assembler.addiu(dataTempRegister, cmpTempRegister, imm.m_value);
     274                else {
     275                    move(imm, immTempRegister);
     276                    m_assembler.addu(dataTempRegister, cmpTempRegister, immTempRegister);
     277                }
     278                m_assembler.sw(dataTempRegister, addrTempRegister, adr & 0xffff);
     279                m_assembler.sltu(immTempRegister, dataTempRegister, cmpTempRegister);
     280                m_assembler.lw(dataTempRegister, addrTempRegister, (adr + 4) & 0xffff);
     281                if (imm.m_value >> 31)
     282                    m_assembler.addiu(dataTempRegister, dataTempRegister, -1);
     283                m_assembler.addu(dataTempRegister, dataTempRegister, immTempRegister);
     284                m_assembler.sw(dataTempRegister, addrTempRegister, (adr + 4) & 0xffff);
     285                return;
     286            }
     287        }
    238288        /*
    239            li   addrTemp, address
    240            li   immTemp, imm
    241            lw   cmpTemp, 0(addrTemp)
    242            addu dataTemp, cmpTemp, immTemp
    243            sw   dataTemp, 0(addrTemp)
     289            add32(imm, address)
     290            sltu  immTemp, dataTemp, cmpTemp    # set carry-in bit
     291            lw    dataTemp, 4(addrTemp)
     292            addiu dataTemp, imm.m_value >> 31 ? -1 : 0
     293            addu  dataTemp, dataTemp, immTemp
     294            sw    dataTemp, 4(addrTemp)
    244295        */
    245296        move(TrustedImmPtr(address.m_ptr), addrTempRegister);
    … …  
    252303        }
    253304        m_assembler.sw(dataTempRegister, addrTempRegister, 0);
    254     }
    255 
    256     void add64(TrustedImm32 imm, AbsoluteAddress address)
    257     {
    258         /*
    259             add32(imm, address)
    260             sltu  immTemp, dataTemp, cmpTemp    # set carry-in bit
    261             lw    dataTemp, 4(addrTemp)
    262             addiu dataTemp, imm.m_value >> 31 ? -1 : 0
    263             addu  dataTemp, dataTemp, immTemp
    264             sw    dataTemp, 4(addrTemp)
    265         */
    266         add32(imm, address);
    267305        m_assembler.sltu(immTempRegister, dataTempRegister, cmpTempRegister);
    268306        m_assembler.lw(dataTempRegister, addrTempRegister, 4);
    … …  
    407445            return;
    408446
    409         // TODO: Swap dataTempRegister and immTempRegister usage
    410         load32(dest.m_ptr, immTempRegister);
    411         or32(imm, immTempRegister);
    412         store32(immTempRegister, dest.m_ptr);
     447        if (m_fixedWidth) {
     448            // TODO: Swap dataTempRegister and immTempRegister usage
     449            load32(dest.m_ptr, immTempRegister);
     450            or32(imm, immTempRegister);
     451            store32(immTempRegister, dest.m_ptr);
     452        } else {
     453            uintptr_t adr = reinterpret_cast<uintptr_t>(dest.m_ptr);
     454            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     455            m_assembler.lw(immTempRegister, addrTempRegister, adr & 0xffff);
     456            or32(imm, immTempRegister);
     457            m_assembler.sw(immTempRegister, addrTempRegister, adr & 0xffff);
     458        }
    413459    }
    414460
    … …  
    454500    void or32(RegisterID src, AbsoluteAddress dest)
    455501    {
    456         load32(dest.m_ptr, dataTempRegister);
    457         m_assembler.orInsn(dataTempRegister, dataTempRegister, src);
    458         store32(dataTempRegister, dest.m_ptr);
     502        if (m_fixedWidth) {
     503            load32(dest.m_ptr, dataTempRegister);
     504            m_assembler.orInsn(dataTempRegister, dataTempRegister, src);
     505            store32(dataTempRegister, dest.m_ptr);
     506        } else {
     507            uintptr_t adr = reinterpret_cast<uintptr_t>(dest.m_ptr);
     508            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     509            m_assembler.lw(dataTempRegister, addrTempRegister, adr & 0xffff);
     510            m_assembler.orInsn(dataTempRegister, dataTempRegister, src);
     511            m_assembler.sw(dataTempRegister, addrTempRegister, adr & 0xffff);
     512        }
    459513    }
    460514
    … …  
    636690    void sub32(TrustedImm32 imm, AbsoluteAddress address)
    637691    {
    638         /*
    639            li   addrTemp, address
    640            li   immTemp, imm
    641            lw   dataTemp, 0(addrTemp)
    642            subu dataTemp, dataTemp, immTemp
    643            sw   dataTemp, 0(addrTemp)
    644         */
    645         move(TrustedImmPtr(address.m_ptr), addrTempRegister);
    646         m_assembler.lw(dataTempRegister, addrTempRegister, 0);
    647 
    648         if (imm.m_value >= -32767 && imm.m_value <= 32768 && !m_fixedWidth)
    649             m_assembler.addiu(dataTempRegister, dataTempRegister, -imm.m_value);
    650         else {
     692        if (!m_fixedWidth) {
     693            uintptr_t adr = reinterpret_cast<uintptr_t>(address.m_ptr);
     694            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     695            m_assembler.lw(cmpTempRegister, addrTempRegister, adr & 0xffff);
     696            if (imm.m_value >= -32767 && imm.m_value <= 32768)
     697                m_assembler.addiu(dataTempRegister, cmpTempRegister, -imm.m_value);
     698            else {
     699                move(imm, immTempRegister);
     700                m_assembler.subu(dataTempRegister, cmpTempRegister, immTempRegister);
     701            }
     702            m_assembler.sw(dataTempRegister, addrTempRegister, adr & 0xffff);
     703        } else {
     704            /*
     705               li   addrTemp, address
     706               lw   dataTemp, 0(addrTemp)
     707               li   immTemp, imm
     708               subu dataTemp, dataTemp, immTemp
     709               sw   dataTemp, 0(addrTemp)
     710            */
     711            move(TrustedImmPtr(address.m_ptr), addrTempRegister);
     712            m_assembler.lw(cmpTempRegister, addrTempRegister, 0);
    651713            move(imm, immTempRegister);
    652             m_assembler.subu(dataTempRegister, dataTempRegister, immTempRegister);
    653         }
    654         m_assembler.sw(dataTempRegister, addrTempRegister, 0);
     714            m_assembler.subu(dataTempRegister, cmpTempRegister, immTempRegister);
     715            m_assembler.sw(dataTempRegister, addrTempRegister, 0);
     716        }
    655717    }
    656718
    … …  
    777839             lbu     dest, address.offset(addrTemp)
    778840             */
    779             m_assembler.sll(addrTempRegister, address.index, address.scale);
    780             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     841            if (!address.scale)
     842                m_assembler.addu(addrTempRegister, address.index, address.base);
     843            else {
     844                m_assembler.sll(addrTempRegister, address.index, address.scale);
     845                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     846            }
    781847            m_assembler.lbu(dest, addrTempRegister, address.offset);
    782848        } else {
    … …  
    788854             lbu     dest, (address.offset & 0xffff)(at)
    789855             */
    790             m_assembler.sll(addrTempRegister, address.index, address.scale);
    791             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     856            if (!address.scale && !m_fixedWidth)
     857                m_assembler.addu(addrTempRegister, address.index, address.base);
     858            else {
     859                m_assembler.sll(addrTempRegister, address.index, address.scale);
     860                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     861            }
    792862            m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);
    793863            m_assembler.addu(addrTempRegister, addrTempRegister, immTempRegister);
    … …  
    803873    void load8(const void* address, RegisterID dest)
    804874    {
    805         /*
    806             li  addrTemp, address
    807             lbu dest, 0(addrTemp)
    808         */
    809         move(TrustedImmPtr(address), addrTempRegister);
    810         m_assembler.lbu(dest, addrTempRegister, 0);
     875        if (m_fixedWidth) {
     876            /*
     877                li  addrTemp, address
     878                lbu dest, 0(addrTemp)
     879            */
     880            move(TrustedImmPtr(address), addrTempRegister);
     881            m_assembler.lbu(dest, addrTempRegister, 0);
     882        } else {
     883            uintptr_t adr = reinterpret_cast<uintptr_t>(address);
     884            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     885            m_assembler.lbu(dest, addrTempRegister, adr & 0xffff);
     886        }
    811887    }
    812888
    … …  
    837913                lb      dest, address.offset(addrTemp)
    838914            */
    839             m_assembler.sll(addrTempRegister, address.index, address.scale);
    840             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     915            if (!address.scale)
     916                m_assembler.addu(addrTempRegister, address.index, address.base);
     917            else {
     918                m_assembler.sll(addrTempRegister, address.index, address.scale);
     919                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     920            }
    841921            m_assembler.lb(dest, addrTempRegister, address.offset);
    842922        } else {
    … …  
    848928                lb     dest, (address.offset & 0xffff)(at)
    849929            */
    850             m_assembler.sll(addrTempRegister, address.index, address.scale);
    851             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     930            if (!address.scale && !m_fixedWidth)
     931                m_assembler.addu(addrTempRegister, address.index, address.base);
     932            else {
     933                m_assembler.sll(addrTempRegister, address.index, address.scale);
     934                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     935            }
    852936            m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);
    853937            m_assembler.addu(addrTempRegister, addrTempRegister, immTempRegister);
    … …  
    863947    void load8SignedExtendTo32(const void* address, RegisterID dest)
    864948    {
    865         /*
    866             li  addrTemp, address
    867             lb  dest, 0(addrTemp)
    868         */
    869         move(TrustedImmPtr(address), addrTempRegister);
    870         m_assembler.lb(dest, addrTempRegister, 0);
     949        if (m_fixedWidth) {
     950            /*
     951                li  addrTemp, address
     952                lb dest, 0(addrTemp)
     953            */
     954            move(TrustedImmPtr(address), addrTempRegister);
     955            m_assembler.lb(dest, addrTempRegister, 0);
     956        } else {
     957            uintptr_t adr = reinterpret_cast<uintptr_t>(address);
     958            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     959            m_assembler.lb(dest, addrTempRegister, adr & 0xffff);
     960        }
    871961    }
    872962
    … …  
    898988                lw      dest, address.offset(addrTemp)
    899989            */
    900             m_assembler.sll(addrTempRegister, address.index, address.scale);
    901             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     990            if (!address.scale)
     991                m_assembler.addu(addrTempRegister, address.index, address.base);
     992            else {
     993                m_assembler.sll(addrTempRegister, address.index, address.scale);
     994                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     995            }
    902996            m_assembler.lw(dest, addrTempRegister, address.offset);
    903997        } else {
    … …  
    10231117    void load32(const void* address, RegisterID dest)
    10241118    {
    1025         /*
    1026             li  addrTemp, address
    1027             lw  dest, 0(addrTemp)
    1028         */
    1029         move(TrustedImmPtr(address), addrTempRegister);
    1030         m_assembler.lw(dest, addrTempRegister, 0);
     1119        if (m_fixedWidth) {
     1120            /*
     1121                li  addrTemp, address
     1122                lw  dest, 0(addrTemp)
     1123            */
     1124            move(TrustedImmPtr(address), addrTempRegister);
     1125            m_assembler.lw(dest, addrTempRegister, 0);
     1126        } else {
     1127            uintptr_t adr = reinterpret_cast<uintptr_t>(address);
     1128            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     1129            m_assembler.lw(dest, addrTempRegister, adr & 0xffff);
     1130        }
    10311131    }
    10321132
    … …  
    11561256                sb      src, address.offset(addrTemp)
    11571257            */
    1158             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1159             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1258            if (!address.scale)
     1259                m_assembler.addu(addrTempRegister, address.index, address.base);
     1260            else {
     1261                m_assembler.sll(addrTempRegister, address.index, address.scale);
     1262                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1263            }
    11601264            m_assembler.sb(src, addrTempRegister, address.offset);
    11611265        } else {
    … …  
    11671271                sb      src, (address.offset & 0xffff)(at)
    11681272            */
    1169             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1170             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1273            if (!address.scale && !m_fixedWidth)
     1274                m_assembler.addu(addrTempRegister, address.index, address.base);
     1275            else {
     1276                m_assembler.sll(addrTempRegister, address.index, address.scale);
     1277                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1278            }
    11711279            m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);
    11721280            m_assembler.addu(addrTempRegister, addrTempRegister, immTempRegister);
    … …  
    11771285    void store8(RegisterID src, void* address)
    11781286    {
    1179         move(TrustedImmPtr(address), addrTempRegister);
    1180         m_assembler.sb(src, addrTempRegister, 0);
     1287        if (m_fixedWidth) {
     1288            /*
     1289                li  addrTemp, address
     1290                sb  src, 0(addrTemp)
     1291            */
     1292            move(TrustedImmPtr(address), addrTempRegister);
     1293            m_assembler.sb(src, addrTempRegister, 0);
     1294        } else {
     1295            uintptr_t adr = reinterpret_cast<uintptr_t>(address);
     1296            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     1297            m_assembler.sb(src, addrTempRegister, adr & 0xffff);
     1298        }
    11811299    }
    11821300
    11831301    void store8(TrustedImm32 imm, void* address)
    11841302    {
    1185         /*
    1186             li  immTemp, imm
    1187             li  addrTemp, address
    1188             sb  src, 0(addrTemp)
    1189         */
    1190         TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
    1191         if (!imm8.m_value && !m_fixedWidth) {
    1192             move(TrustedImmPtr(address), addrTempRegister);
    1193             m_assembler.sb(MIPSRegisters::zero, addrTempRegister, 0);
    1194         } else {
     1303        if (m_fixedWidth) {
     1304            /*
     1305                li  immTemp, imm
     1306                li  addrTemp, address
     1307                sb  src, 0(addrTemp)
     1308            */
     1309            TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
    11951310            move(imm8, immTempRegister);
    11961311            move(TrustedImmPtr(address), addrTempRegister);
    11971312            m_assembler.sb(immTempRegister, addrTempRegister, 0);
     1313        } else {
     1314            uintptr_t adr = reinterpret_cast<uintptr_t>(address);
     1315            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     1316            if (!imm.m_value)
     1317                m_assembler.sb(MIPSRegisters::zero, addrTempRegister, adr & 0xffff);
     1318            else {
     1319                TrustedImm32 imm8(static_cast<int8_t>(imm.m_value));
     1320                move(imm8, immTempRegister);
     1321                m_assembler.sb(immTempRegister, addrTempRegister, adr & 0xffff);
     1322            }
    11981323        }
    11991324    }
    … …  
    12811406                sw      src, address.offset(addrTemp)
    12821407            */
    1283             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1284             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1408            if (!address.scale)
     1409                m_assembler.addu(addrTempRegister, address.index, address.base);
     1410            else {
     1411                m_assembler.sll(addrTempRegister, address.index, address.scale);
     1412                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1413            }
    12851414            m_assembler.sw(src, addrTempRegister, address.offset);
    12861415        } else {
    … …  
    13351464                sw      src, address.offset(addrTemp)
    13361465            */
    1337             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1338             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1466            if (!address.scale)
     1467                m_assembler.addu(addrTempRegister, address.index, address.base);
     1468            else {
     1469                m_assembler.sll(addrTempRegister, address.index, address.scale);
     1470                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1471            }
    13391472            if (!imm.m_value)
    13401473                m_assembler.sw(MIPSRegisters::zero, addrTempRegister, address.offset);
    … …  
    13671500    void store32(RegisterID src, const void* address)
    13681501    {
    1369         /*
    1370             li  addrTemp, address
    1371             sw  src, 0(addrTemp)
    1372         */
    1373         move(TrustedImmPtr(address), addrTempRegister);
    1374         m_assembler.sw(src, addrTempRegister, 0);
     1502        if (m_fixedWidth) {
     1503            /*
     1504                li  addrTemp, address
     1505                sw  src, 0(addrTemp)
     1506            */
     1507            move(TrustedImmPtr(address), addrTempRegister);
     1508            m_assembler.sw(src, addrTempRegister, 0);
     1509        } else {
     1510            uintptr_t adr = reinterpret_cast<uintptr_t>(address);
     1511            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     1512            m_assembler.sw(src, addrTempRegister, adr & 0xffff);
     1513        }
    13751514    }
    13761515
    13771516    void store32(TrustedImm32 imm, const void* address)
    13781517    {
    1379         /*
    1380             li  immTemp, imm
    1381             li  addrTemp, address
    1382             sw  src, 0(addrTemp)
    1383         */
    1384         if (!imm.m_value && !m_fixedWidth) {
    1385             move(TrustedImmPtr(address), addrTempRegister);
    1386             m_assembler.sw(MIPSRegisters::zero, addrTempRegister, 0);
    1387         } else {
     1518        if (m_fixedWidth) {
     1519            /*
     1520                li  immTemp, imm
     1521                li  addrTemp, address
     1522                sw  src, 0(addrTemp)
     1523            */
    13881524            move(imm, immTempRegister);
    13891525            move(TrustedImmPtr(address), addrTempRegister);
    13901526            m_assembler.sw(immTempRegister, addrTempRegister, 0);
     1527        } else {
     1528            uintptr_t adr = reinterpret_cast<uintptr_t>(address);
     1529            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     1530            if (!imm.m_value)
     1531                m_assembler.sw(MIPSRegisters::zero, addrTempRegister, adr & 0xffff);
     1532            else {
     1533                move(imm, immTempRegister);
     1534                m_assembler.sw(immTempRegister, addrTempRegister, adr & 0xffff);
     1535            }
    13911536        }
    13921537    }
    … …  
    17471892    {
    17481893        TrustedImm32 mask8 = MacroAssemblerHelpers::mask8OnCondition(*this, cond, mask);
    1749         move(TrustedImmPtr(address.m_ptr), dataTempRegister);
    1750         MacroAssemblerHelpers::load8OnCondition(*this, cond, Address(dataTempRegister), dataTempRegister);
     1894        MacroAssemblerHelpers::load8OnCondition(*this, cond, address, dataTempRegister);
    17511895        return branchTest32(cond, dataTempRegister, mask8);
    17521896    }
    … …  
    19712115            return jump();
    19722116        }
    1973         move(imm, immTempRegister);
    1974         load32(dest.m_ptr, dataTempRegister);
    1975         add32(immTempRegister, dataTempRegister);
    1976         store32(dataTempRegister, dest.m_ptr);
     2117        if (m_fixedWidth) {
     2118            move(imm, immTempRegister);
     2119            load32(dest.m_ptr, dataTempRegister);
     2120            add32(immTempRegister, dataTempRegister);
     2121            store32(dataTempRegister, dest.m_ptr);
     2122        } else {
     2123            uintptr_t adr = reinterpret_cast<uintptr_t>(dest.m_ptr);
     2124            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     2125            m_assembler.lw(dataTempRegister, addrTempRegister, adr & 0xffff);
     2126            add32(imm, dataTempRegister);
     2127            m_assembler.sw(dataTempRegister, addrTempRegister, adr & 0xffff);
     2128        }
    19772129        if (cond == Signed) {
    19782130            // Check if dest is negative.
    … …  
    25842736        m_assembler.lwc1(FPRegisterID(dest + 1), addrTempRegister, 4);
    25852737#else
    2586         /*
    2587             li          addrTemp, address
    2588             ldc1        dest, 0(addrTemp)
    2589         */
    2590         move(address, addrTempRegister);
    2591         m_assembler.ldc1(dest, addrTempRegister, 0);
     2738        if (m_fixedWidth) {
     2739            /*
     2740                li  addrTemp, address
     2741                ldc1        dest, 0(addrTemp)
     2742            */
     2743            move(TrustedImmPtr(address), addrTempRegister);
     2744            m_assembler.ldc1(dest, addrTempRegister, 0);
     2745        } else {
     2746            uintptr_t adr = reinterpret_cast<uintptr_t>(address.m_value);
     2747            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     2748            m_assembler.ldc1(dest, addrTempRegister, adr & 0xffff);
     2749        }
    25922750#endif
    25932751    }
    … …  
    27342892        m_assembler.swc1(FPRegisterID(src + 1), addrTempRegister, 4);
    27352893#else
    2736         move(address, addrTempRegister);
    2737         m_assembler.sdc1(src, addrTempRegister, 0);
     2894        if (m_fixedWidth) {
     2895            /*
     2896                li  addrTemp, address
     2897                sdc1  src, 0(addrTemp)
     2898            */
     2899            move(TrustedImmPtr(address), addrTempRegister);
     2900            m_assembler.sdc1(src, addrTempRegister, 0);
     2901        } else {
     2902            uintptr_t adr = reinterpret_cast<uintptr_t>(address.m_value);
     2903            m_assembler.lui(addrTempRegister, (adr + 0x8000) >> 16);
     2904            m_assembler.sdc1(src, addrTempRegister, adr & 0xffff);
     2905        }
    27382906#endif
    27392907    }
Note: See TracChangeset for help on using the changeset viewer.