Changeset 62306 in webkit for trunk/JavaScriptCore/assembler


Ignore:
Timestamp:
Jul 1, 2010, 3:56:58 PM (15 years ago)
Author:
[email protected]
Message:

Bug 41490 - Add missing operations to MacroAssemblerARMv7
Also, make single, double, quad register numbers in ARMv7Assembler distinct & strongly typed.

Reviewed by Oliver Hunt.

  • assembler/ARMv7Assembler.h:

(JSC::ARMRegisters::):
(JSC::ARMRegisters::asSingle):
(JSC::ARMRegisters::asDouble):
(JSC::VFPImmediate::VFPImmediate):
(JSC::VFPImmediate::isValid):
(JSC::VFPImmediate::value):
(JSC::ARMv7Assembler::singleRegisterMask):
(JSC::ARMv7Assembler::doubleRegisterMask):
(JSC::ARMv7Assembler::):
(JSC::ARMv7Assembler::add_S):
(JSC::ARMv7Assembler::neg):
(JSC::ARMv7Assembler::orr_S):
(JSC::ARMv7Assembler::sub):
(JSC::ARMv7Assembler::sub_S):
(JSC::ARMv7Assembler::vadd_F64):
(JSC::ARMv7Assembler::vcmp_F64):
(JSC::ARMv7Assembler::vcvt_F64_S32):
(JSC::ARMv7Assembler::vcvtr_S32_F64):
(JSC::ARMv7Assembler::vdiv_F64):
(JSC::ARMv7Assembler::vldr):
(JSC::ARMv7Assembler::vmov_F64_0):
(JSC::ARMv7Assembler::vmov):
(JSC::ARMv7Assembler::vmul_F64):
(JSC::ARMv7Assembler::vstr):
(JSC::ARMv7Assembler::vsub_F64):
(JSC::ARMv7Assembler::vcvt):
(JSC::ARMv7Assembler::vmem):

  • assembler/AbstractMacroAssembler.h:
  • assembler/MacroAssemblerARM.h:
  • assembler/MacroAssemblerARMv7.h:

(JSC::MacroAssemblerARMv7::fpTempRegisterAsSingle):
(JSC::MacroAssemblerARMv7::neg32):
(JSC::MacroAssemblerARMv7::loadDouble):
(JSC::MacroAssemblerARMv7::divDouble):
(JSC::MacroAssemblerARMv7::convertInt32ToDouble):
(JSC::MacroAssemblerARMv7::branchConvertDoubleToInt32):
(JSC::MacroAssemblerARMv7::zeroDouble):
(JSC::MacroAssemblerARMv7::branchOr32):
(JSC::MacroAssemblerARMv7::set32):
(JSC::MacroAssemblerARMv7::set8):

  • assembler/MacroAssemblerMIPS.h:
  • assembler/MacroAssemblerX86Common.h:
Location:
trunk/JavaScriptCore/assembler
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/ARMv7Assembler.h

    r59037 r62306  
    5757    } RegisterID;
    5858
    59     // s0 == d0 == q0
    60     // s4 == d2 == q1
    61     // etc
    6259    typedef enum {
    63         s0 = 0,
    64         s1 = 1,
    65         s2 = 2,
    66         s3 = 3,
    67         s4 = 4,
    68         s5 = 5,
    69         s6 = 6,
    70         s7 = 7,
    71         s8 = 8,
    72         s9 = 9,
    73         s10 = 10,
    74         s11 = 11,
    75         s12 = 12,
    76         s13 = 13,
    77         s14 = 14,
    78         s15 = 15,
    79         s16 = 16,
    80         s17 = 17,
    81         s18 = 18,
    82         s19 = 19,
    83         s20 = 20,
    84         s21 = 21,
    85         s22 = 22,
    86         s23 = 23,
    87         s24 = 24,
    88         s25 = 25,
    89         s26 = 26,
    90         s27 = 27,
    91         s28 = 28,
    92         s29 = 29,
    93         s30 = 30,
    94         s31 = 31,
    95         d0 = 0 << 1,
    96         d1 = 1 << 1,
    97         d2 = 2 << 1,
    98         d3 = 3 << 1,
    99         d4 = 4 << 1,
    100         d5 = 5 << 1,
    101         d6 = 6 << 1,
    102         d7 = 7 << 1,
    103         d8 = 8 << 1,
    104         d9 = 9 << 1,
    105         d10 = 10 << 1,
    106         d11 = 11 << 1,
    107         d12 = 12 << 1,
    108         d13 = 13 << 1,
    109         d14 = 14 << 1,
    110         d15 = 15 << 1,
    111         d16 = 16 << 1,
    112         d17 = 17 << 1,
    113         d18 = 18 << 1,
    114         d19 = 19 << 1,
    115         d20 = 20 << 1,
    116         d21 = 21 << 1,
    117         d22 = 22 << 1,
    118         d23 = 23 << 1,
    119         d24 = 24 << 1,
    120         d25 = 25 << 1,
    121         d26 = 26 << 1,
    122         d27 = 27 << 1,
    123         d28 = 28 << 1,
    124         d29 = 29 << 1,
    125         d30 = 30 << 1,
    126         d31 = 31 << 1,
    127         q0 = 0 << 2,
    128         q1 = 1 << 2,
    129         q2 = 2 << 2,
    130         q3 = 3 << 2,
    131         q4 = 4 << 2,
    132         q5 = 5 << 2,
    133         q6 = 6 << 2,
    134         q7 = 7 << 2,
    135         q8 = 8 << 2,
    136         q9 = 9 << 2,
    137         q10 = 10 << 2,
    138         q11 = 11 << 2,
    139         q12 = 12 << 2,
    140         q13 = 13 << 2,
    141         q14 = 14 << 2,
    142         q15 = 15 << 2,
    143         q16 = 16 << 2,
    144         q17 = 17 << 2,
    145         q18 = 18 << 2,
    146         q19 = 19 << 2,
    147         q20 = 20 << 2,
    148         q21 = 21 << 2,
    149         q22 = 22 << 2,
    150         q23 = 23 << 2,
    151         q24 = 24 << 2,
    152         q25 = 25 << 2,
    153         q26 = 26 << 2,
    154         q27 = 27 << 2,
    155         q28 = 28 << 2,
    156         q29 = 29 << 2,
    157         q30 = 30 << 2,
    158         q31 = 31 << 2,
    159     } FPRegisterID;
     60        s0,
     61        s1,
     62        s2,
     63        s3,
     64        s4,
     65        s5,
     66        s6,
     67        s7,
     68        s8,
     69        s9,
     70        s10,
     71        s11,
     72        s12,
     73        s13,
     74        s14,
     75        s15,
     76        s16,
     77        s17,
     78        s18,
     79        s19,
     80        s20,
     81        s21,
     82        s22,
     83        s23,
     84        s24,
     85        s25,
     86        s26,
     87        s27,
     88        s28,
     89        s29,
     90        s30,
     91        s31,
     92    } FPSingleRegisterID;
     93
     94    typedef enum {
     95        d0,
     96        d1,
     97        d2,
     98        d3,
     99        d4,
     100        d5,
     101        d6,
     102        d7,
     103        d8,
     104        d9,
     105        d10,
     106        d11,
     107        d12,
     108        d13,
     109        d14,
     110        d15,
     111        d16,
     112        d17,
     113        d18,
     114        d19,
     115        d20,
     116        d21,
     117        d22,
     118        d23,
     119        d24,
     120        d25,
     121        d26,
     122        d27,
     123        d28,
     124        d29,
     125        d30,
     126        d31,
     127    } FPDoubleRegisterID;
     128
     129    typedef enum {
     130        q0,
     131        q1,
     132        q2,
     133        q3,
     134        q4,
     135        q5,
     136        q6,
     137        q7,
     138        q8,
     139        q9,
     140        q10,
     141        q11,
     142        q12,
     143        q13,
     144        q14,
     145        q15,
     146        q16,
     147        q17,
     148        q18,
     149        q19,
     150        q20,
     151        q21,
     152        q22,
     153        q23,
     154        q24,
     155        q25,
     156        q26,
     157        q27,
     158        q28,
     159        q29,
     160        q30,
     161        q31,
     162    } FPQuadRegisterID;
     163
     164    inline FPSingleRegisterID asSingle(FPDoubleRegisterID reg)
     165    {
     166        ASSERT(reg < d16);
     167        return (FPSingleRegisterID)(reg << 1);
     168    }
     169
     170    inline FPDoubleRegisterID asDouble(FPSingleRegisterID reg)
     171    {
     172        ASSERT(!(reg & 1));
     173        return (FPDoubleRegisterID)(reg >> 1);
     174    }
    160175}
    161176
    … …  
    355370};
    356371
     372class VFPImmediate {
     373public:
     374    VFPImmediate(double d)
     375        : m_value(-1)
     376    {
     377        union {
     378            uint64_t i;
     379            double d;
     380        } u;
     381
     382        u.d = d;
     383
     384        int sign = (u.i >> 63);
     385        int exponent = (u.i >> 52) & 0x7ff;
     386        uint64_t mantissa = u.i & 0x000fffffffffffffull;
     387
     388        if ((exponent >= 0x3fc) && (exponent <= 0x403) && !(mantissa & 0x0000ffffffffffffull))
     389            m_value = (sign << 7) | ((exponent & 7) << 4) | (int)(mantissa >> 48);
     390    }
     391
     392    bool isValid()
     393    {
     394        return m_value != -1;
     395    }
     396   
     397    uint8_t value()
     398    {
     399        return (uint8_t)m_value;
     400    }
     401
     402private:
     403    int m_value;
     404};
    357405
    358406typedef enum {
    … …  
    418466
    419467    typedef ARMRegisters::RegisterID RegisterID;
    420     typedef ARMRegisters::FPRegisterID FPRegisterID;
     468    typedef ARMRegisters::FPSingleRegisterID FPSingleRegisterID;
     469    typedef ARMRegisters::FPDoubleRegisterID FPDoubleRegisterID;
     470    typedef ARMRegisters::FPQuadRegisterID FPQuadRegisterID;
    421471
    422472    // (HS, LO, HI, LS) -> (AE, B, A, BE)
    … …  
    504554    }
    505555
    506     bool isSingleRegister(FPRegisterID reg)
    507     {
    508         // Check that the high bit isn't set (q16+), and that the low bit isn't (s1, s3, etc).
    509         return !(reg & ~31);
    510     }
    511 
    512     bool isDoubleRegister(FPRegisterID reg)
    513     {
    514         // Check that the high bit isn't set (q16+), and that the low bit isn't (s1, s3, etc).
    515         return !(reg & ~(31 << 1));
    516     }
    517 
    518     bool isQuadRegister(FPRegisterID reg)
    519     {
    520         return !(reg & ~(31 << 2));
    521     }
    522 
    523     uint32_t singleRegisterNum(FPRegisterID reg)
    524     {
    525         ASSERT(isSingleRegister(reg));
    526         return reg;
    527     }
    528 
    529     uint32_t doubleRegisterNum(FPRegisterID reg)
    530     {
    531         ASSERT(isDoubleRegister(reg));
    532         return reg >> 1;
    533     }
    534 
    535     uint32_t quadRegisterNum(FPRegisterID reg)
    536     {
    537         ASSERT(isQuadRegister(reg));
    538         return reg >> 2;
    539     }
    540 
    541     uint32_t singleRegisterMask(FPRegisterID rd, int highBitsShift, int lowBitShift)
    542     {
    543         uint32_t rdNum = singleRegisterNum(rd);
     556    uint32_t singleRegisterMask(FPSingleRegisterID rdNum, int highBitsShift, int lowBitShift)
     557    {
    544558        uint32_t rdMask = (rdNum >> 1) << highBitsShift;
    545559        if (rdNum & 1)
    … …  
    548562    }
    549563
    550     uint32_t doubleRegisterMask(FPRegisterID rd, int highBitShift, int lowBitsShift)
    551     {
    552         uint32_t rdNum = doubleRegisterNum(rd);
     564    uint32_t doubleRegisterMask(FPDoubleRegisterID rdNum, int highBitShift, int lowBitsShift)
     565    {
    553566        uint32_t rdMask = (rdNum & 0xf) << lowBitsShift;
    554567        if (rdNum & 16)
    … …  
    559572    typedef enum {
    560573        OP_ADD_reg_T1       = 0x1800,
    561         OP_ADD_S_reg_T1     = 0x1800,
    562574        OP_SUB_reg_T1       = 0x1A00,
    563         OP_SUB_S_reg_T1     = 0x1A00,
    564575        OP_ADD_imm_T1       = 0x1C00,
    565         OP_ADD_S_imm_T1     = 0x1C00,
    566576        OP_SUB_imm_T1       = 0x1E00,
    567         OP_SUB_S_imm_T1     = 0x1E00,
    568577        OP_MOV_imm_T1       = 0x2000,
    569578        OP_CMP_imm_T1       = 0x2800,
    570579        OP_ADD_imm_T2       = 0x3000,
    571         OP_ADD_S_imm_T2     = 0x3000,
    572580        OP_SUB_imm_T2       = 0x3800,
    573         OP_SUB_S_imm_T2     = 0x3800,
    574581        OP_AND_reg_T1       = 0x4000,
    575582        OP_EOR_reg_T1       = 0x4040,
    576583        OP_TST_reg_T1       = 0x4200,
     584        OP_RSB_imm_T1       = 0x4240,
    577585        OP_CMP_reg_T1       = 0x4280,
    578586        OP_ORR_reg_T1       = 0x4300,
    … …  
    604612        OP_TST_reg_T2   = 0xEA10,
    605613        OP_ORR_reg_T2   = 0xEA40,
     614        OP_ORR_S_reg_T2 = 0xEA50,
    606615        OP_ASR_imm_T1   = 0xEA4F,
    607616        OP_LSL_imm_T1   = 0xEA4F,
    … …  
    628637        OP_SUB_S_imm_T3 = 0xF1B0,
    629638        OP_CMP_imm_T2   = 0xF1B0,
     639        OP_RSB_imm_T2   = 0xF1C0,
    630640        OP_ADD_imm_T4   = 0xF200,
    631641        OP_MOV_imm_T3   = 0xF240,
    … …  
    785795        if (!((rd | rn) & 8)) {
    786796            if (imm.isUInt3()) {
    787                 m_formatter.oneWordOp7Reg3Reg3Reg3(OP_ADD_S_imm_T1, (RegisterID)imm.getUInt3(), rn, rd);
     797                m_formatter.oneWordOp7Reg3Reg3Reg3(OP_ADD_imm_T1, (RegisterID)imm.getUInt3(), rn, rd);
    788798                return;
    789799            } else if ((rd == rn) && imm.isUInt8()) {
    790                 m_formatter.oneWordOp5Reg3Imm8(OP_ADD_S_imm_T2, rd, imm.getUInt8());
     800                m_formatter.oneWordOp5Reg3Imm8(OP_ADD_imm_T2, rd, imm.getUInt8());
    791801                return;
    792802            }
    … …  
    810820    {
    811821        if (!((rd | rn | rm) & 8))
    812             m_formatter.oneWordOp7Reg3Reg3Reg3(OP_ADD_S_reg_T1, rm, rn, rd);
     822            m_formatter.oneWordOp7Reg3Reg3Reg3(OP_ADD_reg_T1, rm, rn, rd);
    813823        else
    814824            add_S(rd, rn, rm, ShiftTypeAndAmount());
    … …  
    12201230    }
    12211231
     1232    void neg(RegisterID rd, RegisterID rm)
     1233    {
     1234        ARMThumbImmediate zero = ARMThumbImmediate::makeUInt12(0);
     1235        sub(rd, zero, rm);
     1236    }
     1237
    12221238    void orr(RegisterID rd, RegisterID rn, ARMThumbImmediate imm)
    12231239    {
    … …  
    12441260        else
    12451261            orr(rd, rn, rm, ShiftTypeAndAmount());
     1262    }
     1263
     1264    void orr_S(RegisterID rd, RegisterID rn, RegisterID rm, ShiftTypeAndAmount shift)
     1265    {
     1266        ASSERT(!BadReg(rd));
     1267        ASSERT(!BadReg(rn));
     1268        ASSERT(!BadReg(rm));
     1269        m_formatter.twoWordOp12Reg4FourFours(OP_ORR_S_reg_T2, rn, FourFours(shift.hi4(), rd, shift.lo4(), rm));
     1270    }
     1271
     1272    void orr_S(RegisterID rd, RegisterID rn, RegisterID rm)
     1273    {
     1274        if ((rd == rn) && !((rd | rm) & 8))
     1275            m_formatter.oneWordOp10Reg3Reg3(OP_ORR_reg_T1, rm, rd);
     1276        else if ((rd == rm) && !((rd | rn) & 8))
     1277            m_formatter.oneWordOp10Reg3Reg3(OP_ORR_reg_T1, rn, rd);
     1278        else
     1279            orr_S(rd, rn, rm, ShiftTypeAndAmount());
    12461280    }
    12471281
    … …  
    13621396    }
    13631397
     1398    void sub(RegisterID rd, ARMThumbImmediate imm, RegisterID rn)
     1399    {
     1400        ASSERT(rd != ARMRegisters::pc);
     1401        ASSERT(rn != ARMRegisters::pc);
     1402        ASSERT(imm.isValid());
     1403        ASSERT(imm.isUInt12());
     1404
     1405        if (!((rd | rn) & 8) && !imm.getUInt12())
     1406            m_formatter.oneWordOp10Reg3Reg3(OP_RSB_imm_T1, rn, rd);
     1407        else
     1408            m_formatter.twoWordOp5i6Imm4Reg4EncodedImm(OP_RSB_imm_T2, rn, rd, imm);
     1409    }
     1410
    13641411    void sub(RegisterID rd, RegisterID rn, RegisterID rm, ShiftTypeAndAmount shift)
    13651412    {
    … …  
    13941441        } else if (!((rd | rn) & 8)) {
    13951442            if (imm.isUInt3()) {
    1396                 m_formatter.oneWordOp7Reg3Reg3Reg3(OP_SUB_S_imm_T1, (RegisterID)imm.getUInt3(), rn, rd);
     1443                m_formatter.oneWordOp7Reg3Reg3Reg3(OP_SUB_imm_T1, (RegisterID)imm.getUInt3(), rn, rd);
    13971444                return;
    13981445            } else if ((rd == rn) && imm.isUInt8()) {
    1399                 m_formatter.oneWordOp5Reg3Imm8(OP_SUB_S_imm_T2, rd, imm.getUInt8());
     1446                m_formatter.oneWordOp5Reg3Imm8(OP_SUB_imm_T2, rd, imm.getUInt8());
    14001447                return;
    14011448            }
    … …  
    14191466    {
    14201467        if (!((rd | rn | rm) & 8))
    1421             m_formatter.oneWordOp7Reg3Reg3Reg3(OP_SUB_S_reg_T1, rm, rn, rd);
     1468            m_formatter.oneWordOp7Reg3Reg3Reg3(OP_SUB_reg_T1, rm, rn, rd);
    14221469        else
    14231470            sub_S(rd, rn, rm, ShiftTypeAndAmount());
    … …  
    14471494    }
    14481495
    1449     void vadd_F64(FPRegisterID rd, FPRegisterID rn, FPRegisterID rm)
     1496    void vadd_F64(FPDoubleRegisterID rd, FPDoubleRegisterID rn, FPDoubleRegisterID rm)
    14501497    {
    14511498        m_formatter.vfpOp(0x0b00ee30 | doubleRegisterMask(rd, 6, 28) | doubleRegisterMask(rn, 23, 0) | doubleRegisterMask(rm, 21, 16));
    14521499    }
    14531500
    1454     void vcmp_F64(FPRegisterID rd, FPRegisterID rm)
     1501    void vcmp_F64(FPDoubleRegisterID rd, FPDoubleRegisterID rm)
    14551502    {
    14561503        m_formatter.vfpOp(0x0bc0eeb4 | doubleRegisterMask(rd, 6, 28) | doubleRegisterMask(rm, 21, 16));
    14571504    }
    14581505
    1459     void vcvt_F64_S32(FPRegisterID fd, FPRegisterID sm)
    1460     {
    1461         m_formatter.vfpOp(0x0bc0eeb8 | doubleRegisterMask(fd, 6, 28) | singleRegisterMask(sm, 16, 21));
    1462     }
    1463 
    1464     void vcvt_S32_F64(FPRegisterID sd, FPRegisterID fm)
    1465     {
    1466         m_formatter.vfpOp(0x0bc0eebd | singleRegisterMask(sd, 28, 6) | doubleRegisterMask(fm, 21, 16));
    1467     }
    1468 
    1469     void vldr(FPRegisterID rd, RegisterID rn, int32_t imm)
     1506    void vcvt_F64_S32(FPDoubleRegisterID rd, FPSingleRegisterID rm)
     1507    {
     1508        vcvt(doubleRegisterMask(rd, 6, 28), singleRegisterMask(rm, 16, 21), false, false, false, true);
     1509    }
     1510
     1511    void vcvtr_S32_F64(FPSingleRegisterID rd, FPDoubleRegisterID rm)
     1512    {
     1513        vcvt(singleRegisterMask(rd, 6, 28), doubleRegisterMask(rm, 16, 21), true, false, true, true);
     1514    }
     1515
     1516    void vdiv_F64(FPDoubleRegisterID rd, FPDoubleRegisterID rn, FPDoubleRegisterID rm)
     1517    {
     1518        m_formatter.vfpOp(0x0b00ee80 | doubleRegisterMask(rd, 6, 28) | doubleRegisterMask(rn, 23, 0) | doubleRegisterMask(rm, 21, 16));
     1519    }
     1520
     1521    void vldr(FPDoubleRegisterID rd, RegisterID rn, int32_t imm)
    14701522    {
    14711523        vmem(rd, rn, imm, true);
    14721524    }
    14731525
    1474     void vmov(RegisterID rd, FPRegisterID sn)
     1526    void vmov_F64_0(FPDoubleRegisterID rd)
     1527    {
     1528        m_formatter.vfpOp(0x0b00eeb0 | doubleRegisterMask(rd, 28, 6));
     1529    }
     1530
     1531    void vmov(RegisterID rd, FPSingleRegisterID sn)
    14751532    {
    14761533        m_formatter.vfpOp(0x0a10ee10 | (rd << 28) | singleRegisterMask(sn, 0, 23));
    14771534    }
    14781535
    1479     void vmov(FPRegisterID sn, RegisterID rd)
     1536    void vmov(FPSingleRegisterID sn, RegisterID rd)
    14801537    {
    14811538        m_formatter.vfpOp(0x0a10ee00 | (rd << 28) | singleRegisterMask(sn, 0, 23));
    … …  
    14881545    }
    14891546
    1490     void vmul_F64(FPRegisterID rd, FPRegisterID rn, FPRegisterID rm)
     1547    void vmul_F64(FPDoubleRegisterID rd, FPDoubleRegisterID rn, FPDoubleRegisterID rm)
    14911548    {
    14921549        m_formatter.vfpOp(0x0b00ee20 | doubleRegisterMask(rd, 6, 28) | doubleRegisterMask(rn, 23, 0) | doubleRegisterMask(rm, 21, 16));
    14931550    }
    14941551
    1495     void vstr(FPRegisterID rd, RegisterID rn, int32_t imm)
     1552    void vstr(FPDoubleRegisterID rd, RegisterID rn, int32_t imm)
    14961553    {
    14971554        vmem(rd, rn, imm, false);
    14981555    }
    14991556
    1500     void vsub_F64(FPRegisterID rd, FPRegisterID rn, FPRegisterID rm)
     1557    void vsub_F64(FPDoubleRegisterID rd, FPDoubleRegisterID rn, FPDoubleRegisterID rm)
    15011558    {
    15021559        m_formatter.vfpOp(0x0b40ee30 | doubleRegisterMask(rd, 6, 28) | doubleRegisterMask(rn, 23, 0) | doubleRegisterMask(rm, 21, 16));
    … …  
    16651722private:
    16661723
     1724    void vcvt(uint32_t rdMask, uint32_t rmMask, bool toInteger, bool isUnsigned, bool isRoundZero, bool isDouble)
     1725    {
     1726        // Cannot specify rounding when converting to float.
     1727        ASSERT(toInteger || !isRoundZero);
     1728
     1729        // 'sz' field
     1730        int op = isDouble ? 0x0b40eeb8 : 0x0a40eeb8;
     1731
     1732        if (toInteger) {
     1733            // opc2 indicates both toInteger & isUnsigned.
     1734            op |= isUnsigned ? 0x00000004 : 0x00000005;
     1735            // 'op' field in instruction is isRoundZero
     1736            if (isRoundZero)
     1737                op |= 0x00800000;
     1738        } else {
     1739            // 'op' field in instruction is isUnsigned
     1740            if (!isUnsigned)
     1741                op |= 0x00800000;
     1742        }
     1743        m_formatter.vfpOp(op | rdMask | rmMask);
     1744    }
     1745
    16671746    // Arm vfp addresses can be offset by a 9-bit ones-comp immediate, left shifted by 2.
    16681747    // (i.e. +/-(0..255) 32-bit words)
    1669     void vmem(FPRegisterID rd, RegisterID rn, int32_t imm, bool isLoad)
     1748    void vmem(FPDoubleRegisterID rd, RegisterID rn, int32_t imm, bool isLoad)
    16701749    {
    16711750        bool up;

  • trunk/JavaScriptCore/assembler/AbstractMacroAssembler.h

    r58469 r62306  
    5050
    5151    typedef typename AssemblerType::RegisterID RegisterID;
    52     typedef typename AssemblerType::FPRegisterID FPRegisterID;
    5352    typedef typename AssemblerType::JmpSrc JmpSrc;
    5453    typedef typename AssemblerType::JmpDst JmpDst;

  • trunk/JavaScriptCore/assembler/MacroAssemblerARM.h

    r59038 r62306  
    4141    COMPILE_ASSERT(!(DoubleConditionBitSpecial & DoubleConditionMask), DoubleConditionBitSpecial_should_not_interfere_with_ARMAssembler_Condition_codes);
    4242public:
     43    typedef ARMRegisters::FPRegisterID FPRegisterID;
     44
    4345    enum Condition {
    4446        Equal = ARMAssembler::EQ,

  • trunk/JavaScriptCore/assembler/MacroAssemblerARMv7.h

    r60577 r62306  
    3939    //        - dTR is likely used more than aTR, and we'll get better instruction
    4040    //        encoding if it's in the low 8 registers.
    41     static const ARMRegisters::RegisterID dataTempRegister = ARMRegisters::ip;
     41    static const RegisterID dataTempRegister = ARMRegisters::ip;
    4242    static const RegisterID addressTempRegister = ARMRegisters::r3;
    43     static const FPRegisterID fpTempRegister = ARMRegisters::d7;
    44 
     43
     44    static const ARMRegisters::FPDoubleRegisterID fpTempRegister = ARMRegisters::d7;
     45    inline ARMRegisters::FPSingleRegisterID fpTempRegisterAsSingle() { return ARMRegisters::asSingle(fpTempRegister); }
     46
     47public:
    4548    struct ArmAddress {
    4649        enum AddressType {
    … …  
    7477   
    7578public:
     79    typedef ARMRegisters::FPDoubleRegisterID FPRegisterID;
    7680
    7781    static const Scale ScalePtr = TimesFour;
    … …  
    223227    }
    224228
     229    void neg32(RegisterID srcDest)
     230    {
     231        m_assembler.neg(srcDest, srcDest);
     232    }
     233
    225234    void not32(RegisterID srcDest)
    226235    {
    … …  
    541550    }
    542551
     552    void loadDouble(const void* address, FPRegisterID dest)
     553    {
     554        move(ImmPtr(address), addressTempRegister);
     555        m_assembler.vldr(dest, addressTempRegister, 0);
     556    }
     557
    543558    void storeDouble(FPRegisterID src, ImplicitAddress address)
    544559    {
    … …  
    567582    }
    568583
     584    void divDouble(FPRegisterID src, FPRegisterID dest)
     585    {
     586        m_assembler.vdiv_F64(dest, dest, src);
     587    }
     588
    569589    void subDouble(FPRegisterID src, FPRegisterID dest)
    570590    {
    … …  
    596616    void convertInt32ToDouble(RegisterID src, FPRegisterID dest)
    597617    {
    598         m_assembler.vmov(fpTempRegister, src);
    599         m_assembler.vcvt_F64_S32(dest, fpTempRegister);
     618        m_assembler.vmov(fpTempRegisterAsSingle(), src);
     619        m_assembler.vcvt_F64_S32(dest, fpTempRegisterAsSingle());
     620    }
     621
     622    void convertInt32ToDouble(Address address, FPRegisterID dest)
     623    {
     624        // Fixme: load directly into the fpr!
     625        load32(address, dataTempRegister);
     626        m_assembler.vmov(fpTempRegisterAsSingle(), dataTempRegister);
     627        m_assembler.vcvt_F64_S32(dest, fpTempRegisterAsSingle());
     628    }
     629
     630    void convertInt32ToDouble(AbsoluteAddress address, FPRegisterID dest)
     631    {
     632        // Fixme: load directly into the fpr!
     633        load32(address.m_ptr, dataTempRegister);
     634        m_assembler.vmov(fpTempRegisterAsSingle(), dataTempRegister);
     635        m_assembler.vcvt_F64_S32(dest, fpTempRegisterAsSingle());
    600636    }
    601637
    … …  
    630666    }
    631667
     668    // Convert 'src' to an integer, and places the resulting 'dest'.
     669    // If the result is not representable as a 32 bit value, branch.
     670    // May also branch for some values that are representable in 32 bits
     671    // (specifically, in this case, 0).
     672    void branchConvertDoubleToInt32(FPRegisterID src, RegisterID dest, JumpList& failureCases, FPRegisterID)
     673    {
     674        m_assembler.vcvtr_S32_F64(fpTempRegisterAsSingle(), src);
     675        m_assembler.vmov(dest, fpTempRegisterAsSingle());
     676
     677        // Convert the integer result back to float & compare to the original value - if not equal or unordered (NaN) then jump.
     678        m_assembler.vcvt_F64_S32(fpTempRegister, fpTempRegisterAsSingle());
     679        failureCases.append(branchDouble(DoubleNotEqualOrUnordered, src, fpTempRegister));
     680
     681        // If the result is zero, it might have been -0.0, and the double comparison won't catch this!
     682        failureCases.append(branchTest32(Zero, dest));
     683    }
     684
     685    void zeroDouble(FPRegisterID dest)
     686    {
     687        m_assembler.vmov_F64_0(dest);
     688    }
    632689
    633690    // Stack manipulation operations:
    … …  
    9711028    }
    9721029
     1030    Jump branchOr32(Condition cond, RegisterID src, RegisterID dest)
     1031    {
     1032        ASSERT((cond == Signed) || (cond == Zero) || (cond == NonZero));
     1033        m_assembler.orr_S(dest, dest, src);
     1034        return Jump(makeBranch(cond));
     1035    }
     1036
    9731037    Jump branchSub32(Condition cond, RegisterID src, RegisterID dest)
    9741038    {
    … …  
    10351099    }
    10361100
     1101    void set32(Condition cond, Address left, RegisterID right, RegisterID dest)
     1102    {
     1103        load32(left, dataTempRegister);
     1104        set32(cond, dataTempRegister, right, dest);
     1105    }
     1106
    10371107    void set32(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
    10381108    {
    … …  
    10411111        m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(1));
    10421112        m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(0));
     1113    }
     1114
     1115    void set8(Condition cond, RegisterID left, RegisterID right, RegisterID dest)
     1116    {
     1117        set32(cond, left, right, dest);
     1118    }
     1119
     1120    void set8(Condition cond, Address left, RegisterID right, RegisterID dest)
     1121    {
     1122        set32(cond, left, right, dest);
     1123    }
     1124
     1125    void set8(Condition cond, RegisterID left, Imm32 right, RegisterID dest)
     1126    {
     1127        set32(cond, left, right, dest);
    10431128    }
    10441129

  • trunk/JavaScriptCore/assembler/MacroAssemblerMIPS.h

    r60383 r62306  
    3737class MacroAssemblerMIPS : public AbstractMacroAssembler<MIPSAssembler> {
    3838public:
     39    typedef MIPSRegisters::FPRegisterID FPRegisterID;
    3940
    4041    MacroAssemblerMIPS()

  • trunk/JavaScriptCore/assembler/MacroAssemblerX86Common.h

    r58902 r62306  
    4040
    4141public:
     42    typedef X86Assembler::FPRegisterID FPRegisterID;
    4243
    4344    enum Condition {
Note: See TracChangeset for help on using the changeset viewer.