← Back to branch summary

~ubuntu-branches/ubuntu/trusty/pcre3/trusty

« back to all changes in this revision

Viewing changes to sljit/sljitLir.c

  • Committer: Package Import Robot
  • Author(s): Mark Baker
  • Date: 2012-03-23 22:34:54 UTC
  • mfrom: (23.1.9 sid)
  • Revision ID: package-import@ubuntu.com-20120323223454-grhqqolk8a7x1h24
Tags: 1:8.30-4
* Reluctantly using an epoch, as it seems the funny version number with
  extra dots causes problems
* Bumped standard version to 3.9.3. No changes needed
* Converted to use new source format / quilt
* Put back obsolete pcre_info() API that upstream have dropped (Closes:
  #665300, #665356)
* Don't include pcregrep binary in debug package

Thanks to Elimar Riesebieter for the conversion to the new source format.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sljit/sljitLir.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
#include "sljitLir.h"
 
28
 
 
29
#define CHECK_ERROR() \
 
30
        do { \
 
31
                if (SLJIT_UNLIKELY(compiler->error)) \
 
32
                        return compiler->error; \
 
33
        } while (0)
 
34
 
 
35
#define CHECK_ERROR_PTR() \
 
36
        do { \
 
37
                if (SLJIT_UNLIKELY(compiler->error)) \
 
38
                        return NULL; \
 
39
        } while (0)
 
40
 
 
41
#define CHECK_ERROR_VOID() \
 
42
        do { \
 
43
                if (SLJIT_UNLIKELY(compiler->error)) \
 
44
                        return; \
 
45
        } while (0)
 
46
 
 
47
#define FAIL_IF(expr) \
 
48
        do { \
 
49
                if (SLJIT_UNLIKELY(expr)) \
 
50
                        return compiler->error; \
 
51
        } while (0)
 
52
 
 
53
#define PTR_FAIL_IF(expr) \
 
54
        do { \
 
55
                if (SLJIT_UNLIKELY(expr)) \
 
56
                        return NULL; \
 
57
        } while (0)
 
58
 
 
59
#define FAIL_IF_NULL(ptr) \
 
60
        do { \
 
61
                if (SLJIT_UNLIKELY(!(ptr))) { \
 
62
                        compiler->error = SLJIT_ERR_ALLOC_FAILED; \
 
63
                        return SLJIT_ERR_ALLOC_FAILED; \
 
64
                } \
 
65
        } while (0)
 
66
 
 
67
#define PTR_FAIL_IF_NULL(ptr) \
 
68
        do { \
 
69
                if (SLJIT_UNLIKELY(!(ptr))) { \
 
70
                        compiler->error = SLJIT_ERR_ALLOC_FAILED; \
 
71
                        return NULL; \
 
72
                } \
 
73
        } while (0)
 
74
 
 
75
#define PTR_FAIL_WITH_EXEC_IF(ptr) \
 
76
        do { \
 
77
                if (SLJIT_UNLIKELY(!(ptr))) { \
 
78
                        compiler->error = SLJIT_ERR_EX_ALLOC_FAILED; \
 
79
                        return NULL; \
 
80
                } \
 
81
        } while (0)
 
82
 
 
83
#if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
 
84
 
 
85
#define GET_OPCODE(op) \
 
86
        ((op) & ~(SLJIT_INT_OP | SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))
 
87
 
 
88
#define GET_FLAGS(op) \
 
89
        ((op) & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C))
 
90
 
 
91
#define GET_ALL_FLAGS(op) \
 
92
        ((op) & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))
 
93
 
 
94
#define BUF_SIZE        4096
 
95
 
 
96
#if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE)
 
97
#define ABUF_SIZE       2048
 
98
#else
 
99
#define ABUF_SIZE       4096
 
100
#endif
 
101
 
 
102
/* Jump flags. */
 
103
#define JUMP_LABEL      0x1
 
104
#define JUMP_ADDR       0x2
 
105
/* SLJIT_REWRITABLE_JUMP is 0x1000. */
 
106
 
 
107
#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
 
108
        #define PATCH_MB        0x4
 
109
        #define PATCH_MW        0x8
 
110
#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
 
111
        #define PATCH_MD        0x10
 
112
#endif
 
113
#endif
 
114
 
 
115
#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
 
116
        #define IS_BL           0x4
 
117
        #define PATCH_B         0x8
 
118
#endif
 
119
 
 
120
#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
 
121
        #define CPOOL_SIZE      512
 
122
#endif
 
123
 
 
124
#if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
 
125
        #define IS_CONDITIONAL  0x04
 
126
        #define IS_BL           0x08
 
127
        /* cannot be encoded as branch */
 
128
        #define B_TYPE0         0x00
 
129
        /* conditional + imm8 */
 
130
        #define B_TYPE1         0x10
 
131
        /* conditional + imm20 */
 
132
        #define B_TYPE2         0x20
 
133
        /* IT + imm24 */
 
134
        #define B_TYPE3         0x30
 
135
        /* imm11 */
 
136
        #define B_TYPE4         0x40
 
137
        /* imm24 */
 
138
        #define B_TYPE5         0x50
 
139
        /* BL + imm24 */
 
140
        #define BL_TYPE6        0x60
 
141
        /* 0xf00 cc code for branches */
 
142
#endif
 
143
 
 
144
#if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
 
145
        #define UNCOND_B        0x04
 
146
        #define PATCH_B         0x08
 
147
        #define ABSOLUTE_B      0x10
 
148
#endif
 
149
 
 
150
#if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
 
151
        #define IS_MOVABLE      0x04
 
152
        #define IS_JAL          0x08
 
153
        #define IS_BIT26_COND   0x10
 
154
        #define IS_BIT16_COND   0x20
 
155
 
 
156
        #define IS_COND         (IS_BIT26_COND | IS_BIT16_COND)
 
157
 
 
158
        #define PATCH_B         0x40
 
159
        #define PATCH_J         0x80
 
160
 
 
161
        /* instruction types */
 
162
        #define UNMOVABLE_INS   0
 
163
        /* 1 - 31 last destination register */
 
164
        #define FCSR_FCC        32
 
165
        /* no destination (i.e: store) */
 
166
        #define MOVABLE_INS     33
 
167
#endif
 
168
 
 
169
#endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */
 
170
 
 
171
/* Utils can still be used even if SLJIT_CONFIG_UNSUPPORTED is set. */
 
172
#include "sljitUtils.c"
 
173
 
 
174
#if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
 
175
 
 
176
#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
 
177
#include "sljitExecAllocator.c"
 
178
#endif
 
179
 
 
180
#if (defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO) && !(defined SLJIT_SSE2 && SLJIT_SSE2)
 
181
#error SLJIT_SSE2_AUTO cannot be enabled without SLJIT_SSE2
 
182
#endif
 
183
 
 
184
/* --------------------------------------------------------------------- */
 
185
/*  Public functions                                                     */
 
186
/* --------------------------------------------------------------------- */
 
187
 
 
188
#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || ((defined SLJIT_SSE2 && SLJIT_SSE2) && ((defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)))
 
189
#define SLJIT_NEEDS_COMPILER_INIT 1
 
190
static int compiler_initialized = 0;
 
191
/* A thread safe initialization. */
 
192
static void init_compiler(void);
 
193
#endif
 
194
 
 
195
 
 
196
SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void)
 
197
{
 
198
        struct sljit_compiler *compiler = (struct sljit_compiler*)SLJIT_MALLOC(sizeof(struct sljit_compiler));
 
199
        if (!compiler)
 
200
                return NULL;
 
201
        SLJIT_ZEROMEM(compiler, sizeof(struct sljit_compiler));
 
202
 
 
203
        SLJIT_COMPILE_ASSERT(
 
204
                sizeof(sljit_b) == 1 && sizeof(sljit_ub) == 1
 
205
                && sizeof(sljit_h) == 2 && sizeof(sljit_uh) == 2
 
206
                && sizeof(sljit_i) == 4 && sizeof(sljit_ui) == 4
 
207
                && ((sizeof(sljit_w) == 4 && sizeof(sljit_uw) == 4) || (sizeof(sljit_w) == 8 && sizeof(sljit_uw) == 8)),
 
208
                invalid_integer_types);
 
209
 
 
210
        /* Only the non-zero members must be set. */
 
211
        compiler->error = SLJIT_SUCCESS;
 
212
 
 
213
        compiler->buf = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE);
 
214
        compiler->abuf = (struct sljit_memory_fragment*)SLJIT_MALLOC(ABUF_SIZE);
 
215
 
 
216
        if (!compiler->buf || !compiler->abuf) {
 
217
                if (compiler->buf)
 
218
                        SLJIT_FREE(compiler->buf);
 
219
                if (compiler->abuf)
 
220
                        SLJIT_FREE(compiler->abuf);
 
221
                SLJIT_FREE(compiler);
 
222
                return NULL;
 
223
        }
 
224
 
 
225
        compiler->buf->next = NULL;
 
226
        compiler->buf->used_size = 0;
 
227
        compiler->abuf->next = NULL;
 
228
        compiler->abuf->used_size = 0;
 
229
 
 
230
        compiler->temporaries = -1;
 
231
        compiler->saveds = -1;
 
232
 
 
233
#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
 
234
        compiler->args = -1;
 
235
#endif
 
236
 
 
237
#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
 
238
        compiler->cpool = (sljit_uw*)SLJIT_MALLOC(CPOOL_SIZE * sizeof(sljit_uw) + CPOOL_SIZE * sizeof(sljit_ub));
 
239
        if (!compiler->cpool) {
 
240
                SLJIT_FREE(compiler->buf);
 
241
                SLJIT_FREE(compiler->abuf);
 
242
                SLJIT_FREE(compiler);
 
243
                return NULL;
 
244
        }
 
245
        compiler->cpool_unique = (sljit_ub*)(compiler->cpool + CPOOL_SIZE);
 
246
        compiler->cpool_diff = 0xffffffff;
 
247
#endif
 
248
 
 
249
#if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
 
250
        compiler->delay_slot = UNMOVABLE_INS;
 
251
#endif
 
252
 
 
253
#if (defined SLJIT_NEEDS_COMPILER_INIT && SLJIT_NEEDS_COMPILER_INIT)
 
254
        if (!compiler_initialized) {
 
255
                init_compiler();
 
256
                compiler_initialized = 1;
 
257
        }
 
258
#endif
 
259
 
 
260
        return compiler;
 
261
}
 
262
 
 
263
SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler)
 
264
{
 
265
        struct sljit_memory_fragment *buf;
 
266
        struct sljit_memory_fragment *curr;
 
267
 
 
268
        buf = compiler->buf;
 
269
        while (buf) {
 
270
                curr = buf;
 
271
                buf = buf->next;
 
272
                SLJIT_FREE(curr);
 
273
        }
 
274
 
 
275
        buf = compiler->abuf;
 
276
        while (buf) {
 
277
                curr = buf;
 
278
                buf = buf->next;
 
279
                SLJIT_FREE(curr);
 
280
        }
 
281
 
 
282
#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
 
283
        SLJIT_FREE(compiler->cpool);
 
284
#endif
 
285
        SLJIT_FREE(compiler);
 
286
}
 
287
 
 
288
#if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
 
289
SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
 
290
{
 
291
        /* Remove thumb mode flag. */
 
292
        SLJIT_FREE_EXEC((void*)((sljit_uw)code & ~0x1));
 
293
}
 
294
#elif (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
 
295
SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
 
296
{
 
297
        /* Resolve indirection. */
 
298
        code = (void*)(*(sljit_uw*)code);
 
299
        SLJIT_FREE_EXEC(code);
 
300
}
 
301
#else
 
302
SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
 
303
{
 
304
        SLJIT_FREE_EXEC(code);
 
305
}
 
306
#endif
 
307
 
 
308
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label)
 
309
{
 
310
        if (SLJIT_LIKELY(!!jump) && SLJIT_LIKELY(!!label)) {
 
311
                jump->flags &= ~JUMP_ADDR;
 
312
                jump->flags |= JUMP_LABEL;
 
313
                jump->u.label = label;
 
314
        }
 
315
}
 
316
 
 
317
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target)
 
318
{
 
319
        if (SLJIT_LIKELY(!!jump)) {
 
320
                SLJIT_ASSERT(jump->flags & SLJIT_REWRITABLE_JUMP);
 
321
 
 
322
                jump->flags &= ~JUMP_LABEL;
 
323
                jump->flags |= JUMP_ADDR;
 
324
                jump->u.target = target;
 
325
        }
 
326
}
 
327
 
 
328
/* --------------------------------------------------------------------- */
 
329
/*  Private functions                                                    */
 
330
/* --------------------------------------------------------------------- */
 
331
 
 
332
static void* ensure_buf(struct sljit_compiler *compiler, int size)
 
333
{
 
334
        sljit_ub *ret;
 
335
        struct sljit_memory_fragment *new_frag;
 
336
 
 
337
        if (compiler->buf->used_size + size <= (int)(BUF_SIZE - sizeof(sljit_uw) - sizeof(void*))) {
 
338
                ret = compiler->buf->memory + compiler->buf->used_size;
 
339
                compiler->buf->used_size += size;
 
340
                return ret;
 
341
        }
 
342
        new_frag = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE);
 
343
        PTR_FAIL_IF_NULL(new_frag);
 
344
        new_frag->next = compiler->buf;
 
345
        compiler->buf = new_frag;
 
346
        new_frag->used_size = size;
 
347
        return new_frag->memory;
 
348
}
 
349
 
 
350
static void* ensure_abuf(struct sljit_compiler *compiler, int size)
 
351
{
 
352
        sljit_ub *ret;
 
353
        struct sljit_memory_fragment *new_frag;
 
354
 
 
355
        if (compiler->abuf->used_size + size <= (int)(ABUF_SIZE - sizeof(sljit_uw) - sizeof(void*))) {
 
356
                ret = compiler->abuf->memory + compiler->abuf->used_size;
 
357
                compiler->abuf->used_size += size;
 
358
                return ret;
 
359
        }
 
360
        new_frag = (struct sljit_memory_fragment*)SLJIT_MALLOC(ABUF_SIZE);
 
361
        PTR_FAIL_IF_NULL(new_frag);
 
362
        new_frag->next = compiler->abuf;
 
363
        compiler->abuf = new_frag;
 
364
        new_frag->used_size = size;
 
365
        return new_frag->memory;
 
366
}
 
367
 
 
368
SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, int size)
 
369
{
 
370
        CHECK_ERROR_PTR();
 
371
 
 
372
#if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 
373
        if (size <= 0 || size > 128)
 
374
                return NULL;
 
375
        size = (size + 7) & ~7;
 
376
#else
 
377
        if (size <= 0 || size > 64)
 
378
                return NULL;
 
379
        size = (size + 3) & ~3;
 
380
#endif
 
381
        return ensure_abuf(compiler, size);
 
382
}
 
383
 
 
384
static SLJIT_INLINE void reverse_buf(struct sljit_compiler *compiler)
 
385
{
 
386
        struct sljit_memory_fragment *buf = compiler->buf;
 
387
        struct sljit_memory_fragment *prev = NULL;
 
388
        struct sljit_memory_fragment *tmp;
 
389
 
 
390
        do {
 
391
                tmp = buf->next;
 
392
                buf->next = prev;
 
393
                prev = buf;
 
394
                buf = tmp;
 
395
        } while (buf != NULL);
 
396
 
 
397
        compiler->buf = prev;
 
398
}
 
399
 
 
400
static SLJIT_INLINE void set_label(struct sljit_label *label, struct sljit_compiler *compiler)
 
401
{
 
402
        label->next = NULL;
 
403
        label->size = compiler->size;
 
404
        if (compiler->last_label)
 
405
                compiler->last_label->next = label;
 
406
        else
 
407
                compiler->labels = label;
 
408
        compiler->last_label = label;
 
409
}
 
410
 
 
411
static SLJIT_INLINE void set_jump(struct sljit_jump *jump, struct sljit_compiler *compiler, int flags)
 
412
{
 
413
        jump->next = NULL;
 
414
        jump->flags = flags;
 
415
        if (compiler->last_jump)
 
416
                compiler->last_jump->next = jump;
 
417
        else
 
418
                compiler->jumps = jump;
 
419
        compiler->last_jump = jump;
 
420
}
 
421
 
 
422
static SLJIT_INLINE void set_const(struct sljit_const *const_, struct sljit_compiler *compiler)
 
423
{
 
424
        const_->next = NULL;
 
425
        const_->addr = compiler->size;
 
426
        if (compiler->last_const)
 
427
                compiler->last_const->next = const_;
 
428
        else
 
429
                compiler->consts = const_;
 
430
        compiler->last_const = const_;
 
431
}
 
432
 
 
433
#define ADDRESSING_DEPENDS_ON(exp, reg) \
 
434
        (((exp) & SLJIT_MEM) && (((exp) & 0xf) == reg || (((exp) >> 4) & 0xf) == reg))
 
435
 
 
436
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
437
#define FUNCTION_CHECK_OP() \
 
438
        SLJIT_ASSERT(!GET_FLAGS(op) || !(op & SLJIT_KEEP_FLAGS)); \
 
439
        switch (GET_OPCODE(op)) { \
 
440
        case SLJIT_NOT: \
 
441
        case SLJIT_CLZ: \
 
442
        case SLJIT_AND: \
 
443
        case SLJIT_OR: \
 
444
        case SLJIT_XOR: \
 
445
        case SLJIT_SHL: \
 
446
        case SLJIT_LSHR: \
 
447
        case SLJIT_ASHR: \
 
448
                SLJIT_ASSERT(!(op & (SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C))); \
 
449
                break; \
 
450
        case SLJIT_NEG: \
 
451
                SLJIT_ASSERT(!(op & (SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_C))); \
 
452
                break; \
 
453
        case SLJIT_MUL: \
 
454
                SLJIT_ASSERT(!(op & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_C))); \
 
455
                break; \
 
456
        case SLJIT_FCMP: \
 
457
                SLJIT_ASSERT(!(op & (SLJIT_INT_OP | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \
 
458
                SLJIT_ASSERT((op & (SLJIT_SET_E | SLJIT_SET_S))); \
 
459
                break; \
 
460
        case SLJIT_ADD: \
 
461
                SLJIT_ASSERT(!(op & (SLJIT_SET_S | SLJIT_SET_U))); \
 
462
                break; \
 
463
        case SLJIT_SUB: \
 
464
                break; \
 
465
        case SLJIT_ADDC: \
 
466
        case SLJIT_SUBC: \
 
467
                SLJIT_ASSERT(!(op & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O))); \
 
468
                break; \
 
469
        default: \
 
470
                /* Nothing allowed */ \
 
471
                SLJIT_ASSERT(!(op & (SLJIT_INT_OP | SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \
 
472
                break; \
 
473
        }
 
474
 
 
475
#define FUNCTION_CHECK_IS_REG(r) \
 
476
        ((r) == SLJIT_UNUSED || (r) == SLJIT_LOCALS_REG || \
 
477
        ((r) >= SLJIT_TEMPORARY_REG1 && (r) <= SLJIT_TEMPORARY_REG3 && (r) <= SLJIT_TEMPORARY_REG1 - 1 + compiler->temporaries) || \
 
478
        ((r) >= SLJIT_SAVED_REG1 && (r) <= SLJIT_SAVED_REG3 && (r) <= SLJIT_SAVED_REG1 - 1 + compiler->saveds)) \
 
479
 
 
480
#define FUNCTION_CHECK_SRC(p, i) \
 
481
        SLJIT_ASSERT(compiler->temporaries != -1 && compiler->saveds != -1); \
 
482
        if (((p) >= SLJIT_TEMPORARY_REG1 && (p) <= SLJIT_TEMPORARY_REG1 - 1 + compiler->temporaries) || \
 
483
                        ((p) >= SLJIT_SAVED_REG1 && (p) <= SLJIT_SAVED_REG1 - 1 + compiler->saveds) || \
 
484
                        (p) == SLJIT_LOCALS_REG) \
 
485
                SLJIT_ASSERT(i == 0); \
 
486
        else if ((p) == SLJIT_IMM) \
 
487
                ; \
 
488
        else if ((p) & SLJIT_MEM) { \
 
489
                SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & 0xf)); \
 
490
                if ((p) & 0xf0) { \
 
491
                        SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(((p) >> 4) & 0xf)); \
 
492
                        SLJIT_ASSERT(((p) & 0xf0) != (SLJIT_LOCALS_REG << 4) && !(i & ~0x3)); \
 
493
                } else \
 
494
                        SLJIT_ASSERT((((p) >> 4) & 0xf) == 0); \
 
495
                SLJIT_ASSERT(((p) >> 9) == 0); \
 
496
        } \
 
497
        else \
 
498
                SLJIT_ASSERT_STOP();
 
499
 
 
500
#define FUNCTION_CHECK_DST(p, i) \
 
501
        SLJIT_ASSERT(compiler->temporaries != -1 && compiler->saveds != -1); \
 
502
        if (((p) >= SLJIT_TEMPORARY_REG1 && (p) <= SLJIT_TEMPORARY_REG1 - 1 + compiler->temporaries) || \
 
503
                        ((p) >= SLJIT_SAVED_REG1 && (p) <= SLJIT_SAVED_REG1 - 1 + compiler->saveds) || \
 
504
                        (p) == SLJIT_UNUSED) \
 
505
                SLJIT_ASSERT(i == 0); \
 
506
        else if ((p) & SLJIT_MEM) { \
 
507
                SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & 0xf)); \
 
508
                if ((p) & 0xf0) { \
 
509
                        SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(((p) >> 4) & 0xf)); \
 
510
                        SLJIT_ASSERT(((p) & 0xf0) != (SLJIT_LOCALS_REG << 4) && !(i & ~0x3)); \
 
511
                } else \
 
512
                        SLJIT_ASSERT((((p) >> 4) & 0xf) == 0); \
 
513
                SLJIT_ASSERT(((p) >> 9) == 0); \
 
514
        } \
 
515
        else \
 
516
                SLJIT_ASSERT_STOP();
 
517
 
 
518
#define FUNCTION_FCHECK(p, i) \
 
519
        if ((p) >= SLJIT_FLOAT_REG1 && (p) <= SLJIT_FLOAT_REG4) \
 
520
                SLJIT_ASSERT(i == 0); \
 
521
        else if ((p) & SLJIT_MEM) { \
 
522
                SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & 0xf)); \
 
523
                if ((p) & 0xf0) { \
 
524
                        SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(((p) >> 4) & 0xf)); \
 
525
                        SLJIT_ASSERT(((p) & 0xf0) != (SLJIT_LOCALS_REG << 4) && !(i & ~0x3)); \
 
526
                } else \
 
527
                        SLJIT_ASSERT((((p) >> 4) & 0xf) == 0); \
 
528
                SLJIT_ASSERT(((p) >> 9) == 0); \
 
529
        } \
 
530
        else \
 
531
                SLJIT_ASSERT_STOP();
 
532
 
 
533
#define FUNCTION_CHECK_OP1() \
 
534
        if (GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_MOVU_SI) { \
 
535
                SLJIT_ASSERT(!GET_ALL_FLAGS(op)); \
 
536
        } \
 
537
        if (GET_OPCODE(op) >= SLJIT_MOVU && GET_OPCODE(op) <= SLJIT_MOVU_SI) { \
 
538
                SLJIT_ASSERT(!(src & SLJIT_MEM) || (src & 0xf) != SLJIT_LOCALS_REG); \
 
539
                SLJIT_ASSERT(!(dst & SLJIT_MEM) || (dst & 0xf) != SLJIT_LOCALS_REG); \
 
540
                if ((src & SLJIT_MEM) && (src & 0xf)) \
 
541
                        SLJIT_ASSERT((dst & 0xf) != (src & 0xf) && ((dst >> 4) & 0xf) != (src & 0xf)); \
 
542
        }
 
543
 
 
544
#endif
 
545
 
 
546
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
547
 
 
548
SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose)
 
549
{
 
550
        compiler->verbose = verbose;
 
551
}
 
552
 
 
553
static char* reg_names[] = {
 
554
        (char*)"<noreg>", (char*)"t1", (char*)"t2", (char*)"t3",
 
555
        (char*)"te1", (char*)"te2", (char*)"s1", (char*)"s2",
 
556
        (char*)"s3", (char*)"se1", (char*)"se2", (char*)"lcr"
 
557
};
 
558
 
 
559
static char* freg_names[] = {
 
560
        (char*)"<noreg>", (char*)"float_r1", (char*)"float_r2", (char*)"float_r3", (char*)"float_r4"
 
561
};
 
562
 
 
563
#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
 
564
#ifdef _WIN64
 
565
        #define SLJIT_PRINT_D   "I64"
 
566
#else
 
567
        #define SLJIT_PRINT_D   "l"
 
568
#endif
 
569
#else
 
570
        #define SLJIT_PRINT_D   ""
 
571
#endif
 
572
 
 
573
#define sljit_verbose_param(p, i) \
 
574
        if ((p) & SLJIT_IMM) \
 
575
                fprintf(compiler->verbose, "#%"SLJIT_PRINT_D"d", (i)); \
 
576
        else if ((p) & SLJIT_MEM) { \
 
577
                if ((p) & 0xf) { \
 
578
                        if (i) { \
 
579
                                if (((p) >> 4) & 0xf) \
 
580
                                        fprintf(compiler->verbose, "[%s + %s * %d]", reg_names[(p) & 0xF], reg_names[((p) >> 4)& 0xF], 1 << (i)); \
 
581
                                else \
 
582
                                        fprintf(compiler->verbose, "[%s + #%"SLJIT_PRINT_D"d]", reg_names[(p) & 0xF], (i)); \
 
583
                        } \
 
584
                        else { \
 
585
                                if (((p) >> 4) & 0xf) \
 
586
                                        fprintf(compiler->verbose, "[%s + %s]", reg_names[(p) & 0xF], reg_names[((p) >> 4)& 0xF]); \
 
587
                                else \
 
588
                                        fprintf(compiler->verbose, "[%s]", reg_names[(p) & 0xF]); \
 
589
                        } \
 
590
                } \
 
591
                else \
 
592
                        fprintf(compiler->verbose, "[#%"SLJIT_PRINT_D"d]", (i)); \
 
593
        } else \
 
594
                fprintf(compiler->verbose, "%s", reg_names[p]);
 
595
#define sljit_verbose_fparam(p, i) \
 
596
        if ((p) & SLJIT_MEM) { \
 
597
                if ((p) & 0xf) { \
 
598
                        if (i) { \
 
599
                                if (((p) >> 4) & 0xf) \
 
600
                                        fprintf(compiler->verbose, "[%s + %s * %d]", reg_names[(p) & 0xF], reg_names[((p) >> 4)& 0xF], 1 << (i)); \
 
601
                                else \
 
602
                                        fprintf(compiler->verbose, "[%s + #%"SLJIT_PRINT_D"d]", reg_names[(p) & 0xF], (i)); \
 
603
                        } \
 
604
                        else { \
 
605
                                if (((p) >> 4) & 0xF) \
 
606
                                        fprintf(compiler->verbose, "[%s + %s]", reg_names[(p) & 0xF], reg_names[((p) >> 4)& 0xF]); \
 
607
                                else \
 
608
                                        fprintf(compiler->verbose, "[%s]", reg_names[(p) & 0xF]); \
 
609
                        } \
 
610
                } \
 
611
                else \
 
612
                        fprintf(compiler->verbose, "[#%"SLJIT_PRINT_D"d]", (i)); \
 
613
        } else \
 
614
                fprintf(compiler->verbose, "%s", freg_names[p]);
 
615
 
 
616
static SLJIT_CONST char* op_names[] = {
 
617
        /* op0 */
 
618
        (char*)"breakpoint", (char*)"nop",
 
619
        (char*)"umul", (char*)"smul", (char*)"udiv", (char*)"sdiv",
 
620
        /* op1 */
 
621
        (char*)"mov", (char*)"mov.ub", (char*)"mov.sb", (char*)"mov.uh",
 
622
        (char*)"mov.sh", (char*)"mov.ui", (char*)"mov.si", (char*)"movu",
 
623
        (char*)"movu.ub", (char*)"movu.sb", (char*)"movu.uh", (char*)"movu.sh",
 
624
        (char*)"movu.ui", (char*)"movu.si", (char*)"not", (char*)"neg",
 
625
        (char*)"clz",
 
626
        /* op2 */
 
627
        (char*)"add", (char*)"addc", (char*)"sub", (char*)"subc",
 
628
        (char*)"mul", (char*)"and", (char*)"or", (char*)"xor",
 
629
        (char*)"shl", (char*)"lshr", (char*)"ashr",
 
630
        /* fop1 */
 
631
        (char*)"fcmp", (char*)"fmov", (char*)"fneg", (char*)"fabs",
 
632
        /* fop2 */
 
633
        (char*)"fadd", (char*)"fsub", (char*)"fmul", (char*)"fdiv"
 
634
};
 
635
 
 
636
static char* jump_names[] = {
 
637
        (char*)"c_equal", (char*)"c_not_equal",
 
638
        (char*)"c_less", (char*)"c_greater_equal",
 
639
        (char*)"c_greater", (char*)"c_less_equal",
 
640
        (char*)"c_sig_less", (char*)"c_sig_greater_equal",
 
641
        (char*)"c_sig_greater", (char*)"c_sig_less_equal",
 
642
        (char*)"c_overflow", (char*)"c_not_overflow",
 
643
        (char*)"c_mul_overflow", (char*)"c_mul_not_overflow",
 
644
        (char*)"c_float_equal", (char*)"c_float_not_equal",
 
645
        (char*)"c_float_less", (char*)"c_float_greater_equal",
 
646
        (char*)"c_float_greater", (char*)"c_float_less_equal",
 
647
        (char*)"c_float_nan", (char*)"c_float_not_nan",
 
648
        (char*)"jump", (char*)"fast_call",
 
649
        (char*)"call0", (char*)"call1", (char*)"call2", (char*)"call3"
 
650
};
 
651
 
 
652
#endif
 
653
 
 
654
/* --------------------------------------------------------------------- */
 
655
/*  Arch dependent                                                       */
 
656
/* --------------------------------------------------------------------- */
 
657
 
 
658
static SLJIT_INLINE void check_sljit_generate_code(struct sljit_compiler *compiler)
 
659
{
 
660
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
661
        struct sljit_jump *jump;
 
662
#endif
 
663
        /* If debug and verbose are disabled, all arguments are unused. */
 
664
        SLJIT_UNUSED_ARG(compiler);
 
665
 
 
666
        SLJIT_ASSERT(compiler->size > 0);
 
667
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
668
        jump = compiler->jumps;
 
669
        while (jump) {
 
670
                /* All jumps have target. */
 
671
                SLJIT_ASSERT(jump->flags & (JUMP_LABEL | JUMP_ADDR));
 
672
                jump = jump->next;
 
673
        }
 
674
#endif
 
675
}
 
676
 
 
677
static SLJIT_INLINE void check_sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
 
678
{
 
679
        /* If debug and verbose are disabled, all arguments are unused. */
 
680
        SLJIT_UNUSED_ARG(compiler);
 
681
        SLJIT_UNUSED_ARG(args);
 
682
        SLJIT_UNUSED_ARG(temporaries);
 
683
        SLJIT_UNUSED_ARG(saveds);
 
684
        SLJIT_UNUSED_ARG(local_size);
 
685
 
 
686
        SLJIT_ASSERT(args >= 0 && args <= 3);
 
687
        SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
 
688
        SLJIT_ASSERT(saveds >= 0 && saveds <= SLJIT_NO_GEN_REGISTERS);
 
689
        SLJIT_ASSERT(args <= saveds);
 
690
        SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
 
691
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
692
        if (SLJIT_UNLIKELY(!!compiler->verbose))
 
693
                fprintf(compiler->verbose, "  enter args=%d temporaries=%d saveds=%d local_size=%d\n", args, temporaries, saveds, local_size);
 
694
#endif
 
695
}
 
696
 
 
697
static SLJIT_INLINE void check_sljit_set_context(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
 
698
{
 
699
        /* If debug and verbose are disabled, all arguments are unused. */
 
700
        SLJIT_UNUSED_ARG(compiler);
 
701
        SLJIT_UNUSED_ARG(args);
 
702
        SLJIT_UNUSED_ARG(temporaries);
 
703
        SLJIT_UNUSED_ARG(saveds);
 
704
        SLJIT_UNUSED_ARG(local_size);
 
705
 
 
706
        SLJIT_ASSERT(args >= 0 && args <= 3);
 
707
        SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
 
708
        SLJIT_ASSERT(saveds >= 0 && saveds <= SLJIT_NO_GEN_REGISTERS);
 
709
        SLJIT_ASSERT(args <= saveds);
 
710
        SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
 
711
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
712
        if (SLJIT_UNLIKELY(!!compiler->verbose))
 
713
                fprintf(compiler->verbose, "  fake_enter args=%d temporaries=%d saveds=%d local_size=%d\n", args, temporaries, saveds, local_size);
 
714
#endif
 
715
}
 
716
 
 
717
static SLJIT_INLINE void check_sljit_emit_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)
 
718
{
 
719
        /* If debug and verbose are disabled, all arguments are unused. */
 
720
        SLJIT_UNUSED_ARG(compiler);
 
721
        SLJIT_UNUSED_ARG(op);
 
722
        SLJIT_UNUSED_ARG(src);
 
723
        SLJIT_UNUSED_ARG(srcw);
 
724
 
 
725
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
726
        if (op != SLJIT_UNUSED) {
 
727
                SLJIT_ASSERT(op >= SLJIT_MOV && op <= SLJIT_MOV_SI);
 
728
                FUNCTION_CHECK_SRC(src, srcw);
 
729
        }
 
730
        else
 
731
                SLJIT_ASSERT(src == 0 && srcw == 0);
 
732
#endif
 
733
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
734
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
735
                if (op == SLJIT_UNUSED)
 
736
                        fprintf(compiler->verbose, "  return\n");
 
737
                else {
 
738
                        fprintf(compiler->verbose, "  return %s ", op_names[op]);
 
739
                        sljit_verbose_param(src, srcw);
 
740
                        fprintf(compiler->verbose, "\n");
 
741
                }
 
742
        }
 
743
#endif
 
744
}
 
745
 
 
746
static SLJIT_INLINE void check_sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw, int args, int temporaries, int saveds, int local_size)
 
747
{
 
748
        /* If debug and verbose are disabled, all arguments are unused. */
 
749
        SLJIT_UNUSED_ARG(compiler);
 
750
        SLJIT_UNUSED_ARG(dst);
 
751
        SLJIT_UNUSED_ARG(dstw);
 
752
        SLJIT_UNUSED_ARG(args);
 
753
        SLJIT_UNUSED_ARG(temporaries);
 
754
        SLJIT_UNUSED_ARG(saveds);
 
755
        SLJIT_UNUSED_ARG(local_size);
 
756
 
 
757
        SLJIT_ASSERT(args >= 0 && args <= 3);
 
758
        SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
 
759
        SLJIT_ASSERT(saveds >= 0 && saveds <= SLJIT_NO_GEN_REGISTERS);
 
760
        SLJIT_ASSERT(args <= saveds);
 
761
        SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
 
762
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
763
        compiler->temporaries = temporaries;
 
764
        compiler->saveds = saveds;
 
765
        FUNCTION_CHECK_DST(dst, dstw);
 
766
        compiler->temporaries = -1;
 
767
        compiler->saveds = -1;
 
768
#endif
 
769
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
770
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
771
                fprintf(compiler->verbose, "  fast_enter ");
 
772
                sljit_verbose_param(dst, dstw);
 
773
                fprintf(compiler->verbose, " args=%d temporaries=%d saveds=%d local_size=%d\n", args, temporaries, saveds, local_size);
 
774
        }
 
775
#endif
 
776
}
 
777
 
 
778
static SLJIT_INLINE void check_sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
 
779
{
 
780
        /* If debug and verbose are disabled, all arguments are unused. */
 
781
        SLJIT_UNUSED_ARG(compiler);
 
782
        SLJIT_UNUSED_ARG(src);
 
783
        SLJIT_UNUSED_ARG(srcw);
 
784
 
 
785
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
786
        FUNCTION_CHECK_SRC(src, srcw);
 
787
#endif
 
788
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
789
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
790
                fprintf(compiler->verbose, "  fast_return ");
 
791
                sljit_verbose_param(src, srcw);
 
792
                fprintf(compiler->verbose, "\n");
 
793
        }
 
794
#endif
 
795
}
 
796
 
 
797
static SLJIT_INLINE void check_sljit_emit_op0(struct sljit_compiler *compiler, int op)
 
798
{
 
799
        /* If debug and verbose are disabled, all arguments are unused. */
 
800
        SLJIT_UNUSED_ARG(compiler);
 
801
        SLJIT_UNUSED_ARG(op);
 
802
 
 
803
        SLJIT_ASSERT((op >= SLJIT_BREAKPOINT && op <= SLJIT_SMUL)
 
804
                || ((op & ~SLJIT_INT_OP) >= SLJIT_UDIV && (op & ~SLJIT_INT_OP) <= SLJIT_SDIV));
 
805
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
806
        if (SLJIT_UNLIKELY(!!compiler->verbose))
 
807
                fprintf(compiler->verbose, "  %s%s\n", !(op & SLJIT_INT_OP) ? "" : "i", op_names[GET_OPCODE(op)]);
 
808
#endif
 
809
}
 
810
 
 
811
static SLJIT_INLINE void check_sljit_emit_op1(struct sljit_compiler *compiler, int op,
 
812
        int dst, sljit_w dstw,
 
813
        int src, sljit_w srcw)
 
814
{
 
815
        /* If debug and verbose are disabled, all arguments are unused. */
 
816
        SLJIT_UNUSED_ARG(compiler);
 
817
        SLJIT_UNUSED_ARG(op);
 
818
        SLJIT_UNUSED_ARG(dst);
 
819
        SLJIT_UNUSED_ARG(dstw);
 
820
        SLJIT_UNUSED_ARG(src);
 
821
        SLJIT_UNUSED_ARG(srcw);
 
822
 
 
823
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
824
        if (SLJIT_UNLIKELY(compiler->skip_checks)) {
 
825
                compiler->skip_checks = 0;
 
826
                return;
 
827
        }
 
828
#endif
 
829
 
 
830
        SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_CLZ);
 
831
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
832
        FUNCTION_CHECK_OP();
 
833
        FUNCTION_CHECK_SRC(src, srcw);
 
834
        FUNCTION_CHECK_DST(dst, dstw);
 
835
        FUNCTION_CHECK_OP1();
 
836
#endif
 
837
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
838
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
839
                fprintf(compiler->verbose, "  %s%s%s%s%s%s%s%s ", !(op & SLJIT_INT_OP) ? "" : "i", op_names[GET_OPCODE(op)],
 
840
                        !(op & SLJIT_SET_E) ? "" : "E", !(op & SLJIT_SET_S) ? "" : "S", !(op & SLJIT_SET_U) ? "" : "U", !(op & SLJIT_SET_O) ? "" : "O", !(op & SLJIT_SET_C) ? "" : "C", !(op & SLJIT_KEEP_FLAGS) ? "" : "K");
 
841
                sljit_verbose_param(dst, dstw);
 
842
                fprintf(compiler->verbose, ", ");
 
843
                sljit_verbose_param(src, srcw);
 
844
                fprintf(compiler->verbose, "\n");
 
845
        }
 
846
#endif
 
847
}
 
848
 
 
849
static SLJIT_INLINE void check_sljit_emit_op2(struct sljit_compiler *compiler, int op,
 
850
        int dst, sljit_w dstw,
 
851
        int src1, sljit_w src1w,
 
852
        int src2, sljit_w src2w)
 
853
{
 
854
        /* If debug and verbose are disabled, all arguments are unused. */
 
855
        SLJIT_UNUSED_ARG(compiler);
 
856
        SLJIT_UNUSED_ARG(op);
 
857
        SLJIT_UNUSED_ARG(dst);
 
858
        SLJIT_UNUSED_ARG(dstw);
 
859
        SLJIT_UNUSED_ARG(src1);
 
860
        SLJIT_UNUSED_ARG(src1w);
 
861
        SLJIT_UNUSED_ARG(src2);
 
862
        SLJIT_UNUSED_ARG(src2w);
 
863
 
 
864
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
865
        if (SLJIT_UNLIKELY(compiler->skip_checks)) {
 
866
                compiler->skip_checks = 0;
 
867
                return;
 
868
        }
 
869
#endif
 
870
 
 
871
        SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_ADD && GET_OPCODE(op) <= SLJIT_ASHR);
 
872
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
873
        FUNCTION_CHECK_OP();
 
874
        FUNCTION_CHECK_SRC(src1, src1w);
 
875
        FUNCTION_CHECK_SRC(src2, src2w);
 
876
        FUNCTION_CHECK_DST(dst, dstw);
 
877
#endif
 
878
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
879
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
880
                fprintf(compiler->verbose, "  %s%s%s%s%s%s%s%s ", !(op & SLJIT_INT_OP) ? "" : "i", op_names[GET_OPCODE(op)],
 
881
                        !(op & SLJIT_SET_E) ? "" : "E", !(op & SLJIT_SET_S) ? "" : "S", !(op & SLJIT_SET_U) ? "" : "U", !(op & SLJIT_SET_O) ? "" : "O", !(op & SLJIT_SET_C) ? "" : "C", !(op & SLJIT_KEEP_FLAGS) ? "" : "K");
 
882
                sljit_verbose_param(dst, dstw);
 
883
                fprintf(compiler->verbose, ", ");
 
884
                sljit_verbose_param(src1, src1w);
 
885
                fprintf(compiler->verbose, ", ");
 
886
                sljit_verbose_param(src2, src2w);
 
887
                fprintf(compiler->verbose, "\n");
 
888
        }
 
889
#endif
 
890
}
 
891
 
 
892
static SLJIT_INLINE void check_sljit_get_register_index(int reg)
 
893
{
 
894
        SLJIT_UNUSED_ARG(reg);
 
895
        SLJIT_ASSERT(reg > 0 && reg <= SLJIT_NO_REGISTERS);
 
896
}
 
897
 
 
898
static SLJIT_INLINE void check_sljit_emit_op_custom(struct sljit_compiler *compiler,
 
899
        void *instruction, int size)
 
900
{
 
901
        SLJIT_UNUSED_ARG(compiler);
 
902
        SLJIT_UNUSED_ARG(instruction);
 
903
        SLJIT_UNUSED_ARG(size);
 
904
        SLJIT_ASSERT(instruction);
 
905
}
 
906
 
 
907
static SLJIT_INLINE void check_sljit_emit_fop1(struct sljit_compiler *compiler, int op,
 
908
        int dst, sljit_w dstw,
 
909
        int src, sljit_w srcw)
 
910
{
 
911
        /* If debug and verbose are disabled, all arguments are unused. */
 
912
        SLJIT_UNUSED_ARG(compiler);
 
913
        SLJIT_UNUSED_ARG(op);
 
914
        SLJIT_UNUSED_ARG(dst);
 
915
        SLJIT_UNUSED_ARG(dstw);
 
916
        SLJIT_UNUSED_ARG(src);
 
917
        SLJIT_UNUSED_ARG(srcw);
 
918
 
 
919
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
920
        if (SLJIT_UNLIKELY(compiler->skip_checks)) {
 
921
                compiler->skip_checks = 0;
 
922
                return;
 
923
        }
 
924
#endif
 
925
 
 
926
        SLJIT_ASSERT(sljit_is_fpu_available());
 
927
        SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_FCMP && GET_OPCODE(op) <= SLJIT_FABS);
 
928
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
929
        FUNCTION_CHECK_OP();
 
930
        FUNCTION_FCHECK(src, srcw);
 
931
        FUNCTION_FCHECK(dst, dstw);
 
932
#endif
 
933
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
934
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
935
                fprintf(compiler->verbose, "  %s%s%s ", op_names[GET_OPCODE(op)],
 
936
                        !(op & SLJIT_SET_E) ? "" : "E", !(op & SLJIT_SET_S) ? "" : "S");
 
937
                sljit_verbose_fparam(dst, dstw);
 
938
                fprintf(compiler->verbose, ", ");
 
939
                sljit_verbose_fparam(src, srcw);
 
940
                fprintf(compiler->verbose, "\n");
 
941
        }
 
942
#endif
 
943
}
 
944
 
 
945
static SLJIT_INLINE void check_sljit_emit_fop2(struct sljit_compiler *compiler, int op,
 
946
        int dst, sljit_w dstw,
 
947
        int src1, sljit_w src1w,
 
948
        int src2, sljit_w src2w)
 
949
{
 
950
        /* If debug and verbose are disabled, all arguments are unused. */
 
951
        SLJIT_UNUSED_ARG(compiler);
 
952
        SLJIT_UNUSED_ARG(op);
 
953
        SLJIT_UNUSED_ARG(dst);
 
954
        SLJIT_UNUSED_ARG(dstw);
 
955
        SLJIT_UNUSED_ARG(src1);
 
956
        SLJIT_UNUSED_ARG(src1w);
 
957
        SLJIT_UNUSED_ARG(src2);
 
958
        SLJIT_UNUSED_ARG(src2w);
 
959
 
 
960
        SLJIT_ASSERT(sljit_is_fpu_available());
 
961
        SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_FADD && GET_OPCODE(op) <= SLJIT_FDIV);
 
962
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
963
        FUNCTION_CHECK_OP();
 
964
        FUNCTION_FCHECK(src1, src1w);
 
965
        FUNCTION_FCHECK(src2, src2w);
 
966
        FUNCTION_FCHECK(dst, dstw);
 
967
#endif
 
968
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
969
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
970
                fprintf(compiler->verbose, "  %s ", op_names[GET_OPCODE(op)]);
 
971
                sljit_verbose_fparam(dst, dstw);
 
972
                fprintf(compiler->verbose, ", ");
 
973
                sljit_verbose_fparam(src1, src1w);
 
974
                fprintf(compiler->verbose, ", ");
 
975
                sljit_verbose_fparam(src2, src2w);
 
976
                fprintf(compiler->verbose, "\n");
 
977
        }
 
978
#endif
 
979
}
 
980
 
 
981
static SLJIT_INLINE void check_sljit_emit_label(struct sljit_compiler *compiler)
 
982
{
 
983
        /* If debug and verbose are disabled, all arguments are unused. */
 
984
        SLJIT_UNUSED_ARG(compiler);
 
985
 
 
986
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
987
        if (SLJIT_UNLIKELY(!!compiler->verbose))
 
988
                fprintf(compiler->verbose, "label:\n");
 
989
#endif
 
990
}
 
991
 
 
992
static SLJIT_INLINE void check_sljit_emit_jump(struct sljit_compiler *compiler, int type)
 
993
{
 
994
        /* If debug and verbose are disabled, all arguments are unused. */
 
995
        SLJIT_UNUSED_ARG(compiler);
 
996
        SLJIT_UNUSED_ARG(type);
 
997
 
 
998
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
999
        if (SLJIT_UNLIKELY(compiler->skip_checks)) {
 
1000
                compiler->skip_checks = 0;
 
1001
                return;
 
1002
        }
 
1003
#endif
 
1004
 
 
1005
        SLJIT_ASSERT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP)));
 
1006
        SLJIT_ASSERT((type & 0xff) >= SLJIT_C_EQUAL && (type & 0xff) <= SLJIT_CALL3);
 
1007
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
1008
        if (SLJIT_UNLIKELY(!!compiler->verbose))
 
1009
                fprintf(compiler->verbose, "  jump%s <%s>\n", !(type & SLJIT_REWRITABLE_JUMP) ? "" : "R", jump_names[type & 0xff]);
 
1010
#endif
 
1011
}
 
1012
 
 
1013
static SLJIT_INLINE void check_sljit_emit_cmp(struct sljit_compiler *compiler, int type,
 
1014
        int src1, sljit_w src1w,
 
1015
        int src2, sljit_w src2w)
 
1016
{
 
1017
        SLJIT_UNUSED_ARG(compiler);
 
1018
        SLJIT_UNUSED_ARG(type);
 
1019
        SLJIT_UNUSED_ARG(src1);
 
1020
        SLJIT_UNUSED_ARG(src1w);
 
1021
        SLJIT_UNUSED_ARG(src2);
 
1022
        SLJIT_UNUSED_ARG(src2w);
 
1023
 
 
1024
        SLJIT_ASSERT(!(type & ~(0xff | SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP)));
 
1025
        SLJIT_ASSERT((type & 0xff) >= SLJIT_C_EQUAL && (type & 0xff) <= SLJIT_C_SIG_LESS_EQUAL);
 
1026
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1027
        FUNCTION_CHECK_SRC(src1, src1w);
 
1028
        FUNCTION_CHECK_SRC(src2, src2w);
 
1029
#endif
 
1030
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
1031
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
1032
                fprintf(compiler->verbose, "  %scmp%s <%s> ", !(type & SLJIT_INT_OP) ? "" : "i", !(type & SLJIT_REWRITABLE_JUMP) ? "" : "R", jump_names[type & 0xff]);
 
1033
                sljit_verbose_param(src1, src1w);
 
1034
                fprintf(compiler->verbose, ", ");
 
1035
                sljit_verbose_param(src2, src2w);
 
1036
                fprintf(compiler->verbose, "\n");
 
1037
        }
 
1038
#endif
 
1039
}
 
1040
 
 
1041
static SLJIT_INLINE void check_sljit_emit_fcmp(struct sljit_compiler *compiler, int type,
 
1042
        int src1, sljit_w src1w,
 
1043
        int src2, sljit_w src2w)
 
1044
{
 
1045
        SLJIT_UNUSED_ARG(compiler);
 
1046
        SLJIT_UNUSED_ARG(type);
 
1047
        SLJIT_UNUSED_ARG(src1);
 
1048
        SLJIT_UNUSED_ARG(src1w);
 
1049
        SLJIT_UNUSED_ARG(src2);
 
1050
        SLJIT_UNUSED_ARG(src2w);
 
1051
 
 
1052
        SLJIT_ASSERT(sljit_is_fpu_available());
 
1053
        SLJIT_ASSERT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP)));
 
1054
        SLJIT_ASSERT((type & 0xff) >= SLJIT_C_FLOAT_EQUAL && (type & 0xff) <= SLJIT_C_FLOAT_NOT_NAN);
 
1055
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1056
        FUNCTION_FCHECK(src1, src1w);
 
1057
        FUNCTION_FCHECK(src2, src2w);
 
1058
#endif
 
1059
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
1060
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
1061
                fprintf(compiler->verbose, "  fcmp%s <%s> ", !(type & SLJIT_REWRITABLE_JUMP) ? "" : "R", jump_names[type & 0xff]);
 
1062
                sljit_verbose_fparam(src1, src1w);
 
1063
                fprintf(compiler->verbose, ", ");
 
1064
                sljit_verbose_fparam(src2, src2w);
 
1065
                fprintf(compiler->verbose, "\n");
 
1066
        }
 
1067
#endif
 
1068
}
 
1069
 
 
1070
static SLJIT_INLINE void check_sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)
 
1071
{
 
1072
        /* If debug and verbose are disabled, all arguments are unused. */
 
1073
        SLJIT_UNUSED_ARG(compiler);
 
1074
        SLJIT_UNUSED_ARG(type);
 
1075
        SLJIT_UNUSED_ARG(src);
 
1076
        SLJIT_UNUSED_ARG(srcw);
 
1077
 
 
1078
        SLJIT_ASSERT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);
 
1079
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1080
        FUNCTION_CHECK_SRC(src, srcw);
 
1081
#endif
 
1082
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
1083
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
1084
                fprintf(compiler->verbose, "  ijump <%s> ", jump_names[type]);
 
1085
                sljit_verbose_param(src, srcw);
 
1086
                fprintf(compiler->verbose, "\n");
 
1087
        }
 
1088
#endif
 
1089
}
 
1090
 
 
1091
static SLJIT_INLINE void check_sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)
 
1092
{
 
1093
        /* If debug and verbose are disabled, all arguments are unused. */
 
1094
        SLJIT_UNUSED_ARG(compiler);
 
1095
        SLJIT_UNUSED_ARG(op);
 
1096
        SLJIT_UNUSED_ARG(dst);
 
1097
        SLJIT_UNUSED_ARG(dstw);
 
1098
        SLJIT_UNUSED_ARG(type);
 
1099
 
 
1100
        SLJIT_ASSERT(type >= SLJIT_C_EQUAL && type < SLJIT_JUMP);
 
1101
        SLJIT_ASSERT(op == SLJIT_MOV || GET_OPCODE(op) == SLJIT_OR);
 
1102
        SLJIT_ASSERT(GET_ALL_FLAGS(op) == 0 || GET_ALL_FLAGS(op) == SLJIT_SET_E || GET_ALL_FLAGS(op) == SLJIT_KEEP_FLAGS);
 
1103
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1104
        FUNCTION_CHECK_DST(dst, dstw);
 
1105
#endif
 
1106
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
1107
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
1108
                fprintf(compiler->verbose, "  cond_set%s%s <%s> ", !(op & SLJIT_SET_E) ? "" : "E",
 
1109
                        !(op & SLJIT_KEEP_FLAGS) ? "" : "K", op_names[GET_OPCODE(op)]);
 
1110
                sljit_verbose_param(dst, dstw);
 
1111
                fprintf(compiler->verbose, ", <%s>\n", jump_names[type]);
 
1112
        }
 
1113
#endif
 
1114
}
 
1115
 
 
1116
static SLJIT_INLINE void check_sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w init_value)
 
1117
{
 
1118
        /* If debug and verbose are disabled, all arguments are unused. */
 
1119
        SLJIT_UNUSED_ARG(compiler);
 
1120
        SLJIT_UNUSED_ARG(dst);
 
1121
        SLJIT_UNUSED_ARG(dstw);
 
1122
        SLJIT_UNUSED_ARG(init_value);
 
1123
 
 
1124
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1125
        FUNCTION_CHECK_DST(dst, dstw);
 
1126
#endif
 
1127
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
1128
        if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 
1129
                fprintf(compiler->verbose, "  const ");
 
1130
                sljit_verbose_param(dst, dstw);
 
1131
                fprintf(compiler->verbose, ", #%"SLJIT_PRINT_D"d\n", init_value);
 
1132
        }
 
1133
#endif
 
1134
}
 
1135
 
 
1136
static SLJIT_INLINE int emit_mov_before_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)
 
1137
{
 
1138
        /* Return if don't need to do anything. */
 
1139
        if (op == SLJIT_UNUSED)
 
1140
                return SLJIT_SUCCESS;
 
1141
 
 
1142
#if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 
1143
        if (src == SLJIT_RETURN_REG && op == SLJIT_MOV)
 
1144
                return SLJIT_SUCCESS;
 
1145
#else
 
1146
        if (src == SLJIT_RETURN_REG && (op == SLJIT_MOV || op == SLJIT_MOV_UI || op == SLJIT_MOV_SI))
 
1147
                return SLJIT_SUCCESS;
 
1148
#endif
 
1149
 
 
1150
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1151
        compiler->skip_checks = 1;
 
1152
#endif
 
1153
        return sljit_emit_op1(compiler, op, SLJIT_RETURN_REG, 0, src, srcw);
 
1154
}
 
1155
 
 
1156
/* CPU description section */
 
1157
 
 
1158
#if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE)
 
1159
#define SLJIT_CPUINFO_PART1 " 32bit ("
 
1160
#elif (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 
1161
#define SLJIT_CPUINFO_PART1 " 64bit ("
 
1162
#else
 
1163
#error "Internal error: CPU type info missing"
 
1164
#endif
 
1165
 
 
1166
#if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
 
1167
#define SLJIT_CPUINFO_PART2 "little endian + "
 
1168
#elif (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN)
 
1169
#define SLJIT_CPUINFO_PART2 "big endian + "
 
1170
#else
 
1171
#error "Internal error: CPU type info missing"
 
1172
#endif
 
1173
 
 
1174
#if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED)
 
1175
#define SLJIT_CPUINFO_PART3 "unaligned)"
 
1176
#else
 
1177
#define SLJIT_CPUINFO_PART3 "aligned)"
 
1178
#endif
 
1179
 
 
1180
#define SLJIT_CPUINFO SLJIT_CPUINFO_PART1 SLJIT_CPUINFO_PART2 SLJIT_CPUINFO_PART3
 
1181
 
 
1182
#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
 
1183
        #include "sljitNativeX86_common.c"
 
1184
#elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
 
1185
        #include "sljitNativeX86_common.c"
 
1186
#elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
 
1187
        #include "sljitNativeARM_v5.c"
 
1188
#elif (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
 
1189
        #include "sljitNativeARM_v5.c"
 
1190
#elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
 
1191
        #include "sljitNativeARM_Thumb2.c"
 
1192
#elif (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
 
1193
        #include "sljitNativePPC_common.c"
 
1194
#elif (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
 
1195
        #include "sljitNativePPC_common.c"
 
1196
#elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
 
1197
        #include "sljitNativeMIPS_common.c"
 
1198
#endif
 
1199
 
 
1200
#if !(defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
 
1201
 
 
1202
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, int type,
 
1203
        int src1, sljit_w src1w,
 
1204
        int src2, sljit_w src2w)
 
1205
{
 
1206
        /* Default compare for most architectures. */
 
1207
        int flags, tmp_src, condition;
 
1208
        sljit_w tmp_srcw;
 
1209
 
 
1210
        CHECK_ERROR_PTR();
 
1211
        check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);
 
1212
 
 
1213
        condition = type & 0xff;
 
1214
        if (SLJIT_UNLIKELY((src1 & SLJIT_IMM) && !(src2 & SLJIT_IMM))) {
 
1215
                /* Immediate is prefered as second argument by most architectures. */
 
1216
                switch (condition) {
 
1217
                case SLJIT_C_LESS:
 
1218
                        condition = SLJIT_C_GREATER;
 
1219
                        break;
 
1220
                case SLJIT_C_GREATER_EQUAL:
 
1221
                        condition = SLJIT_C_LESS_EQUAL;
 
1222
                        break;
 
1223
                case SLJIT_C_GREATER:
 
1224
                        condition = SLJIT_C_LESS;
 
1225
                        break;
 
1226
                case SLJIT_C_LESS_EQUAL:
 
1227
                        condition = SLJIT_C_GREATER_EQUAL;
 
1228
                        break;
 
1229
                case SLJIT_C_SIG_LESS:
 
1230
                        condition = SLJIT_C_SIG_GREATER;
 
1231
                        break;
 
1232
                case SLJIT_C_SIG_GREATER_EQUAL:
 
1233
                        condition = SLJIT_C_SIG_LESS_EQUAL;
 
1234
                        break;
 
1235
                case SLJIT_C_SIG_GREATER:
 
1236
                        condition = SLJIT_C_SIG_LESS;
 
1237
                        break;
 
1238
                case SLJIT_C_SIG_LESS_EQUAL:
 
1239
                        condition = SLJIT_C_SIG_GREATER_EQUAL;
 
1240
                        break;
 
1241
                }
 
1242
                type = condition | (type & (SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP));
 
1243
                tmp_src = src1;
 
1244
                src1 = src2;
 
1245
                src2 = tmp_src;
 
1246
                tmp_srcw = src1w;
 
1247
                src1w = src2w;
 
1248
                src2w = tmp_srcw;
 
1249
        }
 
1250
 
 
1251
        if (condition <= SLJIT_C_NOT_ZERO)
 
1252
                flags = SLJIT_SET_E;
 
1253
        else if (condition <= SLJIT_C_LESS_EQUAL)
 
1254
                flags = SLJIT_SET_U;
 
1255
        else
 
1256
                flags = SLJIT_SET_S;
 
1257
 
 
1258
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1259
        compiler->skip_checks = 1;
 
1260
#endif
 
1261
        PTR_FAIL_IF(sljit_emit_op2(compiler, SLJIT_SUB | flags | (type & SLJIT_INT_OP),
 
1262
                SLJIT_UNUSED, 0, src1, src1w, src2, src2w));
 
1263
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1264
        compiler->skip_checks = 1;
 
1265
#endif
 
1266
        return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
 
1267
}
 
1268
 
 
1269
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, int type,
 
1270
        int src1, sljit_w src1w,
 
1271
        int src2, sljit_w src2w)
 
1272
{
 
1273
        int flags, condition;
 
1274
 
 
1275
        check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w);
 
1276
 
 
1277
        condition = type & 0xff;
 
1278
        if (condition <= SLJIT_C_FLOAT_NOT_EQUAL)
 
1279
                flags = SLJIT_SET_E;
 
1280
        else
 
1281
                flags = SLJIT_SET_S;
 
1282
 
 
1283
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1284
        compiler->skip_checks = 1;
 
1285
#endif
 
1286
        sljit_emit_fop1(compiler, SLJIT_FCMP | flags, src1, src1w, src2, src2w);
 
1287
 
 
1288
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 
1289
        compiler->skip_checks = 1;
 
1290
#endif
 
1291
        return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
 
1292
}
 
1293
 
 
1294
#endif
 
1295
 
 
1296
#else /* SLJIT_CONFIG_UNSUPPORTED */
 
1297
 
 
1298
/* Empty function bodies for those machines, which are not (yet) supported. */
 
1299
 
 
1300
SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char* sljit_get_platform_name()
 
1301
{
 
1302
        return "unsupported";
 
1303
}
 
1304
 
 
1305
SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void)
 
1306
{
 
1307
        SLJIT_ASSERT_STOP();
 
1308
        return NULL;
 
1309
}
 
1310
 
 
1311
SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler)
 
1312
{
 
1313
        SLJIT_UNUSED_ARG(compiler);
 
1314
        SLJIT_ASSERT_STOP();
 
1315
}
 
1316
 
 
1317
SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, int size)
 
1318
{
 
1319
        SLJIT_UNUSED_ARG(compiler);
 
1320
        SLJIT_UNUSED_ARG(size);
 
1321
        SLJIT_ASSERT_STOP();
 
1322
        return NULL;
 
1323
}
 
1324
 
 
1325
#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 
1326
SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose)
 
1327
{
 
1328
        SLJIT_UNUSED_ARG(compiler);
 
1329
        SLJIT_UNUSED_ARG(verbose);
 
1330
        SLJIT_ASSERT_STOP();
 
1331
}
 
1332
#endif
 
1333
 
 
1334
SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
 
1335
{
 
1336
        SLJIT_UNUSED_ARG(compiler);
 
1337
        SLJIT_ASSERT_STOP();
 
1338
        return NULL;
 
1339
}
 
1340
 
 
1341
SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
 
1342
{
 
1343
        SLJIT_UNUSED_ARG(code);
 
1344
        SLJIT_ASSERT_STOP();
 
1345
}
 
1346
 
 
1347
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
 
1348
{
 
1349
        SLJIT_UNUSED_ARG(compiler);
 
1350
        SLJIT_UNUSED_ARG(args);
 
1351
        SLJIT_UNUSED_ARG(temporaries);
 
1352
        SLJIT_UNUSED_ARG(saveds);
 
1353
        SLJIT_UNUSED_ARG(local_size);
 
1354
        SLJIT_ASSERT_STOP();
 
1355
        return SLJIT_ERR_UNSUPPORTED;
 
1356
}
 
1357
 
 
1358
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
 
1359
{
 
1360
        SLJIT_UNUSED_ARG(compiler);
 
1361
        SLJIT_UNUSED_ARG(args);
 
1362
        SLJIT_UNUSED_ARG(temporaries);
 
1363
        SLJIT_UNUSED_ARG(saveds);
 
1364
        SLJIT_UNUSED_ARG(local_size);
 
1365
        SLJIT_ASSERT_STOP();
 
1366
}
 
1367
 
 
1368
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)
 
1369
{
 
1370
        SLJIT_UNUSED_ARG(compiler);
 
1371
        SLJIT_UNUSED_ARG(op);
 
1372
        SLJIT_UNUSED_ARG(src);
 
1373
        SLJIT_UNUSED_ARG(srcw);
 
1374
        SLJIT_ASSERT_STOP();
 
1375
        return SLJIT_ERR_UNSUPPORTED;
 
1376
}
 
1377
 
 
1378
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw, int args, int temporaries, int saveds, int local_size)
 
1379
{
 
1380
        SLJIT_UNUSED_ARG(compiler);
 
1381
        SLJIT_UNUSED_ARG(dst);
 
1382
        SLJIT_UNUSED_ARG(dstw);
 
1383
        SLJIT_UNUSED_ARG(args);
 
1384
        SLJIT_UNUSED_ARG(temporaries);
 
1385
        SLJIT_UNUSED_ARG(saveds);
 
1386
        SLJIT_UNUSED_ARG(local_size);
 
1387
        SLJIT_ASSERT_STOP();
 
1388
        return SLJIT_ERR_UNSUPPORTED;
 
1389
}
 
1390
 
 
1391
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
 
1392
{
 
1393
        SLJIT_UNUSED_ARG(compiler);
 
1394
        SLJIT_UNUSED_ARG(src);
 
1395
        SLJIT_UNUSED_ARG(srcw);
 
1396
        SLJIT_ASSERT_STOP();
 
1397
        return SLJIT_ERR_UNSUPPORTED;
 
1398
}
 
1399
 
 
1400
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op0(struct sljit_compiler *compiler, int op)
 
1401
{
 
1402
        SLJIT_UNUSED_ARG(compiler);
 
1403
        SLJIT_UNUSED_ARG(op);
 
1404
        SLJIT_ASSERT_STOP();
 
1405
        return SLJIT_ERR_UNSUPPORTED;
 
1406
}
 
1407
 
 
1408
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct sljit_compiler *compiler, int op,
 
1409
        int dst, sljit_w dstw,
 
1410
        int src, sljit_w srcw)
 
1411
{
 
1412
        SLJIT_UNUSED_ARG(compiler);
 
1413
        SLJIT_UNUSED_ARG(op);
 
1414
        SLJIT_UNUSED_ARG(dst);
 
1415
        SLJIT_UNUSED_ARG(dstw);
 
1416
        SLJIT_UNUSED_ARG(src);
 
1417
        SLJIT_UNUSED_ARG(srcw);
 
1418
        SLJIT_ASSERT_STOP();
 
1419
        return SLJIT_ERR_UNSUPPORTED;
 
1420
}
 
1421
 
 
1422
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct sljit_compiler *compiler, int op,
 
1423
        int dst, sljit_w dstw,
 
1424
        int src1, sljit_w src1w,
 
1425
        int src2, sljit_w src2w)
 
1426
{
 
1427
        SLJIT_UNUSED_ARG(compiler);
 
1428
        SLJIT_UNUSED_ARG(op);
 
1429
        SLJIT_UNUSED_ARG(dst);
 
1430
        SLJIT_UNUSED_ARG(dstw);
 
1431
        SLJIT_UNUSED_ARG(src1);
 
1432
        SLJIT_UNUSED_ARG(src1w);
 
1433
        SLJIT_UNUSED_ARG(src2);
 
1434
        SLJIT_UNUSED_ARG(src2w);
 
1435
        SLJIT_ASSERT_STOP();
 
1436
        return SLJIT_ERR_UNSUPPORTED;
 
1437
}
 
1438
 
 
1439
SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg)
 
1440
{
 
1441
        SLJIT_ASSERT_STOP();
 
1442
        return reg;
 
1443
}
 
1444
 
 
1445
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op_custom(struct sljit_compiler *compiler,
 
1446
        void *instruction, int size)
 
1447
{
 
1448
        SLJIT_UNUSED_ARG(compiler);
 
1449
        SLJIT_UNUSED_ARG(instruction);
 
1450
        SLJIT_UNUSED_ARG(size);
 
1451
        SLJIT_ASSERT_STOP();
 
1452
        return SLJIT_ERR_UNSUPPORTED;
 
1453
}
 
1454
 
 
1455
SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)
 
1456
{
 
1457
        SLJIT_ASSERT_STOP();
 
1458
        return 0;
 
1459
}
 
1460
 
 
1461
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,
 
1462
        int dst, sljit_w dstw,
 
1463
        int src, sljit_w srcw)
 
1464
{
 
1465
        SLJIT_UNUSED_ARG(compiler);
 
1466
        SLJIT_UNUSED_ARG(op);
 
1467
        SLJIT_UNUSED_ARG(dst);
 
1468
        SLJIT_UNUSED_ARG(dstw);
 
1469
        SLJIT_UNUSED_ARG(src);
 
1470
        SLJIT_UNUSED_ARG(srcw);
 
1471
        SLJIT_ASSERT_STOP();
 
1472
        return SLJIT_ERR_UNSUPPORTED;
 
1473
}
 
1474
 
 
1475
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,
 
1476
        int dst, sljit_w dstw,
 
1477
        int src1, sljit_w src1w,
 
1478
        int src2, sljit_w src2w)
 
1479
{
 
1480
        SLJIT_UNUSED_ARG(compiler);
 
1481
        SLJIT_UNUSED_ARG(op);
 
1482
        SLJIT_UNUSED_ARG(dst);
 
1483
        SLJIT_UNUSED_ARG(dstw);
 
1484
        SLJIT_UNUSED_ARG(src1);
 
1485
        SLJIT_UNUSED_ARG(src1w);
 
1486
        SLJIT_UNUSED_ARG(src2);
 
1487
        SLJIT_UNUSED_ARG(src2w);
 
1488
        SLJIT_ASSERT_STOP();
 
1489
        return SLJIT_ERR_UNSUPPORTED;
 
1490
}
 
1491
 
 
1492
SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
 
1493
{
 
1494
        SLJIT_UNUSED_ARG(compiler);
 
1495
        SLJIT_ASSERT_STOP();
 
1496
        return NULL;
 
1497
}
 
1498
 
 
1499
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type)
 
1500
{
 
1501
        SLJIT_UNUSED_ARG(compiler);
 
1502
        SLJIT_UNUSED_ARG(type);
 
1503
        SLJIT_ASSERT_STOP();
 
1504
        return NULL;
 
1505
}
 
1506
 
 
1507
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, int type,
 
1508
        int src1, sljit_w src1w,
 
1509
        int src2, sljit_w src2w)
 
1510
{
 
1511
        SLJIT_UNUSED_ARG(compiler);
 
1512
        SLJIT_UNUSED_ARG(type);
 
1513
        SLJIT_UNUSED_ARG(src1);
 
1514
        SLJIT_UNUSED_ARG(src1w);
 
1515
        SLJIT_UNUSED_ARG(src2);
 
1516
        SLJIT_UNUSED_ARG(src2w);
 
1517
        SLJIT_ASSERT_STOP();
 
1518
        return NULL;
 
1519
}
 
1520
 
 
1521
SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, int type,
 
1522
        int src1, sljit_w src1w,
 
1523
        int src2, sljit_w src2w)
 
1524
{
 
1525
        SLJIT_UNUSED_ARG(compiler);
 
1526
        SLJIT_UNUSED_ARG(type);
 
1527
        SLJIT_UNUSED_ARG(src1);
 
1528
        SLJIT_UNUSED_ARG(src1w);
 
1529
        SLJIT_UNUSED_ARG(src2);
 
1530
        SLJIT_UNUSED_ARG(src2w);
 
1531
        SLJIT_ASSERT_STOP();
 
1532
        return NULL;
 
1533
}
 
1534
 
 
1535
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label)
 
1536
{
 
1537
        SLJIT_UNUSED_ARG(jump);
 
1538
        SLJIT_UNUSED_ARG(label);
 
1539
        SLJIT_ASSERT_STOP();
 
1540
}
 
1541
 
 
1542
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target)
 
1543
{
 
1544
        SLJIT_UNUSED_ARG(jump);
 
1545
        SLJIT_UNUSED_ARG(target);
 
1546
        SLJIT_ASSERT_STOP();
 
1547
}
 
1548
 
 
1549
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)
 
1550
{
 
1551
        SLJIT_UNUSED_ARG(compiler);
 
1552
        SLJIT_UNUSED_ARG(type);
 
1553
        SLJIT_UNUSED_ARG(src);
 
1554
        SLJIT_UNUSED_ARG(srcw);
 
1555
        SLJIT_ASSERT_STOP();
 
1556
        return SLJIT_ERR_UNSUPPORTED;
 
1557
}
 
1558
 
 
1559
SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)
 
1560
{
 
1561
        SLJIT_UNUSED_ARG(compiler);
 
1562
        SLJIT_UNUSED_ARG(op);
 
1563
        SLJIT_UNUSED_ARG(dst);
 
1564
        SLJIT_UNUSED_ARG(dstw);
 
1565
        SLJIT_UNUSED_ARG(type);
 
1566
        SLJIT_ASSERT_STOP();
 
1567
        return SLJIT_ERR_UNSUPPORTED;
 
1568
}
 
1569
 
 
1570
SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w initval)
 
1571
{
 
1572
        SLJIT_UNUSED_ARG(compiler);
 
1573
        SLJIT_UNUSED_ARG(dst);
 
1574
        SLJIT_UNUSED_ARG(dstw);
 
1575
        SLJIT_UNUSED_ARG(initval);
 
1576
        SLJIT_ASSERT_STOP();
 
1577
        return NULL;
 
1578
}
 
1579
 
 
1580
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)
 
1581
{
 
1582
        SLJIT_UNUSED_ARG(addr);
 
1583
        SLJIT_UNUSED_ARG(new_addr);
 
1584
        SLJIT_ASSERT_STOP();
 
1585
}
 
1586
 
 
1587
SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_w new_constant)
 
1588
{
 
1589
        SLJIT_UNUSED_ARG(addr);
 
1590
        SLJIT_UNUSED_ARG(new_constant);
 
1591
        SLJIT_ASSERT_STOP();
 
1592
}
 
1593
 
 
1594
#endif