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: #ifndef _SLJIT_LIR_H_
28: #define _SLJIT_LIR_H_
29:
30: /*
31: ------------------------------------------------------------------------
32: Stack-Less JIT compiler for multiple architectures (x86, ARM, PowerPC)
33: ------------------------------------------------------------------------
34:
35: Short description
36: Advantages:
37: - The execution can be continued from any LIR instruction
38: In other words, jump into and out of the code is safe
39: - Both target of (conditional) jump and call instructions
40: and constants can be dynamically modified during runtime
41: - although it is not suggested to do it frequently
42: - very effective to cache an important value once
43: - A fixed stack space can be allocated for local variables
44: - The compiler is thread-safe
45: Disadvantages:
46: - Limited number of registers (only 6+4 integer registers, max 3+2
47: temporary and max 3+2 general, and 4 floating point registers)
48: In practice:
49: - This approach is very effective for interpreters
50: - One of the general registers typically points to a stack interface
51: - It can jump to any exception handler anytime (even for another
52: function. It is safe for SLJIT.)
53: - Fast paths can be modified during runtime reflecting the changes
54: of the fastest execution path of the dynamic language
55: - SLJIT supports complex memory addressing modes
56: - mainly position independent code
57: - Optimizations (perhaps later)
58: - Only for basic blocks (when no labels inserted between LIR instructions)
59:
60: For valgrind users:
61: - pass --smc-check=all argument to valgrind, since JIT is a "self-modifying code"
62: */
63:
64: #if !(defined SLJIT_NO_DEFAULT_CONFIG && SLJIT_NO_DEFAULT_CONFIG)
65: #include "sljitConfig.h"
66: #endif
67: #include "sljitConfigInternal.h"
68:
69: /* --------------------------------------------------------------------- */
70: /* Error codes */
71: /* --------------------------------------------------------------------- */
72:
73: /* Indicates no error. */
74: #define SLJIT_SUCCESS 0
75: /* After the call of sljit_generate_code(), the error code of the compiler
76: is set to this value to avoid future sljit calls (in debug mode at least).
77: The complier should be freed after sljit_generate_code(). */
78: #define SLJIT_ERR_COMPILED 1
79: /* Cannot allocate non executable memory. */
80: #define SLJIT_ERR_ALLOC_FAILED 2
81: /* Cannot allocate executable memory.
82: Only for sljit_generate_code() */
83: #define SLJIT_ERR_EX_ALLOC_FAILED 3
84: /* return value for SLJIT_CONFIG_UNSUPPORTED empty architecture. */
85: #define SLJIT_ERR_UNSUPPORTED 4
86:
87: /* --------------------------------------------------------------------- */
88: /* Registers */
89: /* --------------------------------------------------------------------- */
90:
91: #define SLJIT_UNUSED 0
92:
93: /* Temporary (scratch) registers may not preserve their values across function calls. */
94: #define SLJIT_TEMPORARY_REG1 1
95: #define SLJIT_TEMPORARY_REG2 2
96: #define SLJIT_TEMPORARY_REG3 3
97: /* Note: Extra Registers cannot be used for memory addressing. */
98: /* Note: on x86-32, these registers are emulated (using stack loads & stores). */
99: #define SLJIT_TEMPORARY_EREG1 4
100: #define SLJIT_TEMPORARY_EREG2 5
101:
102: /* General (saved) registers preserve their values across function calls. */
103: #define SLJIT_GENERAL_REG1 6
104: #define SLJIT_GENERAL_REG2 7
105: #define SLJIT_GENERAL_REG3 8
106: /* Note: Extra Registers cannot be used for memory addressing. */
107: /* Note: on x86-32, these registers are emulated (using stack loads & stores). */
108: #define SLJIT_GENERAL_EREG1 9
109: #define SLJIT_GENERAL_EREG2 10
110:
111: /* Read-only register (cannot be the destination of an operation). */
112: /* Note: SLJIT_MEM2( ... , SLJIT_LOCALS_REG) is not supported (x86 limitation). */
113: /* Note: SLJIT_LOCALS_REG is not necessary the real stack pointer. See sljit_emit_enter. */
114: #define SLJIT_LOCALS_REG 11
115:
116: /* Number of registers. */
117: #define SLJIT_NO_TMP_REGISTERS 5
118: #define SLJIT_NO_GEN_REGISTERS 5
119: #define SLJIT_NO_REGISTERS 11
120:
121: /* Return with machine word. */
122:
123: #define SLJIT_RETURN_REG SLJIT_TEMPORARY_REG1
124:
125: /* x86 prefers temporary registers for special purposes. If other
126: registers are used such purpose, it costs a little performance
127: drawback. It doesn't matter for other archs. */
128:
129: #define SLJIT_PREF_SHIFT_REG SLJIT_TEMPORARY_REG3
130:
131: /* --------------------------------------------------------------------- */
132: /* Floating point registers */
133: /* --------------------------------------------------------------------- */
134:
135: /* Note: SLJIT_UNUSED as destination is not valid for floating point
136: operations, since they cannot be used for setting flags. */
137:
138: /* Floating point operations are performed on double precision values. */
139:
140: #define SLJIT_FLOAT_REG1 1
141: #define SLJIT_FLOAT_REG2 2
142: #define SLJIT_FLOAT_REG3 3
143: #define SLJIT_FLOAT_REG4 4
144:
145: /* --------------------------------------------------------------------- */
146: /* Main structures and functions */
147: /* --------------------------------------------------------------------- */
148:
149: struct sljit_memory_fragment {
150: struct sljit_memory_fragment *next;
151: sljit_uw used_size;
152: sljit_ub memory[1];
153: };
154:
155: struct sljit_label {
156: struct sljit_label *next;
157: sljit_uw addr;
158: /* The maximum size difference. */
159: sljit_uw size;
160: };
161:
162: struct sljit_jump {
163: struct sljit_jump *next;
164: sljit_uw addr;
165: sljit_w flags;
166: union {
167: sljit_uw target;
168: struct sljit_label* label;
169: } u;
170: };
171:
172: struct sljit_const {
173: struct sljit_const *next;
174: sljit_uw addr;
175: };
176:
177: struct sljit_compiler {
178: int error;
179:
180: struct sljit_label *labels;
181: struct sljit_jump *jumps;
182: struct sljit_const *consts;
183: struct sljit_label *last_label;
184: struct sljit_jump *last_jump;
185: struct sljit_const *last_const;
186:
187: struct sljit_memory_fragment *buf;
188: struct sljit_memory_fragment *abuf;
189:
190: /* Used local registers. */
191: int temporaries;
192: /* Used general registers. */
193: int generals;
194: /* Local stack size. */
195: int local_size;
196: /* Code size. */
197: sljit_uw size;
198: /* For statistical purposes. */
199: sljit_uw executable_size;
200:
201: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
202: int args;
203: int temporaries_start;
204: int generals_start;
205: #endif
206:
207: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
208: int mode32;
209: #ifdef _WIN64
210: int has_locals;
211: #endif
212: #endif
213:
214: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
215: int flags_saved;
216: #endif
217:
218: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
219: /* Constant pool handling. */
220: sljit_uw *cpool;
221: sljit_ub *cpool_unique;
222: sljit_uw cpool_diff;
223: sljit_uw cpool_fill;
224: /* General fields. */
225: /* Contains pointer, "ldr pc, [...]" pairs. */
226: sljit_uw patches;
227: #endif
228:
229: #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
230: /* Temporary fields. */
231: sljit_uw shift_imm;
232: int cache_arg;
233: sljit_w cache_argw;
234: #endif
235:
236: #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
237: int cache_arg;
238: sljit_w cache_argw;
239: #endif
240:
241: #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
242: int has_locals;
243: sljit_w imm;
244: int cache_arg;
245: sljit_w cache_argw;
246: #endif
247:
248: #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
249: int has_locals;
250: int delay_slot;
251: int cache_arg;
252: sljit_w cache_argw;
253: #endif
254:
255: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
256: FILE* verbose;
257: #endif
258:
259: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
260: int skip_checks;
261: #endif
262: };
263:
264: /* --------------------------------------------------------------------- */
265: /* Main functions */
266: /* --------------------------------------------------------------------- */
267:
268: /* Creates an sljit compiler.
269: Returns NULL if failed. */
270: SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void);
271: /* Free everything except the codes. */
272: SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler);
273:
274: static SLJIT_INLINE int sljit_get_compiler_error(struct sljit_compiler *compiler) { return compiler->error; }
275:
276: /*
277: Allocate a small amount of memory. The size must be <= 64 bytes on 32 bit,
278: and <= 128 bytes on 64 bit architectures. The memory area is owned by the compiler,
279: and freed by sljit_free_compiler. The returned pointer is sizeof(sljit_w) aligned.
280: Excellent for allocating small blocks during the compiling, and no need to worry
281: about freeing them. The size is enough to contain at most 16 pointers.
282: If the size is outside of the range, the function will return with NULL,
283: but this return value does not indicate that there is no more memory (does
284: not set the compiler to out-of-memory status).
285: */
286: SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, int size);
287:
288: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
289: /* Passing NULL disables verbose. */
290: SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose);
291: #endif
292:
293: SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler);
294: SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code);
295:
296: /*
297: After the code generation we can retrieve the allocated executable memory size,
298: although this area may not be fully filled with instructions depending on some
299: optimizations. This function is useful only for statistical purposes.
300:
301: Before a successful code generation, this function returns with 0.
302: */
303: static SLJIT_INLINE sljit_uw sljit_get_generated_code_size(struct sljit_compiler *compiler) { return compiler->executable_size; }
304:
305: /* Instruction generation. Returns with error code. */
306:
307: /*
308: Entry instruction. The instruction has "args" number of arguments
309: and will use the first "general" number of general registers.
310: The arguments are passed into the general registers (arg1 to general_reg1, and so on).
311: Thus, "args" must be less or equal than "general". A local_size extra
312: stack space is allocated for the jit code (must be less or equal than
313: SLJIT_MAX_LOCAL_SIZE), which can accessed through SLJIT_LOCALS_REG (see
314: the notes there). SLJIT_LOCALS_REG is not necessary the real stack pointer!
315: It just points somewhere in the stack if local_size > 0 (!). Thus, the only
316: thing which is known that the memory area between SLJIT_LOCALS_REG and
317: SLJIT_LOCALS_REG + local_size is a valid stack area if local_size > 0
318: */
319:
320: /* Note: multiple calls of this function overwrites the previous call. */
321:
322: #define SLJIT_MAX_LOCAL_SIZE 65536
323:
324: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size);
325:
326: /* Since sljit_emit_return (and many asserts) uses variables which are initialized
327: by sljit_emit_enter, a simple return is not possible if these variables are not
328: initialized. sljit_fake_enter does not emit any instruction, just initialize
329: those variables. */
330:
331: /* Note: multiple calls of this function overwrites the previous call. */
332:
333: SLJIT_API_FUNC_ATTRIBUTE void sljit_fake_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size);
334:
335: /* Return from jit. See below the possible values for src and srcw. */
336: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int src, sljit_w srcw);
337:
338: /* Really fast calling method for utility functions inside sljit (see SLJIT_FAST_CALL).
339: All registers and even the stack frame is passed to the callee. The return address is
340: preserved in dst/dstw by sljit_emit_fast_enter, and sljit_emit_fast_return can
341: use this as a return value later. */
342:
343: /* Note: only for sljit specific, non ABI compilant calls. Fast, since only a few machine instructions
344: are needed. Excellent for small uility functions, where saving general registers and setting up
345: a new stack frame would cost too much performance. However, it is still possible to return
346: to the address of the caller (or anywhere else). */
347:
348: /* Note: flags are not changed (unlike sljit_emit_enter / sljit_emit_return). */
349:
350: /* Note: although sljit_emit_fast_return could be replaced by an ijump, it is not suggested,
351: since many architectures do clever branch prediction on call / return instruction pairs. */
352:
353: 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);
354: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw);
355:
356: /*
357: Source and destination values for arithmetical instructions
358: imm - a simple immediate value (cannot be used as a destination)
359: reg - any of the registers (immediate argument must be 0)
360: [imm] - absolute immediate memory address
361: [reg+imm] - indirect memory address
362: [reg+(reg<<imm)] - indirect indexed memory address (shift must be between 0 and 3)
363: useful for (byte, half, int, sljit_w) array access
364: (fully supported by both x86 and ARM architectures, and cheap operation on others)
365: */
366:
367: /*
368: IMPORATNT NOTE: memory access MUST be naturally aligned.
369: length | alignment
370: ---------+-----------
371: byte | 1 byte (not aligned)
372: half | 2 byte (real_address & 0x1 == 0)
373: int | 4 byte (real_address & 0x3 == 0)
374: sljit_w | 4 byte if SLJIT_32BIT_ARCHITECTURE defined
375: | 8 byte if SLJIT_64BIT_ARCHITECTURE defined
376: (This is a strict requirement for embedded systems.)
377:
378: Note: different architectures have different addressing limitations
379: Thus sljit may generate several instructions for other addressing modes
380: x86: all addressing modes supported, but write-back is not supported
381: (requires an extra instruction). On x86-64 only 32 bit signed
382: integers are supported by the architecture.
383: arm: [reg+imm] supported for small immediates (-4095 <= imm <= 4095
384: or -255 <= imm <= 255 for loading signed bytes, any halfs or doubles)
385: [reg+(reg<<imm)] are supported or requires only two instructions
386: Write back is limited to small immediates on thumb2
387: ppc: [reg+imm], -65535 <= imm <= 65535. 64 bit moves requires immediates
388: divisible by 4. [reg+reg] supported, write-back supported
389: [reg+(reg<<imm)] (imm != 0) is cheap (requires two instructions)
390: */
391:
392: /* Register output: simply the name of the register.
393: For destination, you can use SLJIT_UNUSED as well. */
394: #define SLJIT_MEM 0x100
395: #define SLJIT_MEM0() (SLJIT_MEM)
396: #define SLJIT_MEM1(r1) (SLJIT_MEM | (r1))
397: #define SLJIT_MEM2(r1, r2) (SLJIT_MEM | (r1) | ((r2) << 4))
398: #define SLJIT_IMM 0x200
399:
400: /* Set 32 bit operation mode (I) on 64 bit CPUs. The flag is totally ignored on
401: 32 bit CPUs. The arithmetic instruction uses only the lower 32 bit of the
402: input register(s), and set the flags according to the 32 bit result. If the
403: destination is a register, the higher 32 bit of the result is undefined.
404: The addressing modes (SLJIT_MEM1/SLJIT_MEM2 macros) are unaffected by this flag. */
405: #define SLJIT_INT_OP 0x100
406:
407: /* Common CPU status flags for all architectures (x86, ARM, PPC)
408: - carry flag
409: - overflow flag
410: - zero flag
411: - negative/positive flag (depends on arc)
412: On mips, these flags are emulated by software. */
413:
414: /* By default, the instructions may, or may not set the CPU status flags.
415: Forcing to set or keep status flags can be done with the following flags: */
416:
417: /* Note: sljit tries to emit the minimum number of instructions. Using these
418: flags can increase them, so use them wisely to avoid unnecessary code generation. */
419:
420: /* Set Equal (Zero) status flag (E). */
421: #define SLJIT_SET_E 0x0200
422: /* Set signed status flag (S). */
423: #define SLJIT_SET_S 0x0400
424: /* Set unsgined status flag (U). */
425: #define SLJIT_SET_U 0x0800
426: /* Set signed overflow flag (O). */
427: #define SLJIT_SET_O 0x1000
428: /* Set carry flag (C).
429: Note: Kinda unsigned overflow, but behaves differently on various cpus. */
430: #define SLJIT_SET_C 0x2000
431: /* Do not modify the flags (K).
432: Note: This flag cannot be combined with any other SLJIT_SET_* flag. */
433: #define SLJIT_KEEP_FLAGS 0x4000
434:
435: /* Notes:
436: - you cannot postpone conditional jump instructions except if noted that
437: the instruction does not set flags (See: SLJIT_KEEP_FLAGS).
438: - flag combinations: '|' means 'logical or'. */
439:
440: /* Flags: - (never set any flags)
441: Note: breakpoint instruction is not supported by all architectures (namely ppc)
442: It falls back to SLJIT_NOP in those cases. */
443: #define SLJIT_BREAKPOINT 0
444: /* Flags: - (never set any flags)
445: Note: may or may not cause an extra cycle wait
446: it can even decrease the runtime in a few cases. */
447: #define SLJIT_NOP 1
448:
449: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op0(struct sljit_compiler *compiler, int op);
450:
451: /* Notes for MOV instructions:
452: U = Mov with update (post form). If source or destination defined as SLJIT_MEM1(r1)
453: or SLJIT_MEM2(r1, r2), r1 is increased by the sum of r2 and the constant argument
454: UB = unsigned byte (8 bit)
455: SB = signed byte (8 bit)
456: UH = unsgined half (16 bit)
457: SH = unsgined half (16 bit) */
458:
459: /* Flags: - (never set any flags) */
460: #define SLJIT_MOV 2
461: /* Flags: - (never set any flags) */
462: #define SLJIT_MOV_UB 3
463: /* Flags: - (never set any flags) */
464: #define SLJIT_MOV_SB 4
465: /* Flags: - (never set any flags) */
466: #define SLJIT_MOV_UH 5
467: /* Flags: - (never set any flags) */
468: #define SLJIT_MOV_SH 6
469: /* Flags: - (never set any flags) */
470: #define SLJIT_MOV_UI 7
471: /* Flags: - (never set any flags) */
472: #define SLJIT_MOV_SI 8
473: /* Flags: - (never set any flags) */
474: #define SLJIT_MOVU 9
475: /* Flags: - (never set any flags) */
476: #define SLJIT_MOVU_UB 10
477: /* Flags: - (never set any flags) */
478: #define SLJIT_MOVU_SB 11
479: /* Flags: - (never set any flags) */
480: #define SLJIT_MOVU_UH 12
481: /* Flags: - (never set any flags) */
482: #define SLJIT_MOVU_SH 13
483: /* Flags: - (never set any flags) */
484: #define SLJIT_MOVU_UI 14
485: /* Flags: - (never set any flags) */
486: #define SLJIT_MOVU_SI 15
487: /* Flags: I | E | K */
488: #define SLJIT_NOT 16
489: /* Flags: I | E | O | K */
490: #define SLJIT_NEG 17
491: /* Count leading zeroes
492: Flags: I | E | K */
493: #define SLJIT_CLZ 18
494:
495: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct sljit_compiler *compiler, int op,
496: int dst, sljit_w dstw,
497: int src, sljit_w srcw);
498:
499: /* Flags: I | E | O | C | K */
500: #define SLJIT_ADD 19
501: /* Flags: I | C | K */
502: #define SLJIT_ADDC 20
503: /* Flags: I | E | S | U | O | C | K */
504: #define SLJIT_SUB 21
505: /* Flags: I | C | K */
506: #define SLJIT_SUBC 22
507: /* Note: integer mul */
508: /* Flags: I | O (see SLJIT_C_MUL_*) | K */
509: #define SLJIT_MUL 23
510: /* Flags: I | E | K */
511: #define SLJIT_AND 24
512: /* Flags: I | E | K */
513: #define SLJIT_OR 25
514: /* Flags: I | E | K */
515: #define SLJIT_XOR 26
516: /* Flags: I | E | K */
517: #define SLJIT_SHL 27
518: /* Flags: I | E | K */
519: #define SLJIT_LSHR 28
520: /* Flags: I | E | K */
521: #define SLJIT_ASHR 29
522:
523: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct sljit_compiler *compiler, int op,
524: int dst, sljit_w dstw,
525: int src1, sljit_w src1w,
526: int src2, sljit_w src2w);
527:
528: SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void);
529:
530: /* Note: dst is the left and src is the right operand for SLJIT_FCMP.
531: Note: NaN check is always performed. If SLJIT_C_FLOAT_NAN is set,
532: the comparison result is unpredictable.
533: Flags: E | S (see SLJIT_C_FLOAT_*) */
534: #define SLJIT_FCMP 30
535: /* Flags: - (never set any flags) */
536: #define SLJIT_FMOV 31
537: /* Flags: - (never set any flags) */
538: #define SLJIT_FNEG 32
539: /* Flags: - (never set any flags) */
540: #define SLJIT_FABS 33
541:
542: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,
543: int dst, sljit_w dstw,
544: int src, sljit_w srcw);
545:
546: /* Flags: - (never set any flags) */
547: #define SLJIT_FADD 34
548: /* Flags: - (never set any flags) */
549: #define SLJIT_FSUB 35
550: /* Flags: - (never set any flags) */
551: #define SLJIT_FMUL 36
552: /* Flags: - (never set any flags) */
553: #define SLJIT_FDIV 37
554:
555: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,
556: int dst, sljit_w dstw,
557: int src1, sljit_w src1w,
558: int src2, sljit_w src2w);
559:
560: /* Label and jump instructions. */
561:
562: SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler);
563:
564: /* Invert conditional instruction: xor (^) with 0x1 */
565: #define SLJIT_C_EQUAL 0
566: #define SLJIT_C_ZERO 0
567: #define SLJIT_C_NOT_EQUAL 1
568: #define SLJIT_C_NOT_ZERO 1
569:
570: #define SLJIT_C_LESS 2
571: #define SLJIT_C_GREATER_EQUAL 3
572: #define SLJIT_C_GREATER 4
573: #define SLJIT_C_LESS_EQUAL 5
574: #define SLJIT_C_SIG_LESS 6
575: #define SLJIT_C_SIG_GREATER_EQUAL 7
576: #define SLJIT_C_SIG_GREATER 8
577: #define SLJIT_C_SIG_LESS_EQUAL 9
578:
579: #define SLJIT_C_OVERFLOW 10
580: #define SLJIT_C_NOT_OVERFLOW 11
581:
582: #define SLJIT_C_MUL_OVERFLOW 12
583: #define SLJIT_C_MUL_NOT_OVERFLOW 13
584:
585: #define SLJIT_C_FLOAT_EQUAL 14
586: #define SLJIT_C_FLOAT_NOT_EQUAL 15
587: #define SLJIT_C_FLOAT_LESS 16
588: #define SLJIT_C_FLOAT_GREATER_EQUAL 17
589: #define SLJIT_C_FLOAT_GREATER 18
590: #define SLJIT_C_FLOAT_LESS_EQUAL 19
591: #define SLJIT_C_FLOAT_NAN 20
592: #define SLJIT_C_FLOAT_NOT_NAN 21
593:
594: #define SLJIT_JUMP 22
595: #define SLJIT_FAST_CALL 23
596: #define SLJIT_CALL0 24
597: #define SLJIT_CALL1 25
598: #define SLJIT_CALL2 26
599: #define SLJIT_CALL3 27
600:
601: /* Fast calling method. See sljit_emit_fast_enter / sljit_emit_fast_return. */
602:
603: /* The target can be changed during runtime (see: sljit_set_jump_addr). */
604: #define SLJIT_REWRITABLE_JUMP 0x1000
605:
606: /* Emit a jump instruction. The destination is not set, only the type of the jump.
607: type must be between SLJIT_C_EQUAL and SLJIT_CALL3
608: type can be combined (or'ed) with SLJIT_REWRITABLE_JUMP
609: Flags: - (never set any flags) for both conditional and unconditional jumps.
610: Flags: destroy all flags for calls. */
611: SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type);
612:
613: /* Basic arithmetic comparison. In most architectures it is equal to
614: an SLJIT_SUB operation (with SLJIT_UNUSED destination) followed by a
615: sljit_emit_jump. However some architectures (i.e: MIPS) may employ
616: special optimizations here. It is suggested to use this comparison
617: form when flags are unimportant.
618: type must be between SLJIT_C_EQUAL and SLJIT_C_SIG_LESS_EQUAL
619: type can be combined (or'ed) with SLJIT_REWRITABLE_JUMP or SLJIT_INT_OP
620: Flags: destroy flags. */
621: SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, int type,
622: int src1, sljit_w src1w,
623: int src2, sljit_w src2w);
624:
625: /* Set the destination of the jump to this label. */
626: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label);
627: /* Only for jumps defined with SLJIT_REWRITABLE_JUMP flag.
628: Note: use sljit_emit_ijump for fixed jumps. */
629: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target);
630:
631: /* Call function or jump anywhere. Both direct and indirect form
632: type must be between SLJIT_JUMP and SLJIT_CALL3
633: Direct form: set src to SLJIT_IMM() and srcw to the address
634: Indirect form: any other valid addressing mode
635: Flags: - (never set any flags) for unconditional jumps.
636: Flags: destroy all flags for calls. */
637: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw);
638:
639: /* If op == SLJIT_MOV:
640: Set dst to 1 if condition is fulfilled, 0 otherwise
641: type must be between SLJIT_C_EQUAL and SLJIT_C_FLOAT_NOT_NAN
642: Flags: - (never set any flags)
643: If op == SLJIT_OR
644: Dst is used as src as well, and set its lowest bit to 1 if
645: the condition is fulfilled. Otherwise it does nothing.
646: Flags: E | K
647: Note: sljit_emit_cond_value does nothing, if dst is SLJIT_UNUSED (regardless of op). */
648: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type);
649:
650: /* The constant can be changed runtime (see: sljit_set_const)
651: Flags: - (never set any flags) */
652: SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w init_value);
653:
654: /* After the code generation the address for label, jump and const instructions
655: are computed. Since these structures are freed sljit_free_compiler, the
656: addresses must be preserved by the user program elsewere. */
657: static SLJIT_INLINE sljit_uw sljit_get_label_addr(struct sljit_label *label) { return label->addr; }
658: static SLJIT_INLINE sljit_uw sljit_get_jump_addr(struct sljit_jump *jump) { return jump->addr; }
659: static SLJIT_INLINE sljit_uw sljit_get_const_addr(struct sljit_const *const_) { return const_->addr; }
660:
661: /* Only the address is required to rewrite the code. */
662: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr);
663: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_w new_constant);
664:
665: /* --------------------------------------------------------------------- */
666: /* Miscellaneous utility functions */
667: /* --------------------------------------------------------------------- */
668:
669: #define SLJIT_MAJOR_VERSION 0
670: #define SLJIT_MINOR_VERSION 82
671:
672: /* Get the human readable name of the platfrom.
673: Can be useful for debugging on platforms like ARM, where ARM and
674: Thumb2 functions can be mixed. */
675: SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char* sljit_get_platform_name(void);
676:
677: /* Portble helper function to get an offset of a member. */
678: #define SLJIT_OFFSETOF(base, member) ((sljit_w)(&((base*)0x10)->member) - 0x10)
679:
680: #if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK)
681: /* This global lock is useful to compile common functions. */
682: SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_grab_lock(void);
683: SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_release_lock(void);
684: #endif
685:
686: #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)
687:
688: /* The sljit_stack is a utiliy feature of sljit, which allocates a
689: writable memory region between base (inclusive) and limit (exclusive).
690: Both base and limit is a pointer, and base is always <= than limit.
691: This feature uses the "address space reserve" feature
692: of modern operating systems. Basically we don't need to allocate a
693: huge memory block in one step for the worst case, we can start with
694: a smaller chunk and extend it later. Since the address space is
695: reserved, the data never copied to other regions, thus it is safe
696: to store pointers here. */
697:
698: /* Note: The base field is aligned to PAGE_SIZE bytes (usually 4k or more).
699: Note: stack growing should not happen in small steps: 4k, 16k or even
700: bigger growth is better.
701: Note: this structure may not be supported by all operating systems.
702: Some kind of fallback mechanism is suggested when SLJIT_UTIL_STACK
703: is not defined. */
704:
705: struct sljit_stack {
706: /* User data, anything can be stored here.
707: Starting with the same value as base. */
708: sljit_uw top;
709: /* These members are read only. */
710: sljit_uw base;
711: sljit_uw limit;
712: sljit_uw max_limit;
713: };
714:
715: /* Returns NULL if unsuccessful.
716: Note: limit and max_limit contains the size for stack allocation
717: Note: the top field is initialized to base. */
718: SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_CALL sljit_allocate_stack(sljit_uw limit, sljit_uw max_limit);
719: SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_free_stack(struct sljit_stack* stack);
720:
721: /* Can be used to increase (allocate) or decrease (free) the memory area.
722: Returns with a non-zero value if unsuccessful. If new_limit is greater than
723: max_limit, it will fail. It is very easy to implement a stack data structure,
724: since the growth ratio can be added to the current limit, and sljit_stack_resize
725: will do all the necessary checks. The fields of the stack are not changed if
726: sljit_stack_resize fails. */
727: SLJIT_API_FUNC_ATTRIBUTE sljit_w SLJIT_CALL sljit_stack_resize(struct sljit_stack* stack, sljit_uw new_limit);
728:
729: #endif /* (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) */
730:
731: #if !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
732:
733: /* Get the entry address of a given function. */
734: #define SLJIT_FUNC_OFFSET(func_name) ((sljit_w)func_name)
735:
736: #else /* !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) */
737:
738: /* All JIT related code should be placed in the same context (library, binary, etc.). */
739:
740: #define SLJIT_FUNC_OFFSET(func_name) ((sljit_w)*(void**)func_name)
741:
742: /* For powerpc64, the function pointers point to a context descriptor. */
743: struct sljit_function_context {
744: sljit_w addr;
745: sljit_w r2;
746: sljit_w r11;
747: };
748:
749: /* Fill the context arguments using the addr and the function.
750: If func_ptr is NULL, it will not be set to the address of context
751: If addr is NULL, the function address also comes from the func pointer. */
752: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_function_context(void** func_ptr, struct sljit_function_context* context, sljit_w addr, void* func);
753:
754: #endif /* !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) */
755:
756: #endif /* _SLJIT_LIR_H_ */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sljitLir.h 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