Rolling out r64097:64100, oops, more b0rked than I relized by my last changes, sorry!
authorbarraclough@apple.com <barraclough@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 27 Jul 2010 02:53:06 +0000 (02:53 +0000)
committerbarraclough@apple.com <barraclough@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 27 Jul 2010 02:53:06 +0000 (02:53 +0000)
* CMakeListsEfl.txt:
* GNUmakefile.am:
* JavaScriptCore.gypi:
* JavaScriptCore.pro:
* JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
* JavaScriptCore.xcodeproj/project.pbxproj:
* jit/ExecutableAllocator.cpp:
(JSC::ExecutableAllocator::reprotectRegion):
(JSC::ExecutableAllocator::cacheFlush):
* jit/ExecutableAllocator.h:
(JSC::ExecutablePool::ExecutablePool):
(JSC::ExecutablePool::poolAllocate):
* jit/ExecutableAllocatorFixedVMPool.cpp:
(JSC::FixedVMPoolAllocator::release):
(JSC::FixedVMPoolAllocator::reuse):
(JSC::FixedVMPoolAllocator::FixedVMPoolAllocator):
(JSC::FixedVMPoolAllocator::alloc):
(JSC::FixedVMPoolAllocator::free):
(JSC::FixedVMPoolAllocator::isValid):
(JSC::FixedVMPoolAllocator::isWithinVMPool):
(JSC::ExecutablePool::systemAlloc):
(JSC::ExecutablePool::systemRelease):
* jit/ExecutableAllocatorPosix.cpp: Added.
(JSC::ExecutableAllocator::intializePageSize):
(JSC::ExecutablePool::systemAlloc):
(JSC::ExecutablePool::systemRelease):
(JSC::ExecutableAllocator::isValid):
* jit/ExecutableAllocatorSymbian.cpp: Added.
(JSC::ExecutableAllocator::intializePageSize):
(JSC::ExecutablePool::systemAlloc):
(JSC::ExecutablePool::systemRelease):
(JSC::ExecutableAllocator::isValid):
* jit/ExecutableAllocatorWin.cpp: Added.
(JSC::ExecutableAllocator::intializePageSize):
(JSC::ExecutablePool::systemAlloc):
(JSC::ExecutablePool::systemRelease):
(JSC::ExecutableAllocator::isValid):
* wscript:
* wtf/PageAllocation.cpp: Removed.
* wtf/PageAllocation.h: Removed.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@64101 268f45cc-cd09-0410-ab3c-d52691b4dbfc

16 files changed:
JavaScriptCore/CMakeListsEfl.txt
JavaScriptCore/ChangeLog
JavaScriptCore/GNUmakefile.am
JavaScriptCore/JavaScriptCore.gypi
JavaScriptCore/JavaScriptCore.pro
JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj
JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
JavaScriptCore/jit/ExecutableAllocator.cpp
JavaScriptCore/jit/ExecutableAllocator.h
JavaScriptCore/jit/ExecutableAllocatorFixedVMPool.cpp
JavaScriptCore/jit/ExecutableAllocatorPosix.cpp [new file with mode: 0644]
JavaScriptCore/jit/ExecutableAllocatorSymbian.cpp [new file with mode: 0644]
JavaScriptCore/jit/ExecutableAllocatorWin.cpp [new file with mode: 0644]
JavaScriptCore/wscript
JavaScriptCore/wtf/PageAllocation.cpp [deleted file]
JavaScriptCore/wtf/PageAllocation.h [deleted file]

index 7897ea5..945ad52 100644 (file)
@@ -1,6 +1,6 @@
 LIST(APPEND JavaScriptCore_SOURCES
     jit/ExecutableAllocatorFixedVMPool.cpp
-    jit/ExecutableAllocator.cpp
+    jit/ExecutableAllocatorPosix.cpp
     runtime/MarkStackPosix.cpp
 )
 
index 0a4909b..4318511 100644 (file)
@@ -1,5 +1,50 @@
 2010-07-26  Gavin Barraclough  <barraclough@apple.com>
 
+        Rolling out r64097:64100, oops, more b0rked than I relized by my last changes, sorry!
+
+        * CMakeListsEfl.txt:
+        * GNUmakefile.am:
+        * JavaScriptCore.gypi:
+        * JavaScriptCore.pro:
+        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * jit/ExecutableAllocator.cpp:
+        (JSC::ExecutableAllocator::reprotectRegion):
+        (JSC::ExecutableAllocator::cacheFlush):
+        * jit/ExecutableAllocator.h:
+        (JSC::ExecutablePool::ExecutablePool):
+        (JSC::ExecutablePool::poolAllocate):
+        * jit/ExecutableAllocatorFixedVMPool.cpp:
+        (JSC::FixedVMPoolAllocator::release):
+        (JSC::FixedVMPoolAllocator::reuse):
+        (JSC::FixedVMPoolAllocator::FixedVMPoolAllocator):
+        (JSC::FixedVMPoolAllocator::alloc):
+        (JSC::FixedVMPoolAllocator::free):
+        (JSC::FixedVMPoolAllocator::isValid):
+        (JSC::FixedVMPoolAllocator::isWithinVMPool):
+        (JSC::ExecutablePool::systemAlloc):
+        (JSC::ExecutablePool::systemRelease):
+        * jit/ExecutableAllocatorPosix.cpp: Added.
+        (JSC::ExecutableAllocator::intializePageSize):
+        (JSC::ExecutablePool::systemAlloc):
+        (JSC::ExecutablePool::systemRelease):
+        (JSC::ExecutableAllocator::isValid):
+        * jit/ExecutableAllocatorSymbian.cpp: Added.
+        (JSC::ExecutableAllocator::intializePageSize):
+        (JSC::ExecutablePool::systemAlloc):
+        (JSC::ExecutablePool::systemRelease):
+        (JSC::ExecutableAllocator::isValid):
+        * jit/ExecutableAllocatorWin.cpp: Added.
+        (JSC::ExecutableAllocator::intializePageSize):
+        (JSC::ExecutablePool::systemAlloc):
+        (JSC::ExecutablePool::systemRelease):
+        (JSC::ExecutableAllocator::isValid):
+        * wscript:
+        * wtf/PageAllocation.cpp: Removed.
+        * wtf/PageAllocation.h: Removed.
+
+2010-07-26  Gavin Barraclough  <barraclough@apple.com>
+
         Speculative !debug build fix II.
 
         * wtf/PageAllocation.h:
index 8707905..9a2886f 100644 (file)
@@ -526,10 +526,12 @@ javascriptcore_sources += \
 if TARGET_WIN32
 javascriptcore_sources += \
        JavaScriptCore/wtf/ThreadSpecificWin.cpp \
+       JavaScriptCore/jit/ExecutableAllocatorWin.cpp \
        JavaScriptCore/runtime/MarkStackWin.cpp
 else
 javascriptcore_sources += \
        JavaScriptCore/jit/ExecutableAllocatorFixedVMPool.cpp \
+       JavaScriptCore/jit/ExecutableAllocatorPosix.cpp \
        JavaScriptCore/runtime/MarkStackPosix.cpp
 endif
 
index 9300da1..066e1ff 100644 (file)
             'jit/ExecutableAllocator.cpp',
             'jit/ExecutableAllocator.h',
             'jit/ExecutableAllocatorFixedVMPool.cpp',
+            'jit/ExecutableAllocatorPosix.cpp',
+            'jit/ExecutableAllocatorWin.cpp',
             'jit/JIT.cpp',
             'jit/JIT.h',
             'jit/JITArithmetic.cpp',
index 84a5c74..84ce83c 100644 (file)
@@ -94,6 +94,9 @@ SOURCES += \
     interpreter/Interpreter.cpp \
     interpreter/RegisterFile.cpp \
     jit/ExecutableAllocatorFixedVMPool.cpp \
+    jit/ExecutableAllocatorPosix.cpp \
+    jit/ExecutableAllocatorSymbian.cpp \
+    jit/ExecutableAllocatorWin.cpp \
     jit/ExecutableAllocator.cpp \
     jit/JITArithmetic.cpp \
     jit/JITArithmetic32_64.cpp \
index 7819f99..dbddfe0 100644 (file)
                                >\r
                        </File>\r
                        <File\r
+                               RelativePath="..\..\jit\ExecutableAllocatorWin.cpp"\r
+                               >\r
+                       </File>\r
+                       <File\r
                                RelativePath="..\..\jit\JIT.cpp"\r
                                >\r
                        </File>\r
index 783a453..562b4a1 100644 (file)
                860161E50F3A83C100F84710 /* MacroAssemblerX86_64.h in Headers */ = {isa = PBXBuildFile; fileRef = 860161E10F3A83C100F84710 /* MacroAssemblerX86_64.h */; };
                860161E60F3A83C100F84710 /* MacroAssemblerX86Common.h in Headers */ = {isa = PBXBuildFile; fileRef = 860161E20F3A83C100F84710 /* MacroAssemblerX86Common.h */; };
                8626BECF11928E3900782FAB /* StringStatics.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8626BECE11928E3900782FAB /* StringStatics.cpp */; };
-               8627E5EB11F1281900A313B5 /* PageAllocation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8627E5E911F1281900A313B5 /* PageAllocation.cpp */; };
-               8627E5EC11F1281900A313B5 /* PageAllocation.h in Headers */ = {isa = PBXBuildFile; fileRef = 8627E5EA11F1281900A313B5 /* PageAllocation.h */; };
                863B23E00FC6118900703AA4 /* MacroAssemblerCodeRef.h in Headers */ = {isa = PBXBuildFile; fileRef = 863B23DF0FC60E6200703AA4 /* MacroAssemblerCodeRef.h */; settings = {ATTRIBUTES = (Private, ); }; };
                86565742115BE3DA00291F40 /* CString.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 86565740115BE3DA00291F40 /* CString.cpp */; };
                86565743115BE3DA00291F40 /* CString.h in Headers */ = {isa = PBXBuildFile; fileRef = 86565741115BE3DA00291F40 /* CString.h */; settings = {ATTRIBUTES = (Private, ); }; };
                A76C51761182748D00715B05 /* JSInterfaceJIT.h in Headers */ = {isa = PBXBuildFile; fileRef = A76C51741182748D00715B05 /* JSInterfaceJIT.h */; };
                A76EE6590FAE59D5003F069A /* NativeFunctionWrapper.h in Headers */ = {isa = PBXBuildFile; fileRef = A76EE6580FAE59D5003F069A /* NativeFunctionWrapper.h */; settings = {ATTRIBUTES = (Private, ); }; };
                A7795590101A74D500114E55 /* MarkStack.h in Headers */ = {isa = PBXBuildFile; fileRef = A779558F101A74D500114E55 /* MarkStack.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               A782F1A50EEC9FA20036273F /* ExecutableAllocatorPosix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A782F1A40EEC9FA20036273F /* ExecutableAllocatorPosix.cpp */; };
                A783A0D111A36DCA00563D20 /* JSObjectWithGlobalObject.h in Headers */ = {isa = PBXBuildFile; fileRef = A783A0D011A36DCA00563D20 /* JSObjectWithGlobalObject.h */; settings = {ATTRIBUTES = (Private, ); }; };
                A783A2AB11A5BE8400563D20 /* JSObjectWithGlobalObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A783A2AA11A5BE8400563D20 /* JSObjectWithGlobalObject.cpp */; };
                A784A26111D16622005776AC /* ASTBuilder.h in Headers */ = {isa = PBXBuildFile; fileRef = A7A7EE7411B98B8D0065A14F /* ASTBuilder.h */; };
                860161E10F3A83C100F84710 /* MacroAssemblerX86_64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MacroAssemblerX86_64.h; sourceTree = "<group>"; };
                860161E20F3A83C100F84710 /* MacroAssemblerX86Common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MacroAssemblerX86Common.h; sourceTree = "<group>"; };
                8626BECE11928E3900782FAB /* StringStatics.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StringStatics.cpp; path = text/StringStatics.cpp; sourceTree = "<group>"; };
-               8627E5E911F1281900A313B5 /* PageAllocation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PageAllocation.cpp; sourceTree = "<group>"; };
-               8627E5EA11F1281900A313B5 /* PageAllocation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PageAllocation.h; sourceTree = "<group>"; };
                863B23DF0FC60E6200703AA4 /* MacroAssemblerCodeRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MacroAssemblerCodeRef.h; sourceTree = "<group>"; };
                86565740115BE3DA00291F40 /* CString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CString.cpp; path = text/CString.cpp; sourceTree = "<group>"; };
                86565741115BE3DA00291F40 /* CString.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CString.h; path = text/CString.h; sourceTree = "<group>"; };
                86D3B2C210156BDE002865E7 /* MacroAssemblerARM.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MacroAssemblerARM.h; sourceTree = "<group>"; };
                86D3B3C110159D7F002865E7 /* LinkBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LinkBuffer.h; sourceTree = "<group>"; };
                86D3B3C210159D7F002865E7 /* RepatchBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RepatchBuffer.h; sourceTree = "<group>"; };
+               86DB645F0F954E9100D7D921 /* ExecutableAllocatorWin.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ExecutableAllocatorWin.cpp; sourceTree = "<group>"; };
                86DB64630F95C6FC00D7D921 /* ExecutableAllocatorFixedVMPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ExecutableAllocatorFixedVMPool.cpp; sourceTree = "<group>"; };
                86E116B00FE75AC800B512BC /* CodeLocation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CodeLocation.h; sourceTree = "<group>"; };
                86E85538111B9968001AF51E /* JSStringBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSStringBuilder.h; sourceTree = "<group>"; };
                A76C51741182748D00715B05 /* JSInterfaceJIT.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSInterfaceJIT.h; sourceTree = "<group>"; };
                A76EE6580FAE59D5003F069A /* NativeFunctionWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeFunctionWrapper.h; sourceTree = "<group>"; };
                A779558F101A74D500114E55 /* MarkStack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MarkStack.h; sourceTree = "<group>"; };
+               A782F1A40EEC9FA20036273F /* ExecutableAllocatorPosix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ExecutableAllocatorPosix.cpp; sourceTree = "<group>"; };
                A783A0D011A36DCA00563D20 /* JSObjectWithGlobalObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSObjectWithGlobalObject.h; sourceTree = "<group>"; };
                A783A2AA11A5BE8400563D20 /* JSObjectWithGlobalObject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSObjectWithGlobalObject.cpp; sourceTree = "<group>"; };
                A791EF260F11E07900AE1F68 /* JSByteArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSByteArray.h; sourceTree = "<group>"; };
                                A7B48DB60EE74CFC00DCBDB6 /* ExecutableAllocator.cpp */,
                                A7B48DB50EE74CFC00DCBDB6 /* ExecutableAllocator.h */,
                                86DB64630F95C6FC00D7D921 /* ExecutableAllocatorFixedVMPool.cpp */,
+                               A782F1A40EEC9FA20036273F /* ExecutableAllocatorPosix.cpp */,
+                               86DB645F0F954E9100D7D921 /* ExecutableAllocatorWin.cpp */,
                                1429D92D0ED22D7000B89619 /* JIT.cpp */,
                                1429D92E0ED22D7000B89619 /* JIT.h */,
                                86A90ECF0EE7D51F00AB350D /* JITArithmetic.cpp */,
                                0BDFFAD10FC616EC00D69EF4 /* OwnFastMallocPtr.h */,
                                9303F567099118FA00AD71B8 /* OwnPtr.h */,
                                440B7AED0FAF7FCB0073323E /* OwnPtrCommon.h */,
-                               8627E5E911F1281900A313B5 /* PageAllocation.cpp */,
-                               8627E5EA11F1281900A313B5 /* PageAllocation.h */,
                                44DD48520FAEA85000D6B4EB /* PassOwnPtr.h */,
                                6580F795094070560082C219 /* PassRefPtr.h */,
                                65D6D87E09B5A32E0002E4D7 /* Platform.h */,
                                868BFA18117CF19900B908B1 /* WTFString.h in Headers */,
                                86D08D5411793613006E5ED0 /* WTFThreadData.h in Headers */,
                                9688CB160ED12B4E001D649F /* X86Assembler.h in Headers */,
-                               8627E5EC11F1281900A313B5 /* PageAllocation.h in Headers */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
                                86CA032E1038E8440028A609 /* Executable.cpp in Sources */,
                                A7B48F490EE8936F00DCBDB6 /* ExecutableAllocator.cpp in Sources */,
                                86DB64640F95C6FC00D7D921 /* ExecutableAllocatorFixedVMPool.cpp in Sources */,
+                               A782F1A50EEC9FA20036273F /* ExecutableAllocatorPosix.cpp in Sources */,
                                14F8BA3E107EC886009892DC /* FastMalloc.cpp in Sources */,
                                147F39CB107EC37600427A48 /* FunctionConstructor.cpp in Sources */,
                                147F39CC107EC37600427A48 /* FunctionPrototype.cpp in Sources */,
                                E1EF79AA0CE97BA60088D500 /* UTF8.cpp in Sources */,
                                868BFA17117CF19900B908B1 /* WTFString.cpp in Sources */,
                                86D08D5311793613006E5ED0 /* WTFThreadData.cpp in Sources */,
-                               8627E5EB11F1281900A313B5 /* PageAllocation.cpp in Sources */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
index ffe1732..5e10e86 100644 (file)
@@ -33,48 +33,7 @@ namespace JSC {
 
 size_t ExecutableAllocator::pageSize = 0;
 
-#if ENABLE(EXECUTABLE_ALLOCATOR_DEMAND)
-
-void ExecutableAllocator::intializePageSize()
-{
-#if CPU(ARMV5_OR_LOWER)
-    // The moving memory model (as used in ARMv5 and earlier platforms)
-    // on Symbian OS limits the number of chunks for each process to 16. 
-    // To mitigate this limitation increase the pagesize to allocate
-    // fewer, larger chunks. Set the page size to 256 Kb to compensate
-    // for moving memory model limitation
-    ExecutableAllocator::pageSize = 256 * 1024;
-#else
-    ExecutableAllocator::pageSize = PageAllocation::pagesize();
-#endif
-}
-
-ExecutablePool::Allocation ExecutablePool::systemAlloc(size_t size)
-{
-    PageAllocation allocation = PageAllocation::allocate(size, PageAllocation::JSJITCodePages, EXECUTABLE_POOL_WRITABLE, true);
-    if (!allocation)
-        CRASH();
-    return allocation;
-}
-
-void ExecutablePool::systemRelease(const ExecutablePool::Allocation& allocation)
-{
-    allocation.deallocate();
-}
-
-bool ExecutableAllocator::isValid() const
-{
-    return true;
-}
-
-#endif
-
 #if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
-
-#if OS(WINDOWS) || OS(SYMBIAN)
-#error "ASSEMBLER_WX_EXCLUSIVE not yet suported on this platform."
-#endif
-
 void ExecutableAllocator::reprotectRegion(void* start, size_t size, ProtectionSeting setting)
 {
     if (!pageSize)
@@ -93,11 +52,9 @@ void ExecutableAllocator::reprotectRegion(void* start, size_t size, ProtectionSe
 
     mprotect(pageStart, size, (setting == Writable) ? PROTECTION_FLAGS_RW : PROTECTION_FLAGS_RX);
 }
-
 #endif
 
 #if CPU(ARM_TRADITIONAL) && OS(LINUX) && COMPILER(RVCT)
-
 __asm void ExecutableAllocator::cacheFlush(void* code, size_t size)
 {
     ARM
@@ -110,7 +67,6 @@ __asm void ExecutableAllocator::cacheFlush(void* code, size_t size)
     pop {r7}
     bx lr
 }
-
 #endif
 
 }
index 7b55040..8fd6b71 100644 (file)
@@ -28,7 +28,6 @@
 #include <stddef.h> // for ptrdiff_t
 #include <limits>
 #include <wtf/Assertions.h>
-#include <wtf/PageAllocation.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 #include <wtf/UnusedParam.h>
@@ -59,9 +58,9 @@ extern "C" __declspec(dllimport) void CacheRangeFlush(LPVOID pAddr, DWORD dwLeng
 #if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
 #define PROTECTION_FLAGS_RW (PROT_READ | PROT_WRITE)
 #define PROTECTION_FLAGS_RX (PROT_READ | PROT_EXEC)
-#define EXECUTABLE_POOL_WRITABLE false
+#define INITIAL_PROTECTION_FLAGS PROTECTION_FLAGS_RX
 #else
-#define EXECUTABLE_POOL_WRITABLE true
+#define INITIAL_PROTECTION_FLAGS (PROT_READ | PROT_WRITE | PROT_EXEC)
 #endif
 
 namespace JSC {
@@ -86,7 +85,13 @@ namespace JSC {
 
 class ExecutablePool : public RefCounted<ExecutablePool> {
 private:
-    typedef PageAllocation Allocation;
+    struct Allocation {
+        char* pages;
+        size_t size;
+#if OS(SYMBIAN)
+        RChunk* chunk;
+#endif
+    };
     typedef Vector<Allocation, 2> AllocationList;
 
 public:
@@ -291,7 +296,7 @@ inline ExecutablePool::ExecutablePool(size_t n)
     size_t allocSize = roundUpAllocationSize(n, JIT_ALLOCATOR_PAGE_SIZE);
     Allocation mem = systemAlloc(allocSize);
     m_pools.append(mem);
-    m_freePtr = static_cast<char*>(mem.base());
+    m_freePtr = mem.pages;
     if (!m_freePtr)
         CRASH(); // Failed to allocate
     m_end = m_freePtr + allocSize;
@@ -302,18 +307,18 @@ inline void* ExecutablePool::poolAllocate(size_t n)
     size_t allocSize = roundUpAllocationSize(n, JIT_ALLOCATOR_PAGE_SIZE);
     
     Allocation result = systemAlloc(allocSize);
-    if (!result.base())
+    if (!result.pages)
         CRASH(); // Failed to allocate
     
     ASSERT(m_end >= m_freePtr);
     if ((allocSize - n) > static_cast<size_t>(m_end - m_freePtr)) {
         // Replace allocation pool
-        m_freePtr = static_cast<char*>(result.base()) + n;
-        m_end = static_cast<char*>(result.base()) + allocSize;
+        m_freePtr = result.pages + n;
+        m_end = result.pages + allocSize;
     }
 
     m_pools.append(result);
-    return result.base();
+    return result.pages;
 }
 
 }
index 4a401ff..65c9c13 100644 (file)
@@ -124,17 +124,30 @@ class FixedVMPoolAllocator
     // The free list is stored in a sorted tree.
     typedef AVLTree<AVLTreeAbstractorForFreeList, 40> SizeSortedFreeTree;
 
+    // Use madvise as apropriate to prevent freed pages from being spilled,
+    // and to attempt to ensure that used memory is reported correctly.
+#if HAVE(MADV_FREE_REUSE)
     void release(void* position, size_t size)
     {
-        m_allocation.decommit(position, size);
+        while (madvise(position, size, MADV_FREE_REUSABLE) == -1 && errno == EAGAIN) { }
     }
 
     void reuse(void* position, size_t size)
     {
-        bool okay = m_allocation.commit(position, size, EXECUTABLE_POOL_WRITABLE, true);
-        ASSERT_UNUSED(okay, okay);
+        while (madvise(position, size, MADV_FREE_REUSE) == -1 && errno == EAGAIN) { }
+    }
+#elif HAVE(MADV_DONTNEED)
+    void release(void* position, size_t size)
+    {
+        while (madvise(position, size, MADV_DONTNEED) == -1 && errno == EAGAIN) { }
     }
 
+    void reuse(void*, size_t) {}
+#else
+    void release(void*, size_t) {}
+    void reuse(void*, size_t) {}
+#endif
+
     // All addition to the free list should go through this method, rather than
     // calling insert directly, to avoid multiple entries beging added with the
     // same key.  All nodes being added should be singletons, they should not
@@ -275,6 +288,7 @@ public:
     FixedVMPoolAllocator(size_t commonSize, size_t totalHeapSize)
         : m_commonSize(commonSize)
         , m_countFreedSinceLastCoalesce(0)
+        , m_totalHeapSize(totalHeapSize)
     {
         // Cook up an address to allocate at, using the following recipe:
         //   17 bits of zero, stay in userspace kids.
@@ -285,67 +299,36 @@ public:
         // for now instead of 2^26 bits of ASLR lets stick with 25 bits of randomization plus
         // 2^24, which should put up somewhere in the middle of usespace (in the address range
         // 0x200000000000 .. 0x5fffffffffff).
-#if VM_POOL_ASLR
         intptr_t randomLocation = 0;
+#if VM_POOL_ASLR
         randomLocation = arc4random() & ((1 << 25) - 1);
         randomLocation += (1 << 24);
         randomLocation <<= 21;
-        m_allocation = PageAllocation::reserveAt(reinterpret_cast<void*>(randomLocation), false, totalHeapSize, PageAllocation::JSJITCodePages, EXECUTABLE_POOL_WRITABLE, true);
-#else
-        m_allocation = PageAllocation::reserve(totalHeapSize, PageAllocation::JSJITCodePages, EXECUTABLE_POOL_WRITABLE, true);
 #endif
-
-        if (!!m_allocation)
-            m_freeList.insert(new FreeListEntry(m_allocation.base(), m_allocation.size()));
+        m_base = mmap(reinterpret_cast<void*>(randomLocation), m_totalHeapSize, INITIAL_PROTECTION_FLAGS, MAP_PRIVATE | MAP_ANON, VM_TAG_FOR_EXECUTABLEALLOCATOR_MEMORY, 0);
+
+        if (m_base) {
+            // For simplicity, we keep all memory in m_freeList in a 'released' state.
+            // This means that we can simply reuse all memory when allocating, without
+            // worrying about it's previous state, and also makes coalescing m_freeList
+            // simpler since we need not worry about the possibility of coalescing released
+            // chunks with non-released ones.
+            release(m_base, m_totalHeapSize);
+            m_freeList.insert(new FreeListEntry(m_base, m_totalHeapSize));
+        }
 #if !ENABLE(INTERPRETER)
         else
             CRASH();
 #endif
     }
 
-    PageAllocation alloc(size_t size)
-    {
-        return PageAllocation(allocInternal(size), size, m_allocation);
-    }
-
-    void free(PageAllocation allocation)
-    {
-        void* pointer = allocation.base();
-        size_t size = allocation.size();
-
-        ASSERT(!!m_allocation);
-        // Call release to report to the operating system that this
-        // memory is no longer in use, and need not be paged out.
-        ASSERT(isWithinVMPool(pointer, size));
-        release(pointer, size);
-
-        // Common-sized allocations are stored in the m_commonSizedAllocations
-        // vector; all other freed chunks are added to m_freeList.
-        if (size == m_commonSize)
-            m_commonSizedAllocations.append(pointer);
-        else
-            addToFreeList(new FreeListEntry(pointer, size));
-
-        // Do some housekeeping.  Every time we reach a point that
-        // 16MB of allocations have been freed, sweep m_freeList
-        // coalescing any neighboring fragments.
-        m_countFreedSinceLastCoalesce += size;
-        if (m_countFreedSinceLastCoalesce >= COALESCE_LIMIT) {
-            m_countFreedSinceLastCoalesce = 0;
-            coalesceFreeSpace();
-        }
-    }
-
-    bool isValid() const { return !!m_allocation; }
-
-private:
-    void* allocInternal(size_t size)
+    void* alloc(size_t size)
     {
 #if ENABLE(INTERPRETER)
-        if (!m_allocation)
+        if (!m_base)
             return 0;
 #else
-        ASSERT(!!m_allocation);
+        ASSERT(m_base);
 #endif
         void* result;
 
@@ -407,10 +390,39 @@ private:
         return result;
     }
 
+    void free(void* pointer, size_t size)
+    {
+        ASSERT(m_base);
+        // Call release to report to the operating system that this
+        // memory is no longer in use, and need not be paged out.
+        ASSERT(isWithinVMPool(pointer, size));
+        release(pointer, size);
+
+        // Common-sized allocations are stored in the m_commonSizedAllocations
+        // vector; all other freed chunks are added to m_freeList.
+        if (size == m_commonSize)
+            m_commonSizedAllocations.append(pointer);
+        else
+            addToFreeList(new FreeListEntry(pointer, size));
+
+        // Do some housekeeping.  Every time we reach a point that
+        // 16MB of allocations have been freed, sweep m_freeList
+        // coalescing any neighboring fragments.
+        m_countFreedSinceLastCoalesce += size;
+        if (m_countFreedSinceLastCoalesce >= COALESCE_LIMIT) {
+            m_countFreedSinceLastCoalesce = 0;
+            coalesceFreeSpace();
+        }
+    }
+
+    bool isValid() const { return !!m_base; }
+
+private:
+
 #ifndef NDEBUG
     bool isWithinVMPool(void* pointer, size_t size)
     {
-        return pointer >= m_allocation.base() && (reinterpret_cast<char*>(pointer) + size <= reinterpret_cast<char*>(m_allocation.base()) + m_allocation.size());
+        return pointer >= m_base && (reinterpret_cast<char*>(pointer) + size <= reinterpret_cast<char*>(m_base) + m_totalHeapSize);
     }
 #endif
 
@@ -424,7 +436,8 @@ private:
     // This is used for housekeeping, to trigger defragmentation of the freed lists.
     size_t m_countFreedSinceLastCoalesce;
 
-    PageAllocation m_allocation;
+    void* m_base;
+    size_t m_totalHeapSize;
 };
 
 void ExecutableAllocator::intializePageSize()
@@ -446,15 +459,18 @@ bool ExecutableAllocator::isValid() const
 ExecutablePool::Allocation ExecutablePool::systemAlloc(size_t size)
 {
     SpinLockHolder lock_holder(&spinlock);
+    
     ASSERT(allocator);
-    return allocator->alloc(size);
+    ExecutablePool::Allocation alloc = {reinterpret_cast<char*>(allocator->alloc(size)), size};
+    return alloc;
 }
 
 void ExecutablePool::systemRelease(const ExecutablePool::Allocation& allocation) 
 {
     SpinLockHolder lock_holder(&spinlock);
+
     ASSERT(allocator);
-    allocator->free(allocation);
+    allocator->free(allocation.pages, allocation.size);
 }
 
 }
diff --git a/JavaScriptCore/jit/ExecutableAllocatorPosix.cpp b/JavaScriptCore/jit/ExecutableAllocatorPosix.cpp
new file mode 100644 (file)
index 0000000..a841d32
--- /dev/null
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "config.h"
+
+#include "ExecutableAllocator.h"
+
+#if ENABLE(EXECUTABLE_ALLOCATOR_DEMAND) && !OS(WINDOWS) && !OS(SYMBIAN)
+
+#include <sys/mman.h>
+#include <unistd.h>
+#include <wtf/VMTags.h>
+
+namespace JSC {
+
+void ExecutableAllocator::intializePageSize()
+{
+    ExecutableAllocator::pageSize = getpagesize();
+}
+
+ExecutablePool::Allocation ExecutablePool::systemAlloc(size_t n)
+{
+    void* allocation = mmap(NULL, n, INITIAL_PROTECTION_FLAGS, MAP_PRIVATE | MAP_ANON, VM_TAG_FOR_EXECUTABLEALLOCATOR_MEMORY, 0);
+    if (allocation == MAP_FAILED)
+        CRASH();
+    ExecutablePool::Allocation alloc = { reinterpret_cast<char*>(allocation), n };
+    return alloc;
+}
+
+void ExecutablePool::systemRelease(const ExecutablePool::Allocation& alloc)
+{ 
+    int result = munmap(alloc.pages, alloc.size);
+    ASSERT_UNUSED(result, !result);
+}
+
+bool ExecutableAllocator::isValid() const
+{
+    return true;
+}
+
+}
+
+#endif
diff --git a/JavaScriptCore/jit/ExecutableAllocatorSymbian.cpp b/JavaScriptCore/jit/ExecutableAllocatorSymbian.cpp
new file mode 100644 (file)
index 0000000..8b0553d
--- /dev/null
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, 
+ *  Boston, MA  02110-1301  USA
+ *
+ */
+
+#include "config.h"
+
+#include "ExecutableAllocator.h"
+
+#if ENABLE(EXECUTABLE_ALLOCATOR_DEMAND) && OS(SYMBIAN)
+
+#include <e32hal.h>
+#include <e32std.h>
+
+// Set the page size to 256 Kb to compensate for moving memory model limitation
+const size_t MOVING_MEM_PAGE_SIZE = 256 * 1024; 
+
+namespace JSC {
+
+void ExecutableAllocator::intializePageSize()
+{
+#if CPU(ARMV5_OR_LOWER)
+    // The moving memory model (as used in ARMv5 and earlier platforms)
+    // on Symbian OS limits the number of chunks for each process to 16. 
+    // To mitigate this limitation increase the pagesize to 
+    // allocate less of larger chunks.
+    ExecutableAllocator::pageSize = MOVING_MEM_PAGE_SIZE;
+#else
+    TInt page_size;
+    UserHal::PageSizeInBytes(page_size);
+    ExecutableAllocator::pageSize = page_size;
+#endif
+}
+
+ExecutablePool::Allocation ExecutablePool::systemAlloc(size_t n)
+{
+    RChunk* codeChunk = new RChunk();
+
+    TInt errorCode = codeChunk->CreateLocalCode(n, n);
+
+    char* allocation = reinterpret_cast<char*>(codeChunk->Base());
+    if (!allocation)
+        CRASH();
+    ExecutablePool::Allocation alloc = { allocation, n, codeChunk };
+    return alloc;
+}
+
+void ExecutablePool::systemRelease(const ExecutablePool::Allocation& alloc)
+{ 
+    alloc.chunk->Close();
+    delete alloc.chunk;
+}
+
+bool ExecutableAllocator::isValid() const
+{
+    return true;
+}
+
+#if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
+#error "ASSEMBLER_WX_EXCLUSIVE not yet suported on this platform."
+#endif
+
+}
+
+#endif // HAVE(ASSEMBLER)
diff --git a/JavaScriptCore/jit/ExecutableAllocatorWin.cpp b/JavaScriptCore/jit/ExecutableAllocatorWin.cpp
new file mode 100644 (file)
index 0000000..2b13529
--- /dev/null
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include "config.h"
+
+#include "ExecutableAllocator.h"
+
+#if ENABLE(EXECUTABLE_ALLOCATOR_DEMAND) && OS(WINDOWS)
+
+#include "windows.h"
+
+namespace JSC {
+
+void ExecutableAllocator::intializePageSize()
+{
+    SYSTEM_INFO system_info;
+    GetSystemInfo(&system_info);
+    ExecutableAllocator::pageSize = system_info.dwPageSize;
+}
+
+ExecutablePool::Allocation ExecutablePool::systemAlloc(size_t n)
+{
+    void* allocation = VirtualAlloc(0, n, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+    if (!allocation)
+        CRASH();
+    ExecutablePool::Allocation alloc = {reinterpret_cast<char*>(allocation), n};
+    return alloc;
+}
+
+void ExecutablePool::systemRelease(const ExecutablePool::Allocation& alloc)
+{ 
+    VirtualFree(alloc.pages, 0, MEM_RELEASE); 
+}
+
+bool ExecutableAllocator::isValid() const
+{
+    return true;
+}
+
+#if ENABLE(ASSEMBLER_WX_EXCLUSIVE)
+#error "ASSEMBLER_WX_EXCLUSIVE not yet suported on this platform."
+#endif
+
+}
+
+#endif // HAVE(ASSEMBLER)
index 4f9d868..99859f0 100644 (file)
@@ -38,7 +38,7 @@ jscore_excludes.extend(get_excludes(jscore_dir, ['*None.cpp']))
 
 if building_on_win32:
     jscore_excludes += ['ExecutableAllocatorPosix.cpp', 'MarkStackPosix.cpp', 'ThreadingPthreads.cpp']
-    sources += ['runtime/MarkStackWin.cpp']
+    sources += ['jit/ExecutableAllocatorWin.cpp', 'runtime/MarkStackWin.cpp']
 else:
     jscore_excludes.append('JSStringRefBSTR.cpp')
     jscore_excludes.extend(get_excludes(jscore_dir, ['*Win.cpp']))
diff --git a/JavaScriptCore/wtf/PageAllocation.cpp b/JavaScriptCore/wtf/PageAllocation.cpp
deleted file mode 100644 (file)
index 7680380..0000000
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
- * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
- * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#include "config.h"
-#include "PageAllocation.h"
-
-#if HAVE(ERRNO_H)
-#include <errno.h>
-#endif
-
-#if HAVE(MMAP)
-#include <sys/mman.h>
-#endif
-
-#if OS(WINDOWS)
-#include "windows.h"
-#endif
-
-#if OS(SYMBIAN)
-#include <e32hal.h>
-#endif
-
-namespace WTF {
-
-#if HAVE(MMAP)
-
-#if HAVE(MADV_FREE_REUSE)
-bool PageAllocation::commit(void* start, size_t size, bool writable, bool executable) const
-{
-    UNUSED_PARAM(writable);
-    UNUSED_PARAM(executable);
-    while (madvise(start, size, MADV_FREE_REUSE) == -1 && errno == EAGAIN) { }
-    return true;
-}
-
-void PageAllocation::decommit(void* start, size_t size) const
-{
-    while (madvise(start, size, MADV_FREE_REUSABLE) == -1 && errno == EAGAIN) { }
-}
-#elif HAVE(MADV_DONTNEED)
-bool PageAllocation::commit(void* start, size_t size, bool writable, bool executable) const
-{
-    UNUSED_PARAM(writable);
-    UNUSED_PARAM(executable);
-    return true;
-}
-
-void PageAllocation::decommit(void*, size_t) const
-{
-    while (madvise(start, size, MADV_DONTNEED) == -1 && errno == EAGAIN) { }
-}
-#else
-bool PageAllocation::commit(void*, size_t, bool writable, bool executable) const
-{
-    UNUSED_PARAM(writable);
-    UNUSED_PARAM(executable);
-    return true;
-}
-
-void PageAllocation::decommit(void*, size_t) const
-{
-}
-#endif
-
-PageAllocation PageAllocation::allocate(size_t size, Usage usage, bool writable, bool executable)
-{
-    return allocateAt(0, false, size, usage, writable, executable);
-}
-
-PageAllocation PageAllocation::reserve(size_t size, Usage usage, bool writable, bool executable)
-{
-    return reserveAt(0, false, size, usage, writable, executable);
-}
-
-PageAllocation PageAllocation::allocateAt(void* address, bool fixed, size_t size, Usage usage, bool writable, bool executable)
-{
-    int flags = MAP_PRIVATE | MAP_ANON;
-    if (fixed)
-        flags |= MAP_FIXED;
-
-    int protection = PROT_READ;
-    if (writable)
-        protection |= PROT_WRITE;
-    if (executable)
-        protection |= PROT_EXEC;
-
-    void* base = mmap(address, size, protection, flags, usage, 0);
-    if (base == MAP_FAILED)
-        base = 0;
-
-    return PageAllocation(base, size);
-}
-
-PageAllocation PageAllocation::reserveAt(void* address, bool fixed, size_t size, Usage usage, bool writable, bool executable)
-{
-    PageAllocation result = allocateAt(address, fixed, size, usage, writable, executable);
-    if (!!result)
-        result.decommit(result.base(), size);
-    return result;
-}
-
-void PageAllocation::deallocate()
-{
-    int result = munmap(m_base, m_size);
-    ASSERT_UNUSED(result, !result);
-}
-
-size_t PageAllocation::pagesize()
-{
-    static size_t size = 0;
-    if (!size)
-        size = getpagesize();
-    return size;
-}
-
-#elif HAVE(VIRTUALALLOC)
-
-static DWORD protection(bool writable, bool executable)
-{
-    if (executable)
-        return writable ?PAGE_EXECUTE_READWRITE : PAGE_EXECUTE_READ;
-    return writable ?PAGE_READWRITE : PAGE_READONLY;
-}
-
-bool PageAllocation::commit(void* start, size_t size, bool writable, bool executable) const
-{
-    return VirtualAlloc(start, size, MEM_COMMIT, protection(writable, executable)) == start;
-}
-
-void PageAllocation::decommit(void* start, size_t size) const
-{
-    VirtualFree(start, size, MEM_DECOMMIT);
-}
-
-PageAllocation PageAllocation::allocate(size_t size, Usage, bool writable, bool executable)
-{
-    return PageAllocation(VirtualAlloc(0, size, MEM_COMMIT | MEM_RESERVE, protection(writable, executable)), size);
-}
-
-PageAllocation PageAllocation::reserve(size_t size, Usage usage, bool writable, bool executable)
-{
-    return PageAllocation(VirtualAlloc(0, size, MEM_RESERVE, protection(writable, executable)), size);
-}
-
-void PageAllocation::deallocate()
-{
-    VirtualFree(m_base, 0, MEM_RELEASE); 
-}
-
-size_t PageAllocation::pagesize()
-{
-    static size_t size = 0;
-    if (!size) {
-        SYSTEM_INFO system_info;
-        GetSystemInfo(&system_info);
-        size = system_info.dwPageSize;
-    }
-    return size;
-}
-
-#elif OS(SYMBIAN)
-
-bool PageAllocation::commit(void* start, size_t size, bool writable, bool executable) const
-{
-    if (m_chunk) {
-        intptr_t offset = static_cast<intptr_t>(base()) - static_cast<intptr_t>(start);
-        m_chunk->Commit(offset, size);
-    }
-    return true;
-}
-
-void PageAllocation::decommit(void* start, size_t size) const
-{
-    if (m_chunk) {
-        intptr_t offset = static_cast<intptr_t>(base()) - static_cast<intptr_t>(start);
-        m_chunk->Decommit(offset, size);
-    }
-}
-
-PageAllocation PageAllocation::allocate(size_t size, Usage usage, bool writable, bool executable)
-{
-    if (!executable)
-        return PageAllocation(fastMalloc(size), size, 0);
-    RChunk* rchunk = new RChunk();
-    TInt errorCode = rchunk->CreateLocalCode(size, size);
-    return PageAllocation(rchunk->Base(), size, rchunk);
-}
-
-PageAllocation PageAllocation::reserve(size_t size, Usage usage, bool writable, bool executable)
-{
-    if (!executable)
-        return PageAllocation(fastMalloc(size), size, 0);
-    RChunk* rchunk = new RChunk();
-    TInt errorCode = rchunk->CreateLocalCode(0, size);
-    return PageAllocation(rchunk, rchunk->Base(), size);
-}
-
-void PageAllocation::deallocate()
-{
-    if (m_chunk) {
-        m_chunk->Close();
-        delete m_chunk;
-    } else
-        fastFree(m_base);
-}
-
-size_t PageAllocation::pagesize()
-{
-    static TInt page_size = 0;
-    if (!page_size)
-        UserHal::PageSizeInBytes(page_size);
-    return page_size;
-}
-
-#endif
-
-}
diff --git a/JavaScriptCore/wtf/PageAllocation.h b/JavaScriptCore/wtf/PageAllocation.h
deleted file mode 100644 (file)
index 00b5363..0000000
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright (C) 2010 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#ifndef PageAllocation_h
-#define PageAllocation_h
-
-#include <wtf/UnusedParam.h>
-#include <wtf/VMTags.h>
-
-#if OS(SYMBIAN)
-#include <e32std.h>
-#endif
-
-#if HAVE(MMAP)
-#define PAGE_ALLOCATION_ALLOCATE_AT 1
-#else
-#define PAGE_ALLOCATION_ALLOCATE_AT 0
-#endif
-
-namespace WTF {
-
-class PageAllocation {
-public:
-    enum Usage {
-        UnknownUsage = -1,
-        FastMallocPages = VM_TAG_FOR_TCMALLOC_MEMORY,
-        JSGCHeapPages = VM_TAG_FOR_COLLECTOR_MEMORY,
-        JSVMStackPages = VM_TAG_FOR_REGISTERFILE_MEMORY,
-        JSJITCodePages = VM_TAG_FOR_EXECUTABLEALLOCATOR_MEMORY,
-    };
-
-    PageAllocation()
-        : m_base(0)
-        , m_size(0)
-#if OS(SYMBIAN)
-        , m_chunk(0)
-#endif
-    {
-    }
-
-    // Create a PageAllocation object representing a sub-region of an existing allocation;
-    // deallocate should never be called on an object represnting a subregion, only on the
-    // initial allocation.
-    PageAllocation(void* base, size_t size, const PageAllocation& parent)
-        : m_base(base)
-        , m_size(size)
-#if OS(SYMBIAN)
-        , m_chunk(parent.chunk)
-#endif
-    {
-#if defined(NDEBUG) && !OS(SYMBIAN)
-        UNUSED_PARAM(parent);
-#endif
-        ASSERT(base >= parent.m_base);
-        ASSERT(size <= parent.m_size);
-        ASSERT(static_cast<char*>(base) + size <= static_cast<char*>(parent.m_base) + parent.m_size);
-    }
-
-    void* base() const { return m_base; }
-    size_t size() const { return m_size; }
-
-    bool operator!() const { return !m_base; }
-
-    bool commit(void*, size_t, bool writable = true, bool executable = false) const;
-    void decommit(void*, size_t) const;
-    void deallocate();
-
-    static PageAllocation allocate(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
-    static PageAllocation reserve(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
-#if PAGE_ALLOCATION_ALLOCATE_AT
-    static PageAllocation allocateAt(void* address, bool fixed, size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
-    static PageAllocation reserveAt(void* address, bool fixed, size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
-#endif
-    static size_t pagesize();
-
-private:
-#if OS(SYMBIAN)
-    PageAllocation(void* base, size_t size, RChunk* chunk)
-        : m_base(base)
-        , m_size(size)
-        , m_chunk(chunk)
-    {
-    }
-#else
-    PageAllocation(void* base, size_t size)
-        : m_base(base)
-        , m_size(size)
-    {
-    }
-#endif
-
-    void* m_base;
-    size_t m_size;
-#if OS(SYMBIAN)
-    RChunk* m_chunk;
-#endif
-};
-
-}
-
-using WTF::PageAllocation;
-
-#endif // PageAllocation_h