trunk/sljit/sljitUtils.c

/*
 *    Stack-less Just-In-Time compiler
 *
 *    Copyright 2009-2010 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright notice, this list of
 *      conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright notice, this list
 *      of conditions and the following disclaimer in the documentation and/or other materials
 *      provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* ------------------------------------------------------------------------ */
/*  Locks                                                                   */
/* ------------------------------------------------------------------------ */

#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) || (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK)

#ifdef _WIN32

#include "windows.h"

#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)

static HANDLE allocator_mutex = 0;

static SLJIT_INLINE void allocator_grab_lock(void)
{
        /* No idea what to do if an error occures. Static mutexes should never fail... */
        if (!allocator_mutex)
                allocator_mutex = CreateMutex(NULL, TRUE, NULL);
        else
                WaitForSingleObject(allocator_mutex, INFINITE);
}

static SLJIT_INLINE void allocator_release_lock(void)
{
        ReleaseMutex(allocator_mutex);
}

#endif /* SLJIT_EXECUTABLE_ALLOCATOR */

#if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK)

static HANDLE global_mutex = 0;

void SLJIT_CALL sljit_grab_lock(void)
{
        /* No idea what to do if an error occures. Static mutexes should never fail... */
        if (!global_mutex)
                global_mutex = CreateMutex(NULL, TRUE, NULL);
        else
                WaitForSingleObject(global_mutex, INFINITE);
}

void SLJIT_CALL sljit_release_lock(void)
{
        ReleaseMutex(global_mutex);
}

#endif /* SLJIT_UTIL_GLOBAL_LOCK */

#else /* _WIN32 */

#include "pthread.h"

#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)

static pthread_mutex_t allocator_mutex = PTHREAD_MUTEX_INITIALIZER;

static SLJIT_INLINE void allocator_grab_lock(void)
{
        pthread_mutex_lock(&allocator_mutex);
}

static SLJIT_INLINE void allocator_release_lock(void)
{
        pthread_mutex_unlock(&allocator_mutex);
}

#endif /* SLJIT_EXECUTABLE_ALLOCATOR */

#if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK)

static pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER;

void SLJIT_CALL sljit_grab_lock(void)
{
        pthread_mutex_lock(&global_mutex);
}

void SLJIT_CALL sljit_release_lock(void)
{
        pthread_mutex_unlock(&global_mutex);
}

#endif /* SLJIT_UTIL_GLOBAL_LOCK */

#endif /* _WIN32 */

/* ------------------------------------------------------------------------ */
/*  Stack                                                                   */
/* ------------------------------------------------------------------------ */

#if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)

#ifdef _WIN32
#include "windows.h"
#else
#include <sys/mman.h>
#include <unistd.h>
#endif

/* Planning to make it even more clever in the future. */
static sljit_w sljit_page_align = 0;

struct sljit_stack* SLJIT_CALL sljit_allocate_stack(sljit_w limit, sljit_w max_limit)
{
        struct sljit_stack *stack;
        union {
                void *ptr;
                sljit_uw uw;
        } base;
#ifdef _WIN32
        SYSTEM_INFO si;
#endif

        if (limit > max_limit)
                return NULL;

#ifdef _WIN32
        if (!sljit_page_align) {
                GetSystemInfo(&si);
                sljit_page_align = si.dwPageSize - 1;
        }
#else
        if (!sljit_page_align) {
                sljit_page_align = sysconf(_SC_PAGESIZE);
                /* Should never happen. */
                if (sljit_page_align < 0)
                        sljit_page_align = 4096;
                sljit_page_align--;
        }
#endif

        /* Align limit and max_limit. */
        max_limit = (max_limit + sljit_page_align) & ~sljit_page_align;

        stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack));
        if (!stack)
                return NULL;

#ifdef _WIN32
        base.ptr = VirtualAlloc(0, max_limit, MEM_RESERVE, PAGE_READWRITE);
        if (!base.ptr) {
                SLJIT_FREE(stack);
                return NULL;
        }
        stack->base = base.uw;
        stack->limit = stack->base;
        stack->max_limit = stack->base + max_limit;
        if (sljit_stack_resize(stack, stack->base + limit)) {
                sljit_free_stack(stack);
                return NULL;
        }
#else
        base.ptr = mmap(0, max_limit, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
        if (base.ptr == MAP_FAILED) {
                SLJIT_FREE(stack);
                return NULL;
        }
        stack->base = base.uw;
        stack->limit = stack->base + limit;
        stack->max_limit = stack->base + max_limit;
#endif
        stack->top = stack->base;
        return stack;
}

#undef PAGE_ALIGN

void SLJIT_CALL sljit_free_stack(struct sljit_stack* stack)
{
#ifdef _WIN32
        VirtualFree((void*)stack->base, 0, MEM_RELEASE);
#else
        munmap((void*)stack->base, stack->max_limit - stack->base);
#endif
        SLJIT_FREE(stack);
}

sljit_w SLJIT_CALL sljit_stack_resize(struct sljit_stack* stack, sljit_uw new_limit)
{
        sljit_uw aligned_old_limit;
        sljit_uw aligned_new_limit;

        if ((new_limit > stack->max_limit) || (new_limit < stack->base))
                return -1;
#ifdef _WIN32
        aligned_new_limit = (new_limit + sljit_page_align) & ~sljit_page_align;
        aligned_old_limit = (stack->limit + sljit_page_align) & ~sljit_page_align;
        if (aligned_new_limit != aligned_old_limit) {
                if (aligned_new_limit > aligned_old_limit) {
                        if (!VirtualAlloc((void*)aligned_old_limit, aligned_new_limit - aligned_old_limit, MEM_COMMIT, PAGE_READWRITE))
                                return -1;
                }
                else {
                        if (!VirtualFree((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MEM_DECOMMIT))
                                return -1;
                }
        }
        stack->limit = new_limit;
        return 0;
#else
        if (new_limit >= stack->limit) {
                stack->limit = new_limit;
                return 0;
        }
        aligned_new_limit = (new_limit + sljit_page_align) & ~sljit_page_align;
        aligned_old_limit = (stack->limit + sljit_page_align) & ~sljit_page_align;
        if (aligned_new_limit < aligned_old_limit)
                madvise((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MADV_DONTNEED);
        stack->limit = new_limit;
        return 0;
#endif
}

#endif /* SLJIT_UTIL_STACK */

#endif
1	/*
2	* Stack-less Just-In-Time compiler
3	*
4	* Copyright 2009-2010 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	#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \|\| (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK)
32
33	#ifdef _WIN32
34
35	#include "windows.h"
36
37	#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
38
39	static HANDLE allocator_mutex = 0;
40
41	static SLJIT_INLINE void allocator_grab_lock(void)
42	{
43	/* No idea what to do if an error occures. Static mutexes should never fail... */
44	if (!allocator_mutex)
45	allocator_mutex = CreateMutex(NULL, TRUE, NULL);
46	else
47	WaitForSingleObject(allocator_mutex, INFINITE);
48	}
49
50	static SLJIT_INLINE void allocator_release_lock(void)
51	{
52	ReleaseMutex(allocator_mutex);
53	}
54
55	#endif /* SLJIT_EXECUTABLE_ALLOCATOR */
56
57	#if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK)
58
59	static HANDLE global_mutex = 0;
60
61	void SLJIT_CALL sljit_grab_lock(void)
62	{
63	/* No idea what to do if an error occures. Static mutexes should never fail... */
64	if (!global_mutex)
65	global_mutex = CreateMutex(NULL, TRUE, NULL);
66	else
67	WaitForSingleObject(global_mutex, INFINITE);
68	}
69
70	void SLJIT_CALL sljit_release_lock(void)
71	{
72	ReleaseMutex(global_mutex);
73	}
74
75	#endif /* SLJIT_UTIL_GLOBAL_LOCK */
76
77	#else /* _WIN32 */
78
79	#include "pthread.h"
80
81	#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
82
83	static pthread_mutex_t allocator_mutex = PTHREAD_MUTEX_INITIALIZER;
84
85	static SLJIT_INLINE void allocator_grab_lock(void)
86	{
87	pthread_mutex_lock(&allocator_mutex);
88	}
89
90	static SLJIT_INLINE void allocator_release_lock(void)
91	{
92	pthread_mutex_unlock(&allocator_mutex);
93	}
94
95	#endif /* SLJIT_EXECUTABLE_ALLOCATOR */
96
97	#if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK)
98
99	static pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER;
100
101	void SLJIT_CALL sljit_grab_lock(void)
102	{
103	pthread_mutex_lock(&global_mutex);
104	}
105
106	void SLJIT_CALL sljit_release_lock(void)
107	{
108	pthread_mutex_unlock(&global_mutex);
109	}
110
111	#endif /* SLJIT_UTIL_GLOBAL_LOCK */
112
113	#endif /* _WIN32 */
114
115	/* ------------------------------------------------------------------------ */
116	/* Stack */
117	/* ------------------------------------------------------------------------ */
118
119	#if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)
120
121	#ifdef _WIN32
122	#include "windows.h"
123	#else
124	#include <sys/mman.h>
125	#include <unistd.h>
126	#endif
127
128	/* Planning to make it even more clever in the future. */
129	static sljit_w sljit_page_align = 0;
130
131	struct sljit_stack* SLJIT_CALL sljit_allocate_stack(sljit_w limit, sljit_w max_limit)
132	{
133	struct sljit_stack *stack;
134	union {
135	void *ptr;
136	sljit_uw uw;
137	} base;
138	#ifdef _WIN32
139	SYSTEM_INFO si;
140	#endif
141
142	if (limit > max_limit)
143	return NULL;
144
145	#ifdef _WIN32
146	if (!sljit_page_align) {
147	GetSystemInfo(&si);
148	sljit_page_align = si.dwPageSize - 1;
149	}
150	#else
151	if (!sljit_page_align) {
152	sljit_page_align = sysconf(_SC_PAGESIZE);
153	/* Should never happen. */
154	if (sljit_page_align < 0)
155	sljit_page_align = 4096;
156	sljit_page_align--;
157	}
158	#endif
159
160	/* Align limit and max_limit. */
161	max_limit = (max_limit + sljit_page_align) & ~sljit_page_align;
162
163	stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack));
164	if (!stack)
165	return NULL;
166
167	#ifdef _WIN32
168	base.ptr = VirtualAlloc(0, max_limit, MEM_RESERVE, PAGE_READWRITE);
169	if (!base.ptr) {
170	SLJIT_FREE(stack);
171	return NULL;
172	}
173	stack->base = base.uw;
174	stack->limit = stack->base;
175	stack->max_limit = stack->base + max_limit;
176	if (sljit_stack_resize(stack, stack->base + limit)) {
177	sljit_free_stack(stack);
178	return NULL;
179	}
180	#else
181	base.ptr = mmap(0, max_limit, PROT_READ \| PROT_WRITE, MAP_PRIVATE \| MAP_ANON, -1, 0);
182	if (base.ptr == MAP_FAILED) {
183	SLJIT_FREE(stack);
184	return NULL;
185	}
186	stack->base = base.uw;
187	stack->limit = stack->base + limit;
188	stack->max_limit = stack->base + max_limit;
189	#endif
190	stack->top = stack->base;
191	return stack;
192	}
193
194	#undef PAGE_ALIGN
195
196	void SLJIT_CALL sljit_free_stack(struct sljit_stack* stack)
197	{
198	#ifdef _WIN32
199	VirtualFree((void*)stack->base, 0, MEM_RELEASE);
200	#else
201	munmap((void*)stack->base, stack->max_limit - stack->base);
202	#endif
203	SLJIT_FREE(stack);
204	}
205
206	sljit_w SLJIT_CALL sljit_stack_resize(struct sljit_stack* stack, sljit_uw new_limit)
207	{
208	sljit_uw aligned_old_limit;
209	sljit_uw aligned_new_limit;
210
211	if ((new_limit > stack->max_limit) \|\| (new_limit < stack->base))
212	return -1;
213	#ifdef _WIN32
214	aligned_new_limit = (new_limit + sljit_page_align) & ~sljit_page_align;
215	aligned_old_limit = (stack->limit + sljit_page_align) & ~sljit_page_align;
216	if (aligned_new_limit != aligned_old_limit) {
217	if (aligned_new_limit > aligned_old_limit) {
218	if (!VirtualAlloc((void*)aligned_old_limit, aligned_new_limit - aligned_old_limit, MEM_COMMIT, PAGE_READWRITE))
219	return -1;
220	}
221	else {
222	if (!VirtualFree((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MEM_DECOMMIT))
223	return -1;
224	}
225	}
226	stack->limit = new_limit;
227	return 0;
228	#else
229	if (new_limit >= stack->limit) {
230	stack->limit = new_limit;
231	return 0;
232	}
233	aligned_new_limit = (new_limit + sljit_page_align) & ~sljit_page_align;
234	aligned_old_limit = (stack->limit + sljit_page_align) & ~sljit_page_align;
235	if (aligned_new_limit < aligned_old_limit)
236	madvise((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MADV_DONTNEED);
237	stack->limit = new_limit;
238	return 0;
239	#endif
240	}
241
242	#endif /* SLJIT_UTIL_STACK */
243
244	#endif