⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 194388 in webkit


Ignore:
Timestamp:
Dec 23, 2015, 3:52:39 AM (11 years ago)
Author:
commit-queue@webkit.org
Message:

[JSC] Get the JavaScriptCore framework to build on ARM64 with B3 enabled
​https://bugs.webkit.org/show_bug.cgi?id=152503

Patch by Benjamin Poulain <​bpoulain@apple.com> on 2015-12-23
Reviewed by Filip Pizlo.

It is not working but it builds.

  • assembler/ARM64Assembler.h:

(JSC::ARM64Assembler::vand):
(JSC::ARM64Assembler::vectorDataProcessing2Source):

  • assembler/MacroAssemblerARM64.h:

(JSC::MacroAssemblerARM64::add32):
(JSC::MacroAssemblerARM64::add64):
(JSC::MacroAssemblerARM64::countLeadingZeros64):
(JSC::MacroAssemblerARM64::not32):
(JSC::MacroAssemblerARM64::not64):
(JSC::MacroAssemblerARM64::zeroExtend16To32):
(JSC::MacroAssemblerARM64::signExtend16To32):
(JSC::MacroAssemblerARM64::zeroExtend8To32):
(JSC::MacroAssemblerARM64::signExtend8To32):
(JSC::MacroAssemblerARM64::addFloat):
(JSC::MacroAssemblerARM64::ceilFloat):
(JSC::MacroAssemblerARM64::branchDouble):
(JSC::MacroAssemblerARM64::branchFloat):
(JSC::MacroAssemblerARM64::divFloat):
(JSC::MacroAssemblerARM64::moveZeroToDouble):
(JSC::MacroAssemblerARM64::moveFloatTo32):
(JSC::MacroAssemblerARM64::move32ToFloat):
(JSC::MacroAssemblerARM64::moveConditionallyDouble):
(JSC::MacroAssemblerARM64::moveConditionallyFloat):
(JSC::MacroAssemblerARM64::moveConditionallyAfterFloatingPointCompare):
(JSC::MacroAssemblerARM64::mulFloat):
(JSC::MacroAssemblerARM64::andDouble):
(JSC::MacroAssemblerARM64::andFloat):
(JSC::MacroAssemblerARM64::sqrtFloat):
(JSC::MacroAssemblerARM64::subFloat):
(JSC::MacroAssemblerARM64::signExtend32ToPtr):
(JSC::MacroAssemblerARM64::moveConditionally32):
(JSC::MacroAssemblerARM64::moveConditionally64):
(JSC::MacroAssemblerARM64::moveConditionallyTest32):
(JSC::MacroAssemblerARM64::moveConditionallyTest64):
(JSC::MacroAssemblerARM64::test32):
(JSC::MacroAssemblerARM64::setCarry):
(JSC::MacroAssemblerARM64::jumpAfterFloatingPointCompare):

  • assembler/MacroAssemblerX86.h:

(JSC::MacroAssemblerX86::moveDoubleToInts):
(JSC::MacroAssemblerX86::moveIntsToDouble):

  • assembler/MacroAssemblerX86Common.h:

(JSC::MacroAssemblerX86Common::move32ToFloat):
(JSC::MacroAssemblerX86Common::moveFloatTo32):
(JSC::MacroAssemblerX86Common::moveInt32ToPacked): Deleted.
(JSC::MacroAssemblerX86Common::movePackedToInt32): Deleted.

  • b3/B3LowerToAir.cpp:

(JSC::B3::Air::LowerToAir::appendShift):
(JSC::B3::Air::LowerToAir::lower):

  • b3/air/AirInstInlines.h:

(JSC::B3::Air::isX86DivHelperValid):

  • b3/air/AirOpcode.opcodes:
  • jit/AssemblyHelpers.h:

(JSC::AssemblyHelpers::emitFunctionEpilogueWithEmptyFrame):
(JSC::AssemblyHelpers::emitFunctionEpilogue):

  • jit/FPRInfo.h:

(JSC::FPRInfo::toArgumentRegister):

Location:
trunk/Source/JavaScriptCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r194387 r194388  
     12015-12-23  Benjamin Poulain  <bpoulain@apple.com>
     2
     3        [JSC] Get the JavaScriptCore framework to build on ARM64 with B3 enabled
     4        https://bugs.webkit.org/show_bug.cgi?id=152503
     5
     6        Reviewed by Filip Pizlo.
     7
     8        It is not working but it builds.
     9
     10        * assembler/ARM64Assembler.h:
     11        (JSC::ARM64Assembler::vand):
     12        (JSC::ARM64Assembler::vectorDataProcessing2Source):
     13        * assembler/MacroAssemblerARM64.h:
     14        (JSC::MacroAssemblerARM64::add32):
     15        (JSC::MacroAssemblerARM64::add64):
     16        (JSC::MacroAssemblerARM64::countLeadingZeros64):
     17        (JSC::MacroAssemblerARM64::not32):
     18        (JSC::MacroAssemblerARM64::not64):
     19        (JSC::MacroAssemblerARM64::zeroExtend16To32):
     20        (JSC::MacroAssemblerARM64::signExtend16To32):
     21        (JSC::MacroAssemblerARM64::zeroExtend8To32):
     22        (JSC::MacroAssemblerARM64::signExtend8To32):
     23        (JSC::MacroAssemblerARM64::addFloat):
     24        (JSC::MacroAssemblerARM64::ceilFloat):
     25        (JSC::MacroAssemblerARM64::branchDouble):
     26        (JSC::MacroAssemblerARM64::branchFloat):
     27        (JSC::MacroAssemblerARM64::divFloat):
     28        (JSC::MacroAssemblerARM64::moveZeroToDouble):
     29        (JSC::MacroAssemblerARM64::moveFloatTo32):
     30        (JSC::MacroAssemblerARM64::move32ToFloat):
     31        (JSC::MacroAssemblerARM64::moveConditionallyDouble):
     32        (JSC::MacroAssemblerARM64::moveConditionallyFloat):
     33        (JSC::MacroAssemblerARM64::moveConditionallyAfterFloatingPointCompare):
     34        (JSC::MacroAssemblerARM64::mulFloat):
     35        (JSC::MacroAssemblerARM64::andDouble):
     36        (JSC::MacroAssemblerARM64::andFloat):
     37        (JSC::MacroAssemblerARM64::sqrtFloat):
     38        (JSC::MacroAssemblerARM64::subFloat):
     39        (JSC::MacroAssemblerARM64::signExtend32ToPtr):
     40        (JSC::MacroAssemblerARM64::moveConditionally32):
     41        (JSC::MacroAssemblerARM64::moveConditionally64):
     42        (JSC::MacroAssemblerARM64::moveConditionallyTest32):
     43        (JSC::MacroAssemblerARM64::moveConditionallyTest64):
     44        (JSC::MacroAssemblerARM64::test32):
     45        (JSC::MacroAssemblerARM64::setCarry):
     46        (JSC::MacroAssemblerARM64::jumpAfterFloatingPointCompare):
     47        * assembler/MacroAssemblerX86.h:
     48        (JSC::MacroAssemblerX86::moveDoubleToInts):
     49        (JSC::MacroAssemblerX86::moveIntsToDouble):
     50        * assembler/MacroAssemblerX86Common.h:
     51        (JSC::MacroAssemblerX86Common::move32ToFloat):
     52        (JSC::MacroAssemblerX86Common::moveFloatTo32):
     53        (JSC::MacroAssemblerX86Common::moveInt32ToPacked): Deleted.
     54        (JSC::MacroAssemblerX86Common::movePackedToInt32): Deleted.
     55        * b3/B3LowerToAir.cpp:
     56        (JSC::B3::Air::LowerToAir::appendShift):
     57        (JSC::B3::Air::LowerToAir::lower):
     58        * b3/air/AirInstInlines.h:
     59        (JSC::B3::Air::isX86DivHelperValid):
     60        * b3/air/AirOpcode.opcodes:
     61        * jit/AssemblyHelpers.h:
     62        (JSC::AssemblyHelpers::emitFunctionEpilogueWithEmptyFrame):
     63        (JSC::AssemblyHelpers::emitFunctionEpilogue):
     64        * jit/FPRInfo.h:
     65        (JSC::FPRInfo::toArgumentRegister):
     66
    1672015-12-23  Andy VanWagoner  <andy@instructure.com>
    268

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

    r191130 r194388  
    3939#define MEMOPSIZE_OF(datasize) ((datasize == 8 || datasize == 128) ? MemOpSize_8_or_128 : (datasize == 16) ? MemOpSize_16 : (datasize == 32) ? MemOpSize_32 : MemOpSize_64)
    4040#define CHECK_DATASIZE() CHECK_DATASIZE_OF(datasize)
     41#define CHECK_VECTOR_DATASIZE() ASSERT(datasize == 64 || datasize == 128)
    4142#define DATASIZE DATASIZE_OF(datasize)
    4243#define MEMOPSIZE MEMOPSIZE_OF(datasize)
    … …  
    862863    };
    863864
     865    enum SIMD3Same {
     866        SIMD_LogicalOp_AND = 0x03
     867    };
     868
    864869    enum FPIntConvOp {
    865870        FPIntConvOp_FCVTNS = 0x00,
    … …  
    24162421        CHECK_DATASIZE();
    24172422        insn(floatingPointDataProcessing2Source(DATASIZE, vm, FPDataOp_FNMUL, vn, vd));
     2423    }
     2424
     2425    template<int datasize>
     2426    ALWAYS_INLINE void vand(FPRegisterID vd, FPRegisterID vn, FPRegisterID vm)
     2427    {
     2428        CHECK_VECTOR_DATASIZE();
     2429        insn(vectorDataProcessing2Source(SIMD_LogicalOp_AND, vm, vn, vd));
    24182430    }
    24192431
    … …  
    34743486    }
    34753487
     3488    ALWAYS_INLINE static int vectorDataProcessing2Source(SIMD3Same opcode, unsigned size, FPRegisterID vm, FPRegisterID vn, FPRegisterID vd)
     3489    {
     3490        const int Q = 0;
     3491        return (0xe201c00 | Q << 30 | size << 22 | vm << 16 | opcode << 11 | vn << 5 | vd);
     3492    }
     3493
     3494    ALWAYS_INLINE static int vectorDataProcessing2Source(SIMD3Same opcode, FPRegisterID vm, FPRegisterID vn, FPRegisterID vd)
     3495    {
     3496        return vectorDataProcessing2Source(opcode, 0, vm, vn, vd);
     3497    }
     3498
     3499
    34763500    // 'o1' means negate
    34773501    ALWAYS_INLINE static int floatingPointDataProcessing3Source(Datasize type, bool o1, FPRegisterID rm, AddOp o2, FPRegisterID ra, FPRegisterID rn, FPRegisterID rd)

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

    r194208 r194388  
    135135    // Integer operations:
    136136
     137    void add32(RegisterID a, RegisterID b, RegisterID dest)
     138    {
     139        ASSERT(a != ARM64Registers::sp && b != ARM64Registers::sp);
     140        m_assembler.add<32>(dest, a, b);
     141    }
     142
    137143    void add32(RegisterID src, RegisterID dest)
    138144    {
    … …  
    214220    }
    215221
     222    void add64(RegisterID a, RegisterID b, RegisterID dest)
     223    {
     224        ASSERT(a != ARM64Registers::sp || b != ARM64Registers::sp);
     225        if (b == ARM64Registers::sp)
     226            std::swap(a, b);
     227        m_assembler.add<64>(dest, a, b);
     228    }
     229
    216230    void add64(RegisterID src, RegisterID dest)
    217231    {
    … …  
    409423    }
    410424
     425    void countLeadingZeros64(RegisterID src, RegisterID dest)
     426    {
     427        m_assembler.clz<64>(dest, src);
     428    }
     429
    411430    void lshift32(RegisterID src, RegisterID shiftAmount, RegisterID dest)
    412431    {
    … …  
    814833    }
    815834
     835    void not32(RegisterID src, RegisterID dest)
     836    {
     837        m_assembler.mvn<32>(dest, src);
     838    }
     839
     840    void not64(RegisterID src, RegisterID dest)
     841    {
     842        m_assembler.mvn<64>(dest, src);
     843    }
    816844
    817845    // Memory access operations:
    … …  
    964992    }
    965993
     994    void zeroExtend16To32(RegisterID src, RegisterID dest)
     995    {
     996        m_assembler.uxth<64>(dest, src);
     997    }
     998
     999    void signExtend16To32(RegisterID src, RegisterID dest)
     1000    {
     1001        m_assembler.sxth<64>(dest, src);
     1002    }
     1003
    9661004    void load8(ImplicitAddress address, RegisterID dest)
    9671005    {
    … …  
    10031041        m_assembler.add<64>(memoryTempRegister, memoryTempRegister, address.index, ARM64Assembler::UXTX, address.scale);
    10041042        m_assembler.ldrsb<32>(dest, address.base, memoryTempRegister);
     1043    }
     1044
     1045    void zeroExtend8To32(RegisterID src, RegisterID dest)
     1046    {
     1047        m_assembler.uxtb<64>(dest, src);
     1048    }
     1049
     1050    void signExtend8To32(RegisterID src, RegisterID dest)
     1051    {
     1052        m_assembler.sxtb<64>(dest, src);
    10051053    }
    10061054
    … …  
    12311279    }
    12321280
     1281    void addFloat(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1282    {
     1283        m_assembler.fadd<32>(dest, op1, op2);
     1284    }
     1285
    12331286    void ceilDouble(FPRegisterID src, FPRegisterID dest)
    12341287    {
    12351288        m_assembler.frintp<64>(dest, src);
     1289    }
     1290
     1291    void ceilFloat(FPRegisterID src, FPRegisterID dest)
     1292    {
     1293        m_assembler.frintp<32>(dest, src);
    12361294    }
    12371295
    … …  
    12661324    {
    12671325        m_assembler.fcmp<64>(left, right);
    1268 
    1269         if (cond == DoubleNotEqual) {
    1270             // ConditionNE jumps if NotEqual *or* unordered - force the unordered cases not to jump.
    1271             Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    1272             Jump result = makeBranch(ARM64Assembler::ConditionNE);
    1273             unordered.link(this);
    1274             return result;
    1275         }
    1276         if (cond == DoubleEqualOrUnordered) {
    1277             Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
    1278             Jump notEqual = makeBranch(ARM64Assembler::ConditionNE);
    1279             unordered.link(this);
    1280             // We get here if either unordered or equal.
    1281             Jump result = jump();
    1282             notEqual.link(this);
    1283             return result;
    1284         }
    1285         return makeBranch(cond);
     1326        return jumpAfterFloatingPointCompare(cond);
     1327    }
     1328
     1329    Jump branchFloat(DoubleCondition cond, FPRegisterID left, FPRegisterID right)
     1330    {
     1331        m_assembler.fcmp<32>(left, right);
     1332        return jumpAfterFloatingPointCompare(cond);
    12861333    }
    12871334
    … …  
    13651412    }
    13661413
     1414    void divFloat(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1415    {
     1416        m_assembler.fdiv<32>(dest, op1, op2);
     1417    }
     1418
    13671419    void loadDouble(ImplicitAddress address, FPRegisterID dest)
    13681420    {
    … …  
    14091461    }
    14101462
     1463    void moveZeroToDouble(FPRegisterID reg)
     1464    {
     1465        m_assembler.fmov<64>(reg, ARM64Registers::zr);
     1466    }
     1467
    14111468    void moveDoubleTo64(FPRegisterID src, RegisterID dest)
    14121469    {
    … …  
    14141471    }
    14151472
     1473    void moveFloatTo32(FPRegisterID src, RegisterID dest)
     1474    {
     1475        m_assembler.fmov<32>(dest, src);
     1476    }
     1477
    14161478    void move64ToDouble(RegisterID src, FPRegisterID dest)
    14171479    {
    14181480        m_assembler.fmov<64>(dest, src);
     1481    }
     1482
     1483    void move32ToFloat(RegisterID src, FPRegisterID dest)
     1484    {
     1485        m_assembler.fmov<32>(dest, src);
     1486    }
     1487
     1488    void moveConditionallyDouble(DoubleCondition cond, FPRegisterID left, FPRegisterID right, RegisterID src, RegisterID dest)
     1489    {
     1490        m_assembler.fcmp<64>(left, right);
     1491        moveConditionallyAfterFloatingPointCompare<64>(cond, src, dest);
     1492    }
     1493
     1494    void moveConditionallyFloat(DoubleCondition cond, FPRegisterID left, FPRegisterID right, RegisterID src, RegisterID dest)
     1495    {
     1496        m_assembler.fcmp<32>(left, right);
     1497        moveConditionallyAfterFloatingPointCompare<64>(cond, src, dest);
     1498    }
     1499
     1500    template<int datasize>
     1501    void moveConditionallyAfterFloatingPointCompare(DoubleCondition cond, RegisterID src, RegisterID dest)
     1502    {
     1503        if (cond == DoubleNotEqual) {
     1504            Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
     1505            m_assembler.csel<datasize>(dest, src, dest, ARM64Assembler::ConditionNE);
     1506            unordered.link(this);
     1507            return;
     1508        }
     1509        if (cond == DoubleEqualOrUnordered) {
     1510            // If the compare is unordered, src is copied to dest and the
     1511            // next csel has all arguments equal to src.
     1512            // If the compare is ordered, dest is unchanged and EQ decides
     1513            // what value to set.
     1514            m_assembler.csel<datasize>(dest, src, dest, ARM64Assembler::ConditionVS);
     1515            m_assembler.csel<datasize>(dest, src, dest, ARM64Assembler::ConditionEQ);
     1516            return;
     1517        }
     1518        m_assembler.csel<datasize>(dest, src, dest, ARM64Condition(cond));
    14191519    }
    14201520
    … …  
    14351535    }
    14361536
     1537    void mulFloat(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1538    {
     1539        m_assembler.fmul<32>(dest, op1, op2);
     1540    }
     1541
     1542    void andDouble(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1543    {
     1544        m_assembler.vand<64>(dest, op1, op2);
     1545    }
     1546
     1547    void andFloat(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1548    {
     1549        andDouble(op1, op2, dest);
     1550    }
     1551
    14371552    void negateDouble(FPRegisterID src, FPRegisterID dest)
    14381553    {
    … …  
    14431558    {
    14441559        m_assembler.fsqrt<64>(dest, src);
     1560    }
     1561
     1562    void sqrtFloat(FPRegisterID src, FPRegisterID dest)
     1563    {
     1564        m_assembler.fsqrt<32>(dest, src);
    14451565    }
    14461566
    … …  
    14981618        loadDouble(src, fpTempRegister);
    14991619        subDouble(fpTempRegister, dest);
     1620    }
     1621
     1622    void subFloat(FPRegisterID op1, FPRegisterID op2, FPRegisterID dest)
     1623    {
     1624        m_assembler.fsub<32>(dest, op1, op2);
    15001625    }
    15011626
    … …  
    16291754        move(dataTempRegister, reg2);
    16301755    }
     1756
     1757    void signExtend32ToPtr(TrustedImm32 imm, RegisterID dest)
     1758    {
     1759        move(TrustedImmPtr(reinterpret_cast<void*>(static_cast<intptr_t>(imm.m_value))), dest);
     1760    }
    16311761   
    16321762    void signExtend32ToPtr(RegisterID src, RegisterID dest)
    … …  
    16401770    }
    16411771
     1772    void moveConditionally32(RelationalCondition cond, RegisterID left, RegisterID right, RegisterID src, RegisterID dest)
     1773    {
     1774        m_assembler.cmp<32>(left, right);
     1775        m_assembler.csel<32>(dest, src, dest, ARM64Condition(cond));
     1776    }
     1777
     1778    void moveConditionally64(RelationalCondition cond, RegisterID left, RegisterID right, RegisterID src, RegisterID dest)
     1779    {
     1780        m_assembler.cmp<64>(left, right);
     1781        m_assembler.csel<64>(dest, src, dest, ARM64Condition(cond));
     1782    }
     1783
     1784    void moveConditionallyTest32(ResultCondition cond, RegisterID testReg, RegisterID mask, RegisterID src, RegisterID dest)
     1785    {
     1786        m_assembler.tst<32>(testReg, mask);
     1787        m_assembler.csel<32>(dest, src, dest, ARM64Condition(cond));
     1788    }
     1789
     1790    void moveConditionallyTest64(ResultCondition cond, RegisterID testReg, RegisterID mask, RegisterID src, RegisterID dest)
     1791    {
     1792        m_assembler.tst<64>(testReg, mask);
     1793        m_assembler.csel<64>(dest, src, dest, ARM64Condition(cond));
     1794    }
    16421795
    16431796    // Forwards / external control flow operations:
    … …  
    23152468        compare32(cond, memoryTempRegister, dataTempRegister, dest);
    23162469    }
    2317    
     2470
     2471    void test32(ResultCondition cond, RegisterID src, RegisterID mask, RegisterID dest)
     2472    {
     2473        m_assembler.tst<32>(src, mask);
     2474        m_assembler.cset<32>(dest, ARM64Condition(cond));
     2475    }
     2476
    23182477    void test32(ResultCondition cond, RegisterID src, TrustedImm32 mask, RegisterID dest)
    23192478    {
    … …  
    23562515    }
    23572516
     2517    void setCarry(RegisterID dest)
     2518    {
     2519        m_assembler.cset<32>(dest, ARM64Assembler::ConditionCS);
     2520    }
    23582521
    23592522    // Patchable operations
    … …  
    27432906    }
    27442907
    2745     void signExtend32ToPtr(TrustedImm32 imm, RegisterID dest)
    2746     {
    2747         move(TrustedImmPtr(reinterpret_cast<void*>(static_cast<intptr_t>(imm.m_value))), dest);
    2748     }
    2749 
    27502908    template<int datasize>
    27512909    ALWAYS_INLINE void load(const void* address, RegisterID dest)
    … …  
    29343092    }
    29353093
     3094    Jump jumpAfterFloatingPointCompare(DoubleCondition cond)
     3095    {
     3096        if (cond == DoubleNotEqual) {
     3097            // ConditionNE jumps if NotEqual *or* unordered - force the unordered cases not to jump.
     3098            Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
     3099            Jump result = makeBranch(ARM64Assembler::ConditionNE);
     3100            unordered.link(this);
     3101            return result;
     3102        }
     3103        if (cond == DoubleEqualOrUnordered) {
     3104            Jump unordered = makeBranch(ARM64Assembler::ConditionVS);
     3105            Jump notEqual = makeBranch(ARM64Assembler::ConditionNE);
     3106            unordered.link(this);
     3107            // We get here if either unordered or equal.
     3108            Jump result = jump();
     3109            notEqual.link(this);
     3110            return result;
     3111        }
     3112        return makeBranch(cond);
     3113    }
     3114
    29363115    friend class LinkBuffer;
    29373116

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

    r192409 r194388  
    180180        lshift32(TrustedImm32(16), dest1);
    181181        or32(dest1, dest2);
    182         movePackedToInt32(src, dest1);
     182        moveFloatTo32(src, dest1);
    183183    }
    184184
    185185    void moveIntsToDouble(RegisterID src1, RegisterID src2, FPRegisterID dest, FPRegisterID scratch)
    186186    {
    187         moveInt32ToPacked(src1, dest);
    188         moveInt32ToPacked(src2, scratch);
     187        move32ToFloat(src1, dest);
     188        move32ToFloat(src2, scratch);
    189189        lshiftPacked(TrustedImm32(32), scratch);
    190190        orPacked(scratch, dest);

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

    r194354 r194388  
    12091209    }
    12101210
    1211     void moveInt32ToPacked(RegisterID src, XMMRegisterID dst)
     1211    void move32ToFloat(RegisterID src, XMMRegisterID dst)
    12121212    {
    12131213        ASSERT(isSSE2Present());
    … …  
    12151215    }
    12161216
    1217     void movePackedToInt32(XMMRegisterID src, RegisterID dst)
     1217    void moveFloatTo32(XMMRegisterID src, RegisterID dst)
    12181218    {
    12191219        ASSERT(isSSE2Present());

  • trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp

    r194372 r194388  
    645645       
    646646        if (imm(amount)) {
    647             append(Move, tmp(value), tmp(m_value));
    648             append(opcode, imm(amount), tmp(m_value));
    649             return;
    650         }
    651 
     647            if (isValidForm(opcode, Arg::Tmp, Arg::Imm, Arg::Tmp)) {
     648                append(opcode, tmp(value), imm(amount), tmp(m_value));
     649                return;
     650            }
     651            if (isValidForm(opcode, Arg::Imm, Arg::Tmp)) {
     652                append(Move, tmp(value), tmp(m_value));
     653                append(opcode, imm(amount), tmp(m_value));
     654                return;
     655            }
     656        }
     657
     658        if (isValidForm(opcode, Arg::Tmp, Arg::Tmp, Arg::Tmp)) {
     659            append(opcode, tmp(value), tmp(amount), tmp(m_value));
     660            return;
     661        }
     662
     663#if CPU(X86)
    652664        append(Move, tmp(value), tmp(m_value));
    653665        append(Move, tmp(amount), Tmp(X86Registers::ecx));
    654666        append(opcode, Tmp(X86Registers::ecx), tmp(m_value));
     667#endif
    655668    }
    656669
    … …  
    15861599        case Div: {
    15871600            if (isInt(m_value->type())) {
     1601#if CPU(X86)
    15881602                lowerX86Div();
    15891603                append(Move, Tmp(X86Registers::eax), tmp(m_value));
     1604#endif
    15901605                return;
    15911606            }
    … …  
    15971612
    15981613        case Mod: {
     1614#if CPU(X86)
    15991615            lowerX86Div();
    16001616            append(Move, Tmp(X86Registers::edx), tmp(m_value));
     1617#endif
    16011618            return;
    16021619        }
    … …  
    16781695
    16791696        case BitwiseCast: {
    1680             appendUnOp<MoveInt32ToPacked, Move64ToDouble, MoveDoubleTo64, MovePackedToInt32>(m_value->child(0));
     1697            appendUnOp<Move32ToFloat, Move64ToDouble, MoveDoubleTo64, MoveFloatTo32>(m_value->child(0));
    16811698            return;
    16821699        }
    … …  
    21522169    }
    21532170
     2171#if CPU(X86)
    21542172    void lowerX86Div()
    21552173    {
    … …  
    21772195        append(div, eax, edx, tmp(m_value->child(1)));
    21782196    }
    2179    
     2197#endif
     2198
    21802199    IndexSet<Value> m_locked; // These are values that will have no Tmp in Air.
    21812200    IndexMap<Value, Tmp> m_valueToTmp; // These are values that must have a Tmp in Air. We say that a Value* with a non-null Tmp is "pinned".

  • trunk/Source/JavaScriptCore/b3/air/AirInstInlines.h

    r194331 r194388  
    168168        && inst.args[1] == Tmp(X86Registers::edx);
    169169#else
     170    UNUSED_PARAM(inst);
    170171    return false;
    171172#endif

  • trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes

    r194354 r194388  
    129129    Tmp, Tmp, Tmp
    130130
    131 AddDouble U:F:64, UD:F:64
    132     Tmp, Tmp
    133     x86: Addr, Tmp
    134 
    135 AddFloat U:F:32, UD:F:32
    136     Tmp, Tmp
    137     x86: Addr, Tmp
     131arm64: AddDouble U:F:64, U:F:64, D:F:64
     132    Tmp, Tmp, Tmp
     133
     134x86: AddDouble U:F:64, UD:F:64
     135    Tmp, Tmp
     136    Addr, Tmp
     137
     138arm64: AddFloat U:F:32, U:F:32, D:F:32
     139    Tmp, Tmp, Tmp
     140
     141x86: AddFloat U:F:32, UD:F:32
     142    Tmp, Tmp
     143    Addr, Tmp
    138144
    139145Sub32 U:G:32, UZD:G:32
    … …  
    151157    x86: Tmp, Addr
    152158
    153 SubDouble U:F:64, UD:F:64
    154     Tmp, Tmp
    155     x86: Addr, Tmp
    156 
    157 SubFloat U:F:32, UD:F:32
    158     Tmp, Tmp
    159     x86: Addr, Tmp
     159arm64: SubDouble U:F:64, U:F:64, D:F:64
     160    Tmp, Tmp, Tmp
     161
     162x86: SubDouble U:F:64, UD:F:64
     163    Tmp, Tmp
     164    Addr, Tmp
     165
     166arm64: SubFloat U:F:32, U:F:32, D:F:32
     167    Tmp, Tmp, Tmp
     168
     169x86: SubFloat U:F:32, UD:F:32
     170    Tmp, Tmp
     171    Addr, Tmp
    160172
    161173Neg32 UZD:G:32
    162174    Tmp
    163     Addr
     175    x86: Addr
    164176
    16517764: Neg64 UD:G:64
    … …  
    176188    Tmp, Tmp
    177189
    178 MulDouble U:F:64, UD:F:64
    179     Tmp, Tmp
    180     x86: Addr, Tmp
    181 
    182 MulFloat U:F:32, UD:F:32
    183     Tmp, Tmp
    184     x86: Addr, Tmp
    185 
    186 DivDouble U:F:32, UD:F:32
    187     Tmp, Tmp
    188     x86: Addr, Tmp
    189 
    190 DivFloat U:F:32, UD:F:32
    191     Tmp, Tmp
    192     x86: Addr, Tmp
     190arm64: MulDouble U:F:64, U:F:64, D:F:64
     191    Tmp, Tmp, Tmp
     192
     193x86: MulDouble U:F:64, UD:F:64
     194    Tmp, Tmp
     195    Addr, Tmp
     196
     197arm64: MulFloat U:F:32, U:F:32, D:F:32
     198    Tmp, Tmp, Tmp
     199
     200x86: MulFloat U:F:32, UD:F:32
     201    Tmp, Tmp
     202    Addr, Tmp
     203
     204arm64: DivDouble U:F:32, U:F:32, D:F:32
     205    Tmp, Tmp, Tmp
     206
     207x86: DivDouble U:F:32, UD:F:32
     208    Tmp, Tmp
     209    Addr, Tmp
     210
     211arm64: DivFloat U:F:32, U:F:32, D:F:32
     212    Tmp, Tmp, Tmp
     213
     214x86: DivFloat U:F:32, UD:F:32
     215    Tmp, Tmp
     216    Addr, Tmp
    193217
    194218x86: X86ConvertToDoubleWord32 U:G:32, ZD:G:32
    … …  
    204228    Tmp*, Tmp*, Tmp
    205229
    206 Lea UA:G:Ptr, D:G:Ptr
     230x86: Lea UA:G:Ptr, D:G:Ptr
    207231    Addr, Tmp
    208232
    … …  
    218242    Imm, Tmp
    219243
    220 AndDouble U:F:64, UD:F:64
    221     Tmp, Tmp
    222 
    223 AndFloat U:F:32, UD:F:32
    224     Tmp, Tmp
    225 
    226 Lshift32 U:G:32, UZD:G:32
     244arm64: AndDouble U:F:64, U:F:64, D:F:64
     245    Tmp, Tmp, Tmp
     246
     247x86: AndDouble U:F:64, UD:F:64
     248    Tmp, Tmp
     249
     250arm64: AndFloat U:F:32, U:F:32, D:F:32
     251    Tmp, Tmp, Tmp
     252
     253x86: AndFloat U:F:32, UD:F:32
     254    Tmp, Tmp
     255
     256arm64: Lshift32 U:G:32, U:G:32, ZD:G:32
     257    Tmp, Tmp, Tmp
     258    Tmp, Imm, Tmp
     259
     260x86:Lshift32 U:G:32, UZD:G:32
    227261    Tmp*, Tmp
    228262    Imm, Tmp
    229263
    230 64: Lshift64 U:G:64, UD:G:64
     264arm64: Lshift64 U:G:64, U:G:64, ZD:G:64
     265    Tmp, Tmp, Tmp
     266    Tmp, Imm, Tmp
     267
     268x86_64: Lshift64 U:G:64, UD:G:64
    231269    Tmp*, Tmp
    232270    Imm, Tmp
    233271
    234 Rshift32 U:G:32, UZD:G:32
     272arm64: Rshift32 U:G:32, U:G:32, ZD:G:32
     273    Tmp, Tmp, Tmp
     274    Tmp, Imm, Tmp
     275
     276x86: Rshift32 U:G:32, UZD:G:32
    235277    Tmp*, Tmp
    236278    Imm, Tmp
    237279
    238 64: Rshift64 U:G:64, UD:G:64
     280arm64: Rshift64 U:G:64, U:G:64, ZD:G:64
     281    Tmp, Tmp, Tmp
     282    Tmp, Imm, Tmp
     283
     284x86_64: Rshift64 U:G:64, UD:G:64
    239285    Tmp*, Tmp
    240286    Imm, Tmp
    241287
    242 Urshift32 U:G:32, UZD:G:32
     288arm64: urshift32 U:G:32, U:G:32, ZD:G:32
     289    Tmp, Tmp, Tmp
     290    Tmp, Imm, Tmp
     291
     292x86: Urshift32 U:G:32, UZD:G:32
    243293    Tmp*, Tmp
    244294    Imm, Tmp
    245295
    246 64: Urshift64 U:G:64, UD:G:64
     296arm64: Urshift64 U:G:64, U:G:64, ZD:G:64
     297    Tmp, Tmp, Tmp
     298    Tmp, Imm, Tmp
     299
     300x86_64: Urshift64 U:G:64, UD:G:64
    247301    Tmp*, Tmp
    248302    Imm, Tmp
    … …  
    271325    Imm, Tmp
    272326
    273 Not32 UZD:G:32
     327arm64: Not32 U:G:32, ZD:G:32
     328    Tmp, Tmp
     329
     330x86: Not32 UZD:G:32
    274331    Tmp
    275     x86: Addr
    276 
    277 64: Not64 UD:G:64
     332    Addr
     333
     334arm64: Not64 U:G:64, D:G:64
     335    Tmp, Tmp
     336
     337x86: Not64 UD:G:64
    278338    Tmp
    279     x86: Addr
     339    Addr
    280340
    281341CeilDouble U:F:64, UD:F:64
    282342    Tmp, Tmp
    283     Addr, Tmp
     343    x86: Addr, Tmp
    284344
    285345CeilFloat U:F:32, UD:F:32
    286346    Tmp, Tmp
    287     Addr, Tmp
     347    x86: Addr, Tmp
    288348
    289349SqrtDouble U:F:64, UD:F:64
    … …  
    326386    Imm, Tmp as signExtend32ToPtr
    327387    Imm64, Tmp
    328     Addr, Tmp as loadPtr # This means that "Move Addr, Tmp" is code-generated as "load" not "move".
     388    x86: Addr, Tmp as loadPtr # This means that "Move Addr, Tmp" is code-generated as "load" not "move".
    329389    Index, Tmp as loadPtr
    330     Tmp, Addr as storePtr
     390    x86: Tmp, Addr as storePtr
    331391    Tmp, Index as storePtr
    332     Imm, Addr as storePtr
     392    x86: Imm, Addr as storePtr
    333393
    334394Move32 U:G:32, ZD:G:32
    335395    Tmp, Tmp as zeroExtend32ToPtr
    336     Addr, Tmp as load32
     396    x86: Addr, Tmp as load32
    337397    Index, Tmp as load32
    338     Tmp, Addr as store32
     398    x86: Tmp, Addr as store32
    339399    Tmp, Index as store32
    340     Imm, Addr as store32
    341     Imm, Index as store32
     400    x86: Imm, Addr as store32
     401    x86: Imm, Index as store32
    342402
    343403SignExtend32ToPtr U:G:32, D:G:Ptr
    … …  
    346406ZeroExtend8To32 U:G:8, ZD:G:32
    347407    Tmp, Tmp
    348     Addr, Tmp as load8
     408    x86: Addr, Tmp as load8
    349409    Index, Tmp as load8
    350410
    … …  
    356416ZeroExtend16To32 U:G:16, ZD:G:32
    357417    Tmp, Tmp
    358     Addr, Tmp as load16
     418    x86: Addr, Tmp as load16
    359419    Index, Tmp as load16
    360420
    361421SignExtend16To32 U:G:16, ZD:G:32
    362422    Tmp, Tmp
    363     Addr, Tmp as load16SignedExtendTo32
     423    x86: Addr, Tmp as load16SignedExtendTo32
    364424    Index, Tmp as load16SignedExtendTo32
    365425
    366426MoveFloat U:F:32, D:F:32
    367427    Tmp, Tmp as moveDouble
    368     Addr, Tmp as loadFloat
     428    x86: Addr, Tmp as loadFloat
    369429    Index, Tmp as loadFloat
    370     Tmp, Addr as storeFloat
     430    x86: Tmp, Addr as storeFloat
    371431    Tmp, Index as storeFloat
    372432
    373433MoveDouble U:F:64, D:F:64
    374434    Tmp, Tmp
    375     Addr, Tmp as loadDouble
     435    x86: Addr, Tmp as loadDouble
    376436    Index, Tmp as loadDouble
    377     Tmp, Addr as storeDouble
     437    x86: Tmp, Addr as storeDouble
    378438    Tmp, Index as storeDouble
    379439
    … …  
    38344364: Move64ToDouble U:G:64, D:F:64
    384444    Tmp, Tmp
    385     Addr, Tmp as loadDouble
     445    x86: Addr, Tmp as loadDouble
    386446    Index, Tmp as loadDouble
    387447
    388 MoveInt32ToPacked U:G:32, D:F:32
    389     Tmp, Tmp
    390     Addr, Tmp as loadFloat
     448Move32ToFloat U:G:32, D:F:32
     449    Tmp, Tmp
     450    x86: Addr, Tmp as loadFloat
    391451    Index, Tmp as loadFloat
    392452
    39345364: MoveDoubleTo64 U:F:64, D:G:64
    394454    Tmp, Tmp
    395     Addr, Tmp as load64
     455    x86: Addr, Tmp as load64
    396456    Index, Tmp as load64
    397457
    398 MovePackedToInt32 U:F:32, D:G:32
    399     Tmp, Tmp
    400     Addr, Tmp as load32
     458MoveFloatTo32 U:F:32, D:G:32
     459    Tmp, Tmp
     460    x86: Addr, Tmp as load32
    401461    Index, Tmp as load32
    402462
    403463Load8 U:G:8, ZD:G:32
    404     Addr, Tmp
     464    x86: Addr, Tmp
    405465    Index, Tmp
    406466
    407467Store8 U:G:8, D:G:8
    408468    Tmp, Index
    409     Tmp, Addr
    410     Imm, Index
    411     Imm, Addr
     469    x86: Tmp, Addr
     470    x86: Imm, Index
     471    x86: Imm, Addr
    412472
    413473Load8SignedExtendTo32 U:G:8, ZD:G:32
    414     Addr, Tmp
     474    x86: Addr, Tmp
    415475    Index, Tmp
    416476
    417477Load16 U:G:16, ZD:G:32
    418     Addr, Tmp
     478    x86: Addr, Tmp
    419479    Index, Tmp
    420480
    421481Load16SignedExtendTo32 U:G:16, ZD:G:32
    422     Addr, Tmp
     482    x86: Addr, Tmp
    423483    Index, Tmp
    424484
    … …  
    541601MoveConditionallyTest32 U:G:32, U:G:32, U:G:32, U:G:Ptr, UD:G:Ptr
    542602    ResCond, Tmp, Tmp, Tmp, Tmp
    543     ResCond, Tmp, Imm, Tmp, Tmp
     603    x86: ResCond, Tmp, Imm, Tmp, Tmp
    544604
    54560564: MoveConditionallyTest64 U:G:32, U:G:64, U:G:64, U:G:Ptr, UD:G:Ptr
    546606    ResCond, Tmp, Tmp, Tmp, Tmp
    547     ResCond, Tmp, Imm, Tmp, Tmp
     607    x86: ResCond, Tmp, Imm, Tmp, Tmp
    548608
    549609MoveConditionallyDouble U:G:32, U:F:64, U:F:64, U:G:Ptr, UD:G:Ptr

  • trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h

    r194087 r194388  
    437437    }
    438438
     439    void emitFunctionEpilogueWithEmptyFrame()
     440    {
     441        popPair(framePointerRegister, linkRegister);
     442    }
     443
    439444    void emitFunctionEpilogue()
    440445    {
    441446        move(framePointerRegister, stackPointerRegister);
    442         popPair(framePointerRegister, linkRegister);
     447        emitFunctionEpilogueWithEmptyFrame();
    443448    }
    444449

  • trunk/Source/JavaScriptCore/jit/FPRInfo.h

    r192187 r194388  
    188188    typedef FPRReg RegisterType;
    189189    static const unsigned numberOfRegisters = 23;
     190    static const unsigned numberOfArgumentRegisters = 8;
    190191
    191192    // Temporary registers.
    … …  
    259260    }
    260261
     262    static FPRReg toArgumentRegister(unsigned index)
     263    {
     264        ASSERT(index < 8);
     265        return static_cast<FPRReg>(index);
     266    }
     267
    261268    static const char* debugName(FPRReg reg)
    262269    {
Note: See TracChangeset for help on using the changeset viewer.