[python] Replace print operator with print() function for python3 compatibility
[WebKit-https.git] / PerformanceTests / StitchMarker / wtf / StackBounds.cpp
1 /*
2  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  *
19  */
20
21 #include "config.h"
22 #include "StackBounds.h"
23
24 #if OS(DARWIN)
25
26 #include <mach/task.h>
27 #include <mach/thread_act.h>
28 #include <pthread.h>
29
30 #elif OS(WINDOWS)
31
32 #include <windows.h>
33
34 #elif OS(SOLARIS)
35
36 #include <thread.h>
37
38 #elif OS(UNIX)
39
40 #include <pthread.h>
41 #if HAVE(PTHREAD_NP_H)
42 #include <pthread_np.h>
43 #endif
44
45 #endif
46
47 namespace WTF {
48
49 #if OS(DARWIN)
50
51 StackBounds StackBounds::newThreadStackBounds(PlatformThreadHandle thread)
52 {
53     void* origin = pthread_get_stackaddr_np(thread);
54     rlim_t size = pthread_get_stacksize_np(thread);
55     void* bound = static_cast<char*>(origin) - size;
56     return StackBounds { origin, bound };
57 }
58
59 StackBounds StackBounds::currentThreadStackBoundsInternal()
60 {
61     if (pthread_main_np()) {
62         // FIXME: <rdar://problem/13741204>
63         // pthread_get_size lies to us when we're the main thread, use get_rlimit instead
64         void* origin = pthread_get_stackaddr_np(pthread_self());
65         rlimit limit;
66         getrlimit(RLIMIT_STACK, &limit);
67         rlim_t size = limit.rlim_cur;
68         void* bound = static_cast<char*>(origin) - size;
69         return StackBounds { origin, bound };
70     }
71     return newThreadStackBounds(pthread_self());
72 }
73
74 #elif OS(SOLARIS)
75
76 StackBounds StackBounds::currentThreadStackBoundsInternal()
77 {
78     stack_t s;
79     thr_stksegment(&s);
80     void* origin = s.ss_sp;
81     void* bound = static_cast<char*>(origin) - s.ss_size;
82     return StackBounds { origin, bound };
83 }
84
85 #elif OS(UNIX)
86
87 #if OS(OPENBSD)
88
89 StackBounds StackBounds::newThreadStackBounds(PlatformThreadHandle thread)
90 {
91     stack_t stack;
92     pthread_stackseg_np(thread, &stack);
93     void* origin = stack.ss_sp;
94 #if CPU(HPPA)
95     void* bound = static_cast<char*>(origin) + stack.ss_size;
96 #else
97     void* bound = static_cast<char*>(origin) - stack.ss_size;
98 #endif
99     return StackBounds { origin, bound };
100 }
101
102 #else // !OS(OPENBSD)
103
104 StackBounds StackBounds::newThreadStackBounds(PlatformThreadHandle thread)
105 {
106     void* bound = nullptr;
107     size_t stackSize = 0;
108
109     pthread_attr_t sattr;
110     pthread_attr_init(&sattr);
111 #if HAVE(PTHREAD_NP_H) || OS(NETBSD)
112     // e.g. on FreeBSD 5.4, neundorf@kde.org
113     pthread_attr_get_np(thread, &sattr);
114 #else
115     // FIXME: this function is non-portable; other POSIX systems may have different np alternatives
116     pthread_getattr_np(thread, &sattr);
117 #endif
118     int rc = pthread_attr_getstack(&sattr, &bound, &stackSize);
119     UNUSED_PARAM(rc);
120     ASSERT(bound);
121     pthread_attr_destroy(&sattr);
122     void* origin = static_cast<char*>(bound) + stackSize;
123     return StackBounds { origin, bound };
124 }
125
126 #endif // OS(OPENBSD)
127
128 StackBounds StackBounds::currentThreadStackBoundsInternal()
129 {
130     return newThreadStackBounds(pthread_self());
131 }
132
133 #elif OS(WINDOWS)
134
135 StackBounds StackBounds::currentThreadStackBoundsInternal()
136 {
137     MEMORY_BASIC_INFORMATION stackOrigin = { 0 };
138     VirtualQuery(&stackOrigin, &stackOrigin, sizeof(stackOrigin));
139     // stackOrigin.AllocationBase points to the reserved stack memory base address.
140
141     void* origin = static_cast<char*>(stackOrigin.BaseAddress) + stackOrigin.RegionSize;
142     // The stack on Windows consists out of three parts (uncommitted memory, a guard page and present
143     // committed memory). The 3 regions have different BaseAddresses but all have the same AllocationBase
144     // since they are all from the same VirtualAlloc. The 3 regions are laid out in memory (from high to
145     // low) as follows:
146     //
147     //    High |-------------------|  -----
148     //         | committedMemory   |    ^
149     //         |-------------------|    |
150     //         | guardPage         | reserved memory for the stack
151     //         |-------------------|    |
152     //         | uncommittedMemory |    v
153     //    Low  |-------------------|  ----- <--- stackOrigin.AllocationBase
154     //
155     // See http://msdn.microsoft.com/en-us/library/ms686774%28VS.85%29.aspx for more information.
156
157     MEMORY_BASIC_INFORMATION uncommittedMemory;
158     VirtualQuery(stackOrigin.AllocationBase, &uncommittedMemory, sizeof(uncommittedMemory));
159     ASSERT(uncommittedMemory.State == MEM_RESERVE);
160
161     MEMORY_BASIC_INFORMATION guardPage;
162     VirtualQuery(static_cast<char*>(uncommittedMemory.BaseAddress) + uncommittedMemory.RegionSize, &guardPage, sizeof(guardPage));
163     ASSERT(guardPage.Protect & PAGE_GUARD);
164
165     void* endOfStack = stackOrigin.AllocationBase;
166
167 #ifndef NDEBUG
168     MEMORY_BASIC_INFORMATION committedMemory;
169     VirtualQuery(static_cast<char*>(guardPage.BaseAddress) + guardPage.RegionSize, &committedMemory, sizeof(committedMemory));
170     ASSERT(committedMemory.State == MEM_COMMIT);
171
172     void* computedEnd = static_cast<char*>(origin) - (uncommittedMemory.RegionSize + guardPage.RegionSize + committedMemory.RegionSize);
173
174     ASSERT(stackOrigin.AllocationBase == uncommittedMemory.AllocationBase);
175     ASSERT(stackOrigin.AllocationBase == guardPage.AllocationBase);
176     ASSERT(stackOrigin.AllocationBase == committedMemory.AllocationBase);
177     ASSERT(stackOrigin.AllocationBase == uncommittedMemory.BaseAddress);
178     ASSERT(endOfStack == computedEnd);
179 #endif // NDEBUG
180     void* bound = static_cast<char*>(endOfStack) + guardPage.RegionSize;
181     return StackBounds { origin, bound };
182 }
183
184 #else
185 #error Need a way to get the stack bounds on this platform
186 #endif
187
188 } // namespace WTF