JavaScriptCore-7600.1.4.9.tar.gz

[apple/javascriptcore.git] / assembler / MacroAssemblerX86.h

diff --git a/assembler/MacroAssemblerX86.h b/assembler/MacroAssemblerX86.h
index 0918996302022e211db69da6a2cd08f82f145d6b..56416856f2c4b480c6ecc048696bc7d5111f9516 100644 (file)
--- a/assembler/MacroAssemblerX86.h
+++ b/assembler/MacroAssemblerX86.h
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (C) 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2014 Apple Inc. All rights reserved.

  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions


@@ -30,67 +30,116 @@
 
 #include "MacroAssemblerX86Common.h"
 
 
 #include "MacroAssemblerX86Common.h"
 

+#if USE(MASM_PROBE)
+#include <wtf/StdLibExtras.h>
+#endif
+

 namespace JSC {
 
 class MacroAssemblerX86 : public MacroAssemblerX86Common {
 public:
 namespace JSC {
 
 class MacroAssemblerX86 : public MacroAssemblerX86Common {
 public:

-    MacroAssemblerX86()
-        : m_isSSE2Present(isSSE2Present())
-    {
-    }
-

     static const Scale ScalePtr = TimesFour;
 
     using MacroAssemblerX86Common::add32;
     using MacroAssemblerX86Common::and32;
     static const Scale ScalePtr = TimesFour;
 
     using MacroAssemblerX86Common::add32;
     using MacroAssemblerX86Common::and32;

+    using MacroAssemblerX86Common::branchAdd32;
+    using MacroAssemblerX86Common::branchSub32;

     using MacroAssemblerX86Common::sub32;
     using MacroAssemblerX86Common::or32;
     using MacroAssemblerX86Common::load32;
     using MacroAssemblerX86Common::sub32;
     using MacroAssemblerX86Common::or32;
     using MacroAssemblerX86Common::load32;

+    using MacroAssemblerX86Common::load8;

     using MacroAssemblerX86Common::store32;
     using MacroAssemblerX86Common::store32;

+    using MacroAssemblerX86Common::store8;

     using MacroAssemblerX86Common::branch32;
     using MacroAssemblerX86Common::call;
     using MacroAssemblerX86Common::branch32;
     using MacroAssemblerX86Common::call;

+    using MacroAssemblerX86Common::jump;
+    using MacroAssemblerX86Common::addDouble;

     using MacroAssemblerX86Common::loadDouble;
     using MacroAssemblerX86Common::loadDouble;

+    using MacroAssemblerX86Common::storeDouble;

     using MacroAssemblerX86Common::convertInt32ToDouble;
     using MacroAssemblerX86Common::convertInt32ToDouble;

+    using MacroAssemblerX86Common::branch8;
+    using MacroAssemblerX86Common::branchTest8;

 
 

-    void add32(Imm32 imm, RegisterID src, RegisterID dest)
+    void add32(TrustedImm32 imm, RegisterID src, RegisterID dest)

     {
         m_assembler.leal_mr(imm.m_value, src, dest);
     }
 
     {
         m_assembler.leal_mr(imm.m_value, src, dest);
     }
 

-    void add32(Imm32 imm, AbsoluteAddress address)
+    void add32(TrustedImm32 imm, AbsoluteAddress address)

     {
         m_assembler.addl_im(imm.m_value, address.m_ptr);
     }
     
     {
         m_assembler.addl_im(imm.m_value, address.m_ptr);
     }
     

-    void addWithCarry32(Imm32 imm, AbsoluteAddress address)
+    void add32(AbsoluteAddress address, RegisterID dest)

     {
     {

-        m_assembler.adcl_im(imm.m_value, address.m_ptr);
+        m_assembler.addl_mr(address.m_ptr, dest);

     }
     
     }
     

-    void and32(Imm32 imm, AbsoluteAddress address)
+    void add64(TrustedImm32 imm, AbsoluteAddress address)
+    {
+        m_assembler.addl_im(imm.m_value, address.m_ptr);
+        m_assembler.adcl_im(imm.m_value >> 31, reinterpret_cast<const char*>(address.m_ptr) + sizeof(int32_t));
+    }
+
+    void and32(TrustedImm32 imm, AbsoluteAddress address)

     {
         m_assembler.andl_im(imm.m_value, address.m_ptr);
     }
     
     {
         m_assembler.andl_im(imm.m_value, address.m_ptr);
     }
     

-    void or32(Imm32 imm, AbsoluteAddress address)
+    void or32(TrustedImm32 imm, AbsoluteAddress address)

     {
         m_assembler.orl_im(imm.m_value, address.m_ptr);
     }
     {
         m_assembler.orl_im(imm.m_value, address.m_ptr);
     }

-
-    void sub32(Imm32 imm, AbsoluteAddress address)
+    
+    void or32(RegisterID reg, AbsoluteAddress address)
+    {
+        m_assembler.orl_rm(reg, address.m_ptr);
+    }
+    
+    void sub32(TrustedImm32 imm, AbsoluteAddress address)

     {
         m_assembler.subl_im(imm.m_value, address.m_ptr);
     }
 
     {
         m_assembler.subl_im(imm.m_value, address.m_ptr);
     }
 

-    void load32(void* address, RegisterID dest)
+    void load32(const void* address, RegisterID dest)

     {
         m_assembler.movl_mr(address, dest);
     }
     {
         m_assembler.movl_mr(address, dest);
     }

+    
+    void load8(const void* address, RegisterID dest)
+    {
+        m_assembler.movzbl_mr(address, dest);
+    }
+
+    void abortWithReason(AbortReason reason)
+    {
+        move(TrustedImm32(reason), X86Registers::eax);
+        breakpoint();
+    }
+
+    void abortWithReason(AbortReason reason, intptr_t misc)
+    {
+        move(TrustedImm32(misc), X86Registers::edx);
+        abortWithReason(reason);
+    }
+
+    ConvertibleLoadLabel convertibleLoadPtr(Address address, RegisterID dest)
+    {
+        ConvertibleLoadLabel result = ConvertibleLoadLabel(this);
+        m_assembler.movl_mr(address.offset, address.base, dest);
+        return result;
+    }

 
 

-    void loadDouble(const void* address, FPRegisterID dest)
+    void addDouble(AbsoluteAddress address, FPRegisterID dest)
+    {
+        m_assembler.addsd_mr(address.m_ptr, dest);
+    }
+
+    void storeDouble(FPRegisterID src, TrustedImmPtr address)

     {
         ASSERT(isSSE2Present());
     {
         ASSERT(isSSE2Present());

-        m_assembler.movsd_mr(address, dest);
+        ASSERT(address.m_value);
+        m_assembler.movsd_rm(src, address.m_value);

     }
 
     void convertInt32ToDouble(AbsoluteAddress src, FPRegisterID dest)
     }
 
     void convertInt32ToDouble(AbsoluteAddress src, FPRegisterID dest)


@@ -98,7 +147,7 @@ public:
         m_assembler.cvtsi2sd_mr(src.m_ptr, dest);
     }
 
         m_assembler.cvtsi2sd_mr(src.m_ptr, dest);
     }
 

-    void store32(Imm32 imm, void* address)
+    void store32(TrustedImm32 imm, void* address)

     {
         m_assembler.movl_i32m(imm.m_value, address);
     }
     {
         m_assembler.movl_i32m(imm.m_value, address);
     }


@@ -107,14 +156,55 @@ public:
     {
         m_assembler.movl_rm(src, address);
     }
     {
         m_assembler.movl_rm(src, address);
     }

+    
+    void store8(RegisterID src, void* address)
+    {
+        m_assembler.movb_rm(src, address);
+    }

 
 

-    Jump branch32(Condition cond, AbsoluteAddress left, RegisterID right)
+    void store8(TrustedImm32 imm, void* address)
+    {
+        ASSERT(-128 <= imm.m_value && imm.m_value < 128);
+        m_assembler.movb_i8m(imm.m_value, address);
+    }
+    
+    // Possibly clobbers src.
+    // FIXME: Don't do that.
+    // https://bugs.webkit.org/show_bug.cgi?id=131690
+    void moveDoubleToInts(FPRegisterID src, RegisterID dest1, RegisterID dest2)
+    {
+        movePackedToInt32(src, dest1);
+        rshiftPacked(TrustedImm32(32), src);
+        movePackedToInt32(src, dest2);
+    }
+
+    void moveIntsToDouble(RegisterID src1, RegisterID src2, FPRegisterID dest, FPRegisterID scratch)
+    {
+        moveInt32ToPacked(src1, dest);
+        moveInt32ToPacked(src2, scratch);
+        lshiftPacked(TrustedImm32(32), scratch);
+        orPacked(scratch, dest);
+    }
+
+    Jump branchAdd32(ResultCondition cond, TrustedImm32 imm, AbsoluteAddress dest)
+    {
+        m_assembler.addl_im(imm.m_value, dest.m_ptr);
+        return Jump(m_assembler.jCC(x86Condition(cond)));
+    }
+
+    Jump branchSub32(ResultCondition cond, TrustedImm32 imm, AbsoluteAddress dest)
+    {
+        m_assembler.subl_im(imm.m_value, dest.m_ptr);
+        return Jump(m_assembler.jCC(x86Condition(cond)));
+    }
+
+    Jump branch32(RelationalCondition cond, AbsoluteAddress left, RegisterID right)

     {
         m_assembler.cmpl_rm(right, left.m_ptr);
         return Jump(m_assembler.jCC(x86Condition(cond)));
     }
 
     {
         m_assembler.cmpl_rm(right, left.m_ptr);
         return Jump(m_assembler.jCC(x86Condition(cond)));
     }
 

-    Jump branch32(Condition cond, AbsoluteAddress left, Imm32 right)
+    Jump branch32(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)

     {
         m_assembler.cmpl_im(right.m_value, left.m_ptr);
         return Jump(m_assembler.jCC(x86Condition(cond)));
     {
         m_assembler.cmpl_im(right.m_value, left.m_ptr);
         return Jump(m_assembler.jCC(x86Condition(cond)));


@@ -125,6 +215,12 @@ public:
         return Call(m_assembler.call(), Call::Linkable);
     }
 
         return Call(m_assembler.call(), Call::Linkable);
     }
 

+    // Address is a memory location containing the address to jump to
+    void jump(AbsoluteAddress address)
+    {
+        m_assembler.jmp_m(address.m_ptr);
+    }
+

     Call tailRecursiveCall()
     {
         return Call::fromTailJump(jump());
     Call tailRecursiveCall()
     {
         return Call::fromTailJump(jump());


@@ -136,53 +232,136 @@ public:
     }
 
 
     }
 
 

-    DataLabelPtr moveWithPatch(ImmPtr initialValue, RegisterID dest)
+    DataLabelPtr moveWithPatch(TrustedImmPtr initialValue, RegisterID dest)

     {
     {

+        padBeforePatch();

         m_assembler.movl_i32r(initialValue.asIntptr(), dest);
         return DataLabelPtr(this);
     }
         m_assembler.movl_i32r(initialValue.asIntptr(), dest);
         return DataLabelPtr(this);
     }

+    
+    Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right)
+    {
+        m_assembler.cmpb_im(right.m_value, left.m_ptr);
+        return Jump(m_assembler.jCC(x86Condition(cond)));
+    }

 
 

-    Jump branchPtrWithPatch(Condition cond, RegisterID left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
+    Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))

     {
     {

+        ASSERT(mask.m_value >= -128 && mask.m_value <= 255);
+        if (mask.m_value == -1)
+            m_assembler.cmpb_im(0, address.m_ptr);
+        else
+            m_assembler.testb_im(mask.m_value, address.m_ptr);
+        return Jump(m_assembler.jCC(x86Condition(cond)));
+    }
+
+    Jump branchPtrWithPatch(RelationalCondition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
+    {
+        padBeforePatch();

         m_assembler.cmpl_ir_force32(initialRightValue.asIntptr(), left);
         dataLabel = DataLabelPtr(this);
         return Jump(m_assembler.jCC(x86Condition(cond)));
     }
 
         m_assembler.cmpl_ir_force32(initialRightValue.asIntptr(), left);
         dataLabel = DataLabelPtr(this);
         return Jump(m_assembler.jCC(x86Condition(cond)));
     }
 

-    Jump branchPtrWithPatch(Condition cond, Address left, DataLabelPtr& dataLabel, ImmPtr initialRightValue = ImmPtr(0))
+    Jump branchPtrWithPatch(RelationalCondition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))

     {
     {

+        padBeforePatch();

         m_assembler.cmpl_im_force32(initialRightValue.asIntptr(), left.offset, left.base);
         dataLabel = DataLabelPtr(this);
         return Jump(m_assembler.jCC(x86Condition(cond)));
     }
 
         m_assembler.cmpl_im_force32(initialRightValue.asIntptr(), left.offset, left.base);
         dataLabel = DataLabelPtr(this);
         return Jump(m_assembler.jCC(x86Condition(cond)));
     }
 

-    DataLabelPtr storePtrWithPatch(ImmPtr initialValue, ImplicitAddress address)
+    Jump branch32WithPatch(RelationalCondition cond, Address left, DataLabel32& dataLabel, TrustedImm32 initialRightValue = TrustedImm32(0))
+    {
+        padBeforePatch();
+        m_assembler.cmpl_im_force32(initialRightValue.m_value, left.offset, left.base);
+        dataLabel = DataLabel32(this);
+        return Jump(m_assembler.jCC(x86Condition(cond)));
+    }
+
+    DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)

     {
     {

+        padBeforePatch();

         m_assembler.movl_i32m(initialValue.asIntptr(), address.offset, address.base);
         return DataLabelPtr(this);
     }
 
         m_assembler.movl_i32m(initialValue.asIntptr(), address.offset, address.base);
         return DataLabelPtr(this);
     }
 

-    Label loadPtrWithPatchToLEA(Address address, RegisterID dest)
+    static bool supportsFloatingPoint() { return isSSE2Present(); }
+    // See comment on MacroAssemblerARMv7::supportsFloatingPointTruncate()
+    static bool supportsFloatingPointTruncate() { return isSSE2Present(); }
+    static bool supportsFloatingPointSqrt() { return isSSE2Present(); }
+    static bool supportsFloatingPointAbs() { return isSSE2Present(); }
+    
+    static FunctionPtr readCallTarget(CodeLocationCall call)

     {
     {

-        Label label(this);
-        load32(address, dest);
-        return label;
+        intptr_t offset = reinterpret_cast<int32_t*>(call.dataLocation())[-1];
+        return FunctionPtr(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(call.dataLocation()) + offset));

     }
 
     }
 

-    bool supportsFloatingPoint() const { return m_isSSE2Present; }
-    // See comment on MacroAssemblerARMv7::supportsFloatingPointTruncate()
-    bool supportsFloatingPointTruncate() const { return m_isSSE2Present; }
-    bool supportsFloatingPointSqrt() const { return m_isSSE2Present; }
+    static bool canJumpReplacePatchableBranchPtrWithPatch() { return true; }
+    static bool canJumpReplacePatchableBranch32WithPatch() { return true; }
+    
+    static CodeLocationLabel startOfBranchPtrWithPatchOnRegister(CodeLocationDataLabelPtr label)
+    {
+        const int opcodeBytes = 1;
+        const int modRMBytes = 1;
+        const int immediateBytes = 4;
+        const int totalBytes = opcodeBytes + modRMBytes + immediateBytes;
+        ASSERT(totalBytes >= maxJumpReplacementSize());
+        return label.labelAtOffset(-totalBytes);
+    }
+    
+    static CodeLocationLabel startOfPatchableBranchPtrWithPatchOnAddress(CodeLocationDataLabelPtr label)
+    {
+        const int opcodeBytes = 1;
+        const int modRMBytes = 1;
+        const int offsetBytes = 0;
+        const int immediateBytes = 4;
+        const int totalBytes = opcodeBytes + modRMBytes + offsetBytes + immediateBytes;
+        ASSERT(totalBytes >= maxJumpReplacementSize());
+        return label.labelAtOffset(-totalBytes);
+    }
+    
+    static CodeLocationLabel startOfPatchableBranch32WithPatchOnAddress(CodeLocationDataLabel32 label)
+    {
+        const int opcodeBytes = 1;
+        const int modRMBytes = 1;
+        const int offsetBytes = 0;
+        const int immediateBytes = 4;
+        const int totalBytes = opcodeBytes + modRMBytes + offsetBytes + immediateBytes;
+        ASSERT(totalBytes >= maxJumpReplacementSize());
+        return label.labelAtOffset(-totalBytes);
+    }
+    
+    static void revertJumpReplacementToBranchPtrWithPatch(CodeLocationLabel instructionStart, RegisterID reg, void* initialValue)
+    {
+        X86Assembler::revertJumpTo_cmpl_ir_force32(instructionStart.executableAddress(), reinterpret_cast<intptr_t>(initialValue), reg);
+    }

 
 

-private:
-    const bool m_isSSE2Present;
+    static void revertJumpReplacementToPatchableBranchPtrWithPatch(CodeLocationLabel instructionStart, Address address, void* initialValue)
+    {
+        ASSERT(!address.offset);
+        X86Assembler::revertJumpTo_cmpl_im_force32(instructionStart.executableAddress(), reinterpret_cast<intptr_t>(initialValue), 0, address.base);
+    }

 
 

+    static void revertJumpReplacementToPatchableBranch32WithPatch(CodeLocationLabel instructionStart, Address address, int32_t initialValue)
+    {
+        ASSERT(!address.offset);
+        X86Assembler::revertJumpTo_cmpl_im_force32(instructionStart.executableAddress(), initialValue, 0, address.base);
+    }
+
+#if USE(MASM_PROBE)
+    // For details about probe(), see comment in MacroAssemblerX86_64.h.
+    void probe(ProbeFunction, void* arg1 = 0, void* arg2 = 0);
+#endif // USE(MASM_PROBE)
+
+private:

     friend class LinkBuffer;
     friend class RepatchBuffer;
 
     static void linkCall(void* code, Call call, FunctionPtr function)
     {
     friend class LinkBuffer;
     friend class RepatchBuffer;
 
     static void linkCall(void* code, Call call, FunctionPtr function)
     {

-        X86Assembler::linkCall(code, call.m_jmp, function.value());
+        X86Assembler::linkCall(code, call.m_label, function.value());

     }
 
     static void repatchCall(CodeLocationCall call, CodeLocationLabel destination)
     }
 
     static void repatchCall(CodeLocationCall call, CodeLocationLabel destination)


@@ -194,8 +373,46 @@ private:
     {
         X86Assembler::relinkCall(call.dataLocation(), destination.executableAddress());
     }
     {
         X86Assembler::relinkCall(call.dataLocation(), destination.executableAddress());
     }

+
+#if USE(MASM_PROBE)
+    inline TrustedImm32 trustedImm32FromPtr(void* ptr)
+    {
+        return TrustedImm32(TrustedImmPtr(ptr));
+    }
+
+    inline TrustedImm32 trustedImm32FromPtr(ProbeFunction function)
+    {
+        return TrustedImm32(TrustedImmPtr(reinterpret_cast<void*>(function)));
+    }
+
+    inline TrustedImm32 trustedImm32FromPtr(void (*function)())
+    {
+        return TrustedImm32(TrustedImmPtr(reinterpret_cast<void*>(function)));
+    }
+#endif

 };
 
 };
 

+#if USE(MASM_PROBE)
+
+extern "C" void ctiMasmProbeTrampoline();
+
+// For details on "What code is emitted for the probe?" and "What values are in
+// the saved registers?", see comment for MacroAssemblerX86::probe() in
+// MacroAssemblerX86_64.h.
+
+inline void MacroAssemblerX86::probe(MacroAssemblerX86::ProbeFunction function, void* arg1, void* arg2)
+{
+    push(RegisterID::esp);
+    push(RegisterID::eax);
+    push(trustedImm32FromPtr(arg2));
+    push(trustedImm32FromPtr(arg1));
+    push(trustedImm32FromPtr(function));
+
+    move(trustedImm32FromPtr(ctiMasmProbeTrampoline), RegisterID::eax);
+    call(RegisterID::eax);
+}
+#endif // USE(MASM_PROBE)
+

 } // namespace JSC
 
 #endif // ENABLE(ASSEMBLER)
 } // namespace JSC
 
 #endif // ENABLE(ASSEMBLER)