Remove OS(QNX) support.

Source/wtf/StackBounds.cpp

 /*
  *  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,
@@ skipping 17 matching lines @@
 #include <pthread.h>
 
 #elif OS(WINDOWS)
 
 #include <windows.h>
 
 #elif OS(SOLARIS)
 
 #include <thread.h>
 
-#elif OS(QNX)
-
-#include <errno.h>
-#include <fcntl.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/procfs.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
+//     DARWIN, UNIX
 // These platforms are not:
 //     WINDOWS, SOLARIS, OPENBSD
 //
 // 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)
 
 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(QNX)
-
-void StackBounds::initialize()
-{
-    void* stackBase = 0;
-    size_t stackSize = 0;
-
-    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 = static_cast<char*>(stackBase) + 0x1000; // 4kb guard page
-    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);
 }
 
@@ skipping 62 matching lines @@
 #endif
     // Looks like we should be able to get pTib->StackLimit
     m_bound = estimateStackBound(m_origin);
 }
 
 #else
 #error Need a way to get the stack bounds on this platform
 #endif
 
 } // namespace WTF