/[pcre]/code/trunk/sljit/sljitLir.c
ViewVC logotype

Contents of /code/trunk/sljit/sljitLir.c

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.5