JavaScriptCore-7601.1.46.3.tar.gz

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

diff --git a/assembler/MacroAssemblerCodeRef.h b/assembler/MacroAssemblerCodeRef.h
index ec16659d5a729938c443a60fac365cf699573bf4..b4d6c0bfb447308a8ea42d40be026576ceb04a2a 100644 (file)
--- a/assembler/MacroAssemblerCodeRef.h
+++ b/assembler/MacroAssemblerCodeRef.h
@@ -31,19 +31,18 @@
 #include "LLIntData.h"
 #include <wtf/DataLog.h>
 #include <wtf/PassRefPtr.h>
 #include "LLIntData.h"
 #include <wtf/DataLog.h>
 #include <wtf/PassRefPtr.h>

+#include <wtf/PrintStream.h>

 #include <wtf/RefPtr.h>
 
 // ASSERT_VALID_CODE_POINTER checks that ptr is a non-null pointer, and that it is a valid
 // instruction address on the platform (for example, check any alignment requirements).
 #include <wtf/RefPtr.h>
 
 // ASSERT_VALID_CODE_POINTER checks that ptr is a non-null pointer, and that it is a valid
 // instruction address on the platform (for example, check any alignment requirements).

-#if CPU(ARM_THUMB2)
-// ARM/thumb instructions must be 16-bit aligned, but all code pointers to be loaded
-// into the processor are decorated with the bottom bit set, indicating that this is
-// thumb code (as oposed to 32-bit traditional ARM).  The first test checks for both
-// decorated and undectorated null, and the second test ensures that the pointer is
-// decorated.
+#if CPU(ARM_THUMB2) && ENABLE(JIT)
+// ARM instructions must be 16-bit aligned. Thumb2 code pointers to be loaded into
+// into the processor are decorated with the bottom bit set, while traditional ARM has
+// the lower bit clear. Since we don't know what kind of pointer, we check for both
+// decorated and undecorated null.

 #define ASSERT_VALID_CODE_POINTER(ptr) \
 #define ASSERT_VALID_CODE_POINTER(ptr) \

-    ASSERT(reinterpret_cast<intptr_t>(ptr) & ~1); \
-    ASSERT(reinterpret_cast<intptr_t>(ptr) & 1)
+    ASSERT(reinterpret_cast<intptr_t>(ptr) & ~1)

 #define ASSERT_VALID_CODE_OFFSET(offset) \
     ASSERT(!(offset & 1)) // Must be multiple of 2.
 #else
 #define ASSERT_VALID_CODE_OFFSET(offset) \
     ASSERT(!(offset & 1)) // Must be multiple of 2.
 #else


@@ -133,6 +132,12 @@ public:
         ASSERT_VALID_CODE_POINTER(m_value);
     }
 
         ASSERT_VALID_CODE_POINTER(m_value);
     }
 

+    template<typename returnType, typename argType1, typename argType2, typename argType3, typename argType4, typename argType5, typename argType6>
+    FunctionPtr(returnType(*value)(argType1, argType2, argType3, argType4, argType5, argType6))
+        : m_value((void*)value)
+    {
+        ASSERT_VALID_CODE_POINTER(m_value);
+    }

 // MSVC doesn't seem to treat functions with different calling conventions as
 // different types; these methods already defined for fastcall, below.
 #if CALLING_CONVENTION_IS_STDCALL && !OS(WINDOWS)
 // MSVC doesn't seem to treat functions with different calling conventions as
 // different types; these methods already defined for fastcall, below.
 #if CALLING_CONVENTION_IS_STDCALL && !OS(WINDOWS)


@@ -255,6 +260,11 @@ public:
     }
 
     void* value() const { return m_value; }
     }
 
     void* value() const { return m_value; }

+    
+    void dump(PrintStream& out) const
+    {
+        out.print(RawPointer(m_value));
+    }

 
 private:
     void* m_value;
 
 private:
     void* m_value;


@@ -289,12 +299,10 @@ public:
         return result;
     }
 
         return result;
     }
 

-#if ENABLE(LLINT)
-    static MacroAssemblerCodePtr createLLIntCodePtr(LLIntCode codeId)
+    static MacroAssemblerCodePtr createLLIntCodePtr(OpcodeID codeId)

     {
         return createFromExecutableAddress(LLInt::getCodePtr(codeId));
     }
     {
         return createFromExecutableAddress(LLInt::getCodePtr(codeId));
     }

-#endif

 
     explicit MacroAssemblerCodePtr(ReturnAddressPtr ra)
         : m_value(ra.value())
 
     explicit MacroAssemblerCodePtr(ReturnAddressPtr ra)
         : m_value(ra.value())


@@ -310,15 +318,61 @@ public:
     void* dataLocation() const { ASSERT_VALID_CODE_POINTER(m_value); return m_value; }
 #endif
 
     void* dataLocation() const { ASSERT_VALID_CODE_POINTER(m_value); return m_value; }
 #endif
 

-    bool operator!() const
+    explicit operator bool() const { return m_value; }
+    
+    bool operator==(const MacroAssemblerCodePtr& other) const

     {
     {

-        return !m_value;
+        return m_value == other.m_value;

     }
 
     }
 

+    void dumpWithName(const char* name, PrintStream& out) const
+    {
+        if (executableAddress() == dataLocation()) {
+            out.print(name, "(", RawPointer(executableAddress()), ")");
+            return;
+        }
+        out.print(name, "(executable = ", RawPointer(executableAddress()), ", dataLocation = ", RawPointer(dataLocation()), ")");
+    }
+    
+    void dump(PrintStream& out) const
+    {
+        dumpWithName("CodePtr", out);
+    }
+    
+    enum EmptyValueTag { EmptyValue };
+    enum DeletedValueTag { DeletedValue };
+    
+    MacroAssemblerCodePtr(EmptyValueTag)
+        : m_value(emptyValue())
+    {
+    }
+    
+    MacroAssemblerCodePtr(DeletedValueTag)
+        : m_value(deletedValue())
+    {
+    }
+    
+    bool isEmptyValue() const { return m_value == emptyValue(); }
+    bool isDeletedValue() const { return m_value == deletedValue(); }
+    
+    unsigned hash() const { return PtrHash<void*>::hash(m_value); }
+

 private:
 private:

+    static void* emptyValue() { return bitwise_cast<void*>(static_cast<intptr_t>(1)); }
+    static void* deletedValue() { return bitwise_cast<void*>(static_cast<intptr_t>(2)); }
+    

     void* m_value;
 };
 
     void* m_value;
 };
 

+struct MacroAssemblerCodePtrHash {
+    static unsigned hash(const MacroAssemblerCodePtr& ptr) { return ptr.hash(); }
+    static bool equal(const MacroAssemblerCodePtr& a, const MacroAssemblerCodePtr& b)
+    {
+        return a == b;
+    }
+    static const bool safeToCompareToEmptyOrDeleted = true;
+};
+

 // MacroAssemblerCodeRef:
 //
 // A reference to a section of JIT generated code.  A CodeRef consists of a
 // MacroAssemblerCodeRef:
 //
 // A reference to a section of JIT generated code.  A CodeRef consists of a


@@ -356,13 +410,11 @@ public:
         return MacroAssemblerCodeRef(codePtr);
     }
     
         return MacroAssemblerCodeRef(codePtr);
     }
     

-#if ENABLE(LLINT)

     // Helper for creating self-managed code refs from LLInt.
     // Helper for creating self-managed code refs from LLInt.

-    static MacroAssemblerCodeRef createLLIntCodeRef(LLIntCode codeId)
+    static MacroAssemblerCodeRef createLLIntCodeRef(OpcodeID codeId)

     {
         return createSelfManagedCodeRef(MacroAssemblerCodePtr::createFromExecutableAddress(LLInt::getCodePtr(codeId)));
     }
     {
         return createSelfManagedCodeRef(MacroAssemblerCodePtr::createFromExecutableAddress(LLInt::getCodePtr(codeId)));
     }

-#endif

 
     ExecutableMemoryHandle* executableMemory() const
     {
 
     ExecutableMemoryHandle* executableMemory() const
     {


@@ -386,7 +438,12 @@ public:
         return JSC::tryToDisassemble(m_codePtr, size(), prefix, WTF::dataFile());
     }
     
         return JSC::tryToDisassemble(m_codePtr, size(), prefix, WTF::dataFile());
     }
     

-    bool operator!() const { return !m_codePtr; }
+    explicit operator bool() const { return !!m_codePtr; }
+    
+    void dump(PrintStream& out) const
+    {
+        m_codePtr.dumpWithName("CodeRef", out);
+    }

 
 private:
     MacroAssemblerCodePtr m_codePtr;
 
 private:
     MacroAssemblerCodePtr m_codePtr;


@@ -395,4 +452,16 @@ private:
 
 } // namespace JSC
 
 
 } // namespace JSC
 

+namespace WTF {
+
+template<typename T> struct DefaultHash;
+template<> struct DefaultHash<JSC::MacroAssemblerCodePtr> {
+    typedef JSC::MacroAssemblerCodePtrHash Hash;
+};
+
+template<typename T> struct HashTraits;
+template<> struct HashTraits<JSC::MacroAssemblerCodePtr> : public CustomHashTraits<JSC::MacroAssemblerCodePtr> { };
+
+} // namespace WTF
+

 #endif // MacroAssemblerCodeRef_h
 #endif // MacroAssemblerCodeRef_h