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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1460 - (hide annotations) (download)
Wed Mar 5 14:44:22 2014 UTC (6 weeks, 2 days ago) by zherczeg
File MIME type: text/plain
File size: 43295 byte(s)
JIT compiler update (with MIPS64 support).
1 ph10 662 /*
2     * Stack-less Just-In-Time compiler
3     *
4 ph10 836 * Copyright 2009-2012 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
5 ph10 662 *
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 zherczeg 1216 - The execution can be continued from any LIR instruction. In other
38     words, it is possible to jump to any label from anywhere, even from
39     a code fragment, which is compiled later, if both compiled code
40     shares the same context. See sljit_emit_enter for more details
41     - Supports self modifying code: target of (conditional) jump and call
42     instructions and some constant values can be dynamically modified
43     during runtime
44 ph10 662 - although it is not suggested to do it frequently
45 zherczeg 1216 - can be used for inline caching: save an important value once
46     in the instruction stream
47     - since this feature limits the optimization possibilities, a
48     special flag must be passed at compile time when these
49     instructions are emitted
50 ph10 662 - A fixed stack space can be allocated for local variables
51     - The compiler is thread-safe
52 zherczeg 951 - The compiler is highly configurable through preprocessor macros.
53     You can disable unneeded features (multithreading in single
54     threaded applications), and you can use your own system functions
55     (including memory allocators). See sljitConfig.h
56 ph10 662 Disadvantages:
57 zherczeg 1216 - No automatic register allocation, and temporary results are
58     not stored on the stack. (hence the name comes)
59 ph10 662 - Limited number of registers (only 6+4 integer registers, max 3+2
60 zherczeg 1215 scratch, max 3+2 saved and 6 floating point registers)
61 ph10 662 In practice:
62     - This approach is very effective for interpreters
63 zherczeg 880 - One of the saved registers typically points to a stack interface
64 zherczeg 1216 - It can jump to any exception handler anytime (even if it belongs
65     to another function)
66     - Hot paths can be modified during runtime reflecting the changes
67 ph10 662 of the fastest execution path of the dynamic language
68     - SLJIT supports complex memory addressing modes
69 zherczeg 1216 - mainly position and context independent code (except some cases)
70 zherczeg 742
71     For valgrind users:
72     - pass --smc-check=all argument to valgrind, since JIT is a "self-modifying code"
73 ph10 662 */
74    
75     #if !(defined SLJIT_NO_DEFAULT_CONFIG && SLJIT_NO_DEFAULT_CONFIG)
76     #include "sljitConfig.h"
77     #endif
78 zherczeg 839
79     /* The following header file defines useful macros for fine tuning
80 ph10 1325 sljit based code generators. They are listed in the beginning
81 zherczeg 839 of sljitConfigInternal.h */
82    
83 ph10 662 #include "sljitConfigInternal.h"
84    
85     /* --------------------------------------------------------------------- */
86     /* Error codes */
87     /* --------------------------------------------------------------------- */
88    
89     /* Indicates no error. */
90     #define SLJIT_SUCCESS 0
91     /* After the call of sljit_generate_code(), the error code of the compiler
92     is set to this value to avoid future sljit calls (in debug mode at least).
93     The complier should be freed after sljit_generate_code(). */
94     #define SLJIT_ERR_COMPILED 1
95     /* Cannot allocate non executable memory. */
96     #define SLJIT_ERR_ALLOC_FAILED 2
97     /* Cannot allocate executable memory.
98     Only for sljit_generate_code() */
99     #define SLJIT_ERR_EX_ALLOC_FAILED 3
100     /* return value for SLJIT_CONFIG_UNSUPPORTED empty architecture. */
101     #define SLJIT_ERR_UNSUPPORTED 4
102    
103     /* --------------------------------------------------------------------- */
104     /* Registers */
105     /* --------------------------------------------------------------------- */
106    
107     #define SLJIT_UNUSED 0
108    
109 zherczeg 1216 /* Scratch (temporary) registers whose may not preserve their values
110     across function calls. */
111 zherczeg 1215 #define SLJIT_SCRATCH_REG1 1
112     #define SLJIT_SCRATCH_REG2 2
113     #define SLJIT_SCRATCH_REG3 3
114     /* Note: extra registers cannot be used for memory addressing. */
115 zherczeg 1216 /* Note: on x86-32, these registers are emulated (using stack
116     loads & stores). */
117 ph10 662 #define SLJIT_TEMPORARY_EREG1 4
118     #define SLJIT_TEMPORARY_EREG2 5
119    
120 zherczeg 880 /* Saved registers whose preserve their values across function calls. */
121     #define SLJIT_SAVED_REG1 6
122     #define SLJIT_SAVED_REG2 7
123     #define SLJIT_SAVED_REG3 8
124 zherczeg 1215 /* Note: extra registers cannot be used for memory addressing. */
125 zherczeg 1216 /* Note: on x86-32, these registers are emulated (using stack
126     loads & stores). */
127 zherczeg 880 #define SLJIT_SAVED_EREG1 9
128     #define SLJIT_SAVED_EREG2 10
129 ph10 662
130 zherczeg 955 /* Read-only register (cannot be the destination of an operation).
131     Only SLJIT_MEM1(SLJIT_LOCALS_REG) addressing mode is allowed since
132     several ABIs has certain limitations about the stack layout. However
133 zherczeg 1216 sljit_get_local_base() can be used to obtain the offset of a value
134     on the stack. */
135 ph10 662 #define SLJIT_LOCALS_REG 11
136    
137     /* Number of registers. */
138     #define SLJIT_NO_TMP_REGISTERS 5
139     #define SLJIT_NO_GEN_REGISTERS 5
140     #define SLJIT_NO_REGISTERS 11
141    
142     /* Return with machine word. */
143    
144 zherczeg 1215 #define SLJIT_RETURN_REG SLJIT_SCRATCH_REG1
145 ph10 662
146 zherczeg 847 /* x86 prefers specific registers for special purposes. In case of shift
147 zherczeg 1215 by register it supports only SLJIT_SCRATCH_REG3 for shift argument
148 zherczeg 847 (which is the src2 argument of sljit_emit_op2). If another register is
149     used, sljit must exchange data between registers which cause a minor
150     slowdown. Other architectures has no such limitation. */
151 ph10 662
152 zherczeg 1215 #define SLJIT_PREF_SHIFT_REG SLJIT_SCRATCH_REG3
153 ph10 662
154     /* --------------------------------------------------------------------- */
155     /* Floating point registers */
156     /* --------------------------------------------------------------------- */
157    
158     /* Note: SLJIT_UNUSED as destination is not valid for floating point
159     operations, since they cannot be used for setting flags. */
160    
161 zherczeg 1216 /* Floating point operations are performed on double or
162     single precision values. */
163 ph10 662
164 zherczeg 1280 #define SLJIT_FLOAT_REG1 1
165     #define SLJIT_FLOAT_REG2 2
166     #define SLJIT_FLOAT_REG3 3
167     #define SLJIT_FLOAT_REG4 4
168     #define SLJIT_FLOAT_REG5 5
169     #define SLJIT_FLOAT_REG6 6
170 ph10 662
171 zherczeg 1280 #define SLJIT_NO_FLOAT_REGISTERS 6
172    
173 ph10 662 /* --------------------------------------------------------------------- */
174     /* Main structures and functions */
175     /* --------------------------------------------------------------------- */
176    
177     struct sljit_memory_fragment {
178     struct sljit_memory_fragment *next;
179     sljit_uw used_size;
180 zherczeg 1195 /* Must be aligned to sljit_sw. */
181 ph10 662 sljit_ub memory[1];
182     };
183    
184     struct sljit_label {
185     struct sljit_label *next;
186     sljit_uw addr;
187     /* The maximum size difference. */
188     sljit_uw size;
189     };
190    
191     struct sljit_jump {
192     struct sljit_jump *next;
193     sljit_uw addr;
194 zherczeg 1195 sljit_sw flags;
195 ph10 662 union {
196     sljit_uw target;
197     struct sljit_label* label;
198     } u;
199     };
200    
201     struct sljit_const {
202     struct sljit_const *next;
203     sljit_uw addr;
204     };
205    
206     struct sljit_compiler {
207 zherczeg 1195 sljit_si error;
208 ph10 662
209     struct sljit_label *labels;
210     struct sljit_jump *jumps;
211     struct sljit_const *consts;
212     struct sljit_label *last_label;
213     struct sljit_jump *last_jump;
214     struct sljit_const *last_const;
215    
216     struct sljit_memory_fragment *buf;
217     struct sljit_memory_fragment *abuf;
218    
219     /* Used local registers. */
220 zherczeg 1215 sljit_si scratches;
221 zherczeg 880 /* Used saved registers. */
222 zherczeg 1195 sljit_si saveds;
223 ph10 662 /* Local stack size. */
224 zherczeg 1195 sljit_si local_size;
225 ph10 662 /* Code size. */
226     sljit_uw size;
227 ph10 836 /* For statistical purposes. */
228     sljit_uw executable_size;
229 ph10 662
230     #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
231 zherczeg 1195 sljit_si args;
232     sljit_si locals_offset;
233 zherczeg 1215 sljit_si scratches_start;
234 zherczeg 1195 sljit_si saveds_start;
235 ph10 662 #endif
236    
237     #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
238 zherczeg 1195 sljit_si mode32;
239 ph10 662 #endif
240    
241     #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
242 zherczeg 1195 sljit_si flags_saved;
243 ph10 662 #endif
244    
245     #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
246     /* Constant pool handling. */
247     sljit_uw *cpool;
248     sljit_ub *cpool_unique;
249     sljit_uw cpool_diff;
250     sljit_uw cpool_fill;
251 zherczeg 880 /* Other members. */
252 ph10 662 /* Contains pointer, "ldr pc, [...]" pairs. */
253     sljit_uw patches;
254     #endif
255    
256     #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
257     /* Temporary fields. */
258     sljit_uw shift_imm;
259 zherczeg 1195 sljit_si cache_arg;
260     sljit_sw cache_argw;
261 ph10 662 #endif
262    
263     #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
264 zherczeg 1195 sljit_si cache_arg;
265     sljit_sw cache_argw;
266 ph10 662 #endif
267    
268 zherczeg 1453 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
269     sljit_si locals_offset;
270     sljit_si cache_arg;
271     sljit_sw cache_argw;
272     #endif
273    
274 ph10 662 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
275 zherczeg 1195 sljit_sw imm;
276     sljit_si cache_arg;
277     sljit_sw cache_argw;
278 ph10 662 #endif
279    
280 zherczeg 1460 #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32) || (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64)
281 zherczeg 1195 sljit_si delay_slot;
282     sljit_si cache_arg;
283     sljit_sw cache_argw;
284 ph10 662 #endif
285    
286 zherczeg 1149 #if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
287 zherczeg 1195 sljit_si delay_slot;
288     sljit_si cache_arg;
289     sljit_sw cache_argw;
290 zherczeg 1149 #endif
291    
292 zherczeg 1378 #if (defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX)
293     sljit_si cache_arg;
294     sljit_sw cache_argw;
295     #endif
296    
297 ph10 662 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
298     FILE* verbose;
299     #endif
300    
301 zherczeg 955 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
302     /* Local size passed to the functions. */
303 zherczeg 1195 sljit_si logical_local_size;
304 zherczeg 955 #endif
305    
306 ph10 662 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
307 zherczeg 1195 sljit_si skip_checks;
308 ph10 662 #endif
309     };
310    
311     /* --------------------------------------------------------------------- */
312     /* Main functions */
313     /* --------------------------------------------------------------------- */
314    
315     /* Creates an sljit compiler.
316     Returns NULL if failed. */
317 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void);
318 zherczeg 1216
319     /* Free everything except the compiled machine code. */
320 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler);
321 ph10 662
322 ph10 1325 /* Returns the current error code. If an error is occurred, future sljit
323 zherczeg 1216 calls which uses the same compiler argument returns early with the same
324     error code. Thus there is no need for checking the error after every
325     call, it is enough to do it before the code is compiled. Removing
326     these checks increases the performance of the compiling process. */
327 zherczeg 1195 static SLJIT_INLINE sljit_si sljit_get_compiler_error(struct sljit_compiler *compiler) { return compiler->error; }
328 ph10 662
329     /*
330     Allocate a small amount of memory. The size must be <= 64 bytes on 32 bit,
331 zherczeg 1216 and <= 128 bytes on 64 bit architectures. The memory area is owned by the
332     compiler, and freed by sljit_free_compiler. The returned pointer is
333     sizeof(sljit_sw) aligned. Excellent for allocating small blocks during
334     the compiling, and no need to worry about freeing them. The size is
335     enough to contain at most 16 pointers. If the size is outside of the range,
336     the function will return with NULL. However, this return value does not
337     indicate that there is no more memory (does not set the current error code
338     of the compiler to out-of-memory status).
339 ph10 662 */
340 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_si size);
341 ph10 662
342     #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
343     /* Passing NULL disables verbose. */
344 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose);
345 ph10 662 #endif
346    
347 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler);
348     SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code);
349 ph10 662
350 ph10 836 /*
351 zherczeg 1216 After the machine code generation is finished we can retrieve the allocated
352     executable memory size, although this area may not be fully filled with
353     instructions depending on some optimizations. This function is useful only
354     for statistical purposes.
355 ph10 836
356     Before a successful code generation, this function returns with 0.
357     */
358     static SLJIT_INLINE sljit_uw sljit_get_generated_code_size(struct sljit_compiler *compiler) { return compiler->executable_size; }
359    
360 zherczeg 1216 /* Instruction generation. Returns with any error code. If there is no
361     error, they return with SLJIT_SUCCESS. */
362 ph10 662
363     /*
364 zherczeg 860 The executable code is basically a function call from the viewpoint of
365     the C language. The function calls must obey to the ABI (Application
366     Binary Interface) of the platform, which specify the purpose of machine
367     registers and stack handling among other things. The sljit_emit_enter
368     function emits the necessary instructions for setting up a new context
369 zherczeg 880 for the executable code and moves function arguments to the saved
370 zherczeg 860 registers. The number of arguments are specified in the "args"
371 zherczeg 880 parameter and the first argument goes to SLJIT_SAVED_REG1, the second
372 zherczeg 1215 goes to SLJIT_SAVED_REG2 and so on. The number of scratch and
373     saved registers are passed in "scratches" and "saveds" arguments
374 zherczeg 880 respectively. Since the saved registers contains the arguments,
375     "args" must be less or equal than "saveds". The sljit_emit_enter
376 zherczeg 860 is also capable of allocating a stack space for local variables. The
377     "local_size" argument contains the size in bytes of this local area
378     and its staring address is stored in SLJIT_LOCALS_REG. However
379     the SLJIT_LOCALS_REG is not necessary the machine stack pointer.
380     The memory bytes between SLJIT_LOCALS_REG (inclusive) and
381     SLJIT_LOCALS_REG + local_size (exclusive) can be modified freely
382     until the function returns. The stack space is uninitialized.
383 ph10 662
384 zherczeg 1216 Note: every call of sljit_emit_enter and sljit_set_context
385     overwrites the previous context. */
386 ph10 662
387     #define SLJIT_MAX_LOCAL_SIZE 65536
388    
389 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_enter(struct sljit_compiler *compiler,
390 zherczeg 1215 sljit_si args, sljit_si scratches, sljit_si saveds, sljit_si local_size);
391 ph10 662
392 zherczeg 860 /* The machine code has a context (which contains the local stack space size,
393     number of used registers, etc.) which initialized by sljit_emit_enter. Several
394     functions (like sljit_emit_return) requres this context to be able to generate
395     the appropriate code. However, some code fragments (like inline cache) may have
396     no normal entry point so their context is unknown for the compiler. Using the
397 zherczeg 1216 function below we can specify their context.
398 ph10 662
399 zherczeg 860 Note: every call of sljit_emit_enter and sljit_set_context overwrites
400     the previous context. */
401    
402 zherczeg 875 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler,
403 zherczeg 1215 sljit_si args, sljit_si scratches, sljit_si saveds, sljit_si local_size);
404 ph10 662
405 zherczeg 875 /* Return from machine code. The op argument can be SLJIT_UNUSED which means the
406     function does not return with anything or any opcode between SLJIT_MOV and
407 zherczeg 1182 SLJIT_MOV_P (see sljit_emit_op1). As for src and srcw they must be 0 if op
408 zherczeg 875 is SLJIT_UNUSED, otherwise see below the description about source and
409     destination arguments. */
410 zherczeg 1216
411 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_return(struct sljit_compiler *compiler, sljit_si op,
412     sljit_si src, sljit_sw srcw);
413 ph10 662
414 zherczeg 1216 /* Fast calling mechanism for utility functions (see SLJIT_FAST_CALL). All registers and
415     even the stack frame is passed to the callee. The return address is preserved in
416     dst/dstw by sljit_emit_fast_enter (the type of the value stored by this function
417     is sljit_p), and sljit_emit_fast_return can use this as a return value later. */
418 ph10 662
419 zherczeg 1182 /* Note: only for sljit specific, non ABI compilant calls. Fast, since only a few machine
420     instructions are needed. Excellent for small uility functions, where saving registers
421     and setting up a new stack frame would cost too much performance. However, it is still
422     possible to return to the address of the caller (or anywhere else). */
423 ph10 662
424     /* Note: flags are not changed (unlike sljit_emit_enter / sljit_emit_return). */
425    
426     /* Note: although sljit_emit_fast_return could be replaced by an ijump, it is not suggested,
427     since many architectures do clever branch prediction on call / return instruction pairs. */
428    
429 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw);
430     SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw);
431 ph10 662
432     /*
433     Source and destination values for arithmetical instructions
434     imm - a simple immediate value (cannot be used as a destination)
435     reg - any of the registers (immediate argument must be 0)
436     [imm] - absolute immediate memory address
437     [reg+imm] - indirect memory address
438     [reg+(reg<<imm)] - indirect indexed memory address (shift must be between 0 and 3)
439 zherczeg 1195 useful for (byte, half, int, sljit_sw) array access
440 ph10 662 (fully supported by both x86 and ARM architectures, and cheap operation on others)
441     */
442    
443     /*
444 zherczeg 847 IMPORATNT NOTE: memory access MUST be naturally aligned except
445     SLJIT_UNALIGNED macro is defined and its value is 1.
446    
447 ph10 662 length | alignment
448     ---------+-----------
449 zherczeg 1195 byte | 1 byte (any physical_address is accepted)
450     half | 2 byte (physical_address & 0x1 == 0)
451     int | 4 byte (physical_address & 0x3 == 0)
452     word | 4 byte if SLJIT_32BIT_ARCHITECTURE is defined and its value is 1
453 zherczeg 847 | 8 byte if SLJIT_64BIT_ARCHITECTURE is defined and its value is 1
454 zherczeg 1195 pointer | size of sljit_p type (4 byte on 32 bit machines, 4 or 8 byte
455     | on 64 bit machines)
456 ph10 662
457 zherczeg 1195 Note: Different architectures have different addressing limitations.
458     A single instruction is enough for the following addressing
459     modes. Other adrressing modes are emulated by instruction
460     sequences. This information could help to improve those code
461     generators which focuses only a few architectures.
462    
463 ph10 1325 x86: [reg+imm], -2^32+1 <= imm <= 2^32-1 (full address space on x86-32)
464 zherczeg 1195 [reg+(reg<<imm)] is supported
465     [imm], -2^32+1 <= imm <= 2^32-1 is supported
466     Write-back is not supported
467     arm: [reg+imm], -4095 <= imm <= 4095 or -255 <= imm <= 255 for signed
468     bytes, any halfs or floating point values)
469     [reg+(reg<<imm)] is supported
470     Write-back is supported
471     arm-t2: [reg+imm], -255 <= imm <= 4095
472     [reg+(reg<<imm)] is supported
473     Write back is supported only for [reg+imm], where -255 <= imm <= 255
474     ppc: [reg+imm], -65536 <= imm <= 65535. 64 bit loads/stores and 32 bit
475     signed load on 64 bit requires immediates divisible by 4.
476     [reg+imm] is not supported for signed 8 bit values.
477     [reg+reg] is supported
478     Write-back is supported except for one instruction: 32 bit signed
479     load with [reg+imm] addressing mode on 64 bit.
480     mips: [reg+imm], -65536 <= imm <= 65535
481     sparc: [reg+imm], -4096 <= imm <= 4095
482     [reg+reg] is supported
483 ph10 662 */
484    
485     /* Register output: simply the name of the register.
486     For destination, you can use SLJIT_UNUSED as well. */
487 zherczeg 1453 #define SLJIT_MEM 0x80
488 ph10 662 #define SLJIT_MEM0() (SLJIT_MEM)
489     #define SLJIT_MEM1(r1) (SLJIT_MEM | (r1))
490 zherczeg 1453 #define SLJIT_MEM2(r1, r2) (SLJIT_MEM | (r1) | ((r2) << 8))
491     #define SLJIT_IMM 0x40
492 ph10 662
493     /* Set 32 bit operation mode (I) on 64 bit CPUs. The flag is totally ignored on
494 zherczeg 1195 32 bit CPUs. If this flag is set for an arithmetic operation, it uses only the
495     lower 32 bit of the input register(s), and set the CPU status flags according
496     to the 32 bit result. The higher 32 bits are undefined for both the input and
497     output. However, the CPU might not ignore those higher 32 bits, like MIPS, which
498     expects it to be the sign extension of the lower 32 bit. All 32 bit operations
499     are undefined, if this condition is not fulfilled. Therefore, when SLJIT_INT_OP
500     is specified, all register arguments must be the result of other operations with
501     the same SLJIT_INT_OP flag. In other words, although a register can hold either
502     a 64 or 32 bit value, these values cannot be mixed. The only exceptions are
503 zherczeg 1460 SLJIT_IMOV and SLJIT_IMOVU (SLJIT_MOV_SI/SLJIT_MOVU_SI with SLJIT_INT_OP flag)
504     which can convert any source argument to SLJIT_INT_OP compatible result. This
505     conversion might be unnecessary on some CPUs like x86-64, since the upper 32
506     bit is always ignored. In this case SLJIT is clever enough to not generate any
507     instructions if the source and destination operands are the same registers.
508     Affects sljit_emit_op0, sljit_emit_op1 and sljit_emit_op2. */
509 ph10 662 #define SLJIT_INT_OP 0x100
510    
511 zherczeg 1195 /* Single precision mode (SP). This flag is similar to SLJIT_INT_OP, just
512     it applies to floating point registers (it is even the same bit). When
513     this flag is passed, the CPU performs single precision floating point
514     operations. Similar to SLJIT_INT_OP, all register arguments must be the
515     result of other floating point operations with this flag. Affects
516     sljit_emit_fop1, sljit_emit_fop2 and sljit_emit_fcmp. */
517     #define SLJIT_SINGLE_OP 0x100
518    
519 ph10 662 /* Common CPU status flags for all architectures (x86, ARM, PPC)
520     - carry flag
521     - overflow flag
522     - zero flag
523     - negative/positive flag (depends on arc)
524     On mips, these flags are emulated by software. */
525    
526     /* By default, the instructions may, or may not set the CPU status flags.
527     Forcing to set or keep status flags can be done with the following flags: */
528    
529     /* Note: sljit tries to emit the minimum number of instructions. Using these
530     flags can increase them, so use them wisely to avoid unnecessary code generation. */
531    
532     /* Set Equal (Zero) status flag (E). */
533     #define SLJIT_SET_E 0x0200
534 zherczeg 1460 /* Set unsigned status flag (U). */
535     #define SLJIT_SET_U 0x0400
536 ph10 662 /* Set signed status flag (S). */
537 zherczeg 1460 #define SLJIT_SET_S 0x0800
538 ph10 662 /* Set signed overflow flag (O). */
539     #define SLJIT_SET_O 0x1000
540     /* Set carry flag (C).
541     Note: Kinda unsigned overflow, but behaves differently on various cpus. */
542     #define SLJIT_SET_C 0x2000
543     /* Do not modify the flags (K).
544     Note: This flag cannot be combined with any other SLJIT_SET_* flag. */
545     #define SLJIT_KEEP_FLAGS 0x4000
546    
547     /* Notes:
548     - you cannot postpone conditional jump instructions except if noted that
549     the instruction does not set flags (See: SLJIT_KEEP_FLAGS).
550     - flag combinations: '|' means 'logical or'. */
551    
552     /* Flags: - (never set any flags)
553     Note: breakpoint instruction is not supported by all architectures (namely ppc)
554     It falls back to SLJIT_NOP in those cases. */
555     #define SLJIT_BREAKPOINT 0
556     /* Flags: - (never set any flags)
557     Note: may or may not cause an extra cycle wait
558     it can even decrease the runtime in a few cases. */
559     #define SLJIT_NOP 1
560 zherczeg 1195 /* Flags: - (may destroy flags)
561 zherczeg 1215 Unsigned multiplication of SLJIT_SCRATCH_REG1 and SLJIT_SCRATCH_REG2.
562     Result goes to SLJIT_SCRATCH_REG2:SLJIT_SCRATCH_REG1 (high:low) word */
563 zherczeg 847 #define SLJIT_UMUL 2
564 zherczeg 1195 /* Flags: - (may destroy flags)
565 zherczeg 1215 Signed multiplication of SLJIT_SCRATCH_REG1 and SLJIT_SCRATCH_REG2.
566     Result goes to SLJIT_SCRATCH_REG2:SLJIT_SCRATCH_REG1 (high:low) word */
567 zherczeg 847 #define SLJIT_SMUL 3
568 zherczeg 1195 /* Flags: I - (may destroy flags)
569 zherczeg 1215 Unsigned divide of the value in SLJIT_SCRATCH_REG1 by the value in SLJIT_SCRATCH_REG2.
570     The result is placed in SLJIT_SCRATCH_REG1 and the remainder goes to SLJIT_SCRATCH_REG2.
571     Note: if SLJIT_SCRATCH_REG2 contains 0, the behaviour is undefined. */
572 zherczeg 847 #define SLJIT_UDIV 4
573 zherczeg 1195 #define SLJIT_IUDIV (SLJIT_UDIV | SLJIT_INT_OP)
574     /* Flags: I - (may destroy flags)
575 zherczeg 1215 Signed divide of the value in SLJIT_SCRATCH_REG1 by the value in SLJIT_SCRATCH_REG2.
576     The result is placed in SLJIT_SCRATCH_REG1 and the remainder goes to SLJIT_SCRATCH_REG2.
577     Note: if SLJIT_SCRATCH_REG2 contains 0, the behaviour is undefined. */
578 zherczeg 847 #define SLJIT_SDIV 5
579 zherczeg 1195 #define SLJIT_ISDIV (SLJIT_SDIV | SLJIT_INT_OP)
580 ph10 662
581 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op0(struct sljit_compiler *compiler, sljit_si op);
582 ph10 662
583     /* Notes for MOV instructions:
584 zherczeg 1453 U = Mov with update (pre form). If source or destination defined as SLJIT_MEM1(r1)
585 ph10 662 or SLJIT_MEM2(r1, r2), r1 is increased by the sum of r2 and the constant argument
586     UB = unsigned byte (8 bit)
587     SB = signed byte (8 bit)
588 zherczeg 1182 UH = unsigned half (16 bit)
589     SH = signed half (16 bit)
590     UI = unsigned int (32 bit)
591     SI = signed int (32 bit)
592     P = pointer (sljit_p) size */
593 ph10 662
594     /* Flags: - (never set any flags) */
595 zherczeg 847 #define SLJIT_MOV 6
596 zherczeg 1195 /* Flags: I - (never set any flags) */
597 zherczeg 847 #define SLJIT_MOV_UB 7
598 zherczeg 1195 #define SLJIT_IMOV_UB (SLJIT_MOV_UB | SLJIT_INT_OP)
599     /* Flags: I - (never set any flags) */
600 zherczeg 847 #define SLJIT_MOV_SB 8
601 zherczeg 1195 #define SLJIT_IMOV_SB (SLJIT_MOV_SB | SLJIT_INT_OP)
602     /* Flags: I - (never set any flags) */
603 zherczeg 847 #define SLJIT_MOV_UH 9
604 zherczeg 1195 #define SLJIT_IMOV_UH (SLJIT_MOV_UH | SLJIT_INT_OP)
605     /* Flags: I - (never set any flags) */
606 zherczeg 847 #define SLJIT_MOV_SH 10
607 zherczeg 1195 #define SLJIT_IMOV_SH (SLJIT_MOV_SH | SLJIT_INT_OP)
608     /* Flags: I - (never set any flags)
609     Note: see SLJIT_INT_OP for further details. */
610 zherczeg 847 #define SLJIT_MOV_UI 11
611 zherczeg 1460 /* No SLJIT_INT_OP form, since it is the same as SLJIT_IMOV. */
612 zherczeg 1195 /* Flags: I - (never set any flags)
613     Note: see SLJIT_INT_OP for further details. */
614 zherczeg 847 #define SLJIT_MOV_SI 12
615 zherczeg 1195 #define SLJIT_IMOV (SLJIT_MOV_SI | SLJIT_INT_OP)
616 ph10 662 /* Flags: - (never set any flags) */
617 zherczeg 1182 #define SLJIT_MOV_P 13
618 ph10 662 /* Flags: - (never set any flags) */
619 zherczeg 1182 #define SLJIT_MOVU 14
620 zherczeg 1195 /* Flags: I - (never set any flags) */
621 zherczeg 1182 #define SLJIT_MOVU_UB 15
622 zherczeg 1195 #define SLJIT_IMOVU_UB (SLJIT_MOVU_UB | SLJIT_INT_OP)
623     /* Flags: I - (never set any flags) */
624 zherczeg 1182 #define SLJIT_MOVU_SB 16
625 zherczeg 1195 #define SLJIT_IMOVU_SB (SLJIT_MOVU_SB | SLJIT_INT_OP)
626     /* Flags: I - (never set any flags) */
627 zherczeg 1182 #define SLJIT_MOVU_UH 17
628 zherczeg 1195 #define SLJIT_IMOVU_UH (SLJIT_MOVU_UH | SLJIT_INT_OP)
629     /* Flags: I - (never set any flags) */
630 zherczeg 1182 #define SLJIT_MOVU_SH 18
631 zherczeg 1195 #define SLJIT_IMOVU_SH (SLJIT_MOVU_SH | SLJIT_INT_OP)
632     /* Flags: I - (never set any flags)
633     Note: see SLJIT_INT_OP for further details. */
634 zherczeg 1182 #define SLJIT_MOVU_UI 19
635 zherczeg 1460 /* No SLJIT_INT_OP form, since it is the same as SLJIT_IMOVU. */
636 zherczeg 1195 /* Flags: I - (never set any flags)
637     Note: see SLJIT_INT_OP for further details. */
638 zherczeg 1182 #define SLJIT_MOVU_SI 20
639 zherczeg 1195 #define SLJIT_IMOVU (SLJIT_MOVU_SI | SLJIT_INT_OP)
640 zherczeg 1182 /* Flags: - (never set any flags) */
641     #define SLJIT_MOVU_P 21
642 ph10 662 /* Flags: I | E | K */
643 zherczeg 1182 #define SLJIT_NOT 22
644 zherczeg 1195 #define SLJIT_INOT (SLJIT_NOT | SLJIT_INT_OP)
645 ph10 662 /* Flags: I | E | O | K */
646 zherczeg 1182 #define SLJIT_NEG 23
647 zherczeg 1195 #define SLJIT_INEG (SLJIT_NEG | SLJIT_INT_OP)
648 ph10 662 /* Count leading zeroes
649 zherczeg 1149 Flags: I | E | K
650     Important note! Sparc 32 does not support K flag, since
651     the required popc instruction is introduced only in sparc 64. */
652 zherczeg 1182 #define SLJIT_CLZ 24
653 zherczeg 1195 #define SLJIT_ICLZ (SLJIT_CLZ | SLJIT_INT_OP)
654 ph10 662
655 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op1(struct sljit_compiler *compiler, sljit_si op,
656     sljit_si dst, sljit_sw dstw,
657     sljit_si src, sljit_sw srcw);
658 ph10 662
659     /* Flags: I | E | O | C | K */
660 zherczeg 1182 #define SLJIT_ADD 25
661 zherczeg 1195 #define SLJIT_IADD (SLJIT_ADD | SLJIT_INT_OP)
662 ph10 662 /* Flags: I | C | K */
663 zherczeg 1182 #define SLJIT_ADDC 26
664 zherczeg 1195 #define SLJIT_IADDC (SLJIT_ADDC | SLJIT_INT_OP)
665 zherczeg 1460 /* Flags: I | E | U | S | O | C | K */
666 zherczeg 1182 #define SLJIT_SUB 27
667 zherczeg 1195 #define SLJIT_ISUB (SLJIT_SUB | SLJIT_INT_OP)
668 ph10 662 /* Flags: I | C | K */
669 zherczeg 1182 #define SLJIT_SUBC 28
670 zherczeg 1195 #define SLJIT_ISUBC (SLJIT_SUBC | SLJIT_INT_OP)
671 zherczeg 860 /* Note: integer mul
672     Flags: I | O (see SLJIT_C_MUL_*) | K */
673 zherczeg 1182 #define SLJIT_MUL 29
674 zherczeg 1195 #define SLJIT_IMUL (SLJIT_MUL | SLJIT_INT_OP)
675 ph10 662 /* Flags: I | E | K */
676 zherczeg 1182 #define SLJIT_AND 30
677 zherczeg 1195 #define SLJIT_IAND (SLJIT_AND | SLJIT_INT_OP)
678 ph10 662 /* Flags: I | E | K */
679 zherczeg 1182 #define SLJIT_OR 31
680 zherczeg 1195 #define SLJIT_IOR (SLJIT_OR | SLJIT_INT_OP)
681 ph10 662 /* Flags: I | E | K */
682 zherczeg 1182 #define SLJIT_XOR 32
683 zherczeg 1195 #define SLJIT_IXOR (SLJIT_XOR | SLJIT_INT_OP)
684 zherczeg 860 /* Flags: I | E | K
685     Let bit_length be the length of the shift operation: 32 or 64.
686     If src2 is immediate, src2w is masked by (bit_length - 1).
687     Otherwise, if the content of src2 is outside the range from 0
688     to bit_length - 1, the operation is undefined. */
689 zherczeg 1182 #define SLJIT_SHL 33
690 zherczeg 1195 #define SLJIT_ISHL (SLJIT_SHL | SLJIT_INT_OP)
691 zherczeg 860 /* Flags: I | E | K
692     Let bit_length be the length of the shift operation: 32 or 64.
693     If src2 is immediate, src2w is masked by (bit_length - 1).
694     Otherwise, if the content of src2 is outside the range from 0
695     to bit_length - 1, the operation is undefined. */
696 zherczeg 1182 #define SLJIT_LSHR 34
697 zherczeg 1195 #define SLJIT_ILSHR (SLJIT_LSHR | SLJIT_INT_OP)
698 zherczeg 860 /* Flags: I | E | K
699     Let bit_length be the length of the shift operation: 32 or 64.
700     If src2 is immediate, src2w is masked by (bit_length - 1).
701     Otherwise, if the content of src2 is outside the range from 0
702     to bit_length - 1, the operation is undefined. */
703 zherczeg 1182 #define SLJIT_ASHR 35
704 zherczeg 1195 #define SLJIT_IASHR (SLJIT_ASHR | SLJIT_INT_OP)
705 ph10 662
706 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op2(struct sljit_compiler *compiler, sljit_si op,
707     sljit_si dst, sljit_sw dstw,
708     sljit_si src1, sljit_sw src1w,
709     sljit_si src2, sljit_sw src2w);
710 ph10 662
711 zherczeg 839 /* The following function is a helper function for sljit_emit_op_custom.
712 zherczeg 1215 It returns with the real machine register index of any SLJIT_SCRATCH
713 zherczeg 880 SLJIT_SAVED or SLJIT_LOCALS register.
714 zherczeg 1280 Note: it returns with -1 for virtual registers (all EREGs on x86-32). */
715 zherczeg 839
716 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_register_index(sljit_si reg);
717 zherczeg 839
718 zherczeg 1280 /* The following function is a helper function for sljit_emit_op_custom.
719     It returns with the real machine register index of any SLJIT_FLOAT register.
720     Note: the index is divided by 2 on ARM 32 bit architectures. */
721    
722     SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_float_register_index(sljit_si reg);
723    
724 zherczeg 839 /* Any instruction can be inserted into the instruction stream by
725     sljit_emit_op_custom. It has a similar purpose as inline assembly.
726     The size parameter must match to the instruction size of the target
727     architecture:
728    
729     x86: 0 < size <= 15. The instruction argument can be byte aligned.
730     Thumb2: if size == 2, the instruction argument must be 2 byte aligned.
731     if size == 4, the instruction argument must be 4 byte aligned.
732     Otherwise: size must be 4 and instruction argument must be 4 byte aligned. */
733    
734 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op_custom(struct sljit_compiler *compiler,
735     void *instruction, sljit_si size);
736 zherczeg 839
737     /* Returns with non-zero if fpu is available. */
738    
739 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_is_fpu_available(void);
740 ph10 662
741     /* Note: dst is the left and src is the right operand for SLJIT_FCMP.
742 zherczeg 1149 Note: NaN check is always performed. If SLJIT_C_FLOAT_UNORDERED is set,
743 ph10 662 the comparison result is unpredictable.
744 zherczeg 1195 Flags: SP | E | S (see SLJIT_C_FLOAT_*) */
745     #define SLJIT_CMPD 36
746     #define SLJIT_CMPS (SLJIT_CMPD | SLJIT_SINGLE_OP)
747     /* Flags: SP - (never set any flags) */
748     #define SLJIT_MOVD 37
749     #define SLJIT_MOVS (SLJIT_MOVD | SLJIT_SINGLE_OP)
750     /* Flags: SP - (never set any flags) */
751     #define SLJIT_NEGD 38
752     #define SLJIT_NEGS (SLJIT_NEGD | SLJIT_SINGLE_OP)
753     /* Flags: SP - (never set any flags) */
754     #define SLJIT_ABSD 39
755     #define SLJIT_ABSS (SLJIT_ABSD | SLJIT_SINGLE_OP)
756 ph10 662
757 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op,
758     sljit_si dst, sljit_sw dstw,
759     sljit_si src, sljit_sw srcw);
760 ph10 662
761 zherczeg 1195 /* Flags: SP - (never set any flags) */
762     #define SLJIT_ADDD 40
763     #define SLJIT_ADDS (SLJIT_ADDD | SLJIT_SINGLE_OP)
764     /* Flags: SP - (never set any flags) */
765     #define SLJIT_SUBD 41
766     #define SLJIT_SUBS (SLJIT_SUBD | SLJIT_SINGLE_OP)
767     /* Flags: SP - (never set any flags) */
768     #define SLJIT_MULD 42
769     #define SLJIT_MULS (SLJIT_MULD | SLJIT_SINGLE_OP)
770     /* Flags: SP - (never set any flags) */
771     #define SLJIT_DIVD 43
772     #define SLJIT_DIVS (SLJIT_DIVD | SLJIT_SINGLE_OP)
773 ph10 662
774 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop2(struct sljit_compiler *compiler, sljit_si op,
775     sljit_si dst, sljit_sw dstw,
776     sljit_si src1, sljit_sw src1w,
777     sljit_si src2, sljit_sw src2w);
778 ph10 662
779     /* Label and jump instructions. */
780    
781 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler);
782 ph10 662
783     /* Invert conditional instruction: xor (^) with 0x1 */
784     #define SLJIT_C_EQUAL 0
785     #define SLJIT_C_ZERO 0
786     #define SLJIT_C_NOT_EQUAL 1
787     #define SLJIT_C_NOT_ZERO 1
788    
789     #define SLJIT_C_LESS 2
790     #define SLJIT_C_GREATER_EQUAL 3
791     #define SLJIT_C_GREATER 4
792     #define SLJIT_C_LESS_EQUAL 5
793     #define SLJIT_C_SIG_LESS 6
794     #define SLJIT_C_SIG_GREATER_EQUAL 7
795     #define SLJIT_C_SIG_GREATER 8
796     #define SLJIT_C_SIG_LESS_EQUAL 9
797    
798     #define SLJIT_C_OVERFLOW 10
799     #define SLJIT_C_NOT_OVERFLOW 11
800    
801     #define SLJIT_C_MUL_OVERFLOW 12
802     #define SLJIT_C_MUL_NOT_OVERFLOW 13
803    
804     #define SLJIT_C_FLOAT_EQUAL 14
805     #define SLJIT_C_FLOAT_NOT_EQUAL 15
806     #define SLJIT_C_FLOAT_LESS 16
807     #define SLJIT_C_FLOAT_GREATER_EQUAL 17
808     #define SLJIT_C_FLOAT_GREATER 18
809     #define SLJIT_C_FLOAT_LESS_EQUAL 19
810 zherczeg 1149 #define SLJIT_C_FLOAT_UNORDERED 20
811     #define SLJIT_C_FLOAT_ORDERED 21
812 ph10 662
813     #define SLJIT_JUMP 22
814 zherczeg 722 #define SLJIT_FAST_CALL 23
815     #define SLJIT_CALL0 24
816     #define SLJIT_CALL1 25
817     #define SLJIT_CALL2 26
818     #define SLJIT_CALL3 27
819 ph10 662
820     /* Fast calling method. See sljit_emit_fast_enter / sljit_emit_fast_return. */
821    
822     /* The target can be changed during runtime (see: sljit_set_jump_addr). */
823     #define SLJIT_REWRITABLE_JUMP 0x1000
824    
825     /* Emit a jump instruction. The destination is not set, only the type of the jump.
826     type must be between SLJIT_C_EQUAL and SLJIT_CALL3
827     type can be combined (or'ed) with SLJIT_REWRITABLE_JUMP
828     Flags: - (never set any flags) for both conditional and unconditional jumps.
829     Flags: destroy all flags for calls. */
830 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type);
831 ph10 662
832 zherczeg 867 /* Basic arithmetic comparison. In most architectures it is implemented as
833     an SLJIT_SUB operation (with SLJIT_UNUSED destination and setting
834     appropriate flags) followed by a sljit_emit_jump. However some
835     architectures (i.e: MIPS) may employ special optimizations here. It is
836     suggested to use this comparison form when appropriate.
837 ph10 662 type must be between SLJIT_C_EQUAL and SLJIT_C_SIG_LESS_EQUAL
838     type can be combined (or'ed) with SLJIT_REWRITABLE_JUMP or SLJIT_INT_OP
839     Flags: destroy flags. */
840 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,
841     sljit_si src1, sljit_sw src1w,
842     sljit_si src2, sljit_sw src2w);
843 ph10 662
844 zherczeg 867 /* Basic floating point comparison. In most architectures it is implemented as
845     an SLJIT_FCMP operation (setting appropriate flags) followed by a
846     sljit_emit_jump. However some architectures (i.e: MIPS) may employ
847     special optimizations here. It is suggested to use this comparison form
848     when appropriate.
849 zherczeg 1149 type must be between SLJIT_C_FLOAT_EQUAL and SLJIT_C_FLOAT_ORDERED
850 zherczeg 1195 type can be combined (or'ed) with SLJIT_REWRITABLE_JUMP and SLJIT_SINGLE_OP
851 zherczeg 867 Flags: destroy flags.
852     Note: if either operand is NaN, the behaviour is undefined for
853     type <= SLJIT_C_FLOAT_LESS_EQUAL. */
854 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,
855     sljit_si src1, sljit_sw src1w,
856     sljit_si src2, sljit_sw src2w);
857 zherczeg 867
858 ph10 662 /* Set the destination of the jump to this label. */
859 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label);
860 zherczeg 1460 /* Set the destination address of the jump to this label. */
861 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target);
862 ph10 662
863     /* Call function or jump anywhere. Both direct and indirect form
864     type must be between SLJIT_JUMP and SLJIT_CALL3
865     Direct form: set src to SLJIT_IMM() and srcw to the address
866     Indirect form: any other valid addressing mode
867     Flags: - (never set any flags) for unconditional jumps.
868     Flags: destroy all flags for calls. */
869 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw);
870 ph10 662
871 zherczeg 1209 /* Perform the operation using the conditional flags as the second argument.
872     Type must always be between SLJIT_C_EQUAL and SLJIT_C_FLOAT_ORDERED. The
873     value represented by the type is 1, if the condition represented by the type
874     is fulfilled, and 0 otherwise.
875    
876     If op == SLJIT_MOV, SLJIT_MOV_SI, SLJIT_MOV_UI:
877     Set dst to the value represented by the type (0 or 1).
878     Src must be SLJIT_UNUSED, and srcw must be 0
879 ph10 662 Flags: - (never set any flags)
880 zherczeg 1209 If op == SLJIT_OR, op == SLJIT_AND, op == SLJIT_XOR
881     Performs the binary operation using src as the first, and the value
882     represented by type as the second argument.
883     Important note: only dst=src and dstw=srcw is supported at the moment!
884 zherczeg 1203 Flags: I | E | K
885 zherczeg 1209 Note: sljit_emit_op_flags does nothing, if dst is SLJIT_UNUSED (regardless of op). */
886     SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_si op,
887     sljit_si dst, sljit_sw dstw,
888     sljit_si src, sljit_sw srcw,
889     sljit_si type);
890 ph10 662
891 zherczeg 1195 /* Copies the base address of SLJIT_LOCALS_REG+offset to dst.
892 zherczeg 955 Flags: - (never set any flags) */
893 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_local_base(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw offset);
894 zherczeg 955
895 ph10 662 /* The constant can be changed runtime (see: sljit_set_const)
896     Flags: - (never set any flags) */
897 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw init_value);
898 ph10 662
899     /* After the code generation the address for label, jump and const instructions
900 zherczeg 1222 are computed. Since these structures are freed by sljit_free_compiler, the
901 ph10 662 addresses must be preserved by the user program elsewere. */
902     static SLJIT_INLINE sljit_uw sljit_get_label_addr(struct sljit_label *label) { return label->addr; }
903     static SLJIT_INLINE sljit_uw sljit_get_jump_addr(struct sljit_jump *jump) { return jump->addr; }
904     static SLJIT_INLINE sljit_uw sljit_get_const_addr(struct sljit_const *const_) { return const_->addr; }
905    
906     /* Only the address is required to rewrite the code. */
907 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr);
908 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant);
909 ph10 662
910     /* --------------------------------------------------------------------- */
911     /* Miscellaneous utility functions */
912     /* --------------------------------------------------------------------- */
913    
914     #define SLJIT_MAJOR_VERSION 0
915 zherczeg 1229 #define SLJIT_MINOR_VERSION 91
916 ph10 662
917 zherczeg 1222 /* Get the human readable name of the platform. Can be useful on platforms
918 zherczeg 1216 like ARM, where ARM and Thumb2 functions can be mixed, and
919     it is useful to know the type of the code generator. */
920 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char* sljit_get_platform_name(void);
921 ph10 662
922 zherczeg 1222 /* Portable helper function to get an offset of a member. */
923 zherczeg 1195 #define SLJIT_OFFSETOF(base, member) ((sljit_sw)(&((base*)0x10)->member) - 0x10)
924 ph10 662
925     #if (defined SLJIT_UTIL_GLOBAL_LOCK && SLJIT_UTIL_GLOBAL_LOCK)
926     /* This global lock is useful to compile common functions. */
927 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_grab_lock(void);
928     SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_release_lock(void);
929 ph10 662 #endif
930    
931     #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)
932    
933     /* The sljit_stack is a utiliy feature of sljit, which allocates a
934     writable memory region between base (inclusive) and limit (exclusive).
935     Both base and limit is a pointer, and base is always <= than limit.
936     This feature uses the "address space reserve" feature
937     of modern operating systems. Basically we don't need to allocate a
938     huge memory block in one step for the worst case, we can start with
939     a smaller chunk and extend it later. Since the address space is
940     reserved, the data never copied to other regions, thus it is safe
941     to store pointers here. */
942    
943     /* Note: The base field is aligned to PAGE_SIZE bytes (usually 4k or more).
944     Note: stack growing should not happen in small steps: 4k, 16k or even
945     bigger growth is better.
946     Note: this structure may not be supported by all operating systems.
947     Some kind of fallback mechanism is suggested when SLJIT_UTIL_STACK
948     is not defined. */
949    
950     struct sljit_stack {
951     /* User data, anything can be stored here.
952     Starting with the same value as base. */
953     sljit_uw top;
954     /* These members are read only. */
955     sljit_uw base;
956     sljit_uw limit;
957     sljit_uw max_limit;
958     };
959    
960     /* Returns NULL if unsuccessful.
961     Note: limit and max_limit contains the size for stack allocation
962     Note: the top field is initialized to base. */
963 zherczeg 740 SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_CALL sljit_allocate_stack(sljit_uw limit, sljit_uw max_limit);
964     SLJIT_API_FUNC_ATTRIBUTE void SLJIT_CALL sljit_free_stack(struct sljit_stack* stack);
965 ph10 662
966     /* Can be used to increase (allocate) or decrease (free) the memory area.
967     Returns with a non-zero value if unsuccessful. If new_limit is greater than
968     max_limit, it will fail. It is very easy to implement a stack data structure,
969     since the growth ratio can be added to the current limit, and sljit_stack_resize
970     will do all the necessary checks. The fields of the stack are not changed if
971     sljit_stack_resize fails. */
972 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE sljit_sw SLJIT_CALL sljit_stack_resize(struct sljit_stack* stack, sljit_uw new_limit);
973 ph10 662
974     #endif /* (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) */
975    
976     #if !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
977    
978     /* Get the entry address of a given function. */
979 zherczeg 1195 #define SLJIT_FUNC_OFFSET(func_name) ((sljit_sw)func_name)
980 ph10 662
981     #else /* !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) */
982    
983     /* All JIT related code should be placed in the same context (library, binary, etc.). */
984    
985 zherczeg 1222 #define SLJIT_FUNC_OFFSET(func_name) (*(sljit_sw*)(void*)func_name)
986 ph10 662
987     /* For powerpc64, the function pointers point to a context descriptor. */
988     struct sljit_function_context {
989 zherczeg 1195 sljit_sw addr;
990     sljit_sw r2;
991     sljit_sw r11;
992 ph10 662 };
993    
994     /* Fill the context arguments using the addr and the function.
995     If func_ptr is NULL, it will not be set to the address of context
996     If addr is NULL, the function address also comes from the func pointer. */
997 zherczeg 1195 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_function_context(void** func_ptr, struct sljit_function_context* context, sljit_sw addr, void* func);
998 ph10 662
999     #endif /* !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) */
1000    
1001     #endif /* _SLJIT_LIR_H_ */

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12