/src/pcre2/deps/sljit/sljit_src/sljitUtils.c

Source (jump to first uncovered line)
/*
 *    Stack-less Just-In-Time compiler
 *
 *    Copyright 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                                                                   */
/* ------------------------------------------------------------------------ */

/* Executable Allocator */

#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \
  && !(defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR)
#if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED)
#define SLJIT_ALLOCATOR_LOCK()
#define SLJIT_ALLOCATOR_UNLOCK()
#elif !(defined _WIN32)
#include <pthread.h>

static pthread_mutex_t allocator_lock = PTHREAD_MUTEX_INITIALIZER;

#define SLJIT_ALLOCATOR_LOCK() pthread_mutex_lock(&allocator_lock)
#define SLJIT_ALLOCATOR_UNLOCK() pthread_mutex_unlock(&allocator_lock)
#else /* windows */
static HANDLE allocator_lock;

static SLJIT_INLINE void allocator_grab_lock(void)
{
  HANDLE lock;
  if (SLJIT_UNLIKELY(!InterlockedCompareExchangePointer(&allocator_lock, NULL, NULL))) {
    lock = CreateMutex(NULL, FALSE, NULL);
    if (InterlockedCompareExchangePointer(&allocator_lock, lock, NULL))
      CloseHandle(lock);
  }
  WaitForSingleObject(allocator_lock, INFINITE);
}

#define SLJIT_ALLOCATOR_LOCK() allocator_grab_lock()
#define SLJIT_ALLOCATOR_UNLOCK() ReleaseMutex(allocator_lock)
#endif /* thread implementation */
#endif /* SLJIT_EXECUTABLE_ALLOCATOR && !SLJIT_WX_EXECUTABLE_ALLOCATOR */

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

#if ((defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) \
  && !(defined SLJIT_UTIL_SIMPLE_STACK_ALLOCATION && SLJIT_UTIL_SIMPLE_STACK_ALLOCATION)) \
  || ((defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) \
  && !((defined SLJIT_PROT_EXECUTABLE_ALLOCATOR && SLJIT_PROT_EXECUTABLE_ALLOCATOR) \
  || (defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR)))

#ifndef _WIN32
/* Provides mmap function. */
#include <sys/types.h>
#include <sys/mman.h>

#ifndef MAP_ANON
#ifdef MAP_ANONYMOUS
#define MAP_ANON MAP_ANONYMOUS
#endif /* MAP_ANONYMOUS */
#endif /* !MAP_ANON */

#ifndef MAP_ANON

#include <fcntl.h>

#ifdef O_CLOEXEC
#define SLJIT_CLOEXEC O_CLOEXEC
#else /* !O_CLOEXEC */
#define SLJIT_CLOEXEC 0
#endif /* O_CLOEXEC */

/* Some old systems do not have MAP_ANON. */
static int dev_zero = -1;

#if (defined SLJIT_SINGLE_THREADED && SLJIT_SINGLE_THREADED)

static SLJIT_INLINE int open_dev_zero(void)
{
  dev_zero = open("/dev/zero", O_RDWR | SLJIT_CLOEXEC);

  return dev_zero < 0;
}

#else /* !SLJIT_SINGLE_THREADED */

#include <pthread.h>

static pthread_mutex_t dev_zero_mutex = PTHREAD_MUTEX_INITIALIZER;

static SLJIT_INLINE int open_dev_zero(void)
{
  pthread_mutex_lock(&dev_zero_mutex);
  if (SLJIT_UNLIKELY(dev_zero < 0))
    dev_zero = open("/dev/zero", O_RDWR | SLJIT_CLOEXEC);

  pthread_mutex_unlock(&dev_zero_mutex);
  return dev_zero < 0;
}

#endif /* SLJIT_SINGLE_THREADED */
#undef SLJIT_CLOEXEC
#endif /* !MAP_ANON */
#endif /* !_WIN32 */
#endif /* open_dev_zero */

#if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) \
  || (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)

#ifdef _WIN32

static SLJIT_INLINE sljit_uw get_page_alignment(void) {
  SYSTEM_INFO si;
  static sljit_uw sljit_page_align = 0;
  if (!sljit_page_align) {
    GetSystemInfo(&si);
    sljit_page_align = (sljit_uw)si.dwPageSize - 1;
  }
  return sljit_page_align;
}

#else

#include <unistd.h>

static SLJIT_INLINE sljit_uw get_page_alignment(void) {
  static sljit_uw sljit_page_align = 0;

  sljit_sw align;

  if (!sljit_page_align) {
#ifdef _SC_PAGESIZE
    align = sysconf(_SC_PAGESIZE);
#else
    align = getpagesize();
#endif
    /* Should never happen. */
    if (align < 0)
      align = 4096;
    sljit_page_align = (sljit_uw)align - 1;
  }
  return sljit_page_align;
}

#endif /* _WIN32 */

#endif /* get_page_alignment() */

#if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)

#if (defined SLJIT_UTIL_SIMPLE_STACK_ALLOCATION && SLJIT_UTIL_SIMPLE_STACK_ALLOCATION)

SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data)
{
  struct sljit_stack *stack;
  void *ptr;

  SLJIT_UNUSED_ARG(allocator_data);

  if (start_size > max_size || start_size < 1)
    return NULL;

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

  ptr = SLJIT_MALLOC(max_size, allocator_data);
  if (ptr == NULL) {
    SLJIT_FREE(stack, allocator_data);
    return NULL;
  }

  stack->min_start = (sljit_u8 *)ptr;
  stack->end = stack->min_start + max_size;
  stack->start = stack->end - start_size;
  stack->top = stack->end;
  return stack;
}

SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
{
  SLJIT_UNUSED_ARG(allocator_data);
  SLJIT_FREE((void*)stack->min_start, allocator_data);
  SLJIT_FREE(stack, allocator_data);
}

SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start)
{
  if ((new_start < stack->min_start) || (new_start >= stack->end))
    return NULL;
  stack->start = new_start;
  return new_start;
}

#else /* !SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */

#ifdef _WIN32

SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
{
  SLJIT_UNUSED_ARG(allocator_data);
  VirtualFree((void*)stack->min_start, 0, MEM_RELEASE);
  SLJIT_FREE(stack, allocator_data);
}

#else /* !_WIN32 */

SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data)
{
  SLJIT_UNUSED_ARG(allocator_data);
  munmap((void*)stack->min_start, (size_t)(stack->end - stack->min_start));
  SLJIT_FREE(stack, allocator_data);
}

#endif /* _WIN32 */

SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data)
{
  struct sljit_stack *stack;
  void *ptr;
  sljit_uw page_align;

  SLJIT_UNUSED_ARG(allocator_data);

  if (start_size > max_size || start_size < 1)
    return NULL;

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

  /* Align max_size. */
  page_align = get_page_alignment();
  max_size = (max_size + page_align) & ~page_align;

#ifdef _WIN32
  ptr = VirtualAlloc(NULL, max_size, MEM_RESERVE, PAGE_READWRITE);
  if (!ptr) {
    SLJIT_FREE(stack, allocator_data);
    return NULL;
  }

  stack->min_start = (sljit_u8 *)ptr;
  stack->end = stack->min_start + max_size;
  stack->start = stack->end;

  if (sljit_stack_resize(stack, stack->end - start_size) == NULL) {
    sljit_free_stack(stack, allocator_data);
    return NULL;
  }
#else /* !_WIN32 */
#ifdef MAP_ANON
  ptr = mmap(NULL, max_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
#else /* !MAP_ANON */
  if (SLJIT_UNLIKELY((dev_zero < 0) && open_dev_zero())) {
    SLJIT_FREE(stack, allocator_data);
    return NULL;
  }
  ptr = mmap(NULL, max_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, dev_zero, 0);
#endif /* MAP_ANON */
  if (ptr == MAP_FAILED) {
    SLJIT_FREE(stack, allocator_data);
    return NULL;
  }
  stack->min_start = (sljit_u8 *)ptr;
  stack->end = stack->min_start + max_size;
  stack->start = stack->end - start_size;
#endif /* _WIN32 */

  stack->top = stack->end;
  return stack;
}

SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start)
{
#if defined _WIN32 || defined(POSIX_MADV_DONTNEED)
  sljit_uw aligned_old_start;
  sljit_uw aligned_new_start;
  sljit_uw page_align;
#endif

  if ((new_start < stack->min_start) || (new_start >= stack->end))
    return NULL;

#ifdef _WIN32
  page_align = get_page_alignment();

  aligned_new_start = (sljit_uw)new_start & ~page_align;
  aligned_old_start = ((sljit_uw)stack->start) & ~page_align;
  if (aligned_new_start != aligned_old_start) {
    if (aligned_new_start < aligned_old_start) {
      if (!VirtualAlloc((void*)aligned_new_start, aligned_old_start - aligned_new_start, MEM_COMMIT, PAGE_READWRITE))
        return NULL;
    }
    else {
      if (!VirtualFree((void*)aligned_old_start, aligned_new_start - aligned_old_start, MEM_DECOMMIT))
        return NULL;
    }
  }
#elif defined(POSIX_MADV_DONTNEED)
  if (stack->start < new_start) {
    page_align = get_page_alignment();

    aligned_new_start = (sljit_uw)new_start & ~page_align;
    aligned_old_start = ((sljit_uw)stack->start) & ~page_align;

    if (aligned_new_start > aligned_old_start) {
      posix_madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, POSIX_MADV_DONTNEED);
#ifdef MADV_FREE
      madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, MADV_FREE);
#endif /* MADV_FREE */
    }
  }
#endif /* _WIN32 */

  stack->start = new_start;
  return new_start;
}

#endif /* SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */

#endif /* SLJIT_UTIL_STACK */

Coverage Report

Created: 2025-07-11 06:27

Line	Count	Source (jump to first uncovered line)
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	1.16M	#define SLJIT_ALLOCATOR_LOCK() pthread_mutex_lock(&allocator_lock)
44	1.16M	#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	0	static SLJIT_INLINE sljit_uw get_page_alignment(void) {
149	0	static sljit_uw sljit_page_align = 0;
150
151	0	sljit_sw align;
152
153	0	if (!sljit_page_align) {
154	0	#ifdef _SC_PAGESIZE
155	0	align = sysconf(_SC_PAGESIZE);
156		#else
157		align = getpagesize();
158		#endif
159		/* Should never happen. */
160	0	if (align < 0)
161	0	align = 4096;
162	0	sljit_page_align = (sljit_uw)align - 1;
163	0	}
164	0	return sljit_page_align;
165	0	}
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	0	{
232	0	SLJIT_UNUSED_ARG(allocator_data);
233	0	munmap((void*)stack->min_start, (size_t)(stack->end - stack->min_start));
234	0	SLJIT_FREE(stack, allocator_data);
235	0	}
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	0	{
241	0	struct sljit_stack *stack;
242	0	void *ptr;
243	0	sljit_uw page_align;
244
245	0	SLJIT_UNUSED_ARG(allocator_data);
246
247	0	if (start_size > max_size \|\| start_size < 1)
248	0	return NULL;
249
250	0	stack = (struct sljit_stack*)SLJIT_MALLOC(sizeof(struct sljit_stack), allocator_data);
251	0	if (stack == NULL)
252	0	return NULL;
253
254		/* Align max_size. */
255	0	page_align = get_page_alignment();
256	0	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	0	#ifdef MAP_ANON
275	0	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	0	if (ptr == MAP_FAILED) {
284	0	SLJIT_FREE(stack, allocator_data);
285	0	return NULL;
286	0	}
287	0	stack->min_start = (sljit_u8 *)ptr;
288	0	stack->end = stack->min_start + max_size;
289	0	stack->start = stack->end - start_size;
290	0	#endif /* _WIN32 */
291
292	0	stack->top = stack->end;
293	0	return stack;
294	0	}
295
296		SLJIT_API_FUNC_ATTRIBUTE sljit_u8 SLJIT_FUNC sljit_stack_resize(struct sljit_stack stack, sljit_u8 *new_start)
297	0	{
298	0	#if defined _WIN32 \|\| defined(POSIX_MADV_DONTNEED)
299	0	sljit_uw aligned_old_start;
300	0	sljit_uw aligned_new_start;
301	0	sljit_uw page_align;
302	0	#endif
303
304	0	if ((new_start < stack->min_start) \|\| (new_start >= stack->end))
305	0	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	0	if (stack->start < new_start) {
324	0	page_align = get_page_alignment();
325
326	0	aligned_new_start = (sljit_uw)new_start & ~page_align;
327	0	aligned_old_start = ((sljit_uw)stack->start) & ~page_align;
328
329	0	if (aligned_new_start > aligned_old_start) {
330	0	posix_madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, POSIX_MADV_DONTNEED);
331	0	#ifdef MADV_FREE
332	0	madvise((void*)aligned_old_start, aligned_new_start - aligned_old_start, MADV_FREE);
333	0	#endif /* MADV_FREE */
334	0	}
335	0	}
336	0	#endif /* _WIN32 */
337
338	0	stack->start = new_start;
339	0	return new_start;
340	0	}
341
342		#endif /* SLJIT_UTIL_SIMPLE_STACK_ALLOCATION */
343
344		#endif /* SLJIT_UTIL_STACK */