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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.5