1 | /* |
2 | * Stack-less Just-In-Time compiler |
3 | * |
4 | * Copyright Zoltan Herczeg (hzmester@freemail.hu). All rights reserved. |
5 | * |
6 | * Redistribution and use in source and binary forms, with or without modification, are |
7 | * permitted provided that the following conditions are met: |
8 | * |
9 | * 1. Redistributions of source code must retain the above copyright notice, this list of |
10 | * conditions and the following disclaimer. |
11 | * |
12 | * 2. Redistributions in binary form must reproduce the above copyright notice, this list |
13 | * of conditions and the following disclaimer in the documentation and/or other materials |
14 | * provided with the distribution. |
15 | * |
16 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY |
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
18 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT |
19 | * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
20 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED |
21 | * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
22 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
23 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
24 | * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
25 | */ |
26 | |
27 | /* ------------------------------------------------------------------------ */ |
28 | /* Locks */ |
29 | /* ------------------------------------------------------------------------ */ |
30 | |
31 | /* Executable Allocator */ |
32 | |
33 | #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \ |
34 | && !(defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR) |
35 | #if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED) |
36 | #define SLJIT_ALLOCATOR_LOCK() |
37 | #define SLJIT_ALLOCATOR_UNLOCK() |
38 | #elif !(defined _WIN32) |
39 | #include <pthread.h> |
40 | |
41 | static pthread_mutex_t allocator_lock = PTHREAD_MUTEX_INITIALIZER; |
42 | |
43 | #define SLJIT_ALLOCATOR_LOCK() pthread_mutex_lock(&allocator_lock) |
44 | #define SLJIT_ALLOCATOR_UNLOCK() pthread_mutex_unlock(&allocator_lock) |
45 | #else /* windows */ |
46 | static HANDLE allocator_lock; |
47 | |
48 | static SLJIT_INLINE void allocator_grab_lock(void) |
49 | { |
50 | HANDLE lock; |
51 | if (SLJIT_UNLIKELY(!InterlockedCompareExchangePointer(&allocator_lock, NULL, NULL))) { |
52 | lock = CreateMutex(NULL, FALSE, NULL); |
53 | if (InterlockedCompareExchangePointer(&allocator_lock, lock, NULL)) |
54 | CloseHandle(lock); |
55 | } |
56 | WaitForSingleObject(allocator_lock, INFINITE); |
57 | } |
58 | |
59 | #define SLJIT_ALLOCATOR_LOCK() allocator_grab_lock() |
60 | #define SLJIT_ALLOCATOR_UNLOCK() ReleaseMutex(allocator_lock) |
61 | #endif /* thread implementation */ |
62 | #endif /* SLJIT_EXECUTABLE_ALLOCATOR && !SLJIT_WX_EXECUTABLE_ALLOCATOR */ |
63 | |
64 | /* ------------------------------------------------------------------------ */ |
65 | /* Stack */ |
66 | /* ------------------------------------------------------------------------ */ |
67 | |
68 | #if ((defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) \ |
69 | && !(defined SLJIT_UTIL_SIMPLE_STACK_ALLOCATION && SLJIT_UTIL_SIMPLE_STACK_ALLOCATION)) \ |
70 | || ((defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \ |
71 | && !((defined SLJIT_PROT_EXECUTABLE_ALLOCATOR && SLJIT_PROT_EXECUTABLE_ALLOCATOR) \ |
72 | || (defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR))) |
73 | |
74 | #ifndef _WIN32 |
75 | /* Provides mmap function. */ |
76 | #include <sys/types.h> |
77 | #include <sys/mman.h> |
78 | |
79 | #ifndef MAP_ANON |
80 | #ifdef MAP_ANONYMOUS |
81 | #define MAP_ANON MAP_ANONYMOUS |
82 | #endif /* MAP_ANONYMOUS */ |
83 | #endif /* !MAP_ANON */ |
84 | |
85 | #ifndef MAP_ANON |
86 | |
87 | #include <fcntl.h> |
88 | |
89 | #ifdef O_CLOEXEC |
90 | #define SLJIT_CLOEXEC O_CLOEXEC |
91 | #else /* !O_CLOEXEC */ |
92 | #define SLJIT_CLOEXEC 0 |
93 | #endif /* O_CLOEXEC */ |
94 | |
95 | /* Some old systems do not have MAP_ANON. */ |
96 | static int dev_zero = -1; |
97 | |
98 | #if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED) |
99 | |
100 | static SLJIT_INLINE int open_dev_zero(void) |
101 | { |
102 | dev_zero = open("/dev/zero" , O_RDWR | SLJIT_CLOEXEC); |
103 | |
104 | return dev_zero < 0; |
105 | } |
106 | |
107 | #else /* !SLJIT_SINGLE_THREADED */ |
108 | |
109 | #include <pthread.h> |
110 | |
111 | static pthread_mutex_t dev_zero_mutex = PTHREAD_MUTEX_INITIALIZER; |
112 | |
113 | static SLJIT_INLINE int open_dev_zero(void) |
114 | { |
115 | pthread_mutex_lock(&dev_zero_mutex); |
116 | if (SLJIT_UNLIKELY(dev_zero < 0)) |
117 | dev_zero = open("/dev/zero" , O_RDWR | SLJIT_CLOEXEC); |
118 | |
119 | pthread_mutex_unlock(&dev_zero_mutex); |
120 | return dev_zero < 0; |
121 | } |
122 | |
123 | #endif /* SLJIT_SINGLE_THREADED */ |
124 | #undef SLJIT_CLOEXEC |
125 | #endif /* !MAP_ANON */ |
126 | #endif /* !_WIN32 */ |
127 | #endif /* open_dev_zero */ |
128 | |
129 | #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) \ |
130 | || (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) |
131 | |
132 | #ifdef _WIN32 |
133 | |
134 | static SLJIT_INLINE sljit_uw get_page_alignment(void) { |
135 | SYSTEM_INFO si; |
136 | static sljit_uw sljit_page_align = 0; |
137 | if (!sljit_page_align) { |
138 | GetSystemInfo(&si); |
139 | sljit_page_align = (sljit_uw)si.dwPageSize - 1; |
140 | } |
141 | return sljit_page_align; |
142 | } |
143 | |
144 | #else |
145 | |
146 | #include <unistd.h> |
147 | |
148 | static SLJIT_INLINE sljit_uw get_page_alignment(void) { |
149 | static sljit_uw sljit_page_align = 0; |
150 | |
151 | sljit_sw align; |
152 | |
153 | if (!sljit_page_align) { |
154 | #ifdef _SC_PAGESIZE |
155 | align = sysconf(_SC_PAGESIZE); |
156 | #else |
157 | align = getpagesize(); |
158 | #endif |
159 | /* Should never happen. */ |
160 | if (align < 0) |
161 | align = 4096; |
162 | sljit_page_align = (sljit_uw)align - 1; |
163 | } |
164 | return sljit_page_align; |
165 | } |
166 | |
167 | #endif /* _WIN32 */ |
168 | |
169 | #endif /* get_page_alignment() */ |
170 | |
171 | #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) |
172 | |
173 | #if (defined SLJIT_UTIL_SIMPLE_STACK_ALLOCATION && SLJIT_UTIL_SIMPLE_STACK_ALLOCATION) |
174 | |
175 | SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data) |
176 | { |
177 | struct sljit_stack *stack; |
178 | void *ptr; |
179 | |
180 | SLJIT_UNUSED_ARG(allocator_data); |
181 | |
182 | if (start_size > max_size || start_size < 1) |
183 | return NULL; |
184 | |
185 | stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack), allocator_data); |
186 | if (stack == NULL) |
187 | return NULL; |
188 | |
189 | ptr = SLJIT_MALLOC(max_size, allocator_data); |
190 | if (ptr == NULL) { |
191 | SLJIT_FREE(stack, allocator_data); |
192 | return NULL; |
193 | } |
194 | |
195 | stack->min_start = (sljit_u8 *)ptr; |
196 | stack->end = stack->min_start + max_size; |
197 | stack->start = stack->end - start_size; |
198 | stack->top = stack->end; |
199 | return stack; |
200 | } |
201 | |
202 | SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data) |
203 | { |
204 | SLJIT_UNUSED_ARG(allocator_data); |
205 | SLJIT_FREE((void*)stack->min_start, allocator_data); |
206 | SLJIT_FREE(stack, allocator_data); |
207 | } |
208 | |
209 | SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start) |
210 | { |
211 | if ((new_start < stack->min_start) || (new_start >= stack->end)) |
212 | return NULL; |
213 | stack->start = new_start; |
214 | return new_start; |
215 | } |
216 | |
217 | #else /* !SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */ |
218 | |
219 | #ifdef _WIN32 |
220 | |
221 | SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data) |
222 | { |
223 | SLJIT_UNUSED_ARG(allocator_data); |
224 | VirtualFree((void*)stack->min_start, 0, MEM_RELEASE); |
225 | SLJIT_FREE(stack, allocator_data); |
226 | } |
227 | |
228 | #else /* !_WIN32 */ |
229 | |
230 | SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data) |
231 | { |
232 | SLJIT_UNUSED_ARG(allocator_data); |
233 | munmap((void*)stack->min_start, (size_t)(stack->end - stack->min_start)); |
234 | SLJIT_FREE(stack, allocator_data); |
235 | } |
236 | |
237 | #endif /* _WIN32 */ |
238 | |
239 | SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data) |
240 | { |
241 | struct sljit_stack *stack; |
242 | void *ptr; |
243 | sljit_uw page_align; |
244 | |
245 | SLJIT_UNUSED_ARG(allocator_data); |
246 | |
247 | if (start_size > max_size || start_size < 1) |
248 | return NULL; |
249 | |
250 | stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack), allocator_data); |
251 | if (stack == NULL) |
252 | return NULL; |
253 | |
254 | /* Align max_size. */ |
255 | page_align = get_page_alignment(); |
256 | max_size = (max_size + page_align) & ~page_align; |
257 | |
258 | #ifdef _WIN32 |
259 | ptr = VirtualAlloc(NULL, max_size, MEM_RESERVE, PAGE_READWRITE); |
260 | if (!ptr) { |
261 | SLJIT_FREE(stack, allocator_data); |
262 | return NULL; |
263 | } |
264 | |
265 | stack->min_start = (sljit_u8 *)ptr; |
266 | stack->end = stack->min_start + max_size; |
267 | stack->start = stack->end; |
268 | |
269 | if (sljit_stack_resize(stack, stack->end - start_size) == NULL) { |
270 | sljit_free_stack(stack, allocator_data); |
271 | return NULL; |
272 | } |
273 | #else /* !_WIN32 */ |
274 | #ifdef MAP_ANON |
275 | ptr = mmap(NULL, max_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); |
276 | #else /* !MAP_ANON */ |
277 | if (SLJIT_UNLIKELY((dev_zero < 0) && open_dev_zero())) { |
278 | SLJIT_FREE(stack, allocator_data); |
279 | return NULL; |
280 | } |
281 | ptr = mmap(NULL, max_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, dev_zero, 0); |
282 | #endif /* MAP_ANON */ |
283 | if (ptr == MAP_FAILED) { |
284 | SLJIT_FREE(stack, allocator_data); |
285 | return NULL; |
286 | } |
287 | stack->min_start = (sljit_u8 *)ptr; |
288 | stack->end = stack->min_start + max_size; |
289 | stack->start = stack->end - start_size; |
290 | #endif /* _WIN32 */ |
291 | |
292 | stack->top = stack->end; |
293 | return stack; |
294 | } |
295 | |
296 | SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start) |
297 | { |
298 | #if defined _WIN32 || defined(POSIX_MADV_DONTNEED) |
299 | sljit_uw aligned_old_start; |
300 | sljit_uw aligned_new_start; |
301 | sljit_uw page_align; |
302 | #endif |
303 | |
304 | if ((new_start < stack->min_start) || (new_start >= stack->end)) |
305 | return NULL; |
306 | |
307 | #ifdef _WIN32 |
308 | page_align = get_page_alignment(); |
309 | |
310 | aligned_new_start = (sljit_uw)new_start & ~page_align; |
311 | aligned_old_start = ((sljit_uw)stack->start) & ~page_align; |
312 | if (aligned_new_start != aligned_old_start) { |
313 | if (aligned_new_start < aligned_old_start) { |
314 | if (!VirtualAlloc((void*)aligned_new_start, aligned_old_start - aligned_new_start, MEM_COMMIT, PAGE_READWRITE)) |
315 | return NULL; |
316 | } |
317 | else { |
318 | if (!VirtualFree((void*)aligned_old_start, aligned_new_start - aligned_old_start, MEM_DECOMMIT)) |
319 | return NULL; |
320 | } |
321 | } |
322 | #elif defined(POSIX_MADV_DONTNEED) |
323 | if (stack->start < new_start) { |
324 | page_align = get_page_alignment(); |
325 | |
326 | aligned_new_start = (sljit_uw)new_start & ~page_align; |
327 | aligned_old_start = ((sljit_uw)stack->start) & ~page_align; |
328 | |
329 | if (aligned_new_start > aligned_old_start) { |
330 | posix_madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, POSIX_MADV_DONTNEED); |
331 | #ifdef MADV_FREE |
332 | madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, MADV_FREE); |
333 | #endif /* MADV_FREE */ |
334 | } |
335 | } |
336 | #endif /* _WIN32 */ |
337 | |
338 | stack->start = new_start; |
339 | return new_start; |
340 | } |
341 | |
342 | #endif /* SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */ |
343 | |
344 | #endif /* SLJIT_UTIL_STACK */ |
345 | |