Changeset 46247 in webkit for trunk/JavaScriptCore/assembler/ARMv7Assembler.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/assembler/ARMv7Assembler.h (modified) (5 diffs)

trunk/JavaScriptCore/assembler/ARMv7Assembler.h

@@ -1540 +1540 @@
     static void relinkJump(void* from, void* to)
     {
-        ExecutableAllocator::MakeWritable unprotect(reinterpret_cast<uint16_t*>(from) - 2, 2 * sizeof(uint16_t));
-
         ASSERT(!(reinterpret_cast<intptr_t>(from) & 1));
         ASSERT(!(reinterpret_cast<intptr_t>(to) & 1));
@@ -1547 +1545 @@
         intptr_t relative = reinterpret_cast<intptr_t>(to) - reinterpret_cast<intptr_t>(from);
         linkWithOffset(reinterpret_cast<uint16_t*>(from), relative);
+
+        ExecutableAllocator::cacheFlush(reinterpret_cast<uint16_t*>(from) - 2, 2 * sizeof(uint16_t));
     }
     
     static void relinkCall(void* from, void* to)
     {
-        ExecutableAllocator::MakeWritable unprotect(reinterpret_cast<uint16_t*>(from) - 5, 4 * sizeof(uint16_t));
-
         ASSERT(!(reinterpret_cast<intptr_t>(from) & 1));
         ASSERT(reinterpret_cast<intptr_t>(to) & 1);
 
         setPointer(reinterpret_cast<uint16_t*>(from) - 1, to);
+
+        ExecutableAllocator::cacheFlush(reinterpret_cast<uint16_t*>(from) - 5, 4 * sizeof(uint16_t));
     }
 
     static void repatchInt32(void* where, int32_t value)
     {
-        ExecutableAllocator::MakeWritable unprotect(reinterpret_cast<uint16_t*>(where) - 4, 4 * sizeof(uint16_t));
-
         ASSERT(!(reinterpret_cast<intptr_t>(where) & 1));
         
         setInt32(where, value);
+
+        ExecutableAllocator::cacheFlush(reinterpret_cast<uint16_t*>(where) - 4, 4 * sizeof(uint16_t));
     }
 
     static void repatchPointer(void* where, void* value)
     {
-        ExecutableAllocator::MakeWritable unprotect(reinterpret_cast<uint16_t*>(where) - 4, 4 * sizeof(uint16_t));
-
         ASSERT(!(reinterpret_cast<intptr_t>(where) & 1));
         
         setPointer(where, value);
+
+        ExecutableAllocator::cacheFlush(reinterpret_cast<uint16_t*>(where) - 4, 4 * sizeof(uint16_t));
     }
 
@@ -1584 +1584 @@
         ASSERT((*loadOp & 0xfff0) == OP_LDR_reg_T2);
 
-        ExecutableAllocator::MakeWritable unprotect(loadOp, sizeof(uint16_t));
         *loadOp = OP_ADD_reg_T3 | (*loadOp & 0xf);
+        ExecutableAllocator::cacheFlush(loadOp, sizeof(uint16_t));
     }
 
@@ -1616 +1616 @@
         uint16_t* location = reinterpret_cast<uint16_t*>(code);
 
-        ExecutableAllocator::MakeWritable unprotect(location - 4, 4 * sizeof(uint16_t));
-
         uint16_t lo16 = value;
         uint16_t hi16 = value >> 16;
@@ -1625 +1623 @@
         spliceHi5(location - 2, hi16);
         spliceLo11(location - 1, hi16);
+
+        ExecutableAllocator::cacheFlush(location - 4, 4 * sizeof(uint16_t));
     }