Changeset 44514 in webkit for trunk/JavaScriptCore/yarr/RegexJIT.cpp

Timestamp:

Jun 8, 2009, 6:40:59 PM (16 years ago)

Author:

[email protected]

Message:

2009-06-08 Gavin Barraclough <​[email protected]>

Reviewed by Geoff Garen.

Add (incomplete) support to YARR for running with the jit enabled
on Arm thumb2 platforms. Adds new Assembler/MacroAssembler classes,
along with cache flushing support, tweaks to MacroAssemblerCodePtr
to support decorated thumb code pointers, and new enter/exit code
to YARR jit for the platform.

Support for this platform is still under development - the assembler
currrently only supports planting and linking jumps with a 16Mb range.
As such, initially commiting in a disabled state.

• JavaScriptCore.xcodeproj/project.pbxproj:

Add new assembler files.

• assembler/ARMv7Assembler.h: Added.

Add new Assembler.

• assembler/AbstractMacroAssembler.h:

Tweaks to ensure sizes of pointer values planted in JIT code do not change.

• assembler/MacroAssembler.h:

On ARMv7 platforms use MacroAssemblerARMv7.

• assembler/MacroAssemblerARMv7.h: Added.

Add new MacroAssembler.

• assembler/MacroAssemblerCodeRef.h: (JSC::FunctionPtr::FunctionPtr):

Add better ASSERT.

(JSC::ReturnAddressPtr::ReturnAddressPtr):

Add better ASSERT.

(JSC::MacroAssemblerCodePtr::MacroAssemblerCodePtr):

On ARMv7, MacroAssemblerCodePtr's mush be 'decorated' with a low bit set,
to indicate to the processor that the code is thumb code, not traditional
32-bit ARM.

(JSC::MacroAssemblerCodePtr::dataLocation):

On ARMv7, decoration must be removed.

• jit/ExecutableAllocator.h: (JSC::ExecutableAllocator::makeWritable):

Reformatted, no change.

(JSC::ExecutableAllocator::makeExecutable):

When marking code executable also cache flush it, where necessary.

(JSC::ExecutableAllocator::MakeWritable::MakeWritable):

Only use the null implementation of this class if both !ASSEMBLER_WX_EXCLUSIVE
and running on x86(_64) - on other platforms we may also need ensure that
makeExecutable is called at the end to flush caches.

(JSC::ExecutableAllocator::reprotectRegion):

Reformatted, no change.

(JSC::ExecutableAllocator::cacheFlush):

Cache flush a region of memory, or platforms where this is necessary.

• wtf/Platform.h:

Add changes necessary to allow YARR jit to build on this platform, disabled.

• yarr/RegexJIT.cpp: (JSC::Yarr::RegexGenerator::generateEnter): (JSC::Yarr::RegexGenerator::generateReturn):

Add support to these methods for ARMv7.

File:

• trunk/JavaScriptCore/yarr/RegexJIT.cpp (modified) (3 diffs)

trunk/JavaScriptCore/yarr/RegexJIT.cpp

@@ -44 +44 @@
     friend void jitCompileRegex(JSGlobalData* globalData, RegexCodeBlock& jitObject, const UString& pattern, unsigned& numSubpatterns, const char*& error, bool ignoreCase, bool multiline);
 
+#if PLATFORM(ARM_V7)
+    static const RegisterID input = ARM::r0;
+    static const RegisterID index = ARM::r1;
+    static const RegisterID length = ARM::r2;
+
+    static const RegisterID output = ARM::r4;
+    static const RegisterID regT0 = ARM::r5;
+    static const RegisterID regT1 = ARM::r6;
+
+    static const RegisterID returnRegister = ARM::r0;
+#endif
 #if PLATFORM(X86)
     static const RegisterID input = X86::eax;
@@ -1279 +1290 @@
     void generateEnter()
     {
-        // On x86 edi & esi are callee preserved registers.
+#if PLATFORM(X86_64)
         push(X86::ebp);
         move(stackPointerRegister, X86::ebp);
-#if PLATFORM(X86)
+#elif PLATFORM(X86)
+        push(X86::ebp);
+        move(stackPointerRegister, X86::ebp);
         // TODO: do we need spill registers to fill the output pointer if there are no sub captures?
         push(X86::ebx);
@@ -1288 +1301 @@
         push(X86::esi);
         // load output into edi (2 = saved ebp + return address).
-#if COMPILER(MSVC)
+    #if COMPILER(MSVC)
         loadPtr(Address(X86::ebp, 2 * sizeof(void*)), input);
         loadPtr(Address(X86::ebp, 3 * sizeof(void*)), index);
         loadPtr(Address(X86::ebp, 4 * sizeof(void*)), length);
         loadPtr(Address(X86::ebp, 5 * sizeof(void*)), output);
-#else
+    #else
         loadPtr(Address(X86::ebp, 2 * sizeof(void*)), output);
+    #endif
+#elif PLATFORM(ARM_V7)
+        push(ARM::r4);
+        push(ARM::r5);
+        push(ARM::r6);
+        move(ARM::r3, output);
 #endif
-#endif
     }
 
     void generateReturn()
     {
-#if PLATFORM(X86)
+#if PLATFORM(X86_64)
+        pop(X86::ebp);
+#elif PLATFORM(X86)
         pop(X86::esi);
         pop(X86::edi);
         pop(X86::ebx);
+        pop(X86::ebp);
+#elif PLATFORM(ARM_V7)
+        pop(ARM::r6);
+        pop(ARM::r5);
+        pop(ARM::r4);
 #endif
-        pop(X86::ebp);
         ret();
     }