2010-12-23 Patrick Gansterer <paroga@webkit.org>
authorparoga@webkit.org <paroga@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 24 Dec 2010 01:03:23 +0000 (01:03 +0000)
committerparoga@webkit.org <paroga@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 24 Dec 2010 01:03:23 +0000 (01:03 +0000)
        Unreviewed build fix for WinCE after r74360.

        Move the OS(WINDOWS) section after the OS(WINCE) section
        and add missing argument to the getStackMax call.

        * wtf/StackBounds.cpp:
        (WTF::StackBounds::initialize):

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

JavaScriptCore/ChangeLog
JavaScriptCore/wtf/StackBounds.cpp

index 69b6d3b..d869dd1 100644 (file)
@@ -1,3 +1,13 @@
+2010-12-23  Patrick Gansterer  <paroga@webkit.org>
+
+        Unreviewed build fix for WinCE after r74360.
+
+        Move the OS(WINDOWS) section after the OS(WINCE) section
+        and add missing argument to the getStackMax call.
+
+        * wtf/StackBounds.cpp:
+        (WTF::StackBounds::initialize):
+
 2010-12-22  Laszlo Gombos  <laszlo.1.gombos@nokia.com>
 
         Unreviewed build fix.
index 2691db1..f260007 100644 (file)
-/*
- *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
- *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
- *
- *  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 "StackBounds.h"
-
-#if OS(DARWIN)
-
-#include <mach/task.h>
-#include <mach/thread_act.h>
-#include <pthread.h>
-
-#elif OS(WINDOWS)
-
-#include <windows.h>
-
-#elif OS(HAIKU)
-
-#include <OS.h>
-
-#elif OS(SOLARIS)
-
-#include <thread.h>
-
-#elif OS(QNX)
-
-#include <fcntl.h>
-#include <sys/procfs.h>
-#include <stdio.h>
-#include <errno.h>
-
-#elif OS(UNIX)
-
-#include <pthread.h>
-#if HAVE(PTHREAD_NP_H)
-#include <pthread_np.h>
-#endif
-
-#endif
-
-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, SYMBIAN, HAIKU, WINCE
-//
-// FIXME: remove this! - this code unsafely guesses at stack sizes!
-#if OS(WINDOWS) || OS(SOLARIS) || OS(OPENBSD) || OS(SYMBIAN) || OS(HAIKU) || OS(WINCE)
-// 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)
-
-void StackBounds::initialize()
-{
-    pthread_t thread = pthread_self();
-    m_origin = pthread_get_stackaddr_np(thread);
-    m_bound = static_cast<char*>(m_origin) - pthread_get_stacksize_np(thread);
-}
-
-#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 OS(WINDOWS) && 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 OS(WINDOWS) && CPU(X86_64)
-    PNT_TIB64 pTib = reinterpret_cast<PNT_TIB64>(NtCurrentTeb());
-    m_origin = reinterpret_cast<void*>(pTib->StackBase);
-#else
-#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);
-}
-
-#elif OS(QNX)
-
-void StackBounds::initialize()
-{
-    void* stackBase = 0;
-    size_t stackSize = 0;
-    pthread_t thread = pthread_self();
-
-    struct _debug_thread_info threadInfo;
-    memset(&threadInfo, 0, sizeof(threadInfo));
-    threadInfo.tid = pthread_self();
-    int fd = open("/proc/self", O_RDONLY);
-    if (fd == -1) {
-        LOG_ERROR("Unable to open /proc/self (errno: %d)", errno);
-        CRASH();
-    }
-    devctl(fd, DCMD_PROC_TIDSTATUS, &threadInfo, sizeof(threadInfo), 0);
-    close(fd);
-    stackBase = reinterpret_cast<void*>(threadInfo.stkbase);
-    stackSize = threadInfo.stksize;
-    ASSERT(stackBase);
-
-    m_bound = stackBase;
-    m_origin = static_cast<char*>(stackBase) + stackSize;
-}
-
-#elif OS(SOLARIS)
-
-void StackBounds::initialize()
-{
-    stack_t s;
-    thr_stksegment(&s);
-    m_origin = s.ss_sp;
-    m_bound = estimateStackBound(m_origin);
-}
-
-#elif OS(OPENBSD)
-
-void StackBounds::initialize()
-{
-    pthread_t thread = pthread_self();
-    stack_t stack;
-    pthread_stackseg_np(thread, &stack);
-    m_origin = stack.ss_sp;
-    m_bound = estimateStackBound(m_origin);
-}
-
-#elif OS(SYMBIAN)
-
-void StackBounds::initialize()
-{
-    TThreadStackInfo info;
-    RThread thread;
-    thread.StackInfo(info);
-    m_origin = (void*)info.iBase;
-    m_bound = estimateStackBound(m_origin);
-}
-
-#elif OS(HAIKU)
-
-void StackBounds::initialize()
-{
-    thread_info threadInfo;
-    get_thread_info(find_thread(NULL), &threadInfo);
-    m_origin = threadInfo.stack_end;
-    m_bound = estimateStackBound(m_origin);
-}
-
-#elif OS(UNIX)
-
-void StackBounds::initialize()
-{
-    void* stackBase = 0;
-    size_t stackSize = 0;
-
-    pthread_t thread = pthread_self();
-    pthread_attr_t sattr;
-    pthread_attr_init(&sattr);
-#if HAVE(PTHREAD_NP_H) || OS(NETBSD)
-    // e.g. on FreeBSD 5.4, neundorf@kde.org
-    pthread_attr_get_np(thread, &sattr);
-#else
-    // FIXME: this function is non-portable; other POSIX systems may have different np alternatives
-    pthread_getattr_np(thread, &sattr);
-#endif
-    int rc = pthread_attr_getstack(&sattr, &stackBase, &stackSize);
-    (void)rc; // FIXME: Deal with error code somehow? Seems fatal.
-    ASSERT(stackBase);
-    pthread_attr_destroy(&sattr);
-    m_bound = stackBase;
-    m_origin = static_cast<char*>(stackBase) + stackSize;
-}
-
-#elif OS(WINCE)
-
-} // namespace WTF
-// FIXME: this is not threadsafe, and should probably be removed.
-namespace JSC { JS_EXPORTDATA void* g_stackBase = 0; }
-namespace WTF {
-
-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 void* getStackMax(void* previousFrame, bool& isGrowingDownward)
-{
-    // find the address of this stack frame by taking the address of a local variable
-    void* thisFrame = &thisFrame;
-    isGrowingDownward = previousFrame < &thisFrame;
-
-    if (JSC::g_stackBase)
-        return JSC::g_stackBase;
-
-    SYSTEM_INFO systemInfo;
-    GetSystemInfo(&systemInfo);
-    DWORD pageSize = systemInfo.dwPageSize;
-
-    // scan all of memory starting from this frame, and return the last writeable page found
-    register char* currentPage = (char*)((DWORD)thisFrame & ~(pageSize - 1));
-    if (isGrowingDownward) {
-        while (currentPage > 0) {
-            // check for underflow
-            if (currentPage >= (char*)pageSize)
-                currentPage -= pageSize;
-            else
-                currentPage = 0;
-            if (!isPageWritable(currentPage))
-                return currentPage + pageSize;
-        }
-        return 0;
-    } else {
-        while (true) {
-            // guaranteed to complete because isPageWritable returns false at end of memory
-            currentPage += pageSize;
-            if (!isPageWritable(currentPage))
-                return currentPage;
-        }
-    }
-}
-
-void StackBounds::initialize()
-{
-    bool isGrowingDownward
-    m_origin = getStackMax(isGrowingDownward);
-    m_bound = isGrowingDownward
-        ? static_cast<char*>(m_origin) - estimatedStackSize
-        : static_cast<char*>(m_origin) + estimatedStackSize;
-}
-
-#else
-#error Need a way to get the stack bounds on this platform
-#endif
-
-} // namespace WTF
+/*\r
+ *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.\r
+ *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>\r
+ *\r
+ *  This library is free software; you can redistribute it and/or\r
+ *  modify it under the terms of the GNU Lesser General Public\r
+ *  License as published by the Free Software Foundation; either\r
+ *  version 2 of the License, or (at your option) any later version.\r
+ *\r
+ *  This library is distributed in the hope that it will be useful,\r
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
+ *  Lesser General Public License for more details.\r
+ *\r
+ *  You should have received a copy of the GNU Lesser General Public\r
+ *  License along with this library; if not, write to the Free Software\r
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA\r
+ *\r
+ */\r
+\r
+#include "config.h"\r
+#include "StackBounds.h"\r
+\r
+#if OS(DARWIN)\r
+\r
+#include <mach/task.h>\r
+#include <mach/thread_act.h>\r
+#include <pthread.h>\r
+\r
+#elif OS(WINDOWS)\r
+\r
+#include <windows.h>\r
+\r
+#elif OS(HAIKU)\r
+\r
+#include <OS.h>\r
+\r
+#elif OS(SOLARIS)\r
+\r
+#include <thread.h>\r
+\r
+#elif OS(QNX)\r
+\r
+#include <fcntl.h>\r
+#include <sys/procfs.h>\r
+#include <stdio.h>\r
+#include <errno.h>\r
+\r
+#elif OS(UNIX)\r
+\r
+#include <pthread.h>\r
+#if HAVE(PTHREAD_NP_H)\r
+#include <pthread_np.h>\r
+#endif\r
+\r
+#endif\r
+\r
+namespace WTF {\r
+\r
+// Bug 26276 - Need a mechanism to determine stack extent\r
+//\r
+// These platforms should now be working correctly:\r
+//     DARWIN, QNX, UNIX\r
+// These platforms are not:\r
+//     WINDOWS, SOLARIS, OPENBSD, SYMBIAN, HAIKU, WINCE\r
+//\r
+// FIXME: remove this! - this code unsafely guesses at stack sizes!\r
+#if OS(WINDOWS) || OS(SOLARIS) || OS(OPENBSD) || OS(SYMBIAN) || OS(HAIKU) || OS(WINCE)\r
+// Based on the current limit used by the JSC parser, guess the stack size.\r
+static const ptrdiff_t estimatedStackSize = 128 * sizeof(void*) * 1024;\r
+// This method assumes the stack is growing downwards.\r
+static void* estimateStackBound(void* origin)\r
+{\r
+    return static_cast<char*>(origin) - estimatedStackSize;\r
+}\r
+#endif\r
+\r
+#if OS(DARWIN)\r
+\r
+void StackBounds::initialize()\r
+{\r
+    pthread_t thread = pthread_self();\r
+    m_origin = pthread_get_stackaddr_np(thread);\r
+    m_bound = static_cast<char*>(m_origin) - pthread_get_stacksize_np(thread);\r
+}\r
+\r
+#elif OS(QNX)\r
+\r
+void StackBounds::initialize()\r
+{\r
+    void* stackBase = 0;\r
+    size_t stackSize = 0;\r
+    pthread_t thread = pthread_self();\r
+\r
+    struct _debug_thread_info threadInfo;\r
+    memset(&threadInfo, 0, sizeof(threadInfo));\r
+    threadInfo.tid = pthread_self();\r
+    int fd = open("/proc/self", O_RDONLY);\r
+    if (fd == -1) {\r
+        LOG_ERROR("Unable to open /proc/self (errno: %d)", errno);\r
+        CRASH();\r
+    }\r
+    devctl(fd, DCMD_PROC_TIDSTATUS, &threadInfo, sizeof(threadInfo), 0);\r
+    close(fd);\r
+    stackBase = reinterpret_cast<void*>(threadInfo.stkbase);\r
+    stackSize = threadInfo.stksize;\r
+    ASSERT(stackBase);\r
+\r
+    m_bound = stackBase;\r
+    m_origin = static_cast<char*>(stackBase) + stackSize;\r
+}\r
+\r
+#elif OS(SOLARIS)\r
+\r
+void StackBounds::initialize()\r
+{\r
+    stack_t s;\r
+    thr_stksegment(&s);\r
+    m_origin = s.ss_sp;\r
+    m_bound = estimateStackBound(m_origin);\r
+}\r
+\r
+#elif OS(OPENBSD)\r
+\r
+void StackBounds::initialize()\r
+{\r
+    pthread_t thread = pthread_self();\r
+    stack_t stack;\r
+    pthread_stackseg_np(thread, &stack);\r
+    m_origin = stack.ss_sp;\r
+    m_bound = estimateStackBound(m_origin);\r
+}\r
+\r
+#elif OS(SYMBIAN)\r
+\r
+void StackBounds::initialize()\r
+{\r
+    TThreadStackInfo info;\r
+    RThread thread;\r
+    thread.StackInfo(info);\r
+    m_origin = (void*)info.iBase;\r
+    m_bound = estimateStackBound(m_origin);\r
+}\r
+\r
+#elif OS(HAIKU)\r
+\r
+void StackBounds::initialize()\r
+{\r
+    thread_info threadInfo;\r
+    get_thread_info(find_thread(NULL), &threadInfo);\r
+    m_origin = threadInfo.stack_end;\r
+    m_bound = estimateStackBound(m_origin);\r
+}\r
+\r
+#elif OS(UNIX)\r
+\r
+void StackBounds::initialize()\r
+{\r
+    void* stackBase = 0;\r
+    size_t stackSize = 0;\r
+\r
+    pthread_t thread = pthread_self();\r
+    pthread_attr_t sattr;\r
+    pthread_attr_init(&sattr);\r
+#if HAVE(PTHREAD_NP_H) || OS(NETBSD)\r
+    // e.g. on FreeBSD 5.4, neundorf@kde.org\r
+    pthread_attr_get_np(thread, &sattr);\r
+#else\r
+    // FIXME: this function is non-portable; other POSIX systems may have different np alternatives\r
+    pthread_getattr_np(thread, &sattr);\r
+#endif\r
+    int rc = pthread_attr_getstack(&sattr, &stackBase, &stackSize);\r
+    (void)rc; // FIXME: Deal with error code somehow? Seems fatal.\r
+    ASSERT(stackBase);\r
+    pthread_attr_destroy(&sattr);\r
+    m_bound = stackBase;\r
+    m_origin = static_cast<char*>(stackBase) + stackSize;\r
+}\r
+\r
+#elif OS(WINCE)\r
+\r
+} // namespace WTF\r
+// FIXME: this is not threadsafe, and should probably be removed.\r
+namespace JSC { JS_EXPORTDATA void* g_stackBase = 0; }\r
+namespace WTF {\r
+\r
+inline bool isPageWritable(void* page)\r
+{\r
+    MEMORY_BASIC_INFORMATION memoryInformation;\r
+    DWORD result = VirtualQuery(page, &memoryInformation, sizeof(memoryInformation));\r
+\r
+    // return false on error, including ptr outside memory\r
+    if (result != sizeof(memoryInformation))\r
+        return false;\r
+\r
+    DWORD protect = memoryInformation.Protect & ~(PAGE_GUARD | PAGE_NOCACHE);\r
+    return protect == PAGE_READWRITE\r
+        || protect == PAGE_WRITECOPY\r
+        || protect == PAGE_EXECUTE_READWRITE\r
+        || protect == PAGE_EXECUTE_WRITECOPY;\r
+}\r
+\r
+static void* getStackMax(void* previousFrame, bool& isGrowingDownward)\r
+{\r
+    // find the address of this stack frame by taking the address of a local variable\r
+    void* thisFrame = &thisFrame;\r
+    isGrowingDownward = previousFrame < &thisFrame;\r
+\r
+    if (JSC::g_stackBase)\r
+        return JSC::g_stackBase;\r
+\r
+    SYSTEM_INFO systemInfo;\r
+    GetSystemInfo(&systemInfo);\r
+    DWORD pageSize = systemInfo.dwPageSize;\r
+\r
+    // scan all of memory starting from this frame, and return the last writeable page found\r
+    register char* currentPage = (char*)((DWORD)thisFrame & ~(pageSize - 1));\r
+    if (isGrowingDownward) {\r
+        while (currentPage > 0) {\r
+            // check for underflow\r
+            if (currentPage >= (char*)pageSize)\r
+                currentPage -= pageSize;\r
+            else\r
+                currentPage = 0;\r
+            if (!isPageWritable(currentPage))\r
+                return currentPage + pageSize;\r
+        }\r
+        return 0;\r
+    } else {\r
+        while (true) {\r
+            // guaranteed to complete because isPageWritable returns false at end of memory\r
+            currentPage += pageSize;\r
+            if (!isPageWritable(currentPage))\r
+                return currentPage;\r
+        }\r
+    }\r
+}\r
+\r
+void StackBounds::initialize()\r
+{\r
+    int dummy;\r
+    bool isGrowingDownward;\r
+    m_origin = getStackMax(&dummy, isGrowingDownward);\r
+    m_bound = isGrowingDownward\r
+        ? static_cast<char*>(m_origin) - estimatedStackSize\r
+        : static_cast<char*>(m_origin) + estimatedStackSize;\r
+}\r
+\r
+#elif OS(WINDOWS)\r
+\r
+void StackBounds::initialize()\r
+{\r
+#if CPU(X86) && COMPILER(MSVC)\r
+    // offset 0x18 from the FS segment register gives a pointer to\r
+    // the thread information block for the current thread\r
+    NT_TIB* pTib;\r
+    __asm {\r
+        MOV EAX, FS:[18h]\r
+        MOV pTib, EAX\r
+    }\r
+    m_origin = static_cast<void*>(pTib->StackBase);\r
+#elif CPU(X86) && COMPILER(GCC)\r
+    // offset 0x18 from the FS segment register gives a pointer to\r
+    // the thread information block for the current thread\r
+    NT_TIB* pTib;\r
+    asm ( "movl %%fs:0x18, %0\n"\r
+          : "=r" (pTib)\r
+        );\r
+    m_origin = static_cast<void*>(pTib->StackBase);\r
+#elif CPU(X86_64)\r
+    PNT_TIB64 pTib = reinterpret_cast<PNT_TIB64>(NtCurrentTeb());\r
+    m_origin = reinterpret_cast<void*>(pTib->StackBase);\r
+#else\r
+#error Need a way to get the stack bounds on this platform (Windows)\r
+#endif\r
+    // Looks like we should be able to get pTib->StackLimit\r
+    m_bound = estimateStackBound(m_origin);\r
+}\r
+\r
+#else\r
+#error Need a way to get the stack bounds on this platform\r
+#endif\r
+\r
+} // namespace WTF\r