Changeset 150621 in webkit

Timestamp:

May 23, 2013 6:33:04 PM (11 years ago)

Author:

Brent Fulgham

Message:

[Windows] Rolling back r150600 as it breaks the VS2010 builds.

• wtf/StackBounds.cpp: Rollback.

Location:

trunk/Source/WTF

Files:

• ChangeLog (modified) (1 diff)
• wtf/StackBounds.cpp (modified) (4 diffs)

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2013-05-23  Brent Fulgham  <bfulgham@apple.com>
+
+        [Windows] Rolling back r150600 as it breaks the VS2010 builds.
+
+        * wtf/StackBounds.cpp: Rollback.
+
 2013-05-23 Patrick Gansterer <paroga@webkit.org>
 

trunk/Source/WTF/wtf/StackBounds.cpp

@@ -55 +55 @@
 
 namespace WTF {
+
+// Bug 26276 - Need a mechanism to determine stack extent
+//
+// These platforms should now be working correctly:
+//     DARWIN, QNX, UNIX
+// These platforms are not:
+//     WINDOWS, SOLARIS, OPENBSD, WINCE
+//
+// FIXME: remove this! - this code unsafely guesses at stack sizes!
+#if OS(WINDOWS) || OS(SOLARIS) || OS(OPENBSD)
+// Based on the current limit used by the JSC parser, guess the stack size.
+static const ptrdiff_t estimatedStackSize = 128 * sizeof(void*) * 1024;
+// This method assumes the stack is growing downwards.
+static void* estimateStackBound(void* origin)
+{
+    return static_cast<char*>(origin) - estimatedStackSize;
+}
+#endif
 
 #if OS(DARWIN)
@@ -107 +125 @@
     thr_stksegment(&s);
     m_origin = s.ss_sp;
-    m_bound = static_cast<char*>(m_origin) - s.ss_size;
+    m_bound = estimateStackBound(m_origin);
 }
 
@@ -118 +136 @@
     pthread_stackseg_np(thread, &stack);
     m_origin = stack.ss_sp;
-#if CPU(HPPA)
-    m_bound = static_cast<char*>(m_origin) + stack.ss_size;
-#else
-    m_bound = static_cast<char*>(m_origin) - stack.ss_size;
-#endif
+    m_bound = estimateStackBound(m_origin);
 }
 
@@ -150 +164 @@
 }
 
-#elif OS(WINDOWS)
-
-void StackBounds::initialize()
-{
+#elif OS(WINCE)
+
+static bool detectGrowingDownward(void* previousFrame)
+{
+    // Find the address of this stack frame by taking the address of a local variable.
+    int thisFrame;
+    return previousFrame > &thisFrame;
+}
+
+static inline bool isPageWritable(void* page)
+{
+    MEMORY_BASIC_INFORMATION memoryInformation;
+    DWORD result = VirtualQuery(page, &memoryInformation, sizeof(memoryInformation));
+
+    // return false on error, including ptr outside memory
+    if (result != sizeof(memoryInformation))
+        return false;
+
+    DWORD protect = memoryInformation.Protect & ~(PAGE_GUARD | PAGE_NOCACHE);
+    return protect == PAGE_READWRITE
+        || protect == PAGE_WRITECOPY
+        || protect == PAGE_EXECUTE_READWRITE
+        || protect == PAGE_EXECUTE_WRITECOPY;
+}
+
+static inline void* getLowerStackBound(char* currentPage, DWORD pageSize)
+{
+    while (currentPage > 0) {
+        // check for underflow
+        if (currentPage >= reinterpret_cast<char*>(pageSize))
+            currentPage -= pageSize;
+        else
+            currentPage = 0;
+
+        if (!isPageWritable(currentPage))
+            return currentPage + pageSize;
+    }
+
+    return 0;
+}
+
+static inline void* getUpperStackBound(char* currentPage, DWORD pageSize)
+{
+    do {
+        // guaranteed to complete because isPageWritable returns false at end of memory
+        currentPage += pageSize;
+    } while (isPageWritable(currentPage));
+
+    return currentPage - pageSize;
+}
+
+void StackBounds::initialize()
+{
+    // find the address of this stack frame by taking the address of a local variable
+    void* thisFrame = &thisFrame;
+    bool isGrowingDownward = detectGrowingDownward(thisFrame);
+
     SYSTEM_INFO systemInfo;
     GetSystemInfo(&systemInfo);
     DWORD pageSize = systemInfo.dwPageSize;
 
-    MEMORY_BASIC_INFORMATION stackOrigin;
-    VirtualQuery(&stackOrigin, &stackOrigin, sizeof(stackOrigin));
-    // stackOrigin.AllocationBase points to the reserved stack memory base address.
-
-    m_origin = static_cast<char*>(stackOrigin.BaseAddress) + stackOrigin.RegionSize;
-#if OS(WINCE)
-    MEMORY_BASIC_INFORMATION stackMemory;
-    VirtualQuery(m_origin, &stackMemory, sizeof(stackMemory));
-
-    m_bound = static_cast<char*>(m_origin) - stackMemory.RegionSize + pageSize;
+    // scan all of memory starting from this frame, and return the last writeable page found
+    char* currentPage = reinterpret_cast<char*>(reinterpret_cast<DWORD>(thisFrame) & ~(pageSize - 1));
+    void* lowerStackBound = getLowerStackBound(currentPage, pageSize);
+    void* upperStackBound = getUpperStackBound(currentPage, pageSize);
+
+    m_origin = isGrowingDownward ? upperStackBound : lowerStackBound;
+    m_bound = isGrowingDownward ? lowerStackBound : upperStackBound;
+}
+
+#elif OS(WINDOWS)
+
+void StackBounds::initialize()
+{
+#if CPU(X86) && COMPILER(MSVC)
+    // offset 0x18 from the FS segment register gives a pointer to
+    // the thread information block for the current thread
+    NT_TIB* pTib;
+    __asm {
+        MOV EAX, FS:[18h]
+        MOV pTib, EAX
+    }
+    m_origin = static_cast<void*>(pTib->StackBase);
+#elif CPU(X86) && COMPILER(GCC)
+    // offset 0x18 from the FS segment register gives a pointer to
+    // the thread information block for the current thread
+    NT_TIB* pTib;
+    asm ( "movl %%fs:0x18, %0\n"
+          : "=r" (pTib)
+        );
+    m_origin = static_cast<void*>(pTib->StackBase);
+#elif CPU(X86_64)
+    PNT_TIB64 pTib = reinterpret_cast<PNT_TIB64>(NtCurrentTeb());
+    m_origin = reinterpret_cast<void*>(pTib->StackBase);
 #else
-    // The stack on Windows consists out of three parts (reserved memory, a guard page and initially committed memory),
-    // which need to me queried seperately to get the full size of the stack.
-    // See http://msdn.microsoft.com/en-us/library/ms686774%28VS.85%29.aspx for more information.
-
-    MEMORY_BASIC_INFORMATION reservedMemory;
-    VirtualQuery(stackOrigin.AllocationBase, &reservedMemory, sizeof(reservedMemory));
-    ASSERT(reservedMemory.State == MEM_RESERVE);
-    // reservedMemory.BaseAddress and reservedMemory.RegionSize describe reserved (uncommitted) portion of the stack.
-
-    MEMORY_BASIC_INFORMATION guardPage;
-    VirtualQuery(static_cast<char*>(reservedMemory.BaseAddress) + reservedMemory.RegionSize, &guardPage, sizeof(guardPage));
-    ASSERT(guardPage.Protect & PAGE_GUARD);
-    // guardPage.BaseAddress and guardPage.RegionSize describe the guard page.
-
-    MEMORY_BASIC_INFORMATION committedMemory;
-    VirtualQuery(static_cast<char*>(guardPage.BaseAddress) + guardPage.RegionSize, &committedMemory, sizeof(committedMemory));
-    ASSERT(committedMemory.State == MEM_COMMIT);
-    // committedMemory.BaseAddress, committedMemory.RegionSize describe the committed (i.e. accessed) portion of the stack.
-
-    m_bound = static_cast<char*>(m_origin) - (reservedMemory.RegionSize - guardPage.RegionSize + committedMemory.RegionSize) + pageSize;
-#endif
+#error Need a way to get the stack bounds on this platform (Windows)
+#endif
+    // Looks like we should be able to get pTib->StackLimit
+    m_bound = estimateStackBound(m_origin);
 }