Changeset 65303 in webkit for trunk/JavaScriptCore/assembler


Ignore:
Timestamp:
Aug 12, 2010, 11:49:16 PM (15 years ago)
Author:
[email protected]
Message:

Refactoring the fpu code generator for the ARM port
​https://bugs.webkit.org/show_bug.cgi?id=43842

Reviewed by Gavin Barraclough.

Support up to 32 double precision registers, and the
recent VFP instruction formats. This patch is mainly
a style change which keeps the current functionality.

  • assembler/ARMAssembler.h:

(JSC::ARMRegisters::):
(JSC::ARMAssembler::):
(JSC::ARMAssembler::emitInst):
(JSC::ARMAssembler::emitDoublePrecisionInst):
(JSC::ARMAssembler::emitSinglePrecisionInst):
(JSC::ARMAssembler::vadd_f64_r):
(JSC::ARMAssembler::vdiv_f64_r):
(JSC::ARMAssembler::vsub_f64_r):
(JSC::ARMAssembler::vmul_f64_r):
(JSC::ARMAssembler::vcmp_f64_r):
(JSC::ARMAssembler::vsqrt_f64_r):
(JSC::ARMAssembler::vmov_vfp_r):
(JSC::ARMAssembler::vmov_arm_r):
(JSC::ARMAssembler::vcvt_f64_s32_r):
(JSC::ARMAssembler::vcvt_s32_f64_r):
(JSC::ARMAssembler::vmrs_apsr):

  • assembler/MacroAssemblerARM.h:

(JSC::MacroAssemblerARM::addDouble):
(JSC::MacroAssemblerARM::divDouble):
(JSC::MacroAssemblerARM::subDouble):
(JSC::MacroAssemblerARM::mulDouble):
(JSC::MacroAssemblerARM::sqrtDouble):
(JSC::MacroAssemblerARM::convertInt32ToDouble):
(JSC::MacroAssemblerARM::branchDouble):
(JSC::MacroAssemblerARM::branchConvertDoubleToInt32):

Location:
trunk/JavaScriptCore/assembler
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/ARMAssembler.h

    r59038 r65303  
    4141            r1,
    4242            r2,
    43             r3,
    44             S0 = r3,
     43            r3, S0 = r3,
    4544            r4,
    4645            r5,
    4746            r6,
    4847            r7,
    49             r8,
    50             S1 = r8,
     48            r8, S1 = r8,
    5149            r9,
    5250            r10,
    5351            r11,
    5452            r12,
    55             r13,
    56             sp = r13,
    57             r14,
    58             lr = r14,
    59             r15,
    60             pc = r15
     53            r13, sp = r13,
     54            r14, lr = r14,
     55            r15, pc = r15
    6156        } RegisterID;
    6257
    … …  
    6560            d1,
    6661            d2,
    67             d3,
    68             SD0 = d3
     62            d3, SD0 = d3,
     63            d4,
     64            d5,
     65            d6,
     66            d7,
     67            d8,
     68            d9,
     69            d10,
     70            d11,
     71            d12,
     72            d13,
     73            d14,
     74            d15,
     75            d16,
     76            d17,
     77            d18,
     78            d19,
     79            d20,
     80            d21,
     81            d22,
     82            d23,
     83            d24,
     84            d25,
     85            d26,
     86            d27,
     87            d28,
     88            d29,
     89            d30,
     90            d31
    6991        } FPRegisterID;
    7092
    … …  
    119141            MUL = 0x00000090,
    120142            MULL = 0x00c00090,
    121             FADDD = 0x0e300b00,
    122             FDIVD = 0x0e800b00,
    123             FSUBD = 0x0e300b40,
    124             FMULD = 0x0e200b00,
    125             FCMPD = 0x0eb40b40,
    126             FSQRTD = 0x0eb10bc0,
     143            VADD_F64 = 0x0e300b00,
     144            VDIV_F64 = 0x0e800b00,
     145            VSUB_F64 = 0x0e300b40,
     146            VMUL_F64 = 0x0e200b00,
     147            VCMP_F64 = 0x0eb40b40,
     148            VSQRT_F64 = 0x0eb10bc0,
    127149            DTR = 0x05000000,
    128150            LDRH = 0x00100090,
    … …  
    136158            BX = 0x012fff10,
    137159#endif
    138             FMSR = 0x0e000a10,
    139             FMRS = 0x0e100a10,
    140             FSITOD = 0x0eb80bc0,
    141             FTOSID = 0x0ebd0b40,
    142             FMSTAT = 0x0ef1fa10,
     160            VMOV_VFP = 0x0e000a10,
     161            VMOV_ARM = 0x0e100a10,
     162            VCVT_F64_S32 = 0x0eb80bc0,
     163            VCVT_S32_F64 = 0x0ebd0b40,
     164            VMRS_APSR = 0x0ef1fa10,
    143165#if WTF_ARM_ARCH_AT_LEAST(5)
    144166            CLZ = 0x016f0f10,
    … …  
    235257        void emitInst(ARMWord op, int rd, int rn, ARMWord op2)
    236258        {
    237             ASSERT ( ((op2 & ~OP2_IMM) <= 0xfff) || (((op2 & ~OP2_IMMh) <= 0xfff)) );
     259            ASSERT(((op2 & ~OP2_IMM) <= 0xfff) || (((op2 & ~OP2_IMMh) <= 0xfff)));
    238260            m_buffer.putInt(op | RN(rn) | RD(rd) | op2);
     261        }
     262
     263        void emitDoublePrecisionInst(ARMWord op, int dd, int dn, int dm)
     264        {
     265            ASSERT((dd >= 0 && dd <= 31) && (dn >= 0 && dn <= 31) && (dm >= 0 && dm <= 31));
     266            m_buffer.putInt(op | ((dd & 0xf) << 12) | ((dd & 0x10) << (22 - 4))
     267                               | ((dn & 0xf) << 16) | ((dn & 0x10) << (7 - 4))
     268                               | (dm & 0xf) | ((dm & 0x10) << (5 - 4)));
     269        }
     270
     271        void emitSinglePrecisionInst(ARMWord op, int sd, int sn, int sm)
     272        {
     273            ASSERT((sd >= 0 && sd <= 31) && (sn >= 0 && sn <= 31) && (sm >= 0 && sm <= 31));
     274            m_buffer.putInt(op | ((sd >> 1) << 12) | ((sd & 0x1) << 22)
     275                               | ((sn >> 1) << 16) | ((sn & 0x1) << 7)
     276                               | (sm >> 1) | ((sm & 0x1) << 5));
    239277        }
    240278
    … …  
    403441        }
    404442
    405         void faddd_r(int dd, int dn, int dm, Condition cc = AL)
    406         {
    407             emitInst(static_cast<ARMWord>(cc) | FADDD, dd, dn, dm);
    408         }
    409 
    410         void fdivd_r(int dd, int dn, int dm, Condition cc = AL)
    411         {
    412             emitInst(static_cast<ARMWord>(cc) | FDIVD, dd, dn, dm);
    413         }
    414 
    415         void fsubd_r(int dd, int dn, int dm, Condition cc = AL)
    416         {
    417             emitInst(static_cast<ARMWord>(cc) | FSUBD, dd, dn, dm);
    418         }
    419 
    420         void fmuld_r(int dd, int dn, int dm, Condition cc = AL)
    421         {
    422             emitInst(static_cast<ARMWord>(cc) | FMULD, dd, dn, dm);
    423         }
    424 
    425         void fcmpd_r(int dd, int dm, Condition cc = AL)
    426         {
    427             emitInst(static_cast<ARMWord>(cc) | FCMPD, dd, 0, dm);
    428         }
    429 
    430         void fsqrtd_r(int dd, int dm, Condition cc = AL)
    431         {
    432             emitInst(static_cast<ARMWord>(cc) | FSQRTD, dd, 0, dm);
     443        void vadd_f64_r(int dd, int dn, int dm, Condition cc = AL)
     444        {
     445            emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VADD_F64, dd, dn, dm);
     446        }
     447
     448        void vdiv_f64_r(int dd, int dn, int dm, Condition cc = AL)
     449        {
     450            emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VDIV_F64, dd, dn, dm);
     451        }
     452
     453        void vsub_f64_r(int dd, int dn, int dm, Condition cc = AL)
     454        {
     455            emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VSUB_F64, dd, dn, dm);
     456        }
     457
     458        void vmul_f64_r(int dd, int dn, int dm, Condition cc = AL)
     459        {
     460            emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VMUL_F64, dd, dn, dm);
     461        }
     462
     463        void vcmp_f64_r(int dd, int dm, Condition cc = AL)
     464        {
     465            emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VCMP_F64, dd, 0, dm);
     466        }
     467
     468        void vsqrt_f64_r(int dd, int dm, Condition cc = AL)
     469        {
     470            emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VSQRT_F64, dd, 0, dm);
    433471        }
    434472
    … …  
    517555        }
    518556
    519         void fmsr_r(int dd, int rn, Condition cc = AL)
    520         {
    521             emitInst(static_cast<ARMWord>(cc) | FMSR, rn, dd, 0);
    522         }
    523 
    524         void fmrs_r(int rd, int dn, Condition cc = AL)
    525         {
    526             emitInst(static_cast<ARMWord>(cc) | FMRS, rd, dn, 0);
    527         }
    528 
    529         void fsitod_r(int dd, int dm, Condition cc = AL)
    530         {
    531             emitInst(static_cast<ARMWord>(cc) | FSITOD, dd, 0, dm);
    532         }
    533 
    534         void ftosid_r(int fd, int dm, Condition cc = AL)
    535         {
    536             emitInst(static_cast<ARMWord>(cc) | FTOSID, fd, 0, dm);
    537         }
    538 
    539         void fmstat(Condition cc = AL)
    540         {
    541             m_buffer.putInt(static_cast<ARMWord>(cc) | FMSTAT);
     557        void vmov_vfp_r(int sn, int rt, Condition cc = AL)
     558        {
     559            ASSERT(rt <= 15);
     560            emitSinglePrecisionInst(static_cast<ARMWord>(cc) | VMOV_VFP, rt << 1, sn, 0);
     561        }
     562
     563        void vmov_arm_r(int rt, int sn, Condition cc = AL)
     564        {
     565            ASSERT(rt <= 15);
     566            emitSinglePrecisionInst(static_cast<ARMWord>(cc) | VMOV_ARM, rt << 1, sn, 0);
     567        }
     568
     569        void vcvt_f64_s32_r(int dd, int sm, Condition cc = AL)
     570        {
     571            ASSERT(!(sm & 0x1)); // sm must be divisible by 2
     572            emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VCVT_F64_S32, dd, 0, (sm >> 1));
     573        }
     574
     575        void vcvt_s32_f64_r(int sd, int dm, Condition cc = AL)
     576        {
     577            ASSERT(!(sd & 0x1)); // sd must be divisible by 2
     578            emitDoublePrecisionInst(static_cast<ARMWord>(cc) | VCVT_S32_F64, (sd >> 1), 0, dm);
     579        }
     580
     581        void vmrs_apsr(Condition cc = AL)
     582        {
     583            m_buffer.putInt(static_cast<ARMWord>(cc) | VMRS_APSR);
    542584        }
    543585

  • trunk/JavaScriptCore/assembler/MacroAssemblerARM.h

    r63228 r65303  
    796796    void addDouble(FPRegisterID src, FPRegisterID dest)
    797797    {
    798         m_assembler.faddd_r(dest, dest, src);
     798        m_assembler.vadd_f64_r(dest, dest, src);
    799799    }
    800800
    … …  
    807807    void divDouble(FPRegisterID src, FPRegisterID dest)
    808808    {
    809         m_assembler.fdivd_r(dest, dest, src);
     809        m_assembler.vdiv_f64_r(dest, dest, src);
    810810    }
    811811
    … …  
    819819    void subDouble(FPRegisterID src, FPRegisterID dest)
    820820    {
    821         m_assembler.fsubd_r(dest, dest, src);
     821        m_assembler.vsub_f64_r(dest, dest, src);
    822822    }
    823823
    … …  
    830830    void mulDouble(FPRegisterID src, FPRegisterID dest)
    831831    {
    832         m_assembler.fmuld_r(dest, dest, src);
     832        m_assembler.vmul_f64_r(dest, dest, src);
    833833    }
    834834
    … …  
    841841    void sqrtDouble(FPRegisterID src, FPRegisterID dest)
    842842    {
    843         m_assembler.fsqrtd_r(dest, src);
     843        m_assembler.vsqrt_f64_r(dest, src);
    844844    }
    845845
    846846    void convertInt32ToDouble(RegisterID src, FPRegisterID dest)
    847847    {
    848         m_assembler.fmsr_r(dest, src);
    849         m_assembler.fsitod_r(dest, dest);
     848        m_assembler.vmov_vfp_r(dest << 1, src);
     849        m_assembler.vcvt_f64_s32_r(dest, dest << 1);
    850850    }
    851851
    … …  
    869869    Jump branchDouble(DoubleCondition cond, FPRegisterID left, FPRegisterID right)
    870870    {
    871         m_assembler.fcmpd_r(left, right);
    872         m_assembler.fmstat();
     871        m_assembler.vcmp_f64_r(left, right);
     872        m_assembler.vmrs_apsr();
    873873        if (cond & DoubleConditionBitSpecial)
    874874            m_assembler.cmp_r(ARMRegisters::S0, ARMRegisters::S0, ARMAssembler::VS);
    … …  
    894894    void branchConvertDoubleToInt32(FPRegisterID src, RegisterID dest, JumpList& failureCases, FPRegisterID fpTemp)
    895895    {
    896         m_assembler.ftosid_r(ARMRegisters::SD0, src);
    897         m_assembler.fmrs_r(dest, ARMRegisters::SD0);
     896        m_assembler.vcvt_s32_f64_r(ARMRegisters::SD0 << 1, src);
     897        m_assembler.vmov_arm_r(dest, ARMRegisters::SD0 << 1);
    898898
    899899        // Convert the integer result back to float & compare to the original value - if not equal or unordered (NaN) then jump.
    900         m_assembler.fsitod_r(ARMRegisters::SD0, ARMRegisters::SD0);
     900        m_assembler.vcvt_f64_s32_r(ARMRegisters::SD0, ARMRegisters::SD0 << 1);
    901901        failureCases.append(branchDouble(DoubleNotEqualOrUnordered, src, ARMRegisters::SD0));
    902902
Note: See TracChangeset for help on using the changeset viewer.