Annotation of embedaddon/pcre/sljit/sljitLir.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Stack-less Just-In-Time compiler
3: *
4: * Copyright 2009-2010 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without modification, are
7: * permitted provided that the following conditions are met:
8: *
9: * 1. Redistributions of source code must retain the above copyright notice, this list of
10: * conditions and the following disclaimer.
11: *
12: * 2. Redistributions in binary form must reproduce the above copyright notice, this list
13: * of conditions and the following disclaimer in the documentation and/or other materials
14: * provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
17: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
19: * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
21: * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
22: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
24: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25: */
26:
27: #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->generals = -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_GENERAL_REG1 && (r) <= SLJIT_GENERAL_REG3 && (r) <= SLJIT_GENERAL_REG1 - 1 + compiler->generals)) \
479:
480: #define FUNCTION_CHECK_SRC(p, i) \
481: SLJIT_ASSERT(compiler->temporaries != -1 && compiler->generals != -1); \
482: if (((p) >= SLJIT_TEMPORARY_REG1 && (p) <= SLJIT_TEMPORARY_REG1 - 1 + compiler->temporaries) || \
483: ((p) >= SLJIT_GENERAL_REG1 && (p) <= SLJIT_GENERAL_REG1 - 1 + compiler->generals) || \
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->generals != -1); \
502: if (((p) >= SLJIT_TEMPORARY_REG1 && (p) <= SLJIT_TEMPORARY_REG1 - 1 + compiler->temporaries) || \
503: ((p) >= SLJIT_GENERAL_REG1 && (p) <= SLJIT_GENERAL_REG1 - 1 + compiler->generals) || \
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*)"tmp_r1", (char*)"tmp_r2", (char*)"tmp_r3",
555: (char*)"tmp_er1", (char*)"tmp_er2", (char*)"gen_r1", (char*)"gen_r2",
556: (char*)"gen_r3", (char*)"gen_er1", (char*)"gen_er2", (char*)"stack_r"
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: /* op1 */
620: (char*)"mov", (char*)"mov.ub", (char*)"mov.sb", (char*)"mov.uh",
621: (char*)"mov.sh", (char*)"mov.ui", (char*)"mov.si", (char*)"movu",
622: (char*)"movu.ub", (char*)"movu.sb", (char*)"movu.uh", (char*)"movu.sh",
623: (char*)"movu.ui", (char*)"movu.si", (char*)"not", (char*)"neg",
624: (char*)"clz",
625: /* op2 */
626: (char*)"add", (char*)"addc", (char*)"sub", (char*)"subc",
627: (char*)"mul", (char*)"and", (char*)"or", (char*)"xor",
628: (char*)"shl", (char*)"lshr", (char*)"ashr",
629: /* fop1 */
630: (char*)"fcmp", (char*)"fmov", (char*)"fneg", (char*)"fabs",
631: /* fop2 */
632: (char*)"fadd", (char*)"fsub", (char*)"fmul", (char*)"fdiv"
633: };
634:
635: static char* jump_names[] = {
636: (char*)"c_equal", (char*)"c_not_equal",
637: (char*)"c_less", (char*)"c_greater_equal",
638: (char*)"c_greater", (char*)"c_less_equal",
639: (char*)"c_sig_less", (char*)"c_sig_greater_equal",
640: (char*)"c_sig_greater", (char*)"c_sig_less_equal",
641: (char*)"c_overflow", (char*)"c_not_overflow",
642: (char*)"c_mul_overflow", (char*)"c_mul_not_overflow",
643: (char*)"c_float_equal", (char*)"c_float_not_equal",
644: (char*)"c_float_less", (char*)"c_float_greater_equal",
645: (char*)"c_float_greater", (char*)"c_float_less_equal",
646: (char*)"c_float_nan", (char*)"c_float_not_nan",
647: (char*)"jump", (char*)"fast_call",
648: (char*)"call0", (char*)"call1", (char*)"call2", (char*)"call3"
649: };
650:
651: #endif
652:
653: /* --------------------------------------------------------------------- */
654: /* Arch dependent */
655: /* --------------------------------------------------------------------- */
656:
657: static SLJIT_INLINE void check_sljit_generate_code(struct sljit_compiler *compiler)
658: {
659: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
660: struct sljit_jump *jump;
661: #endif
662: /* If debug and verbose are disabled, all arguments are unused. */
663: SLJIT_UNUSED_ARG(compiler);
664:
665: SLJIT_ASSERT(compiler->size > 0);
666: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
667: jump = compiler->jumps;
668: while (jump) {
669: /* All jumps have target. */
670: SLJIT_ASSERT(jump->flags & (JUMP_LABEL | JUMP_ADDR));
671: jump = jump->next;
672: }
673: #endif
674: }
675:
676: static SLJIT_INLINE void check_sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size)
677: {
678: /* If debug and verbose are disabled, all arguments are unused. */
679: SLJIT_UNUSED_ARG(compiler);
680: SLJIT_UNUSED_ARG(args);
681: SLJIT_UNUSED_ARG(temporaries);
682: SLJIT_UNUSED_ARG(generals);
683: SLJIT_UNUSED_ARG(local_size);
684:
685: SLJIT_ASSERT(args >= 0 && args <= 3);
686: SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
687: SLJIT_ASSERT(generals >= 0 && generals <= SLJIT_NO_GEN_REGISTERS);
688: SLJIT_ASSERT(args <= generals);
689: SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
690: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
691: if (SLJIT_UNLIKELY(!!compiler->verbose))
692: fprintf(compiler->verbose, " enter args=%d temporaries=%d generals=%d local_size=%d\n", args, temporaries, generals, local_size);
693: #endif
694: }
695:
696: static SLJIT_INLINE void check_sljit_fake_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size)
697: {
698: /* If debug and verbose are disabled, all arguments are unused. */
699: SLJIT_UNUSED_ARG(compiler);
700: SLJIT_UNUSED_ARG(args);
701: SLJIT_UNUSED_ARG(temporaries);
702: SLJIT_UNUSED_ARG(generals);
703: SLJIT_UNUSED_ARG(local_size);
704:
705: SLJIT_ASSERT(args >= 0 && args <= 3);
706: SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
707: SLJIT_ASSERT(generals >= 0 && generals <= SLJIT_NO_GEN_REGISTERS);
708: SLJIT_ASSERT(args <= generals);
709: SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
710: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
711: if (SLJIT_UNLIKELY(!!compiler->verbose))
712: fprintf(compiler->verbose, " fake_enter args=%d temporaries=%d generals=%d local_size=%d\n", args, temporaries, generals, local_size);
713: #endif
714: }
715:
716: static SLJIT_INLINE void check_sljit_emit_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
717: {
718: /* If debug and verbose are disabled, all arguments are unused. */
719: SLJIT_UNUSED_ARG(compiler);
720: SLJIT_UNUSED_ARG(src);
721: SLJIT_UNUSED_ARG(srcw);
722:
723: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
724: if (src != SLJIT_UNUSED) {
725: FUNCTION_CHECK_SRC(src, srcw);
726: }
727: else
728: SLJIT_ASSERT(srcw == 0);
729: #endif
730: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
731: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
732: fprintf(compiler->verbose, " return ");
733: sljit_verbose_param(src, srcw);
734: fprintf(compiler->verbose, "\n");
735: }
736: #endif
737: }
738:
739: static SLJIT_INLINE void check_sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw, int args, int temporaries, int generals, int local_size)
740: {
741: /* If debug and verbose are disabled, all arguments are unused. */
742: SLJIT_UNUSED_ARG(compiler);
743: SLJIT_UNUSED_ARG(dst);
744: SLJIT_UNUSED_ARG(dstw);
745: SLJIT_UNUSED_ARG(args);
746: SLJIT_UNUSED_ARG(temporaries);
747: SLJIT_UNUSED_ARG(generals);
748: SLJIT_UNUSED_ARG(local_size);
749:
750: SLJIT_ASSERT(args >= 0 && args <= 3);
751: SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
752: SLJIT_ASSERT(generals >= 0 && generals <= SLJIT_NO_GEN_REGISTERS);
753: SLJIT_ASSERT(args <= generals);
754: SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
755: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
756: compiler->temporaries = temporaries;
757: compiler->generals = generals;
758: FUNCTION_CHECK_DST(dst, dstw);
759: compiler->temporaries = -1;
760: compiler->generals = -1;
761: #endif
762: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
763: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
764: fprintf(compiler->verbose, " fast_enter ");
765: sljit_verbose_param(dst, dstw);
766: fprintf(compiler->verbose, " args=%d temporaries=%d generals=%d local_size=%d\n", args, temporaries, generals, local_size);
767: }
768: #endif
769: }
770:
771: static SLJIT_INLINE void check_sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
772: {
773: /* If debug and verbose are disabled, all arguments are unused. */
774: SLJIT_UNUSED_ARG(compiler);
775: SLJIT_UNUSED_ARG(src);
776: SLJIT_UNUSED_ARG(srcw);
777:
778: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
779: FUNCTION_CHECK_SRC(src, srcw);
780: #endif
781: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
782: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
783: fprintf(compiler->verbose, " fast_return ");
784: sljit_verbose_param(src, srcw);
785: fprintf(compiler->verbose, "\n");
786: }
787: #endif
788: }
789:
790: static SLJIT_INLINE void check_sljit_emit_op0(struct sljit_compiler *compiler, int op)
791: {
792: /* If debug and verbose are disabled, all arguments are unused. */
793: SLJIT_UNUSED_ARG(compiler);
794: SLJIT_UNUSED_ARG(op);
795:
796: SLJIT_ASSERT(op >= SLJIT_BREAKPOINT && op <= SLJIT_NOP);
797: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
798: if (SLJIT_UNLIKELY(!!compiler->verbose))
799: fprintf(compiler->verbose, " %s\n", op_names[op]);
800: #endif
801: }
802:
803: static SLJIT_INLINE void check_sljit_emit_op1(struct sljit_compiler *compiler, int op,
804: int dst, sljit_w dstw,
805: int src, sljit_w srcw)
806: {
807: /* If debug and verbose are disabled, all arguments are unused. */
808: SLJIT_UNUSED_ARG(compiler);
809: SLJIT_UNUSED_ARG(op);
810: SLJIT_UNUSED_ARG(dst);
811: SLJIT_UNUSED_ARG(dstw);
812: SLJIT_UNUSED_ARG(src);
813: SLJIT_UNUSED_ARG(srcw);
814:
815: SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_CLZ);
816: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
817: FUNCTION_CHECK_OP();
818: FUNCTION_CHECK_SRC(src, srcw);
819: FUNCTION_CHECK_DST(dst, dstw);
820: FUNCTION_CHECK_OP1();
821: #endif
822: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
823: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
824: fprintf(compiler->verbose, " %s%s%s%s%s%s%s%s ", !(op & SLJIT_INT_OP) ? "" : "i", op_names[GET_OPCODE(op)],
825: !(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");
826: sljit_verbose_param(dst, dstw);
827: fprintf(compiler->verbose, ", ");
828: sljit_verbose_param(src, srcw);
829: fprintf(compiler->verbose, "\n");
830: }
831: #endif
832: }
833:
834: static SLJIT_INLINE void check_sljit_emit_op2(struct sljit_compiler *compiler, int op,
835: int dst, sljit_w dstw,
836: int src1, sljit_w src1w,
837: int src2, sljit_w src2w)
838: {
839: /* If debug and verbose are disabled, all arguments are unused. */
840: SLJIT_UNUSED_ARG(compiler);
841: SLJIT_UNUSED_ARG(op);
842: SLJIT_UNUSED_ARG(dst);
843: SLJIT_UNUSED_ARG(dstw);
844: SLJIT_UNUSED_ARG(src1);
845: SLJIT_UNUSED_ARG(src1w);
846: SLJIT_UNUSED_ARG(src2);
847: SLJIT_UNUSED_ARG(src2w);
848:
849: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
850: if (SLJIT_UNLIKELY(compiler->skip_checks)) {
851: compiler->skip_checks = 0;
852: return;
853: }
854: #endif
855:
856: SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_ADD && GET_OPCODE(op) <= SLJIT_ASHR);
857: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
858: FUNCTION_CHECK_OP();
859: FUNCTION_CHECK_SRC(src1, src1w);
860: FUNCTION_CHECK_SRC(src2, src2w);
861: FUNCTION_CHECK_DST(dst, dstw);
862: #endif
863: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
864: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
865: fprintf(compiler->verbose, " %s%s%s%s%s%s%s%s ", !(op & SLJIT_INT_OP) ? "" : "i", op_names[GET_OPCODE(op)],
866: !(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");
867: sljit_verbose_param(dst, dstw);
868: fprintf(compiler->verbose, ", ");
869: sljit_verbose_param(src1, src1w);
870: fprintf(compiler->verbose, ", ");
871: sljit_verbose_param(src2, src2w);
872: fprintf(compiler->verbose, "\n");
873: }
874: #endif
875: }
876:
877: static SLJIT_INLINE void check_sljit_emit_fop1(struct sljit_compiler *compiler, int op,
878: int dst, sljit_w dstw,
879: int src, sljit_w srcw)
880: {
881: /* If debug and verbose are disabled, all arguments are unused. */
882: SLJIT_UNUSED_ARG(compiler);
883: SLJIT_UNUSED_ARG(op);
884: SLJIT_UNUSED_ARG(dst);
885: SLJIT_UNUSED_ARG(dstw);
886: SLJIT_UNUSED_ARG(src);
887: SLJIT_UNUSED_ARG(srcw);
888:
889: SLJIT_ASSERT(sljit_is_fpu_available());
890: SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_FCMP && GET_OPCODE(op) <= SLJIT_FABS);
891: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
892: FUNCTION_CHECK_OP();
893: FUNCTION_FCHECK(src, srcw);
894: FUNCTION_FCHECK(dst, dstw);
895: #endif
896: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
897: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
898: fprintf(compiler->verbose, " %s%s%s ", op_names[GET_OPCODE(op)],
899: !(op & SLJIT_SET_E) ? "" : "E", !(op & SLJIT_SET_S) ? "" : "S");
900: sljit_verbose_fparam(dst, dstw);
901: fprintf(compiler->verbose, ", ");
902: sljit_verbose_fparam(src, srcw);
903: fprintf(compiler->verbose, "\n");
904: }
905: #endif
906: }
907:
908: static SLJIT_INLINE void check_sljit_emit_fop2(struct sljit_compiler *compiler, int op,
909: int dst, sljit_w dstw,
910: int src1, sljit_w src1w,
911: int src2, sljit_w src2w)
912: {
913: /* If debug and verbose are disabled, all arguments are unused. */
914: SLJIT_UNUSED_ARG(compiler);
915: SLJIT_UNUSED_ARG(op);
916: SLJIT_UNUSED_ARG(dst);
917: SLJIT_UNUSED_ARG(dstw);
918: SLJIT_UNUSED_ARG(src1);
919: SLJIT_UNUSED_ARG(src1w);
920: SLJIT_UNUSED_ARG(src2);
921: SLJIT_UNUSED_ARG(src2w);
922:
923: SLJIT_ASSERT(sljit_is_fpu_available());
924: SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_FADD && GET_OPCODE(op) <= SLJIT_FDIV);
925: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
926: FUNCTION_CHECK_OP();
927: FUNCTION_FCHECK(src1, src1w);
928: FUNCTION_FCHECK(src2, src2w);
929: FUNCTION_FCHECK(dst, dstw);
930: #endif
931: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
932: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
933: fprintf(compiler->verbose, " %s ", op_names[GET_OPCODE(op)]);
934: sljit_verbose_fparam(dst, dstw);
935: fprintf(compiler->verbose, ", ");
936: sljit_verbose_fparam(src1, src1w);
937: fprintf(compiler->verbose, ", ");
938: sljit_verbose_fparam(src2, src2w);
939: fprintf(compiler->verbose, "\n");
940: }
941: #endif
942: }
943:
944: static SLJIT_INLINE void check_sljit_emit_label(struct sljit_compiler *compiler)
945: {
946: /* If debug and verbose are disabled, all arguments are unused. */
947: SLJIT_UNUSED_ARG(compiler);
948:
949: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
950: if (SLJIT_UNLIKELY(!!compiler->verbose))
951: fprintf(compiler->verbose, "label:\n");
952: #endif
953: }
954:
955: static SLJIT_INLINE void check_sljit_emit_jump(struct sljit_compiler *compiler, int type)
956: {
957: /* If debug and verbose are disabled, all arguments are unused. */
958: SLJIT_UNUSED_ARG(compiler);
959: SLJIT_UNUSED_ARG(type);
960:
961: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
962: if (SLJIT_UNLIKELY(compiler->skip_checks)) {
963: compiler->skip_checks = 0;
964: return;
965: }
966: #endif
967:
968: SLJIT_ASSERT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP)));
969: SLJIT_ASSERT((type & 0xff) >= SLJIT_C_EQUAL && (type & 0xff) <= SLJIT_CALL3);
970: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
971: if (SLJIT_UNLIKELY(!!compiler->verbose))
972: fprintf(compiler->verbose, " jump%s <%s>\n", !(type & SLJIT_REWRITABLE_JUMP) ? "" : "R", jump_names[type & 0xff]);
973: #endif
974: }
975:
976: static SLJIT_INLINE void check_sljit_emit_cmp(struct sljit_compiler *compiler, int type,
977: int src1, sljit_w src1w,
978: int src2, sljit_w src2w)
979: {
980: SLJIT_UNUSED_ARG(compiler);
981: SLJIT_UNUSED_ARG(type);
982: SLJIT_UNUSED_ARG(src1);
983: SLJIT_UNUSED_ARG(src1w);
984: SLJIT_UNUSED_ARG(src2);
985: SLJIT_UNUSED_ARG(src2w);
986:
987: SLJIT_ASSERT(!(type & ~(0xff | SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP)));
988: SLJIT_ASSERT((type & 0xff) >= SLJIT_C_EQUAL && (type & 0xff) <= SLJIT_C_SIG_LESS_EQUAL);
989: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
990: FUNCTION_CHECK_SRC(src1, src1w);
991: FUNCTION_CHECK_SRC(src2, src2w);
992: #endif
993: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
994: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
995: fprintf(compiler->verbose, " %scmp%s <%s> ", !(type & SLJIT_INT_OP) ? "" : "i", !(type & SLJIT_REWRITABLE_JUMP) ? "" : "R", jump_names[type & 0xff]);
996: sljit_verbose_param(src1, src1w);
997: fprintf(compiler->verbose, ", ");
998: sljit_verbose_param(src2, src2w);
999: fprintf(compiler->verbose, "\n");
1000: }
1001: #endif
1002: }
1003:
1004: static SLJIT_INLINE void check_sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)
1005: {
1006: /* If debug and verbose are disabled, all arguments are unused. */
1007: SLJIT_UNUSED_ARG(compiler);
1008: SLJIT_UNUSED_ARG(type);
1009: SLJIT_UNUSED_ARG(src);
1010: SLJIT_UNUSED_ARG(srcw);
1011:
1012: SLJIT_ASSERT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);
1013: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
1014: FUNCTION_CHECK_SRC(src, srcw);
1015: #endif
1016: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1017: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1018: fprintf(compiler->verbose, " ijump <%s> ", jump_names[type]);
1019: sljit_verbose_param(src, srcw);
1020: fprintf(compiler->verbose, "\n");
1021: }
1022: #endif
1023: }
1024:
1025: static SLJIT_INLINE void check_sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)
1026: {
1027: /* If debug and verbose are disabled, all arguments are unused. */
1028: SLJIT_UNUSED_ARG(compiler);
1029: SLJIT_UNUSED_ARG(op);
1030: SLJIT_UNUSED_ARG(dst);
1031: SLJIT_UNUSED_ARG(dstw);
1032: SLJIT_UNUSED_ARG(type);
1033:
1034: SLJIT_ASSERT(type >= SLJIT_C_EQUAL && type < SLJIT_JUMP);
1035: SLJIT_ASSERT(op == SLJIT_MOV || GET_OPCODE(op) == SLJIT_OR);
1036: SLJIT_ASSERT(GET_ALL_FLAGS(op) == 0 || GET_ALL_FLAGS(op) == SLJIT_SET_E || GET_ALL_FLAGS(op) == SLJIT_KEEP_FLAGS);
1037: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
1038: FUNCTION_CHECK_DST(dst, dstw);
1039: #endif
1040: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1041: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1042: fprintf(compiler->verbose, " cond_set%s%s <%s> ", !(op & SLJIT_SET_E) ? "" : "E",
1043: !(op & SLJIT_KEEP_FLAGS) ? "" : "K", op_names[GET_OPCODE(op)]);
1044: sljit_verbose_param(dst, dstw);
1045: fprintf(compiler->verbose, ", <%s>\n", jump_names[type]);
1046: }
1047: #endif
1048: }
1049:
1050: static SLJIT_INLINE void check_sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w init_value)
1051: {
1052: /* If debug and verbose are disabled, all arguments are unused. */
1053: SLJIT_UNUSED_ARG(compiler);
1054: SLJIT_UNUSED_ARG(dst);
1055: SLJIT_UNUSED_ARG(dstw);
1056: SLJIT_UNUSED_ARG(init_value);
1057:
1058: #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
1059: FUNCTION_CHECK_DST(dst, dstw);
1060: #endif
1061: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1062: if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1063: fprintf(compiler->verbose, " const ");
1064: sljit_verbose_param(dst, dstw);
1065: fprintf(compiler->verbose, ", #%"SLJIT_PRINT_D"d\n", init_value);
1066: }
1067: #endif
1068: }
1069:
1070: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1071: #include "sljitNativeX86_common.c"
1072: #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1073: #include "sljitNativeX86_common.c"
1074: #elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
1075: #include "sljitNativeARM_v5.c"
1076: #elif (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
1077: #include "sljitNativeARM_v5.c"
1078: #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
1079: #include "sljitNativeARM_Thumb2.c"
1080: #elif (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
1081: #include "sljitNativePPC_common.c"
1082: #elif (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1083: #include "sljitNativePPC_common.c"
1084: #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
1085: #include "sljitNativeMIPS_common.c"
1086: #endif
1087:
1088: #if !(defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
1089: SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, int type,
1090: int src1, sljit_w src1w,
1091: int src2, sljit_w src2w)
1092: {
1093: /* Default compare for most architectures. */
1094: int flags, tmp_src, condition;
1095: sljit_w tmp_srcw;
1096:
1097: CHECK_ERROR_PTR();
1098: check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);
1099:
1100: condition = type & 0xff;
1101: if (SLJIT_UNLIKELY((src1 & SLJIT_IMM) && !(src2 & SLJIT_IMM))) {
1102: /* Immediate is prefered as second argument by most architectures. */
1103: switch (condition) {
1104: case SLJIT_C_LESS:
1105: condition = SLJIT_C_GREATER;
1106: break;
1107: case SLJIT_C_GREATER_EQUAL:
1108: condition = SLJIT_C_LESS_EQUAL;
1109: break;
1110: case SLJIT_C_GREATER:
1111: condition = SLJIT_C_LESS;
1112: break;
1113: case SLJIT_C_LESS_EQUAL:
1114: condition = SLJIT_C_GREATER_EQUAL;
1115: break;
1116: case SLJIT_C_SIG_LESS:
1117: condition = SLJIT_C_SIG_GREATER;
1118: break;
1119: case SLJIT_C_SIG_GREATER_EQUAL:
1120: condition = SLJIT_C_SIG_LESS_EQUAL;
1121: break;
1122: case SLJIT_C_SIG_GREATER:
1123: condition = SLJIT_C_SIG_LESS;
1124: break;
1125: case SLJIT_C_SIG_LESS_EQUAL:
1126: condition = SLJIT_C_SIG_GREATER_EQUAL;
1127: break;
1128: }
1129: type = condition | (type & (SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP));
1130: tmp_src = src1;
1131: src1 = src2;
1132: src2 = tmp_src;
1133: tmp_srcw = src1w;
1134: src1w = src2w;
1135: src2w = tmp_srcw;
1136: }
1137:
1138: if (condition <= SLJIT_C_NOT_ZERO)
1139: flags = SLJIT_SET_E;
1140: else if (condition <= SLJIT_C_LESS_EQUAL)
1141: flags = SLJIT_SET_U;
1142: else
1143: flags = SLJIT_SET_S;
1144:
1145: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
1146: compiler->skip_checks = 1;
1147: #endif
1148: PTR_FAIL_IF(sljit_emit_op2(compiler, SLJIT_SUB | flags | (type & SLJIT_INT_OP),
1149: SLJIT_UNUSED, 0, src1, src1w, src2, src2w));
1150: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
1151: compiler->skip_checks = 1;
1152: #endif
1153: return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
1154: }
1155: #endif
1156:
1157: #else /* SLJIT_CONFIG_UNSUPPORTED */
1158:
1159: /* Empty function bodies for those machines, which are not (yet) supported. */
1160:
1161: SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char* sljit_get_platform_name()
1162: {
1163: return "unsupported";
1164: }
1165:
1166: SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void)
1167: {
1168: SLJIT_ASSERT_STOP();
1169: return NULL;
1170: }
1171:
1172: SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler)
1173: {
1174: SLJIT_UNUSED_ARG(compiler);
1175: SLJIT_ASSERT_STOP();
1176: }
1177:
1178: SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, int size)
1179: {
1180: SLJIT_UNUSED_ARG(compiler);
1181: SLJIT_UNUSED_ARG(size);
1182: SLJIT_ASSERT_STOP();
1183: return NULL;
1184: }
1185:
1186: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1187: SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose)
1188: {
1189: SLJIT_UNUSED_ARG(compiler);
1190: SLJIT_UNUSED_ARG(verbose);
1191: SLJIT_ASSERT_STOP();
1192: }
1193: #endif
1194:
1195: SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
1196: {
1197: SLJIT_UNUSED_ARG(compiler);
1198: SLJIT_ASSERT_STOP();
1199: return NULL;
1200: }
1201:
1202: SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
1203: {
1204: SLJIT_UNUSED_ARG(code);
1205: SLJIT_ASSERT_STOP();
1206: }
1207:
1208: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size)
1209: {
1210: SLJIT_UNUSED_ARG(compiler);
1211: SLJIT_UNUSED_ARG(args);
1212: SLJIT_UNUSED_ARG(temporaries);
1213: SLJIT_UNUSED_ARG(generals);
1214: SLJIT_UNUSED_ARG(local_size);
1215: SLJIT_ASSERT_STOP();
1216: return SLJIT_ERR_UNSUPPORTED;
1217: }
1218:
1219: SLJIT_API_FUNC_ATTRIBUTE void sljit_fake_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size)
1220: {
1221: SLJIT_UNUSED_ARG(compiler);
1222: SLJIT_UNUSED_ARG(args);
1223: SLJIT_UNUSED_ARG(temporaries);
1224: SLJIT_UNUSED_ARG(generals);
1225: SLJIT_UNUSED_ARG(local_size);
1226: SLJIT_ASSERT_STOP();
1227: }
1228:
1229: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
1230: {
1231: SLJIT_UNUSED_ARG(compiler);
1232: SLJIT_UNUSED_ARG(src);
1233: SLJIT_UNUSED_ARG(srcw);
1234: SLJIT_ASSERT_STOP();
1235: return SLJIT_ERR_UNSUPPORTED;
1236: }
1237:
1238: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw, int args, int temporaries, int generals, int local_size)
1239: {
1240: SLJIT_UNUSED_ARG(compiler);
1241: SLJIT_UNUSED_ARG(dst);
1242: SLJIT_UNUSED_ARG(dstw);
1243: SLJIT_UNUSED_ARG(args);
1244: SLJIT_UNUSED_ARG(temporaries);
1245: SLJIT_UNUSED_ARG(generals);
1246: SLJIT_UNUSED_ARG(local_size);
1247: SLJIT_ASSERT_STOP();
1248: return SLJIT_ERR_UNSUPPORTED;
1249: }
1250:
1251: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
1252: {
1253: SLJIT_UNUSED_ARG(compiler);
1254: SLJIT_UNUSED_ARG(src);
1255: SLJIT_UNUSED_ARG(srcw);
1256: SLJIT_ASSERT_STOP();
1257: return SLJIT_ERR_UNSUPPORTED;
1258: }
1259:
1260: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op0(struct sljit_compiler *compiler, int op)
1261: {
1262: SLJIT_UNUSED_ARG(compiler);
1263: SLJIT_UNUSED_ARG(op);
1264: SLJIT_ASSERT_STOP();
1265: return SLJIT_ERR_UNSUPPORTED;
1266: }
1267:
1268: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct sljit_compiler *compiler, int op,
1269: int dst, sljit_w dstw,
1270: int src, sljit_w srcw)
1271: {
1272: SLJIT_UNUSED_ARG(compiler);
1273: SLJIT_UNUSED_ARG(op);
1274: SLJIT_UNUSED_ARG(dst);
1275: SLJIT_UNUSED_ARG(dstw);
1276: SLJIT_UNUSED_ARG(src);
1277: SLJIT_UNUSED_ARG(srcw);
1278: SLJIT_ASSERT_STOP();
1279: return SLJIT_ERR_UNSUPPORTED;
1280: }
1281:
1282: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct sljit_compiler *compiler, int op,
1283: int dst, sljit_w dstw,
1284: int src1, sljit_w src1w,
1285: int src2, sljit_w src2w)
1286: {
1287: SLJIT_UNUSED_ARG(compiler);
1288: SLJIT_UNUSED_ARG(op);
1289: SLJIT_UNUSED_ARG(dst);
1290: SLJIT_UNUSED_ARG(dstw);
1291: SLJIT_UNUSED_ARG(src1);
1292: SLJIT_UNUSED_ARG(src1w);
1293: SLJIT_UNUSED_ARG(src2);
1294: SLJIT_UNUSED_ARG(src2w);
1295: SLJIT_ASSERT_STOP();
1296: return SLJIT_ERR_UNSUPPORTED;
1297: }
1298:
1299: SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)
1300: {
1301: SLJIT_ASSERT_STOP();
1302: return 0;
1303: }
1304:
1305: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,
1306: int dst, sljit_w dstw,
1307: int src, sljit_w srcw)
1308: {
1309: SLJIT_UNUSED_ARG(compiler);
1310: SLJIT_UNUSED_ARG(op);
1311: SLJIT_UNUSED_ARG(dst);
1312: SLJIT_UNUSED_ARG(dstw);
1313: SLJIT_UNUSED_ARG(src);
1314: SLJIT_UNUSED_ARG(srcw);
1315: SLJIT_ASSERT_STOP();
1316: return SLJIT_ERR_UNSUPPORTED;
1317: }
1318:
1319: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,
1320: int dst, sljit_w dstw,
1321: int src1, sljit_w src1w,
1322: int src2, sljit_w src2w)
1323: {
1324: SLJIT_UNUSED_ARG(compiler);
1325: SLJIT_UNUSED_ARG(op);
1326: SLJIT_UNUSED_ARG(dst);
1327: SLJIT_UNUSED_ARG(dstw);
1328: SLJIT_UNUSED_ARG(src1);
1329: SLJIT_UNUSED_ARG(src1w);
1330: SLJIT_UNUSED_ARG(src2);
1331: SLJIT_UNUSED_ARG(src2w);
1332: SLJIT_ASSERT_STOP();
1333: return SLJIT_ERR_UNSUPPORTED;
1334: }
1335:
1336: SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
1337: {
1338: SLJIT_UNUSED_ARG(compiler);
1339: SLJIT_ASSERT_STOP();
1340: return NULL;
1341: }
1342:
1343: SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type)
1344: {
1345: SLJIT_UNUSED_ARG(compiler);
1346: SLJIT_UNUSED_ARG(type);
1347: SLJIT_ASSERT_STOP();
1348: return NULL;
1349: }
1350:
1351: SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, int type,
1352: int src1, sljit_w src1w,
1353: int src2, sljit_w src2w)
1354: {
1355: SLJIT_UNUSED_ARG(compiler);
1356: SLJIT_UNUSED_ARG(type);
1357: SLJIT_UNUSED_ARG(src1);
1358: SLJIT_UNUSED_ARG(src1w);
1359: SLJIT_UNUSED_ARG(src2);
1360: SLJIT_UNUSED_ARG(src2w);
1361: SLJIT_ASSERT_STOP();
1362: return NULL;
1363: }
1364:
1365: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label)
1366: {
1367: SLJIT_UNUSED_ARG(jump);
1368: SLJIT_UNUSED_ARG(label);
1369: SLJIT_ASSERT_STOP();
1370: }
1371:
1372: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target)
1373: {
1374: SLJIT_UNUSED_ARG(jump);
1375: SLJIT_UNUSED_ARG(target);
1376: SLJIT_ASSERT_STOP();
1377: }
1378:
1379: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)
1380: {
1381: SLJIT_UNUSED_ARG(compiler);
1382: SLJIT_UNUSED_ARG(type);
1383: SLJIT_UNUSED_ARG(src);
1384: SLJIT_UNUSED_ARG(srcw);
1385: SLJIT_ASSERT_STOP();
1386: return SLJIT_ERR_UNSUPPORTED;
1387: }
1388:
1389: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)
1390: {
1391: SLJIT_UNUSED_ARG(compiler);
1392: SLJIT_UNUSED_ARG(op);
1393: SLJIT_UNUSED_ARG(dst);
1394: SLJIT_UNUSED_ARG(dstw);
1395: SLJIT_UNUSED_ARG(type);
1396: SLJIT_ASSERT_STOP();
1397: return SLJIT_ERR_UNSUPPORTED;
1398: }
1399:
1400: SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w initval)
1401: {
1402: SLJIT_UNUSED_ARG(compiler);
1403: SLJIT_UNUSED_ARG(dst);
1404: SLJIT_UNUSED_ARG(dstw);
1405: SLJIT_UNUSED_ARG(initval);
1406: SLJIT_ASSERT_STOP();
1407: return NULL;
1408: }
1409:
1410: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)
1411: {
1412: SLJIT_UNUSED_ARG(addr);
1413: SLJIT_UNUSED_ARG(new_addr);
1414: SLJIT_ASSERT_STOP();
1415: }
1416:
1417: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_w new_constant)
1418: {
1419: SLJIT_UNUSED_ARG(addr);
1420: SLJIT_UNUSED_ARG(new_constant);
1421: SLJIT_ASSERT_STOP();
1422: }
1423:
1424: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sljitLir.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre / sljit