1 /* 2 * Stack-less Just-In-Time compiler 3 * 4 * Copyright 2009-2012 Zoltan Herczeg (hzmester (at) 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 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) || (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK) 32 33 #if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED) 34 35 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) 36 37 static SLJIT_INLINE void allocator_grab_lock(void) 38 { 39 /* Always successful. */ 40 } 41 42 static SLJIT_INLINE void allocator_release_lock(void) 43 { 44 /* Always successful. */ 45 } 46 47 #endif /* SLJIT_EXECUTABLE_ALLOCATOR */ 48 49 #if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK) 50 51 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_grab_lock(void) 52 { 53 /* Always successful. */ 54 } 55 56 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_release_lock(void) 57 { 58 /* Always successful. */ 59 } 60 61 #endif /* SLJIT_UTIL_GLOBAL_LOCK */ 62 63 #elif defined(_WIN32) /* SLJIT_SINGLE_THREADED */ 64 65 #include "windows.h" 66 67 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) 68 69 static HANDLE allocator_mutex = 0; 70 71 static SLJIT_INLINE void allocator_grab_lock(void) 72 { 73 /* No idea what to do if an error occures. Static mutexes should never fail... */ 74 if (!allocator_mutex) 75 allocator_mutex = CreateMutex(NULL, TRUE, NULL); 76 else 77 WaitForSingleObject(allocator_mutex, INFINITE); 78 } 79 80 static SLJIT_INLINE void allocator_release_lock(void) 81 { 82 ReleaseMutex(allocator_mutex); 83 } 84 85 #endif /* SLJIT_EXECUTABLE_ALLOCATOR */ 86 87 #if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK) 88 89 static HANDLE global_mutex = 0; 90 91 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_grab_lock(void) 92 { 93 /* No idea what to do if an error occures. Static mutexes should never fail... */ 94 if (!global_mutex) 95 global_mutex = CreateMutex(NULL, TRUE, NULL); 96 else 97 WaitForSingleObject(global_mutex, INFINITE); 98 } 99 100 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_release_lock(void) 101 { 102 ReleaseMutex(global_mutex); 103 } 104 105 #endif /* SLJIT_UTIL_GLOBAL_LOCK */ 106 107 #else /* _WIN32 */ 108 109 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) 110 111 #include <pthread.h> 112 113 static pthread_mutex_t allocator_mutex = PTHREAD_MUTEX_INITIALIZER; 114 115 static SLJIT_INLINE void allocator_grab_lock(void) 116 { 117 pthread_mutex_lock(&allocator_mutex); 118 } 119 120 static SLJIT_INLINE void allocator_release_lock(void) 121 { 122 pthread_mutex_unlock(&allocator_mutex); 123 } 124 125 #endif /* SLJIT_EXECUTABLE_ALLOCATOR */ 126 127 #if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK) 128 129 #include <pthread.h> 130 131 static pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER; 132 133 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_grab_lock(void) 134 { 135 pthread_mutex_lock(&global_mutex); 136 } 137 138 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_release_lock(void) 139 { 140 pthread_mutex_unlock(&global_mutex); 141 } 142 143 #endif /* SLJIT_UTIL_GLOBAL_LOCK */ 144 145 #endif /* _WIN32 */ 146 147 /* ------------------------------------------------------------------------ */ 148 /* Stack */ 149 /* ------------------------------------------------------------------------ */ 150 151 #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) || (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) 152 153 #ifdef _WIN32 154 #include "windows.h" 155 #else 156 /* Provides mmap function. */ 157 #include <sys/mman.h> 158 /* For detecting the page size. */ 159 #include <unistd.h> 160 161 #ifndef MAP_ANON 162 163 #include <fcntl.h> 164 165 /* Some old systems does not have MAP_ANON. */ 166 static sljit_s32 dev_zero = -1; 167 168 #if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED) 169 170 static SLJIT_INLINE sljit_s32 open_dev_zero(void) 171 { 172 dev_zero = open("/dev/zero", O_RDWR); 173 return dev_zero < 0; 174 } 175 176 #else /* SLJIT_SINGLE_THREADED */ 177 178 #include <pthread.h> 179 180 static pthread_mutex_t dev_zero_mutex = PTHREAD_MUTEX_INITIALIZER; 181 182 static SLJIT_INLINE sljit_s32 open_dev_zero(void) 183 { 184 pthread_mutex_lock(&dev_zero_mutex); 185 /* The dev_zero might be initialized by another thread during the waiting. */ 186 if (dev_zero < 0) { 187 dev_zero = open("/dev/zero", O_RDWR); 188 } 189 pthread_mutex_unlock(&dev_zero_mutex); 190 return dev_zero < 0; 191 } 192 193 #endif /* SLJIT_SINGLE_THREADED */ 194 195 #endif 196 197 #endif 198 199 #endif /* SLJIT_UTIL_STACK || SLJIT_EXECUTABLE_ALLOCATOR */ 200 201 #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) 202 203 /* Planning to make it even more clever in the future. */ 204 static sljit_sw sljit_page_align = 0; 205 206 SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_CALL sljit_allocate_stack(sljit_uw limit, sljit_uw max_limit, void *allocator_data) 207 { 208 struct sljit_stack *stack; 209 union { 210 void *ptr; 211 sljit_uw uw; 212 } base; 213 #ifdef _WIN32 214 SYSTEM_INFO si; 215 #endif 216 217 SLJIT_UNUSED_ARG(allocator_data); 218 if (limit > max_limit || limit < 1) 219 return NULL; 220 221 #ifdef _WIN32 222 if (!sljit_page_align) { 223 GetSystemInfo(&si); 224 sljit_page_align = si.dwPageSize - 1; 225 } 226 #else 227 if (!sljit_page_align) { 228 sljit_page_align = sysconf(_SC_PAGESIZE); 229 /* Should never happen. */ 230 if (sljit_page_align < 0) 231 sljit_page_align = 4096; 232 sljit_page_align--; 233 } 234 #endif 235 236 /* Align limit and max_limit. */ 237 max_limit = (max_limit + sljit_page_align) & ~sljit_page_align; 238 239 stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack), allocator_data); 240 if (!stack) 241 return NULL; 242 243 #ifdef _WIN32 244 base.ptr = VirtualAlloc(NULL, max_limit, MEM_RESERVE, PAGE_READWRITE); 245 if (!base.ptr) { 246 SLJIT_FREE(stack, allocator_data); 247 return NULL; 248 } 249 stack->base = base.uw; 250 stack->limit = stack->base; 251 stack->max_limit = stack->base + max_limit; 252 if (sljit_stack_resize(stack, stack->base + limit)) { 253 sljit_free_stack(stack, allocator_data); 254 return NULL; 255 } 256 #else 257 #ifdef MAP_ANON 258 base.ptr = mmap(NULL, max_limit, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); 259 #else 260 if (dev_zero < 0) { 261 if (open_dev_zero()) { 262 SLJIT_FREE(stack, allocator_data); 263 return NULL; 264 } 265 } 266 base.ptr = mmap(NULL, max_limit, PROT_READ | PROT_WRITE, MAP_PRIVATE, dev_zero, 0); 267 #endif 268 if (base.ptr == MAP_FAILED) { 269 SLJIT_FREE(stack, allocator_data); 270 return NULL; 271 } 272 stack->base = base.uw; 273 stack->limit = stack->base + limit; 274 stack->max_limit = stack->base + max_limit; 275 #endif 276 stack->top = stack->base; 277 return stack; 278 } 279 280 #undef PAGE_ALIGN 281 282 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_free_stack(struct sljit_stack* stack, void *allocator_data) 283 { 284 SLJIT_UNUSED_ARG(allocator_data); 285 #ifdef _WIN32 286 VirtualFree((void*)stack->base, 0, MEM_RELEASE); 287 #else 288 munmap((void*)stack->base, stack->max_limit - stack->base); 289 #endif 290 SLJIT_FREE(stack, allocator_data); 291 } 292 293 SLJIT_API_FUNC_ATTRIBUTE sljit_sw SLJIT_CALL sljit_stack_resize(struct sljit_stack* stack, sljit_uw new_limit) 294 { 295 sljit_uw aligned_old_limit; 296 sljit_uw aligned_new_limit; 297 298 if ((new_limit > stack->max_limit) || (new_limit < stack->base)) 299 return -1; 300 #ifdef _WIN32 301 aligned_new_limit = (new_limit + sljit_page_align) & ~sljit_page_align; 302 aligned_old_limit = (stack->limit + sljit_page_align) & ~sljit_page_align; 303 if (aligned_new_limit != aligned_old_limit) { 304 if (aligned_new_limit > aligned_old_limit) { 305 if (!VirtualAlloc((void*)aligned_old_limit, aligned_new_limit - aligned_old_limit, MEM_COMMIT, PAGE_READWRITE)) 306 return -1; 307 } 308 else { 309 if (!VirtualFree((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MEM_DECOMMIT)) 310 return -1; 311 } 312 } 313 stack->limit = new_limit; 314 return 0; 315 #else 316 if (new_limit >= stack->limit) { 317 stack->limit = new_limit; 318 return 0; 319 } 320 aligned_new_limit = (new_limit + sljit_page_align) & ~sljit_page_align; 321 aligned_old_limit = (stack->limit + sljit_page_align) & ~sljit_page_align; 322 /* If madvise is available, we release the unnecessary space. */ 323 #if defined(MADV_DONTNEED) 324 if (aligned_new_limit < aligned_old_limit) 325 madvise((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MADV_DONTNEED); 326 #elif defined(POSIX_MADV_DONTNEED) 327 if (aligned_new_limit < aligned_old_limit) 328 posix_madvise((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, POSIX_MADV_DONTNEED); 329 #endif 330 stack->limit = new_limit; 331 return 0; 332 #endif 333 } 334 335 #endif /* SLJIT_UTIL_STACK */ 336 337 #endif 338
