From 6882a04fb36642862b11efe514251d32070c3d65 Mon Sep 17 00:00:00 2001 From: Konstantin Tokarev Date: Thu, 25 Aug 2016 19:20:41 +0300 Subject: Imported QtWebKit TP3 (git b57bc6801f1876c3220d5a4bfea33d620d477443) Change-Id: I3b1d8a2808782c9f34d50240000e20cb38d3680f Reviewed-by: Konstantin Tokarev --- .../assembler/MacroAssemblerCodeRef.h | 107 +++++++++++++++++---- 1 file changed, 90 insertions(+), 17 deletions(-) (limited to 'Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h') diff --git a/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h b/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h index ec16659d5..2d9738478 100644 --- a/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h +++ b/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.h @@ -31,19 +31,18 @@ #include "LLIntData.h" #include #include +#include #include // 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) \ - ASSERT(reinterpret_cast(ptr) & ~1); \ - ASSERT(reinterpret_cast(ptr) & 1) + ASSERT(reinterpret_cast(ptr) & ~1) #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); } + template + 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) @@ -255,6 +260,11 @@ public: } void* value() const { return m_value; } + + void dump(PrintStream& out) const + { + out.print(RawPointer(m_value)); + } private: void* m_value; @@ -289,12 +299,10 @@ public: return result; } -#if ENABLE(LLINT) - static MacroAssemblerCodePtr createLLIntCodePtr(LLIntCode codeId) + static MacroAssemblerCodePtr createLLIntCodePtr(OpcodeID codeId) { return createFromExecutableAddress(LLInt::getCodePtr(codeId)); } -#endif explicit MacroAssemblerCodePtr(ReturnAddressPtr ra) : m_value(ra.value()) @@ -310,15 +318,65 @@ public: 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 (!m_value) { + out.print(name, "(null)"); + return; + } + 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::hash(m_value); } + private: + static void* emptyValue() { return bitwise_cast(static_cast(1)); } + static void* deletedValue() { return bitwise_cast(static_cast(2)); } + 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 @@ -356,13 +414,11 @@ public: return MacroAssemblerCodeRef(codePtr); } -#if ENABLE(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))); } -#endif ExecutableMemoryHandle* executableMemory() const { @@ -386,7 +442,12 @@ public: 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; @@ -395,4 +456,16 @@ private: } // namespace JSC +namespace WTF { + +template struct DefaultHash; +template<> struct DefaultHash { + typedef JSC::MacroAssemblerCodePtrHash Hash; +}; + +template struct HashTraits; +template<> struct HashTraits : public CustomHashTraits { }; + +} // namespace WTF + #endif // MacroAssemblerCodeRef_h -- cgit v1.2.1