Changeset 46247 in webkit for trunk/JavaScriptCore/jit/ExecutableAllocator.h

Timestamp:

Jul 22, 2009, 3:17:10 PM (16 years ago)

Author:

[email protected]

Message:

2009-07-22 Gavin Barraclough <​[email protected]>

Reviewed by Sam Weinig.

With ENABLE(ASSEMBLER_WX_EXCLUSIVE), only change permissions once per repatch event.
( ​https://bugs.webkit.org/show_bug.cgi?id=27564 )

Currently we change permissions forwards and backwards for each instruction modified,
instead we should only change permissions once per complete repatching event.

2.5% progression running with ENABLE(ASSEMBLER_WX_EXCLUSIVE) enabled,
which recoups 1/3 of the penalty of running with this mode enabled.

• assembler/ARMAssembler.cpp: (JSC::ARMAssembler::linkBranch):
  • Replace usage of MakeWritable with cacheFlush.

• assembler/ARMAssembler.h: (JSC::ARMAssembler::patchPointerInternal): (JSC::ARMAssembler::repatchLoadPtrToLEA):
  • Replace usage of MakeWritable with cacheFlush.

• assembler/ARMv7Assembler.h: (JSC::ARMv7Assembler::relinkJump): (JSC::ARMv7Assembler::relinkCall): (JSC::ARMv7Assembler::repatchInt32): (JSC::ARMv7Assembler::repatchPointer): (JSC::ARMv7Assembler::repatchLoadPtrToLEA): (JSC::ARMv7Assembler::setInt32):
  • Replace usage of MakeWritable with cacheFlush.

• assembler/LinkBuffer.h: (JSC::LinkBuffer::performFinalization):
  • Make explicit call to cacheFlush.

• assembler/MacroAssemblerCodeRef.h: (JSC::MacroAssemblerCodeRef::MacroAssemblerCodeRef):
  • Make size always available.

• assembler/RepatchBuffer.h: (JSC::RepatchBuffer::RepatchBuffer): (JSC::RepatchBuffer::~RepatchBuffer):
  • Add calls to MakeWritable & makeExecutable.

• assembler/X86Assembler.h: (JSC::X86Assembler::relinkJump): (JSC::X86Assembler::relinkCall): (JSC::X86Assembler::repatchInt32): (JSC::X86Assembler::repatchPointer): (JSC::X86Assembler::repatchLoadPtrToLEA):
  • Remove usage of MakeWritable.

• bytecode/CodeBlock.h: (JSC::CodeBlock::getJITCode):
  • Provide access to CodeBlock's JITCode.

• jit/ExecutableAllocator.h: (JSC::ExecutableAllocator::makeExecutable): (JSC::ExecutableAllocator::cacheFlush):
  • Remove MakeWritable, make cacheFlush public.

• jit/JIT.cpp: (JSC::ctiPatchNearCallByReturnAddress): (JSC::ctiPatchCallByReturnAddress): (JSC::JIT::privateCompile): (JSC::JIT::unlinkCall): (JSC::JIT::linkCall):
  • Add CodeBlock argument to RepatchBuffer.

• jit/JIT.h:
  • Pass CodeBlock argument for use by RepatchBuffer.

• jit/JITCode.h: (JSC::JITCode::start): (JSC::JITCode::size):
  • Provide access to code start & size.

• jit/JITPropertyAccess.cpp: (JSC::JIT::privateCompilePutByIdTransition): (JSC::JIT::patchGetByIdSelf): (JSC::JIT::patchMethodCallProto): (JSC::JIT::patchPutByIdReplace): (JSC::JIT::privateCompilePatchGetArrayLength): (JSC::JIT::privateCompileGetByIdProto): (JSC::JIT::privateCompileGetByIdSelfList): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList): (JSC::JIT::privateCompileGetByIdChain):
  • Add CodeBlock argument to RepatchBuffer.

• jit/JITStubs.cpp: (JSC::JITThunks::tryCachePutByID): (JSC::JITThunks::tryCacheGetByID): (JSC::JITStubs::DEFINE_STUB_FUNCTION):
  • Pass CodeBlock argument for use by RepatchBuffer.

File:

• trunk/JavaScriptCore/jit/ExecutableAllocator.h (modified) (3 diffs)

trunk/JavaScriptCore/jit/ExecutableAllocator.h

@@ -157 +157 @@
     }
 
-#if ENABLE(ASSEMBLER_WX_EXCLUSIVE) || !(PLATFORM(X86) || PLATFORM(X86_64))
+#if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
     static void makeWritable(void* start, size_t size)
     {
@@ -166 +166 @@
     {
         reprotectRegion(start, size, Executable);
-        cacheFlush(start, size);
-    }
-
-    // If ASSEMBLER_WX_EXCLUSIVE protection is turned on, or on non-x86 platforms,
-    // we need to track start & size so we can makeExecutable/cacheFlush at the end.
-    class MakeWritable {
-    public:
-        MakeWritable(void* start, size_t size)
-            : m_start(start)
-            , m_size(size)
-        {
-            makeWritable(start, size);
-        }
-
-        ~MakeWritable()
-        {
-            makeExecutable(m_start, m_size);
-        }
-
-    private:
-        void* m_start;
-        size_t m_size;
-    };
+    }
 #else
     static void makeWritable(void*, size_t) {}
     static void makeExecutable(void*, size_t) {}
-
-    // On x86, without ASSEMBLER_WX_EXCLUSIVE, there is nothing to do here.
-    class MakeWritable { public: MakeWritable(void*, size_t) {} };
-#endif
-
-private:
-
-#if ENABLE(ASSEMBLER_WX_EXCLUSIVE) || !(PLATFORM(X86) || PLATFORM(X86_64))
-#if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
-    static void reprotectRegion(void*, size_t, ProtectionSeting);
-#else
-    static void reprotectRegion(void*, size_t, ProtectionSeting) {}
-#endif
-
-   static void cacheFlush(void* code, size_t size)
-    {
+#endif
+
+
 #if PLATFORM(X86) || PLATFORM(X86_64)
-        UNUSED_PARAM(code);
-        UNUSED_PARAM(size);
+    static void cacheFlush(void*, size_t)
+    {
+    }
 #elif PLATFORM_ARM_ARCH(7) && PLATFORM(IPHONE)
+    static void cacheFlush(void* code, size_t size)
+    {
         sys_dcache_flush(code, size);
         sys_icache_invalidate(code, size);
+    }
 #elif PLATFORM(ARM)
+    static void cacheFlush(void* code, size_t size)
+    {
     #if COMPILER(GCC) && (GCC_VERSION >= 30406)
         __clear_cache(reinterpret_cast<char*>(code), reinterpret_cast<char*>(code) + size);
@@ -229 +200 @@
            :   "r0", "r1", "r7");
     #endif // COMPILER(GCC) && (GCC_VERSION >= 30406)
-#else
-#error "ExecutableAllocator::cacheFlush not implemented on this platform."
-#endif
-    }
+    }
+#endif
+
+private:
+
+#if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
+    static void reprotectRegion(void*, size_t, ProtectionSeting);
 #endif