Changeset 46832 in webkit for trunk/JavaScriptCore/assembler


Ignore:
Timestamp:
Aug 5, 2009, 10:33:27 PM (16 years ago)
Author:
[email protected]
Message:

2009-08-05 Zoltan Herczeg <​[email protected]>

Reviewed by Gavin Barraclough.

Add floating point support for generic ARM port.
​https://bugs.webkit.org/show_bug.cgi?id=24986

  • assembler/ARMAssembler.cpp: (JSC::ARMAssembler::doubleTransfer):
  • assembler/ARMAssembler.h: (JSC::ARM::): (JSC::ARMAssembler::): (JSC::ARMAssembler::faddd_r): (JSC::ARMAssembler::fsubd_r): (JSC::ARMAssembler::fmuld_r): (JSC::ARMAssembler::fcmpd_r): (JSC::ARMAssembler::fdtr_u): (JSC::ARMAssembler::fdtr_d): (JSC::ARMAssembler::fmsr_r): (JSC::ARMAssembler::fsitod_r): (JSC::ARMAssembler::fmstat):
  • assembler/MacroAssemblerARM.h: (JSC::MacroAssemblerARM::): (JSC::MacroAssemblerARM::supportsFloatingPoint): (JSC::MacroAssemblerARM::loadDouble): (JSC::MacroAssemblerARM::storeDouble): (JSC::MacroAssemblerARM::addDouble): (JSC::MacroAssemblerARM::subDouble): (JSC::MacroAssemblerARM::mulDouble): (JSC::MacroAssemblerARM::convertInt32ToDouble): (JSC::MacroAssemblerARM::branchDouble):
  • jit/JIT.h:
Location:
trunk/JavaScriptCore/assembler
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/ARMAssembler.cpp

    r46831 r46832  
    335335}
    336336
     337void ARMAssembler::doubleTransfer(bool isLoad, FPRegisterID srcDst, RegisterID base, int32_t offset)
     338{
     339    if (offset & 0x3) {
     340        if (offset <= 0x3ff && offset >= 0) {
     341            fdtr_u(isLoad, srcDst, base, offset >> 2);
     342            return;
     343        }
     344        if (offset <= 0x3ffff && offset >= 0) {
     345            add_r(ARM::S0, base, OP2_IMM | (offset >> 10) | (11 << 8));
     346            fdtr_u(isLoad, srcDst, ARM::S0, (offset >> 2) & 0xff);
     347            return;
     348        }
     349        offset = -offset;
     350
     351        if (offset <= 0x3ff && offset >= 0) {
     352            fdtr_d(isLoad, srcDst, base, offset >> 2);
     353            return;
     354        }
     355        if (offset <= 0x3ffff && offset >= 0) {
     356            sub_r(ARM::S0, base, OP2_IMM | (offset >> 10) | (11 << 8));
     357            fdtr_d(isLoad, srcDst, ARM::S0, (offset >> 2) & 0xff);
     358            return;
     359        }
     360        offset = -offset;
     361    }
     362
     363    ldr_un_imm(ARM::S0, offset);
     364    add_r(ARM::S0, ARM::S0, base);
     365    fdtr_u(isLoad, srcDst, ARM::S0, 0);
     366}
     367
    337368void* ARMAssembler::executableCopy(ExecutablePool* allocator)
    338369{

  • trunk/JavaScriptCore/assembler/ARMAssembler.h

    r46247 r46832  
    6464
    6565    typedef enum {
    66         fp0 //FIXME
     66        d0,
     67        d1,
     68        d2,
     69        d3,
     70        SD0 = d3
    6771    } FPRegisterID;
     72
    6873} // namespace ARM
    6974
    … …  
    116121            MUL = 0x00000090,
    117122            MULL = 0x00c00090,
     123            FADDD = 0x0e300b00,
     124            FSUBD = 0x0e300b40,
     125            FMULD = 0x0e200b00,
     126            FCMPD = 0x0eb40b40,
    118127            DTR = 0x05000000,
    119128            LDRH = 0x00100090,
    … …  
    121130            STMDB = 0x09200000,
    122131            LDMIA = 0x08b00000,
     132            FDTR = 0x0d000b00,
    123133            B = 0x0a000000,
    124134            BL = 0x0b000000,
     135            FMSR = 0x0e000a10,
     136            FSITOD = 0x0eb80bc0,
     137            FMSTAT = 0x0ef1fa10,
    125138#if ARM_ARCH_VERSION >= 5
    126139            CLZ = 0x016f0f10,
    … …  
    365378        }
    366379
     380        void faddd_r(int dd, int dn, int dm, Condition cc = AL)
     381        {
     382            emitInst(static_cast<ARMWord>(cc) | FADDD, dd, dn, dm);
     383        }
     384
     385        void fsubd_r(int dd, int dn, int dm, Condition cc = AL)
     386        {
     387            emitInst(static_cast<ARMWord>(cc) | FSUBD, dd, dn, dm);
     388        }
     389
     390        void fmuld_r(int dd, int dn, int dm, Condition cc = AL)
     391        {
     392            emitInst(static_cast<ARMWord>(cc) | FMULD, dd, dn, dm);
     393        }
     394
     395        void fcmpd_r(int dd, int dm, Condition cc = AL)
     396        {
     397            emitInst(static_cast<ARMWord>(cc) | FCMPD, dd, 0, dm);
     398        }
     399
    367400        void ldr_imm(int rd, ARMWord imm, Condition cc = AL)
    368401        {
    … …  
    413446        {
    414447            emitInst(static_cast<ARMWord>(cc) | STRH | HDT_UH | DT_UP | DT_PRE, rd, rn, rm);
     448        }
     449
     450        void fdtr_u(bool isLoad, int rd, int rb, ARMWord op2, Condition cc = AL)
     451        {
     452            ASSERT(op2 <= 0xff);
     453            emitInst(static_cast<ARMWord>(cc) | FDTR | DT_UP | (isLoad ? DT_LOAD : 0), rd, rb, op2);
     454        }
     455
     456        void fdtr_d(bool isLoad, int rd, int rb, ARMWord op2, Condition cc = AL)
     457        {
     458            ASSERT(op2 <= 0xff);
     459            emitInst(static_cast<ARMWord>(cc) | FDTR | (isLoad ? DT_LOAD : 0), rd, rb, op2);
    415460        }
    416461
    … …  
    435480        {
    436481            dtr_u(true, reg, ARM::sp, 0, cc);
     482        }
     483
     484        void fmsr_r(int dd, int rn, Condition cc = AL)
     485        {
     486            emitInst(static_cast<ARMWord>(cc) | FMSR, rn, dd, 0);
     487        }
     488
     489        void fsitod_r(int dd, int dm, Condition cc = AL)
     490        {
     491            emitInst(static_cast<ARMWord>(cc) | FSITOD, dd, 0, dm);
     492        }
     493
     494        void fmstat(Condition cc = AL)
     495        {
     496            m_buffer.putInt(static_cast<ARMWord>(cc) | FMSTAT);
    437497        }
    438498
    … …  
    654714        void dataTransfer32(bool isLoad, RegisterID srcDst, RegisterID base, int32_t offset);
    655715        void baseIndexTransfer32(bool isLoad, RegisterID srcDst, RegisterID base, RegisterID index, int scale, int32_t offset);
     716        void doubleTransfer(bool isLoad, FPRegisterID srcDst, RegisterID base, int32_t offset);
    656717
    657718        // Constant pool hnadlers

  • trunk/JavaScriptCore/assembler/MacroAssemblerARM.h

    r46831 r46832  
    5858
    5959    enum DoubleCondition {
    60         DoubleEqual, //FIXME
    61         DoubleNotEqual, //FIXME
    62         DoubleGreaterThan, //FIXME
    63         DoubleGreaterThanOrEqual, //FIXME
    64         DoubleLessThan, //FIXME
    65         DoubleLessThanOrEqual, //FIXME
     60        DoubleEqual = ARMAssembler::EQ,
     61        DoubleGreaterThan = ARMAssembler::GT,
     62        DoubleGreaterThanOrEqual = ARMAssembler::GE,
     63        DoubleLessThan = ARMAssembler::LT,
     64        DoubleLessThanOrEqual = ARMAssembler::LE,
    6665    };
    6766
    … …  
    641640    bool supportsFloatingPoint() const
    642641    {
     642        // FIXME: should be a dynamic test: VFP, FPA, or nothing
    643643        return false;
    644644    }
    … …  
    651651    void loadDouble(ImplicitAddress address, FPRegisterID dest)
    652652    {
    653         UNUSED_PARAM(address);
    654         UNUSED_PARAM(dest);
    655         ASSERT_NOT_REACHED();
     653        m_assembler.doubleTransfer(true, dest, address.base, address.offset);
    656654    }
    657655
    658656    void storeDouble(FPRegisterID src, ImplicitAddress address)
    659657    {
    660         UNUSED_PARAM(src);
    661         UNUSED_PARAM(address);
    662         ASSERT_NOT_REACHED();
     658        m_assembler.doubleTransfer(false, src, address.base, address.offset);
    663659    }
    664660
    665661    void addDouble(FPRegisterID src, FPRegisterID dest)
    666662    {
    667         UNUSED_PARAM(src);
    668         UNUSED_PARAM(dest);
    669         ASSERT_NOT_REACHED();
     663        m_assembler.faddd_r(dest, dest, src);
    670664    }
    671665
    672666    void addDouble(Address src, FPRegisterID dest)
    673667    {
    674         UNUSED_PARAM(src);
    675         UNUSED_PARAM(dest);
    676         ASSERT_NOT_REACHED();
     668        loadDouble(src, ARM::SD0);
     669        addDouble(ARM::SD0, dest);
    677670    }
    678671
    679672    void subDouble(FPRegisterID src, FPRegisterID dest)
    680673    {
    681         UNUSED_PARAM(src);
    682         UNUSED_PARAM(dest);
    683         ASSERT_NOT_REACHED();
     674        m_assembler.fsubd_r(dest, dest, src);
    684675    }
    685676
    686677    void subDouble(Address src, FPRegisterID dest)
    687678    {
    688         UNUSED_PARAM(src);
    689         UNUSED_PARAM(dest);
    690         ASSERT_NOT_REACHED();
     679        loadDouble(src, ARM::SD0);
     680        subDouble(ARM::SD0, dest);
    691681    }
    692682
    693683    void mulDouble(FPRegisterID src, FPRegisterID dest)
    694684    {
    695         UNUSED_PARAM(src);
    696         UNUSED_PARAM(dest);
    697         ASSERT_NOT_REACHED();
     685        m_assembler.fmuld_r(dest, dest, src);
    698686    }
    699687
    700688    void mulDouble(Address src, FPRegisterID dest)
    701689    {
    702         UNUSED_PARAM(src);
    703         UNUSED_PARAM(dest);
    704         ASSERT_NOT_REACHED();
     690        loadDouble(src, ARM::SD0);
     691        mulDouble(ARM::SD0, dest);
    705692    }
    706693
    707694    void convertInt32ToDouble(RegisterID src, FPRegisterID dest)
    708695    {
    709         UNUSED_PARAM(src);
    710         UNUSED_PARAM(dest);
    711         ASSERT_NOT_REACHED();
     696        m_assembler.fmsr_r(dest, src);
     697        m_assembler.fsitod_r(dest, dest);
    712698    }
    713699
    714700    Jump branchDouble(DoubleCondition cond, FPRegisterID left, FPRegisterID right)
    715701    {
    716         UNUSED_PARAM(cond);
    717         UNUSED_PARAM(left);
    718         UNUSED_PARAM(right);
    719         ASSERT_NOT_REACHED();
    720         return jump();
     702        m_assembler.fcmpd_r(left, right);
     703        m_assembler.fmstat();
     704        return Jump(m_assembler.jmp(static_cast<ARMAssembler::Condition>(cond)));
    721705    }
    722706
Note: See TracChangeset for help on using the changeset viewer.