Changeset 37804 in webkit for trunk/JavaScriptCore

Timestamp:

Oct 22, 2008, 8:36:04 PM (17 years ago)

Author:

[email protected]

Message:

Really "fix" CTI mode on windows 2k3.

Reviewed my Maciej Stachowiak

This adds new methods fastMallocExecutable and fastFreeExecutable
to wrap allocation for cti code. This still just makes fastMalloc
return executable memory all the time, which will be fixed in a
later patch.

However in windows debug builds all executable allocations will be
allocated on separate executable pages, which should resolve any
remaining 2k3 issues. Conveniently the 2k3 bot will now also fail
if there are any fastFree vs. fastFreeExecutable errors.

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• VM/CodeBlock.cpp (modified) (2 diffs)
• kjs/regexp.cpp (modified) (1 diff)
• masm/X86Assembler.h (modified) (2 diffs)
• wtf/FastMalloc.cpp (modified) (3 diffs)
• wtf/FastMalloc.h (modified) (1 diff)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-10-22  Oliver Hunt  <[email protected]>
+
+        Reviewed by Maciej Stachowiak.
+
+        Really "fix" CTI mode on windows 2k3.
+
+        This adds new methods fastMallocExecutable and fastFreeExecutable
+        to wrap allocation for cti code.  This still just makes fastMalloc
+        return executable memory all the time, which will be fixed in a
+        later patch.
+
+        However in windows debug builds all executable allocations will be
+        allocated on separate executable pages, which should resolve any
+        remaining 2k3 issues.  Conveniently the 2k3 bot will now also fail
+        if there are any fastFree vs. fastFreeExecutable errors.
+
+        * ChangeLog:
+        * VM/CodeBlock.cpp:
+        (JSC::CodeBlock::~CodeBlock):
+        * kjs/regexp.cpp:
+        (JSC::RegExp::~RegExp):
+        * masm/X86Assembler.h:
+        (JSC::JITCodeBuffer::copy):
+        * wtf/FastMalloc.cpp:
+        (WTF::fastMallocExecutable):
+        (WTF::fastFreeExecutable):
+        (WTF::TCMallocStats::fastMallocExecutable):
+        (WTF::TCMallocStats::fastFreeExecutable):
+        * wtf/FastMalloc.h:
+
 2008-10-22  Darin Adler  <[email protected]>
 

trunk/JavaScriptCore/VM/CodeBlock.cpp

@@ -946 +946 @@
         derefStructureIDs(&instructions[structureIDInstructions[i].opcodeIndex]);
         if (structureIDInstructions[i].stubRoutine)
-            fastFree(structureIDInstructions[i].stubRoutine);
+            WTF::fastFreeExecutable(structureIDInstructions[i].stubRoutine);
         if (CallLinkInfo* callLinkInfo = structureIDInstructions[i].linkInfoPtr) {
             callLinkInfo->callee->removeCaller(callLinkInfo);
@@ -957 +957 @@
 
     if (ctiCode)
-        fastFree(ctiCode);
+        WTF::fastFreeExecutable(ctiCode);
 #endif
 }

trunk/JavaScriptCore/kjs/regexp.cpp

@@ -106 +106 @@
 #if ENABLE(WREC)
     if (m_wrecFunction)
-        fastFree(m_wrecFunction);
+        WTF::fastFreeExecutable(m_wrecFunction);
 #endif
 }

trunk/JavaScriptCore/masm/X86Assembler.h

@@ -31 +31 @@
 #include <wtf/Assertions.h>
 #include <wtf/AlwaysInline.h>
+#include <wtf/FastMalloc.h>
+
 #if HAVE(MMAN)
 #include <sys/mman.h>
@@ -124 +126 @@
             return 0;
 
-        void* result = fastMalloc(m_index);
+        void* result = WTF::fastMallocExecutable(m_index);
 
         if (!result)

trunk/JavaScriptCore/wtf/FastMalloc.cpp

@@ -175 +175 @@
 #if !PLATFORM(WIN_OS)
     #include <pthread.h>
+#else
+    #include "windows.h"
 #endif
 
 namespace WTF {
-    
+
 void* tryFastMalloc(size_t n) 
 {
@@ -231 +233 @@
 
 void releaseFastMallocFreeMemory() { }
+
+#if HAVE(VIRTUALALLOC)
+void* fastMallocExecutable(size_t n)
+{
+    return VirtualAlloc(0, n, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+}
+
+void fastFreeExecutable(void* p)
+{ 
+    VirtualFree(p, 0, MEM_RELEASE); 
+}
+#else
+void* fastMallocExecutable(size_t n)
+{
+    return fastMalloc(n);
+}
+
+void fastFreeExecutable(void* p)
+{ 
+    fastFree(p);
+}
+#endif
 
 } // namespace WTF
@@ -3360 +3384 @@
     return old_ptr;
   }
+}
+
+void* fastMallocExecutable(size_t n)
+{
+    return malloc<false>(n);
+}
+
+void fastFreeExecutable(void* p)
+{ 
+    free(p);
 }
 

trunk/JavaScriptCore/wtf/FastMalloc.h

@@ -41 +41 @@
 
     void fastFree(void* p);
+
+    void* fastMallocExecutable(size_t n);
+    void fastFreeExecutable(void* p);
 
 #ifndef NDEBUG