← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

« back to all changes in this revision

Viewing changes to src/3rdparty/pcre/sljit/sljitUtils.c

  • Committer: Package Import Robot
  • Author(s): Timo Jyrinki
  • Date: 2013-02-05 12:46:17 UTC
  • Revision ID: package-import@ubuntu.com-20130205124617-c8jouts182j002fx
Tags: upstream-5.0.1+dfsg
Import upstream version 5.0.1+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/pcre/sljit/sljitUtils.c
 
1
/*
 
2
 *    Stack-less Just-In-Time compiler
 
3
 *
 
4
 *    Copyright 2009-2012 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
SLJIT_API_FUNC_ATTRIBUTE 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
SLJIT_API_FUNC_ATTRIBUTE 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
SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_grab_lock(void)
 
102
{
 
103
        pthread_mutex_lock(&global_mutex);
 
104
}
 
105
 
 
106
SLJIT_API_FUNC_ATTRIBUTE 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
SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_CALL sljit_allocate_stack(sljit_uw limit, sljit_uw 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 || limit < 1)
 
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
SLJIT_API_FUNC_ATTRIBUTE 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_API_FUNC_ATTRIBUTE 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
#if defined(__QNXNTO__) || defined(__LSB_VERSION__)
 
237
                posix_madvise((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, POSIX_MADV_DONTNEED);
 
238
#else
 
239
                madvise((void*)aligned_new_limit, aligned_old_limit - aligned_new_limit, MADV_DONTNEED);
 
240
#endif
 
241
        stack->limit = new_limit;
 
242
        return 0;
 
243
#endif
 
244
}
 
245
 
 
246
#endif /* SLJIT_UTIL_STACK */
 
247
 
 
248
#endif