Changeset 231554 in webkit


Ignore:
Timestamp:
May 9, 2018 7:17:01 AM (6 years ago)
Author:
commit-queue@webkit.org
Message:

[MIPS] Optimize generated JIT code using r2
​https://bugs.webkit.org/show_bug.cgi?id=184584

Patch by Srdjan Lazarevic <​srdjan.lazarevic@rt-rk.com> on 2018-05-09
Reviewed by Yusuke Suzuki.

EXT and MFHC1 instructions from MIPSR2 implemented and used where it is possible.
Also, done some code size optimizations that were discovered in meantime.

  • assembler/MIPSAssembler.h:

(JSC::MIPSAssembler::ext):
(JSC::MIPSAssembler::mfhc1):

  • assembler/MacroAssemblerMIPS.cpp:
  • assembler/MacroAssemblerMIPS.h:

(JSC::MacroAssemblerMIPS::isPowerOf2):
(JSC::MacroAssemblerMIPS::bitPosition):
(JSC::MacroAssemblerMIPS::loadAddress):
(JSC::MacroAssemblerMIPS::getEffectiveAddress):
(JSC::MacroAssemblerMIPS::load8):
(JSC::MacroAssemblerMIPS::load8SignedExtendTo32):
(JSC::MacroAssemblerMIPS::load32):
(JSC::MacroAssemblerMIPS::load16Unaligned):
(JSC::MacroAssemblerMIPS::load32WithUnalignedHalfWords):
(JSC::MacroAssemblerMIPS::load16):
(JSC::MacroAssemblerMIPS::load16SignedExtendTo32):
(JSC::MacroAssemblerMIPS::store8):
(JSC::MacroAssemblerMIPS::store16):
(JSC::MacroAssemblerMIPS::store32):
(JSC::MacroAssemblerMIPS::branchTest32):
(JSC::MacroAssemblerMIPS::loadFloat):
(JSC::MacroAssemblerMIPS::loadDouble):
(JSC::MacroAssemblerMIPS::storeFloat):
(JSC::MacroAssemblerMIPS::storeDouble):

Location:
trunk/Source/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r231553 r231554  
     12018-05-09  Srdjan Lazarevic  <srdjan.lazarevic@rt-rk.com>
     2
     3        [MIPS] Optimize generated JIT code using r2
     4        https://bugs.webkit.org/show_bug.cgi?id=184584
     5
     6        Reviewed by Yusuke Suzuki.
     7
     8        EXT and MFHC1 instructions from MIPSR2 implemented and used where it is possible.
     9        Also, done some code size optimizations that were discovered in meantime.
     10
     11        * assembler/MIPSAssembler.h:
     12        (JSC::MIPSAssembler::ext):
     13        (JSC::MIPSAssembler::mfhc1):
     14        * assembler/MacroAssemblerMIPS.cpp:
     15        * assembler/MacroAssemblerMIPS.h:
     16        (JSC::MacroAssemblerMIPS::isPowerOf2):
     17        (JSC::MacroAssemblerMIPS::bitPosition):
     18        (JSC::MacroAssemblerMIPS::loadAddress):
     19        (JSC::MacroAssemblerMIPS::getEffectiveAddress):
     20        (JSC::MacroAssemblerMIPS::load8):
     21        (JSC::MacroAssemblerMIPS::load8SignedExtendTo32):
     22        (JSC::MacroAssemblerMIPS::load32):
     23        (JSC::MacroAssemblerMIPS::load16Unaligned):
     24        (JSC::MacroAssemblerMIPS::load32WithUnalignedHalfWords):
     25        (JSC::MacroAssemblerMIPS::load16):
     26        (JSC::MacroAssemblerMIPS::load16SignedExtendTo32):
     27        (JSC::MacroAssemblerMIPS::store8):
     28        (JSC::MacroAssemblerMIPS::store16):
     29        (JSC::MacroAssemblerMIPS::store32):
     30        (JSC::MacroAssemblerMIPS::branchTest32):
     31        (JSC::MacroAssemblerMIPS::loadFloat):
     32        (JSC::MacroAssemblerMIPS::loadDouble):
     33        (JSC::MacroAssemblerMIPS::storeFloat):
     34        (JSC::MacroAssemblerMIPS::storeDouble):
     35
    1362018-05-06  Yusuke Suzuki  <utatane.tea@gmail.com>
    237

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

    r230310 r231554  
    239239        OP_SH_FD = 6,
    240240        OP_SH_FS = 11,
    241         OP_SH_FT = 16
     241        OP_SH_FT = 16,
     242        OP_SH_MSB = 11,
     243        OP_SH_LSB = 6
    242244    };
    243245
    … …  
    318320                ori(dest, dest, imm);
    319321        }
     322    }
     323
     324    void ext(RegisterID rt, RegisterID rs, int pos, int size)
     325    {
     326        int msb = size - 1;
     327        emitInst(0x7c000000 | (rt << OP_SH_RT) | (rs << OP_SH_RS) | (pos << OP_SH_LSB) | (msb << OP_SH_MSB));
     328    }
     329
     330    void mfhc1(RegisterID rt, FPRegisterID fs)
     331    {
     332        emitInst(0x4460000 | (rt << OP_SH_RT) | (fs << OP_SH_FS));
    320333    }
    321334

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

    r225301 r231554  
    3131#include "ProbeContext.h"
    3232#include <wtf/InlineASM.h>
     33#include <wtf/MathExtras.h>
    3334
    3435namespace JSC {

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

    r231290 r231554  
    5252    }
    5353
     54    inline bool isPowerOf2(int32_t v)
     55    {
     56        return hasOneBitSet(v);
     57    }
     58
     59    inline int bitPosition(int32_t v)
     60    {
     61        return getLSBSet(v);
     62    }
     63
    5464    static const Scale ScalePtr = TimesFour;
    5565
    … …  
    102112        DoubleLessThanOrUnordered,
    103113        DoubleLessThanOrEqualOrUnordered
     114    };
     115
     116    enum class LoadAddressMode {
     117        ScaleAndAddOffsetIfOffsetIsOutOfBounds,
     118        Scale
    104119    };
    105120
    … …  
    311326    }
    312327
     328    void loadAddress(BaseIndex address, LoadAddressMode mode)
     329    {
     330        if (mode == LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds) {
     331            if (!address.scale)
     332                m_assembler.addu(addrTempRegister, address.index, address.base);
     333            else {
     334                m_assembler.sll(addrTempRegister, address.index, address.scale);
     335                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     336            }
     337            if (address.offset < -32768 || address.offset > 32767) {
     338                m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);
     339                m_assembler.addu(addrTempRegister, addrTempRegister, immTempRegister);
     340            }
     341        } else {
     342            if (!address.scale)
     343                m_assembler.addu(addrTempRegister, address.index, address.base);
     344            else {
     345                m_assembler.sll(addrTempRegister, address.index, address.scale);
     346                m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     347            }
     348        }
     349    }
     350
    313351    void getEffectiveAddress(BaseIndex address, RegisterID dest)
    314352    {
    315         m_assembler.sll(addrTempRegister, address.index, address.scale);
    316         m_assembler.addu(dest, addrTempRegister, address.base);
     353        if (!address.scale && !m_fixedWidth)
     354            m_assembler.addu(dest, address.index, address.base);
     355        else {
     356            m_assembler.sll(addrTempRegister, address.index, address.scale);
     357            m_assembler.addu(dest, addrTempRegister, address.base);
     358        }
    317359        if (address.offset)
    318360            add32(TrustedImm32(address.offset), dest);
    … …  
    846888    void load8(BaseIndex address, RegisterID dest)
    847889    {
    848         if (address.offset >= -32768 && address.offset <= 32767
    849             && !m_fixedWidth) {
    850             /*
    851              sll     addrTemp, address.index, address.scale
    852              addu    addrTemp, addrTemp, address.base
    853              lbu     dest, address.offset(addrTemp)
    854              */
    855             if (!address.scale)
    856                 m_assembler.addu(addrTempRegister, address.index, address.base);
    857             else {
    858                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    859                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    860             }
     890        if (!m_fixedWidth) {
     891            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    861892            m_assembler.lbu(dest, addrTempRegister, address.offset);
    862893        } else {
    … …  
    868899             lbu     dest, (address.offset & 0xffff)(at)
    869900             */
    870             if (!address.scale && !m_fixedWidth)
    871                 m_assembler.addu(addrTempRegister, address.index, address.base);
    872             else {
    873                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    874                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    875             }
     901            m_assembler.sll(addrTempRegister, address.index, address.scale);
     902            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    876903            m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);
    877904            m_assembler.addu(addrTempRegister, addrTempRegister, immTempRegister);
    … …  
    920947    void load8SignedExtendTo32(BaseIndex address, RegisterID dest)
    921948    {
    922         if (address.offset >= -32768 && address.offset <= 32767
    923             && !m_fixedWidth) {
    924             /*
    925                 sll     addrTemp, address.index, address.scale
    926                 addu    addrTemp, addrTemp, address.base
    927                 lb      dest, address.offset(addrTemp)
    928             */
    929             if (!address.scale)
    930                 m_assembler.addu(addrTempRegister, address.index, address.base);
    931             else {
    932                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    933                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    934             }
     949        if (!m_fixedWidth) {
     950            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    935951            m_assembler.lb(dest, addrTempRegister, address.offset);
    936952        } else {
    … …  
    942958                lb     dest, (address.offset & 0xffff)(at)
    943959            */
    944             if (!address.scale && !m_fixedWidth)
    945                 m_assembler.addu(addrTempRegister, address.index, address.base);
    946             else {
    947                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    948                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    949             }
     960            m_assembler.sll(addrTempRegister, address.index, address.scale);
     961            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    950962            m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);
    951963            m_assembler.addu(addrTempRegister, addrTempRegister, immTempRegister);
    … …  
    9951007    void load32(BaseIndex address, RegisterID dest)
    9961008    {
    997         if (address.offset >= -32768 && address.offset <= 32767
    998             && !m_fixedWidth) {
    999             /*
    1000                 sll     addrTemp, address.index, address.scale
    1001                 addu    addrTemp, addrTemp, address.base
    1002                 lw      dest, address.offset(addrTemp)
    1003             */
    1004             if (!address.scale)
    1005                 m_assembler.addu(addrTempRegister, address.index, address.base);
    1006             else {
    1007                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    1008                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    1009             }
     1009        if (!m_fixedWidth) {
     1010            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    10101011            m_assembler.lw(dest, addrTempRegister, address.offset);
    10111012        } else {
    … …  
    10361037                or      dest, dest, immTemp
    10371038            */
    1038             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1039             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1039            loadAddress(address, LoadAddressMode::Scale);
    10401040#if CPU(BIG_ENDIAN)
    10411041            m_assembler.lbu(immTempRegister, addrTempRegister, address.offset + 1);
    … …  
    10901090                lwr     dest, address.offset(addrTemp)
    10911091            */
    1092             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1093             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1092            loadAddress(address, LoadAddressMode::Scale);
    10941093#if CPU(BIG_ENDIAN)
    10951094            m_assembler.lwl(dest, addrTempRegister, address.offset);
    … …  
    11901189    void load16(BaseIndex address, RegisterID dest)
    11911190    {
    1192         if (address.offset >= -32768 && address.offset <= 32767
    1193             && !m_fixedWidth) {
    1194             /*
    1195                 sll     addrTemp, address.index, address.scale
    1196                 addu    addrTemp, addrTemp, address.base
    1197                 lhu     dest, address.offset(addrTemp)
    1198             */
    1199             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1200             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1191        if (!m_fixedWidth) {
     1192            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    12011193            m_assembler.lhu(dest, addrTempRegister, address.offset);
    12021194        } else {
    … …  
    12181210    void load16SignedExtendTo32(BaseIndex address, RegisterID dest)
    12191211    {
    1220         if (address.offset >= -32768 && address.offset <= 32767
    1221             && !m_fixedWidth) {
    1222             /*
    1223                 sll     addrTemp, address.index, address.scale
    1224                 addu    addrTemp, addrTemp, address.base
    1225                 lh     dest, address.offset(addrTemp)
    1226             */
    1227             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1228             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1212        if (!m_fixedWidth) {
     1213            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    12291214            m_assembler.lh(dest, addrTempRegister, address.offset);
    12301215        } else {
    … …  
    12631248    void store8(RegisterID src, BaseIndex address)
    12641249    {
    1265         if (address.offset >= -32768 && address.offset <= 32767
    1266             && !m_fixedWidth) {
    1267             /*
    1268                 sll     addrTemp, address.index, address.scale
    1269                 addu    addrTemp, addrTemp, address.base
    1270                 sb      src, address.offset(addrTemp)
    1271             */
    1272             if (!address.scale)
    1273                 m_assembler.addu(addrTempRegister, address.index, address.base);
    1274             else {
    1275                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    1276                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    1277             }
     1250        if (!m_fixedWidth) {
     1251            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    12781252            m_assembler.sb(src, addrTempRegister, address.offset);
    12791253        } else {
    … …  
    12851259                sb      src, (address.offset & 0xffff)(at)
    12861260            */
    1287             if (!address.scale && !m_fixedWidth)
    1288                 m_assembler.addu(addrTempRegister, address.index, address.base);
    1289             else {
    1290                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    1291                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    1292             }
     1261            m_assembler.sll(addrTempRegister, address.index, address.scale);
     1262            m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    12931263            m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);
    12941264            m_assembler.addu(addrTempRegister, addrTempRegister, immTempRegister);
    … …  
    13851355    void store16(RegisterID src, BaseIndex address)
    13861356    {
    1387         if (address.offset >= -32768 && address.offset <= 32767
    1388             && !m_fixedWidth) {
    1389             /*
    1390                 sll     addrTemp, address.index, address.scale
    1391                 addu    addrTemp, addrTemp, address.base
    1392                 sh      src, address.offset(addrTemp)
    1393             */
    1394             m_assembler.sll(addrTempRegister, address.index, address.scale);
    1395             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     1357        if (!m_fixedWidth) {
     1358            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    13961359            m_assembler.sh(src, addrTempRegister, address.offset);
    13971360        } else {
    … …  
    14301393    void store32(RegisterID src, BaseIndex address)
    14311394    {
    1432         if (address.offset >= -32768 && address.offset <= 32767
    1433             && !m_fixedWidth) {
    1434             /*
    1435                 sll     addrTemp, address.index, address.scale
    1436                 addu    addrTemp, addrTemp, address.base
    1437                 sw      src, address.offset(addrTemp)
    1438             */
    1439             if (!address.scale)
    1440                 m_assembler.addu(addrTempRegister, address.index, address.base);
    1441             else {
    1442                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    1443                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    1444             }
     1395        if (!m_fixedWidth) {
     1396            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    14451397            m_assembler.sw(src, addrTempRegister, address.offset);
    14461398        } else {
    … …  
    14891441    void store32(TrustedImm32 imm, BaseIndex address)
    14901442    {
    1491         if (address.offset >= -32768 && address.offset <= 32767 && !m_fixedWidth) {
    1492             /*
    1493                 sll     addrTemp, address.index, address.scale
    1494                 addu    addrTemp, addrTemp, address.base
    1495                 sw      src, address.offset(addrTemp)
    1496             */
    1497             if (!address.scale)
    1498                 m_assembler.addu(addrTempRegister, address.index, address.base);
    1499             else {
    1500                 m_assembler.sll(addrTempRegister, address.index, address.scale);
    1501                 m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
    1502             }
     1443        if (!m_fixedWidth) {
     1444            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    15031445            if (!imm.m_value)
    15041446                m_assembler.sw(MIPSRegisters::zero, addrTempRegister, address.offset);
    … …  
    15191461            m_assembler.lui(immTempRegister, (address.offset + 0x8000) >> 16);
    15201462            m_assembler.addu(addrTempRegister, addrTempRegister, immTempRegister);
    1521             if (!imm.m_value && !m_fixedWidth)
    1522                 m_assembler.sw(MIPSRegisters::zero, addrTempRegister, address.offset);
    1523             else {
    1524                 move(imm, immTempRegister);
    1525                 m_assembler.sw(immTempRegister, addrTempRegister, address.offset);
    1526             }
     1463            move(imm, immTempRegister);
     1464            m_assembler.sw(immTempRegister, addrTempRegister, address.offset);
    15271465        }
    15281466    }
    … …  
    18981836                }
    18991837            }
     1838#if WTF_MIPS_ISA_REV(2)
     1839            if (isPowerOf2(mask.m_value)) {
     1840                uint16_t pos= bitPosition(mask.m_value);
     1841                m_assembler.ext(cmpTempRegister, reg, pos, 1);
     1842                switch (cond) {
     1843                case Zero:
     1844                    return branchEqual(cmpTempRegister, MIPSRegisters::zero);
     1845                case NonZero:
     1846                    return branchNotEqual(cmpTempRegister, MIPSRegisters::zero);
     1847                case Signed:
     1848                    m_assembler.slt(cmpTempRegister, cmpTempRegister, MIPSRegisters::zero);
     1849                    return branchNotEqual(cmpTempRegister, MIPSRegisters::zero);
     1850                default:
     1851                    RELEASE_ASSERT_NOT_REACHED();
     1852                }
     1853            }
     1854#endif
    19001855            if (mask.m_value >= 0 && mask.m_value <= 65535) {
    19011856                m_assembler.andi(cmpTempRegister, reg, mask.m_value);
    … …  
    27642719    void loadFloat(BaseIndex address, FPRegisterID dest)
    27652720    {
    2766         if (address.offset >= -32768 && address.offset <= 32767
    2767             && !m_fixedWidth) {
    2768             /*
    2769                 sll     addrTemp, address.index, address.scale
    2770                 addu    addrTemp, addrTemp, address.base
    2771                 lwc1    dest, address.offset(addrTemp)
    2772             */
    2773             m_assembler.sll(addrTempRegister, address.index, address.scale);
    2774             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     2721        if (!m_fixedWidth) {
     2722            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    27752723            m_assembler.lwc1(dest, addrTempRegister, address.offset);
    27762724        } else {
    … …  
    28402788    {
    28412789#if WTF_MIPS_ISA(1)
    2842         if (address.offset >= -32768 && address.offset <= 32767
    2843             && !m_fixedWidth) {
    2844             /*
    2845                 sll     addrTemp, address.index, address.scale
    2846                 addu    addrTemp, addrTemp, address.base
    2847                 lwc1    dest, address.offset(addrTemp)
    2848                 lwc1    dest+1, (address.offset+4)(addrTemp)
    2849             */
    2850             m_assembler.sll(addrTempRegister, address.index, address.scale);
    2851             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     2790        if (!m_fixedWidth) {
     2791            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    28522792            m_assembler.lwc1(dest, addrTempRegister, address.offset);
    28532793            m_assembler.lwc1(FPRegisterID(dest + 1), addrTempRegister, address.offset + 4);
    … …  
    28692809        }
    28702810#else
    2871         if (address.offset >= -32768 && address.offset <= 32767
    2872             && !m_fixedWidth) {
    2873             /*
    2874                 sll     addrTemp, address.index, address.scale
    2875                 addu    addrTemp, addrTemp, address.base
    2876                 ldc1    dest, address.offset(addrTemp)
    2877             */
    2878             m_assembler.sll(addrTempRegister, address.index, address.scale);
    2879             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     2811        if (!m_fixedWidth) {
     2812            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    28802813            m_assembler.ldc1(dest, addrTempRegister, address.offset);
    28812814        } else {
    … …  
    29252858    void storeFloat(FPRegisterID src, BaseIndex address)
    29262859    {
    2927         if (address.offset >= -32768 && address.offset <= 32767
    2928             && !m_fixedWidth) {
    2929             /*
    2930                 sll     addrTemp, address.index, address.scale
    2931                 addu    addrTemp, addrTemp, address.base
    2932                 swc1    src, address.offset(addrTemp)
    2933             */
    2934             m_assembler.sll(addrTempRegister, address.index, address.scale);
    2935             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     2860        if (!m_fixedWidth) {
     2861            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    29362862            m_assembler.swc1(src, addrTempRegister, address.offset);
    29372863        } else {
    … …  
    30012927    {
    30022928#if WTF_MIPS_ISA(1)
    3003         if (address.offset >= -32768 && address.offset <= 32767
    3004             && !m_fixedWidth) {
    3005             /*
    3006                 sll     addrTemp, address.index, address.scale
    3007                 addu    addrTemp, addrTemp, address.base
    3008                 swc1    src, address.offset(addrTemp)
    3009                 swc1    src+1, (address.offset + 4)(addrTemp)
    3010             */
    3011             m_assembler.sll(addrTempRegister, address.index, address.scale);
    3012             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     2929        if (!m_fixedWidth) {
     2930            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    30132931            m_assembler.swc1(src, addrTempRegister, address.offset);
    30142932            m_assembler.swc1(FPRegisterID(src + 1), addrTempRegister, address.offset + 4);
    … …  
    30302948        }
    30312949#else
    3032         if (address.offset >= -32768 && address.offset <= 32767
    3033             && !m_fixedWidth) {
    3034             /*
    3035                 sll     addrTemp, address.index, address.scale
    3036                 addu    addrTemp, addrTemp, address.base
    3037                 sdc1    src, address.offset(addrTemp)
    3038             */
    3039             m_assembler.sll(addrTempRegister, address.index, address.scale);
    3040             m_assembler.addu(addrTempRegister, addrTempRegister, address.base);
     2950        if (!m_fixedWidth) {
     2951            loadAddress(address, LoadAddressMode::ScaleAndAddOffsetIfOffsetIsOutOfBounds);
    30412952            m_assembler.sdc1(src, addrTempRegister, address.offset);
    30422953        } else {
Note: See TracChangeset for help on using the changeset viewer.