webkitgtk-2.4.9webkitgtk-2.4.9

1 files changed, 69 insertions, 144 deletions

diff --git a/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h b/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h
index 2e71e61d8..68a04fd22 100644
--- a/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h
+++ b/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009, 2010, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 University of Szeged
  *
  * Redistribution and use in source and binary forms, with or without
@@ -34,7 +34,7 @@
 
 namespace JSC {
 
-class MacroAssemblerARMv7 : public AbstractMacroAssembler<ARMv7Assembler, MacroAssemblerARMv7> {
+class MacroAssemblerARMv7 : public AbstractMacroAssembler<ARMv7Assembler> {
     static const RegisterID dataTempRegister = ARMRegisters::ip;
     static const RegisterID addressTempRegister = ARMRegisters::r6;
 
@@ -62,11 +62,12 @@ public:
 
     Vector<LinkRecord, 0, UnsafeVectorOverflow>& jumpsToLink() { return m_assembler.jumpsToLink(); }
     void* unlinkedCode() { return m_assembler.unlinkedCode(); }
-    static bool canCompact(JumpType jumpType) { return ARMv7Assembler::canCompact(jumpType); }
-    static JumpLinkType computeJumpType(JumpType jumpType, const uint8_t* from, const uint8_t* to) { return ARMv7Assembler::computeJumpType(jumpType, from, to); }
-    static JumpLinkType computeJumpType(LinkRecord& record, const uint8_t* from, const uint8_t* to) { return ARMv7Assembler::computeJumpType(record, from, to); }
-    static int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkType) { return ARMv7Assembler::jumpSizeDelta(jumpType, jumpLinkType); }
-    static void link(LinkRecord& record, uint8_t* from, uint8_t* to) { return ARMv7Assembler::link(record, from, to); }
+    bool canCompact(JumpType jumpType) { return m_assembler.canCompact(jumpType); }
+    JumpLinkType computeJumpType(JumpType jumpType, const uint8_t* from, const uint8_t* to) { return m_assembler.computeJumpType(jumpType, from, to); }
+    JumpLinkType computeJumpType(LinkRecord& record, const uint8_t* from, const uint8_t* to) { return m_assembler.computeJumpType(record, from, to); }
+    void recordLinkOffsets(int32_t regionStart, int32_t regionEnd, int32_t offset) {return m_assembler.recordLinkOffsets(regionStart, regionEnd, offset); }
+    int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkType) { return m_assembler.jumpSizeDelta(jumpType, jumpLinkType); }
+    void link(LinkRecord& record, uint8_t* from, uint8_t* to) { return m_assembler.link(record, from, to); }
 
     struct ArmAddress {
         enum AddressType {
@@ -169,14 +170,6 @@ public:
     void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)
     {
         ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12OrEncodedImm(imm.m_value);
-
-        // For adds with stack pointer destination, moving the src first to sp is
-        // needed to avoid unpredictable instruction
-        if (dest == ARMRegisters::sp && src != dest) {
-            move(src, ARMRegisters::sp);
-            src = ARMRegisters::sp;
-        }
-
         if (armImm.isValid())
             m_assembler.add(dest, src, armImm);
         else {
@@ -225,11 +218,6 @@ public:
         store32(dataTempRegister, address.m_ptr);
     }
 
-    void addPtrNoFlags(TrustedImm32 imm, RegisterID srcDest)
-    {
-        add32(imm, srcDest);
-    }
-    
     void add64(TrustedImm32 imm, AbsoluteAddress address)
     {
         move(TrustedImmPtr(address.m_ptr), addressTempRegister);
@@ -341,13 +329,6 @@ public:
         store32(dataTempRegister, addressTempRegister);
     }
 
-    void or32(TrustedImm32 imm, Address address)
-    {
-        load32(address, dataTempRegister);
-        or32(imm, dataTempRegister, dataTempRegister);
-        store32(dataTempRegister, address);
-    }
-
     void or32(TrustedImm32 imm, RegisterID dest)
     {
         or32(imm, dest, dest);
@@ -546,7 +527,7 @@ private:
         }
     }
     
-    void load16SignedExtendTo32(ArmAddress address, RegisterID dest)
+    void load16Signed(ArmAddress address, RegisterID dest)
     {
         ASSERT(address.type == ArmAddress::HasIndex);
         m_assembler.ldrsh(dest, address.base, address.u.index, address.u.scale);
@@ -566,7 +547,7 @@ private:
         }
     }
     
-    void load8SignedExtendTo32(ArmAddress address, RegisterID dest)
+    void load8Signed(ArmAddress address, RegisterID dest)
     {
         ASSERT(address.type == ArmAddress::HasIndex);
         m_assembler.ldrsb(dest, address.base, address.u.index, address.u.scale);
@@ -643,18 +624,6 @@ public:
         m_assembler.ldr(dest, addressTempRegister, ARMThumbImmediate::makeUInt16(0));
     }
     
-    void abortWithReason(AbortReason reason)
-    {
-        move(TrustedImm32(reason), dataTempRegister);
-        breakpoint();
-    }
-
-    void abortWithReason(AbortReason reason, intptr_t misc)
-    {
-        move(TrustedImm32(misc), addressTempRegister);
-        abortWithReason(reason);
-    }
-
     ConvertibleLoadLabel convertibleLoadPtr(Address address, RegisterID dest)
     {
         ConvertibleLoadLabel result(this);
@@ -668,7 +637,7 @@ public:
         load8(setupArmAddress(address), dest);
     }
 
-    void load8SignedExtendTo32(ImplicitAddress, RegisterID)
+    void load8Signed(ImplicitAddress, RegisterID)
     {
         UNREACHABLE_FOR_PLATFORM();
     }
@@ -678,9 +647,9 @@ public:
         load8(setupArmAddress(address), dest);
     }
     
-    void load8SignedExtendTo32(BaseIndex address, RegisterID dest)
+    void load8Signed(BaseIndex address, RegisterID dest)
     {
-        load8SignedExtendTo32(setupArmAddress(address), dest);
+        load8Signed(setupArmAddress(address), dest);
     }
 
     void load8(const void* address, RegisterID dest)
@@ -714,9 +683,9 @@ public:
         m_assembler.ldrh(dest, makeBaseIndexBase(address), address.index, address.scale);
     }
     
-    void load16SignedExtendTo32(BaseIndex address, RegisterID dest)
+    void load16Signed(BaseIndex address, RegisterID dest)
     {
-        load16SignedExtendTo32(setupArmAddress(address), dest);
+        load16Signed(setupArmAddress(address), dest);
     }
     
     void load16(ImplicitAddress address, RegisterID dest)
@@ -730,7 +699,7 @@ public:
         }
     }
     
-    void load16SignedExtendTo32(ImplicitAddress, RegisterID)
+    void load16Signed(ImplicitAddress, RegisterID)
     {
         UNREACHABLE_FOR_PLATFORM();
     }
@@ -776,11 +745,6 @@ public:
         store32(dataTempRegister, address);
     }
 
-    void store8(RegisterID src, Address address)
-    {
-        store8(src, setupArmAddress(address));
-    }
-    
     void store8(RegisterID src, BaseIndex address)
     {
         store8(src, setupArmAddress(address));
@@ -798,12 +762,6 @@ public:
         store8(dataTempRegister, address);
     }
     
-    void store8(TrustedImm32 imm, Address address)
-    {
-        move(imm, dataTempRegister);
-        store8(dataTempRegister, address);
-    }
-    
     void store16(RegisterID src, BaseIndex address)
     {
         store16(src, setupArmAddress(address));
@@ -898,9 +856,9 @@ public:
             m_assembler.vmov(dest, src);
     }
 
-    void loadDouble(TrustedImmPtr address, FPRegisterID dest)
+    void loadDouble(const void* address, FPRegisterID dest)
     {
-        move(address, addressTempRegister);
+        move(TrustedImmPtr(address), addressTempRegister);
         m_assembler.vldr(dest, addressTempRegister, 0);
     }
 
@@ -934,9 +892,9 @@ public:
         m_assembler.fsts(ARMRegisters::asSingle(src), base, offset);
     }
 
-    void storeDouble(FPRegisterID src, TrustedImmPtr address)
+    void storeDouble(FPRegisterID src, const void* address)
     {
-        move(address, addressTempRegister);
+        move(TrustedImmPtr(address), addressTempRegister);
         storeDouble(src, addressTempRegister);
     }
 
@@ -974,7 +932,7 @@ public:
 
     void addDouble(AbsoluteAddress address, FPRegisterID dest)
     {
-        loadDouble(TrustedImmPtr(address.m_ptr), fpTempRegister);
+        loadDouble(address.m_ptr, fpTempRegister);
         m_assembler.vadd(dest, dest, fpTempRegister);
     }
 
@@ -1180,12 +1138,14 @@ public:
     
     void pop(RegisterID dest)
     {
-        m_assembler.pop(dest);
+        // store postindexed with writeback
+        m_assembler.ldr(dest, ARMRegisters::sp, sizeof(void*), false, true);
     }
 
     void push(RegisterID src)
     {
-        m_assembler.push(src);
+        // store preindexed with writeback
+        m_assembler.str(src, ARMRegisters::sp, -sizeof(void*), true, true);
     }
 
     void push(Address address)
@@ -1200,16 +1160,6 @@ public:
         push(dataTempRegister);
     }
 
-    void popPair(RegisterID dest1, RegisterID dest2)
-    {
-        m_assembler.pop(1 << dest1 | 1 << dest2);
-    }
-    
-    void pushPair(RegisterID src1, RegisterID src2)
-    {
-        m_assembler.push(1 << src1 | 1 << src2);
-    }
-    
     // Register move operations:
     //
     // Move values in registers.
@@ -1308,14 +1258,18 @@ private:
     void compare32(RegisterID left, TrustedImm32 right)
     {
         int32_t imm = right.m_value;
-        ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm);
-        if (armImm.isValid())
-            m_assembler.cmp(left, armImm);
-        else if ((armImm = ARMThumbImmediate::makeEncodedImm(-imm)).isValid())
-            m_assembler.cmn(left, armImm);
+        if (!imm)
+            m_assembler.tst(left, left);
         else {
-            move(TrustedImm32(imm), dataTempRegister);
-            m_assembler.cmp(left, dataTempRegister);
+            ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm);
+            if (armImm.isValid())
+                m_assembler.cmp(left, armImm);
+            else if ((armImm = ARMThumbImmediate::makeEncodedImm(-imm)).isValid())
+                m_assembler.cmn(left, armImm);
+            else {
+                move(TrustedImm32(imm), dataTempRegister);
+                m_assembler.cmp(left, dataTempRegister);
+            }
         }
     }
 
@@ -1327,34 +1281,16 @@ private:
             m_assembler.tst(reg, reg);
         else {
             ARMThumbImmediate armImm = ARMThumbImmediate::makeEncodedImm(imm);
-            if (armImm.isValid()) {
-                if (reg == ARMRegisters::sp) {
-                    move(reg, addressTempRegister);
-                    m_assembler.tst(addressTempRegister, armImm);
-                } else
-                    m_assembler.tst(reg, armImm);
-            } else {
+            if (armImm.isValid())
+                m_assembler.tst(reg, armImm);
+            else {
                 move(mask, dataTempRegister);
-                if (reg == ARMRegisters::sp) {
-                    move(reg, addressTempRegister);
-                    m_assembler.tst(addressTempRegister, dataTempRegister);
-                } else
-                    m_assembler.tst(reg, dataTempRegister);
+                m_assembler.tst(reg, dataTempRegister);
             }
         }
     }
 
 public:
-    void test32(ResultCondition, RegisterID reg, TrustedImm32 mask)
-    {
-        test32(reg, mask);
-    }
-    
-    Jump branch(ResultCondition cond)
-    {
-        return Jump(makeBranch(cond));
-    }
-
     Jump branch32(RelationalCondition cond, RegisterID left, RegisterID right)
     {
         m_assembler.cmp(left, right);
@@ -1413,12 +1349,6 @@ public:
         return branch32(cond, addressTempRegister, right);
     }
 
-    Jump branchPtr(RelationalCondition cond, BaseIndex left, RegisterID right)
-    {
-        load32(left, dataTempRegister);
-        return branch32(cond, dataTempRegister, right);
-    }
-
     Jump branch8(RelationalCondition cond, RegisterID left, TrustedImm32 right)
     {
         compare32(left, right);
@@ -1776,13 +1706,6 @@ public:
         return branch32(cond, addressTempRegister, dataTempRegister);
     }
     
-    ALWAYS_INLINE Jump branch32WithPatch(RelationalCondition cond, Address left, DataLabel32& dataLabel, TrustedImm32 initialRightValue = TrustedImm32(0))
-    {
-        load32(left, addressTempRegister);
-        dataLabel = moveWithPatch(initialRightValue, dataTempRegister);
-        return branch32(cond, addressTempRegister, dataTempRegister);
-    }
-    
     PatchableJump patchableBranchPtr(RelationalCondition cond, Address left, TrustedImmPtr right = TrustedImmPtr(0))
     {
         m_makeJumpPatchable = true;
@@ -1815,14 +1738,6 @@ public:
         return PatchableJump(result);
     }
 
-    PatchableJump patchableBranch32WithPatch(RelationalCondition cond, Address left, DataLabel32& dataLabel, TrustedImm32 initialRightValue = TrustedImm32(0))
-    {
-        m_makeJumpPatchable = true;
-        Jump result = branch32WithPatch(cond, left, dataLabel, initialRightValue);
-        m_makeJumpPatchable = false;
-        return PatchableJump(result);
-    }
-
     PatchableJump patchableJump()
     {
         padBeforePatch();
@@ -1855,13 +1770,17 @@ public:
     }
 
     
+    int executableOffsetFor(int location)
+    {
+        return m_assembler.executableOffsetFor(location);
+    }
+
     static FunctionPtr readCallTarget(CodeLocationCall call)
     {
         return FunctionPtr(reinterpret_cast<void(*)()>(ARMv7Assembler::readCallTarget(call.dataLocation())));
     }
     
     static bool canJumpReplacePatchableBranchPtrWithPatch() { return false; }
-    static bool canJumpReplacePatchableBranch32WithPatch() { return false; }
     
     static CodeLocationLabel startOfBranchPtrWithPatchOnRegister(CodeLocationDataLabelPtr label)
     {
@@ -1885,30 +1804,36 @@ public:
         return CodeLocationLabel();
     }
     
-    static CodeLocationLabel startOfPatchableBranch32WithPatchOnAddress(CodeLocationDataLabel32)
-    {
-        UNREACHABLE_FOR_PLATFORM();
-        return CodeLocationLabel();
-    }
-    
     static void revertJumpReplacementToPatchableBranchPtrWithPatch(CodeLocationLabel, Address, void*)
     {
         UNREACHABLE_FOR_PLATFORM();
     }
 
-    static void revertJumpReplacementToPatchableBranch32WithPatch(CodeLocationLabel, Address, int32_t)
-    {
-        UNREACHABLE_FOR_PLATFORM();
-    }
+#if USE(MASM_PROBE)
+    struct CPUState {
+        #define DECLARE_REGISTER(_type, _regName) \
+            _type _regName;
+        FOR_EACH_CPU_REGISTER(DECLARE_REGISTER)
+        #undef DECLARE_REGISTER
+    };
+
+    struct ProbeContext;
+    typedef void (*ProbeFunction)(struct ProbeContext*);
+
+    struct ProbeContext {
+        ProbeFunction probeFunction;
+        void* arg1;
+        void* arg2;
+        CPUState cpu;
+
+        void dump(const char* indentation = 0);
+    private:
+        void dumpCPURegisters(const char* indentation);
+    };
 
-#if ENABLE(MASM_PROBE)
-    // Methods required by the MASM_PROBE mechanism as defined in
-    // AbstractMacroAssembler.h. 
-    static void printCPURegisters(CPUState&, int indentation = 0);
-    static void printRegister(CPUState&, RegisterID);
-    static void printRegister(CPUState&, FPRegisterID);
+    // For details about probe(), see comment in MacroAssemblerX86_64.h.
     void probe(ProbeFunction, void* arg1 = 0, void* arg2 = 0);
-#endif // ENABLE(MASM_PROBE)
+#endif // USE(MASM_PROBE)
 
 protected:
     ALWAYS_INLINE Jump jump()
@@ -2020,7 +1945,7 @@ private:
         ARMv7Assembler::relinkCall(call.dataLocation(), destination.executableAddress());
     }
 
-#if ENABLE(MASM_PROBE)
+#if USE(MASM_PROBE)
     inline TrustedImm32 trustedImm32FromPtr(void* ptr)
     {
         return TrustedImm32(TrustedImmPtr(ptr));