JavaScriptCore-1097.13.tar.gz

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

diff --git a/assembler/AbstractMacroAssembler.h b/assembler/AbstractMacroAssembler.h
index 7d9d0925c5ee42931c3f7568eec49d7dda05049f..e7cc70fc5e2add38caa3eeb98b8ea65a1a2ef25b 100644 (file)
--- a/assembler/AbstractMacroAssembler.h
+++ b/assembler/AbstractMacroAssembler.h
@@ -26,17 +26,31 @@
 #ifndef AbstractMacroAssembler_h
 #define AbstractMacroAssembler_h
 
 #ifndef AbstractMacroAssembler_h
 #define AbstractMacroAssembler_h
 

+#include "AssemblerBuffer.h"

 #include "CodeLocation.h"
 #include "MacroAssemblerCodeRef.h"
 #include "CodeLocation.h"
 #include "MacroAssemblerCodeRef.h"

+#include <wtf/CryptographicallyRandomNumber.h>

 #include <wtf/Noncopyable.h>
 #include <wtf/UnusedParam.h>
 
 #if ENABLE(ASSEMBLER)
 
 #include <wtf/Noncopyable.h>
 #include <wtf/UnusedParam.h>
 
 #if ENABLE(ASSEMBLER)
 

+
+#if PLATFORM(QT)
+#define ENABLE_JIT_CONSTANT_BLINDING 0
+#endif
+
+#ifndef ENABLE_JIT_CONSTANT_BLINDING
+#define ENABLE_JIT_CONSTANT_BLINDING 1
+#endif
+

 namespace JSC {
 
 class LinkBuffer;
 class RepatchBuffer;
 namespace JSC {
 
 class LinkBuffer;
 class RepatchBuffer;

+namespace DFG {
+class CorrectableJumpPoint;
+}

 
 template <class AssemblerType>
 class AbstractMacroAssembler {
 
 template <class AssemblerType>
 class AbstractMacroAssembler {


@@ -161,6 +175,19 @@ public:
             : m_value(value)
         {
         }
             : m_value(value)
         {
         }

+        
+        // This is only here so that TrustedImmPtr(0) does not confuse the C++
+        // overload handling rules.
+        explicit TrustedImmPtr(int value)
+            : m_value(0)
+        {
+            ASSERT_UNUSED(value, !value);
+        }
+
+        explicit TrustedImmPtr(size_t value)
+            : m_value(reinterpret_cast<void*>(value))
+        {
+        }

 
         intptr_t asIntptr()
         {
 
         intptr_t asIntptr()
         {


@@ -170,11 +197,19 @@ public:
         const void* m_value;
     };
 
         const void* m_value;
     };
 

-    struct ImmPtr : public TrustedImmPtr {
+    struct ImmPtr : 
+#if ENABLE(JIT_CONSTANT_BLINDING)
+        private TrustedImmPtr 
+#else
+        public TrustedImmPtr
+#endif
+    {

         explicit ImmPtr(const void* value)
             : TrustedImmPtr(value)
         {
         }
         explicit ImmPtr(const void* value)
             : TrustedImmPtr(value)
         {
         }

+
+        TrustedImmPtr asTrustedImmPtr() { return *this; }

     };
 
     // TrustedImm32:
     };
 
     // TrustedImm32:


@@ -216,7 +251,13 @@ public:
     };
 
 
     };
 
 

-    struct Imm32 : public TrustedImm32 {
+    struct Imm32 : 
+#if ENABLE(JIT_CONSTANT_BLINDING)
+        private TrustedImm32 
+#else
+        public TrustedImm32
+#endif
+    {

         explicit Imm32(int32_t value)
             : TrustedImm32(value)
         {
         explicit Imm32(int32_t value)
             : TrustedImm32(value)
         {


@@ -227,6 +268,8 @@ public:
         {
         }
 #endif
         {
         }
 #endif

+        const TrustedImm32& asTrustedImm32() const { return *this; }
+

     };
     
     // Section 2: MacroAssembler code buffer handles
     };
     
     // Section 2: MacroAssembler code buffer handles


@@ -244,6 +287,7 @@ public:
     class Label {
         template<class TemplateAssemblerType>
         friend class AbstractMacroAssembler;
     class Label {
         template<class TemplateAssemblerType>
         friend class AbstractMacroAssembler;

+        friend class DFG::CorrectableJumpPoint;

         friend class Jump;
         friend class MacroAssemblerCodeRef;
         friend class LinkBuffer;
         friend class Jump;
         friend class MacroAssemblerCodeRef;
         friend class LinkBuffer;


@@ -362,7 +406,7 @@ public:
         }
         
         Call(AssemblerLabel jmp, Flags flags)
         }
         
         Call(AssemblerLabel jmp, Flags flags)

-            : m_jmp(jmp)
+            : m_label(jmp)

             , m_flags(flags)
         {
         }
             , m_flags(flags)
         {
         }


@@ -374,10 +418,10 @@ public:
 
         static Call fromTailJump(Jump jump)
         {
 
         static Call fromTailJump(Jump jump)
         {

-            return Call(jump.m_jmp, Linkable);
+            return Call(jump.m_label, Linkable);

         }
 
         }
 

-        AssemblerLabel m_jmp;
+        AssemblerLabel m_label;

     private:
         Flags m_flags;
     };
     private:
         Flags m_flags;
     };


@@ -392,6 +436,7 @@ public:
         template<class TemplateAssemblerType>
         friend class AbstractMacroAssembler;
         friend class Call;
         template<class TemplateAssemblerType>
         friend class AbstractMacroAssembler;
         friend class Call;

+        friend class DFG::CorrectableJumpPoint;

         friend class LinkBuffer;
     public:
         Jump()
         friend class LinkBuffer;
     public:
         Jump()


@@ -401,14 +446,20 @@ public:
 #if CPU(ARM_THUMB2)
         // Fixme: this information should be stored in the instruction stream, not in the Jump object.
         Jump(AssemblerLabel jmp, ARMv7Assembler::JumpType type, ARMv7Assembler::Condition condition = ARMv7Assembler::ConditionInvalid)
 #if CPU(ARM_THUMB2)
         // Fixme: this information should be stored in the instruction stream, not in the Jump object.
         Jump(AssemblerLabel jmp, ARMv7Assembler::JumpType type, ARMv7Assembler::Condition condition = ARMv7Assembler::ConditionInvalid)

-            : m_jmp(jmp)
+            : m_label(jmp)

             , m_type(type)
             , m_condition(condition)
         {
         }
             , m_type(type)
             , m_condition(condition)
         {
         }

+#elif CPU(SH4)
+        Jump(AssemblerLabel jmp, SH4Assembler::JumpType type = SH4Assembler::JumpFar)
+            : m_label(jmp)
+            , m_type(type)
+        {
+        }

 #else
         Jump(AssemblerLabel jmp)    
 #else
         Jump(AssemblerLabel jmp)    

-            : m_jmp(jmp)
+            : m_label(jmp)

         {
         }
 #endif
         {
         }
 #endif


@@ -416,29 +467,49 @@ public:
         void link(AbstractMacroAssembler<AssemblerType>* masm) const
         {
 #if CPU(ARM_THUMB2)
         void link(AbstractMacroAssembler<AssemblerType>* masm) const
         {
 #if CPU(ARM_THUMB2)

-            masm->m_assembler.linkJump(m_jmp, masm->m_assembler.label(), m_type, m_condition);
+            masm->m_assembler.linkJump(m_label, masm->m_assembler.label(), m_type, m_condition);
+#elif CPU(SH4)
+            masm->m_assembler.linkJump(m_label, masm->m_assembler.label(), m_type);

 #else
 #else

-            masm->m_assembler.linkJump(m_jmp, masm->m_assembler.label());
+            masm->m_assembler.linkJump(m_label, masm->m_assembler.label());

 #endif
         }
         
         void linkTo(Label label, AbstractMacroAssembler<AssemblerType>* masm) const
         {
 #if CPU(ARM_THUMB2)
 #endif
         }
         
         void linkTo(Label label, AbstractMacroAssembler<AssemblerType>* masm) const
         {
 #if CPU(ARM_THUMB2)

-            masm->m_assembler.linkJump(m_jmp, label.m_label, m_type, m_condition);
+            masm->m_assembler.linkJump(m_label, label.m_label, m_type, m_condition);

 #else
 #else

-            masm->m_assembler.linkJump(m_jmp, label.m_label);
+            masm->m_assembler.linkJump(m_label, label.m_label);

 #endif
         }
 
 #endif
         }
 

-        bool isSet() const { return m_jmp.isSet(); }
+        bool isSet() const { return m_label.isSet(); }

 
     private:
 
     private:

-        AssemblerLabel m_jmp;
+        AssemblerLabel m_label;

 #if CPU(ARM_THUMB2)
         ARMv7Assembler::JumpType m_type;
         ARMv7Assembler::Condition m_condition;
 #endif
 #if CPU(ARM_THUMB2)
         ARMv7Assembler::JumpType m_type;
         ARMv7Assembler::Condition m_condition;
 #endif

+#if CPU(SH4)
+        SH4Assembler::JumpType m_type;
+#endif
+    };
+
+    struct PatchableJump {
+        PatchableJump()
+        {
+        }
+
+        explicit PatchableJump(Jump jump)
+            : m_jump(jump)
+        {
+        }
+
+        operator Jump&() { return m_jump; }
+
+        Jump m_jump;

     };
 
     // JumpList:
     };
 
     // JumpList:


@@ -506,72 +577,50 @@ public:
         return Label(this);
     }
 
         return Label(this);
     }
 

-    ptrdiff_t differenceBetween(Label from, Jump to)
-    {
-        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_jmp);
-    }
-
-    ptrdiff_t differenceBetween(Label from, Call to)
-    {
-        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_jmp);
-    }
-
-    ptrdiff_t differenceBetween(Label from, Label to)
+    template<typename T, typename U>
+    static ptrdiff_t differenceBetween(T from, U to)

     {
         return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_label);
     }
 
     {
         return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_label);
     }
 

-    ptrdiff_t differenceBetween(Label from, DataLabelPtr to)
+    static ptrdiff_t differenceBetweenCodePtr(const MacroAssemblerCodePtr& a, const MacroAssemblerCodePtr& b)

     {
     {

-        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_label);
+        return reinterpret_cast<ptrdiff_t>(b.executableAddress()) - reinterpret_cast<ptrdiff_t>(a.executableAddress());

     }
 
     }
 

-    ptrdiff_t differenceBetween(Label from, DataLabel32 to)
-    {
-        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_label);
-    }
-    
-    ptrdiff_t differenceBetween(Label from, DataLabelCompact to)
-    {
-        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_label);
-    }
+    unsigned debugOffset() { return m_assembler.debugOffset(); }

 
 

-    ptrdiff_t differenceBetween(DataLabelPtr from, Jump to)
+    ALWAYS_INLINE static void cacheFlush(void* code, size_t size)

     {
     {

-        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_jmp);
+        AssemblerType::cacheFlush(code, size);

     }
     }

-
-    ptrdiff_t differenceBetween(DataLabelPtr from, DataLabelPtr to)
+protected:
+    AbstractMacroAssembler()
+        : m_randomSource(cryptographicallyRandomNumber())

     {
     {

-        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_label);

     }
 
     }
 

-    ptrdiff_t differenceBetween(DataLabelPtr from, Call to)
+    AssemblerType m_assembler;
+    
+    uint32_t random()

     {
     {

-        return AssemblerType::getDifferenceBetweenLabels(from.m_label, to.m_jmp);
+        return m_randomSource.getUint32();

     }
 
     }
 

-    // Temporary interface; likely to be removed, since may be hard to port to all architectures.
-#if CPU(X86) || CPU(X86_64)
-    void rewindToLabel(Label rewindTo) { m_assembler.rewindToLabel(rewindTo.m_label); }
-#endif
-
-    void beginUninterruptedSequence() { }
-    void endUninterruptedSequence() { }
+    WeakRandom m_randomSource;

 
 

-#ifndef NDEBUG
-    unsigned debugOffset() { return m_assembler.debugOffset(); }
+#if ENABLE(JIT_CONSTANT_BLINDING)
+    static bool scratchRegisterForBlinding() { return false; }
+    static bool shouldBlindForSpecificArch(uint32_t) { return true; }
+    static bool shouldBlindForSpecificArch(uint64_t) { return true; }

 #endif
 
 #endif
 

-protected:
-    AssemblerType m_assembler;
-

     friend class LinkBuffer;
     friend class RepatchBuffer;
 
     static void linkJump(void* code, Jump jump, CodeLocationLabel target)
     {
     friend class LinkBuffer;
     friend class RepatchBuffer;
 
     static void linkJump(void* code, Jump jump, CodeLocationLabel target)
     {

-        AssemblerType::linkJump(code, jump.m_jmp, target.dataLocation());
+        AssemblerType::linkJump(code, jump.m_label, target.dataLocation());

     }
 
     static void linkPointer(void* code, AssemblerLabel label, void* value)
     }
 
     static void linkPointer(void* code, AssemblerLabel label, void* value)


@@ -586,7 +635,7 @@ protected:
 
     static unsigned getLinkerCallReturnOffset(Call call)
     {
 
     static unsigned getLinkerCallReturnOffset(Call call)
     {

-        return AssemblerType::getCallReturnOffset(call.m_jmp);
+        return AssemblerType::getCallReturnOffset(call.m_label);

     }
 
     static void repatchJump(CodeLocationJump jump, CodeLocationLabel destination)
     }
 
     static void repatchJump(CodeLocationJump jump, CodeLocationLabel destination)


@@ -618,6 +667,18 @@ protected:
     {
         return AssemblerType::readPointer(dataLabelPtr.dataLocation());
     }
     {
         return AssemblerType::readPointer(dataLabelPtr.dataLocation());
     }

+    
+    static void unreachableForPlatform()
+    {
+#if COMPILER(CLANG)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmissing-noreturn"
+        ASSERT_NOT_REACHED();
+#pragma clang diagnostic pop
+#else
+        ASSERT_NOT_REACHED();
+#endif
+    }

 };
 
 } // namespace JSC
 };
 
 } // namespace JSC