Debian Codegraph @

src/3rdparty/pcre2/deps/sljit/sljit_src/sljitLir.h

raw
1 /*
2 * Stack-less Just-In-Time compiler
3 *
4 * Copyright Zoltan Herczeg ([email protected]). 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, as long as the compiling
40 context is the same. See sljit_emit_enter for more details.
41 - Supports self modifying code: target of any jump and call
42 instructions and some constant values can be dynamically modified
43 during runtime. See SLJIT_REWRITABLE_JUMP.
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 - A fixed stack space can be allocated for local variables
48 - The compiler is thread-safe
49 - The compiler is highly configurable through preprocessor macros.
50 You can disable unneeded features (multithreading in single
51 threaded applications), and you can use your own system functions
52 (including memory allocators). See sljitConfig.h.
53 Disadvantages:
54 - The compiler is more like a platform independent assembler, so
55 there is no built-in variable management. Registers and stack must
56 be managed manually (the name of the compiler refers to this).
57 In practice:
58 - This approach is very effective for interpreters
59 - One of the saved registers typically points to a stack interface
60 - It can jump to any exception handler anytime (even if it belongs
61 to another function)
62 - Hot paths can be modified during runtime reflecting the changes
63 of the fastest execution path of the dynamic language
64 - SLJIT supports complex memory addressing modes
65 - mainly position and context independent code (except some cases)
66
67 For valgrind users:
68 - pass --smc-check=all argument to valgrind, since JIT is a "self-modifying code"
69 */
70
71 #if (defined SLJIT_HAVE_CONFIG_PRE && SLJIT_HAVE_CONFIG_PRE)
72 #include "sljitConfigPre.h"
73 #endif /* SLJIT_HAVE_CONFIG_PRE */
74
75 #include "sljitConfigCPU.h"
76 #include "sljitConfig.h"
77
78 /* The following header file defines useful macros for fine tuning
79 SLJIT based code generators. They are listed in the beginning
80 of sljitConfigInternal.h */
81
82 #include "sljitConfigInternal.h"
83
84 #if (defined SLJIT_HAVE_CONFIG_POST && SLJIT_HAVE_CONFIG_POST)
85 #include "sljitConfigPost.h"
86 #endif /* SLJIT_HAVE_CONFIG_POST */
87
88 #ifdef __cplusplus
89 extern "C" {
90 #endif /* __cplusplus */
91
92 /* Version numbers. */
93 #define SLJIT_MAJOR_VERSION 0
94 #define SLJIT_MINOR_VERSION 95
95
96 /* --------------------------------------------------------------------- */
97 /* Error codes */
98 /* --------------------------------------------------------------------- */
99
100 /* Indicates no error. */
101 #define SLJIT_SUCCESS 0
102 /* After the call of sljit_generate_code(), the error code of the compiler
103 is set to this value to avoid further code generation.
104 The complier should be freed after sljit_generate_code(). */
105 #define SLJIT_ERR_COMPILED 1
106 /* Cannot allocate non-executable memory. */
107 #define SLJIT_ERR_ALLOC_FAILED 2
108 /* Cannot allocate executable memory.
109 Only sljit_generate_code() returns with this error code. */
110 #define SLJIT_ERR_EX_ALLOC_FAILED 3
111 /* Unsupported instruction form. */
112 #define SLJIT_ERR_UNSUPPORTED 4
113 /* An invalid argument is passed to any SLJIT function. */
114 #define SLJIT_ERR_BAD_ARGUMENT 5
115
116 /* --------------------------------------------------------------------- */
117 /* Registers */
118 /* --------------------------------------------------------------------- */
119
120 /*
121 Scratch (R) registers: registers which may not preserve their values
122 across function calls.
123
124 Saved (S) registers: registers which preserve their values across
125 function calls.
126
127 The scratch and saved register sets overlap. The last scratch register
128 is the first saved register, the one before the last is the second saved
129 register, and so on.
130
131 For example, in an architecture with only five registers (A-E), if two
132 are scratch and three saved registers, they will be defined as follows:
133
134 A | R0 | | R0 always represent scratch register A
135 B | R1 | | R1 always represent scratch register B
136 C | [R2] | S2 | R2 and S2 represent the same physical register C
137 D | [R3] | S1 | R3 and S1 represent the same physical register D
138 E | [R4] | S0 | R4 and S0 represent the same physical register E
139
140 Note: SLJIT_NUMBER_OF_SCRATCH_REGISTERS will be 2 and
141 SLJIT_NUMBER_OF_SAVED_REGISTERS will be 3.
142
143 Note: For all supported architectures SLJIT_NUMBER_OF_REGISTERS >= 12
144 and SLJIT_NUMBER_OF_SAVED_REGISTERS >= 6. However, 6 registers
145 are virtual on x86-32. See below.
146
147 The purpose of this definition is convenience: saved registers can
148 be used as extra scratch registers. For example, building in the
149 previous example, four registers can be specified as scratch registers
150 and the fifth one as saved register, allowing any user code which requires
151 four scratch registers to run unmodified. The SLJIT compiler automatically
152 saves the content of the two extra scratch register on the stack. Scratch
153 registers can also be preserved by saving their value on the stack but
154 that needs to be done manually.
155
156 Note: To emphasize that registers assigned to R2-R4 are saved
157 registers, they are enclosed by square brackets.
158
159 Note: sljit_emit_enter and sljit_set_context define whether a register
160 is S or R register. E.g: if in the previous example 3 scratches and
161 1 saved are mapped by sljit_emit_enter, the allowed register set
162 will be: R0-R2 and S0. Although S2 is mapped to the same register
163 than R2, it is not available in that configuration. Furthermore
164 the S1 register cannot be used at all.
165 */
166
167 /* Scratch registers. */
168 #define SLJIT_R0 1
169 #define SLJIT_R1 2
170 #define SLJIT_R2 3
171 /* Note: on x86-32, R3 - R6 (same as S3 - S6) are emulated (they
172 are allocated on the stack). These registers are called virtual
173 and cannot be used for memory addressing (cannot be part of
174 any SLJIT_MEM1, SLJIT_MEM2 construct). There is no such
175 limitation on other CPUs. See sljit_get_register_index(). */
176 #define SLJIT_R3 4
177 #define SLJIT_R4 5
178 #define SLJIT_R5 6
179 #define SLJIT_R6 7
180 #define SLJIT_R7 8
181 #define SLJIT_R8 9
182 #define SLJIT_R9 10
183 /* All R registers provided by the architecture can be accessed by SLJIT_R(i)
184 The i parameter must be >= 0 and < SLJIT_NUMBER_OF_REGISTERS. */
185 #define SLJIT_R(i) (1 + (i))
186
187 /* Saved registers. */
188 #define SLJIT_S0 (SLJIT_NUMBER_OF_REGISTERS)
189 #define SLJIT_S1 (SLJIT_NUMBER_OF_REGISTERS - 1)
190 #define SLJIT_S2 (SLJIT_NUMBER_OF_REGISTERS - 2)
191 /* Note: on x86-32, S3 - S6 (same as R3 - R6) are emulated (they
192 are allocated on the stack). These registers are called virtual
193 and cannot be used for memory addressing (cannot be part of
194 any SLJIT_MEM1, SLJIT_MEM2 construct). There is no such
195 limitation on other CPUs. See sljit_get_register_index(). */
196 #define SLJIT_S3 (SLJIT_NUMBER_OF_REGISTERS - 3)
197 #define SLJIT_S4 (SLJIT_NUMBER_OF_REGISTERS - 4)
198 #define SLJIT_S5 (SLJIT_NUMBER_OF_REGISTERS - 5)
199 #define SLJIT_S6 (SLJIT_NUMBER_OF_REGISTERS - 6)
200 #define SLJIT_S7 (SLJIT_NUMBER_OF_REGISTERS - 7)
201 #define SLJIT_S8 (SLJIT_NUMBER_OF_REGISTERS - 8)
202 #define SLJIT_S9 (SLJIT_NUMBER_OF_REGISTERS - 9)
203 /* All S registers provided by the architecture can be accessed by SLJIT_S(i)
204 The i parameter must be >= 0 and < SLJIT_NUMBER_OF_SAVED_REGISTERS. */
205 #define SLJIT_S(i) (SLJIT_NUMBER_OF_REGISTERS - (i))
206
207 /* Registers >= SLJIT_FIRST_SAVED_REG are saved registers. */
208 #define SLJIT_FIRST_SAVED_REG (SLJIT_S0 - SLJIT_NUMBER_OF_SAVED_REGISTERS + 1)
209
210 /* The SLJIT_SP provides direct access to the linear stack space allocated by
211 sljit_emit_enter. It can only be used in the following form: SLJIT_MEM1(SLJIT_SP).
212 The immediate offset is extended by the relative stack offset automatically.
213 sljit_get_local_base can be used to obtain the real address of a value. */
214 #define SLJIT_SP (SLJIT_NUMBER_OF_REGISTERS + 1)
215
216 /* Return with machine word. */
217
218 #define SLJIT_RETURN_REG SLJIT_R0
219
220 /* --------------------------------------------------------------------- */
221 /* Floating point registers */
222 /* --------------------------------------------------------------------- */
223
224 /* Each floating point register can store a 32 or a 64 bit precision
225 value. The FR and FS register sets overlap in the same way as R
226 and S register sets. See above. */
227
228 /* Floating point scratch registers. */
229 #define SLJIT_FR0 1
230 #define SLJIT_FR1 2
231 #define SLJIT_FR2 3
232 #define SLJIT_FR3 4
233 #define SLJIT_FR4 5
234 #define SLJIT_FR5 6
235 #define SLJIT_FR6 7
236 #define SLJIT_FR7 8
237 #define SLJIT_FR8 9
238 #define SLJIT_FR9 10
239 /* All FR registers provided by the architecture can be accessed by SLJIT_FR(i)
240 The i parameter must be >= 0 and < SLJIT_NUMBER_OF_FLOAT_REGISTERS. */
241 #define SLJIT_FR(i) (1 + (i))
242
243 /* Floating point saved registers. */
244 #define SLJIT_FS0 (SLJIT_NUMBER_OF_FLOAT_REGISTERS)
245 #define SLJIT_FS1 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 1)
246 #define SLJIT_FS2 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 2)
247 #define SLJIT_FS3 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 3)
248 #define SLJIT_FS4 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 4)
249 #define SLJIT_FS5 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 5)
250 #define SLJIT_FS6 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 6)
251 #define SLJIT_FS7 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 7)
252 #define SLJIT_FS8 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 8)
253 #define SLJIT_FS9 (SLJIT_NUMBER_OF_FLOAT_REGISTERS - 9)
254 /* All FS registers provided by the architecture can be accessed by SLJIT_FS(i)
255 The i parameter must be >= 0 and < SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS. */
256 #define SLJIT_FS(i) (SLJIT_NUMBER_OF_FLOAT_REGISTERS - (i))
257
258 /* Float registers >= SLJIT_FIRST_SAVED_FLOAT_REG are saved registers. */
259 #define SLJIT_FIRST_SAVED_FLOAT_REG (SLJIT_FS0 - SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS + 1)
260
261 /* Return with floating point arg. */
262
263 #define SLJIT_RETURN_FREG SLJIT_FR0
264
265 /* --------------------------------------------------------------------- */
266 /* Vector registers */
267 /* --------------------------------------------------------------------- */
268
269 /* Vector registers are storage areas, which are used for Single Instruction
270 Multiple Data (SIMD) computations. The VR and VS register sets overlap
271 in the same way as R and S register sets. See above.
272
273 The storage space of vector registers often overlap with floating point
274 registers. In this case setting the value of SLJIT_VR(i) destroys the
275 value of SLJIT_FR(i) and vice versa. See SLJIT_SEPARATE_VECTOR_REGISTERS
276 macro. */
277
278 /* Vector scratch registers. */
279 #define SLJIT_VR0 1
280 #define SLJIT_VR1 2
281 #define SLJIT_VR2 3
282 #define SLJIT_VR3 4
283 #define SLJIT_VR4 5
284 #define SLJIT_VR5 6
285 #define SLJIT_VR6 7
286 #define SLJIT_VR7 8
287 #define SLJIT_VR8 9
288 #define SLJIT_VR9 10
289 /* All VR registers provided by the architecture can be accessed by SLJIT_VR(i)
290 The i parameter must be >= 0 and < SLJIT_NUMBER_OF_VECTOR_REGISTERS. */
291 #define SLJIT_VR(i) (1 + (i))
292
293 /* Vector saved registers. */
294 #define SLJIT_VS0 (SLJIT_NUMBER_OF_VECTOR_REGISTERS)
295 #define SLJIT_VS1 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 1)
296 #define SLJIT_VS2 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 2)
297 #define SLJIT_VS3 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 3)
298 #define SLJIT_VS4 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 4)
299 #define SLJIT_VS5 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 5)
300 #define SLJIT_VS6 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 6)
301 #define SLJIT_VS7 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 7)
302 #define SLJIT_VS8 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 8)
303 #define SLJIT_VS9 (SLJIT_NUMBER_OF_VECTOR_REGISTERS - 9)
304 /* All VS registers provided by the architecture can be accessed by SLJIT_VS(i)
305 The i parameter must be >= 0 and < SLJIT_NUMBER_OF_SAVED_VECTOR_REGISTERS. */
306 #define SLJIT_VS(i) (SLJIT_NUMBER_OF_VECTOR_REGISTERS - (i))
307
308 /* Vector registers >= SLJIT_FIRST_SAVED_VECTOR_REG are saved registers. */
309 #define SLJIT_FIRST_SAVED_VECTOR_REG (SLJIT_VS0 - SLJIT_NUMBER_OF_SAVED_VECTOR_REGISTERS + 1)
310
311 /* --------------------------------------------------------------------- */
312 /* Argument type definitions */
313 /* --------------------------------------------------------------------- */
314
315 /* The following argument type definitions are used by sljit_emit_enter,
316 sljit_set_context, sljit_emit_call, and sljit_emit_icall functions.
317
318 For sljit_emit_call and sljit_emit_icall, the first integer argument
319 must be placed into SLJIT_R0, the second one into SLJIT_R1, and so on.
320 Similarly the first floating point argument must be placed into SLJIT_FR0,
321 the second one into SLJIT_FR1, and so on.
322
323 For sljit_emit_enter, the integer arguments can be stored in scratch
324 or saved registers. Scratch registers are identified by a _R suffix.
325
326 If only saved registers are used, then the allocation mirrors what is
327 done for the "call" functions but using saved registers, meaning that
328 the first integer argument goes to SLJIT_S0, the second one goes into
329 SLJIT_S1, and so on.
330
331 If scratch registers are used, then the way the integer registers are
332 allocated changes so that SLJIT_S0, SLJIT_S1, etc; will be assigned
333 only for the arguments not using scratch registers, while SLJIT_R<n>
334 will be used for the ones using scratch registers.
335
336 Furthermore, the index (shown as "n" above) that will be used for the
337 scratch register depends on how many previous integer registers
338 (scratch or saved) were used already, starting with SLJIT_R0.
339 Eventhough some indexes will be likely skipped, they still need to be
340 accounted for in the scratches parameter of sljit_emit_enter. See below
341 for some examples.
342
343 The floating point arguments always use scratch registers (but not the
344 _R suffix like the integer arguments) and must use SLJIT_FR0, SLJIT_FR1,
345 just like in the "call" functions.
346
347 Note: the mapping for scratch registers is part of the compiler context
348 and therefore a new context after sljit_emit_call/sljit_emit_icall
349 could remove access to some scratch registers that were used as
350 arguments.
351
352 Example function definition:
353 sljit_f32 SLJIT_FUNC example_c_callback(void *arg_a,
354 sljit_f64 arg_b, sljit_u32 arg_c, sljit_f32 arg_d);
355
356 Argument type definition:
357 SLJIT_ARG_RETURN(SLJIT_ARG_TYPE_F32)
358 | SLJIT_ARG_VALUE(SLJIT_ARG_TYPE_P, 1) | SLJIT_ARG_VALUE(SLJIT_ARG_TYPE_F64, 2)
359 | SLJIT_ARG_VALUE(SLJIT_ARG_TYPE_32, 3) | SLJIT_ARG_VALUE(SLJIT_ARG_TYPE_F32, 4)
360
361 Short form of argument type definition:
362 SLJIT_ARGS4(F32, P, F64, 32, F32)
363
364 Argument passing:
365 arg_a must be placed in SLJIT_R0
366 arg_b must be placed in SLJIT_FR0
367 arg_c must be placed in SLJIT_R1
368 arg_d must be placed in SLJIT_FR1
369
370 Examples for argument processing by sljit_emit_enter:
371 SLJIT_ARGS4V(P, 32_R, F32, W)
372 Arguments are placed into: SLJIT_S0, SLJIT_R1, SLJIT_FR0, SLJIT_S1
373 The type of the result is void.
374
375 SLJIT_ARGS4(F32, W, W_R, W, W_R)
376 Arguments are placed into: SLJIT_S0, SLJIT_R1, SLJIT_S1, SLJIT_R3
377 The type of the result is sljit_f32.
378
379 SLJIT_ARGS4(P, W, F32, P_R)
380 Arguments are placed into: SLJIT_FR0, SLJIT_S0, SLJIT_FR1, SLJIT_R1
381 The type of the result is pointer.
382
383 Note: it is recommended to pass the scratch arguments first
384 followed by the saved arguments:
385
386 SLJIT_ARGS4(W, W_R, W_R, W, W)
387 Arguments are placed into: SLJIT_R0, SLJIT_R1, SLJIT_S0, SLJIT_S1
388 The type of the result is sljit_sw / sljit_uw.
389 */
390
391 /* The following flag is only allowed for the integer arguments of
392 sljit_emit_enter. When the flag is set, the integer argument is
393 stored in a scratch register instead of a saved register. */
394 #define SLJIT_ARG_TYPE_SCRATCH_REG 0x8
395
396 /* No return value, only supported by SLJIT_ARG_RETURN. */
397 #define SLJIT_ARG_TYPE_RET_VOID 0
398 /* Machine word sized integer argument or result. */
399 #define SLJIT_ARG_TYPE_W 1
400 #define SLJIT_ARG_TYPE_W_R (SLJIT_ARG_TYPE_W | SLJIT_ARG_TYPE_SCRATCH_REG)
401 /* 32 bit integer argument or result. */
402 #define SLJIT_ARG_TYPE_32 2
403 #define SLJIT_ARG_TYPE_32_R (SLJIT_ARG_TYPE_32 | SLJIT_ARG_TYPE_SCRATCH_REG)
404 /* Pointer sized integer argument or result. */
405 #define SLJIT_ARG_TYPE_P 3
406 #define SLJIT_ARG_TYPE_P_R (SLJIT_ARG_TYPE_P | SLJIT_ARG_TYPE_SCRATCH_REG)
407 /* 64 bit floating point argument or result. */
408 #define SLJIT_ARG_TYPE_F64 4
409 /* 32 bit floating point argument or result. */
410 #define SLJIT_ARG_TYPE_F32 5
411
412 #define SLJIT_ARG_SHIFT 4
413 #define SLJIT_ARG_RETURN(type) (type)
414 #define SLJIT_ARG_VALUE(type, idx) ((type) << ((idx) * SLJIT_ARG_SHIFT))
415
416 /* Simplified argument list definitions.
417
418 The following definition:
419 SLJIT_ARG_RETURN(SLJIT_ARG_TYPE_W) | SLJIT_ARG_VALUE(SLJIT_ARG_TYPE_F32, 1)
420
421 can be shortened to:
422 SLJIT_ARGS1(W, F32)
423
424 Another example where no value is returned:
425 SLJIT_ARG_RETURN(SLJIT_ARG_TYPE_RET_VOID) | SLJIT_ARG_VALUE(SLJIT_ARG_TYPE_W_R, 1)
426
427 can be shortened to:
428 SLJIT_ARGS1V(W_R)
429 */
430
431 #define SLJIT_ARG_TO_TYPE(type) SLJIT_ARG_TYPE_ ## type
432
433 #define SLJIT_ARGS0(ret) \
434 SLJIT_ARG_RETURN(SLJIT_ARG_TO_TYPE(ret))
435 #define SLJIT_ARGS0V() \
436 SLJIT_ARG_RETURN(SLJIT_ARG_TYPE_RET_VOID)
437
438 #define SLJIT_ARGS1(ret, arg1) \
439 (SLJIT_ARGS0(ret) | SLJIT_ARG_VALUE(SLJIT_ARG_TO_TYPE(arg1), 1))
440 #define SLJIT_ARGS1V(arg1) \
441 (SLJIT_ARGS0V() | SLJIT_ARG_VALUE(SLJIT_ARG_TO_TYPE(arg1), 1))
442
443 #define SLJIT_ARGS2(ret, arg1, arg2) \
444 (SLJIT_ARGS1(ret, arg1) | SLJIT_ARG_VALUE(SLJIT_ARG_TO_TYPE(arg2), 2))
445 #define SLJIT_ARGS2V(arg1, arg2) \
446 (SLJIT_ARGS1V(arg1) | SLJIT_ARG_VALUE(SLJIT_ARG_TO_TYPE(arg2), 2))
447
448 #define SLJIT_ARGS3(ret, arg1, arg2, arg3) \
449 (SLJIT_ARGS2(ret, arg1, arg2) | SLJIT_ARG_VALUE(SLJIT_ARG_TO_TYPE(arg3), 3))
450 #define SLJIT_ARGS3V(arg1, arg2, arg3) \
451 (SLJIT_ARGS2V(arg1, arg2) | SLJIT_ARG_VALUE(SLJIT_ARG_TO_TYPE(arg3), 3))
452
453 #define SLJIT_ARGS4(ret, arg1, arg2, arg3, arg4) \
454 (SLJIT_ARGS3(ret, arg1, arg2, arg3) | SLJIT_ARG_VALUE(SLJIT_ARG_TO_TYPE(arg4), 4))
455 #define SLJIT_ARGS4V(arg1, arg2, arg3, arg4) \
456 (SLJIT_ARGS3V(arg1, arg2, arg3) | SLJIT_ARG_VALUE(SLJIT_ARG_TO_TYPE(arg4), 4))
457
458 /* --------------------------------------------------------------------- */
459 /* Main structures and functions */
460 /* --------------------------------------------------------------------- */
461
462 /*
463 The following structures are private, and can be changed in the
464 future. Keeping them here allows code inlining.
465 */
466
467 struct sljit_memory_fragment {
468 struct sljit_memory_fragment *next;
469 sljit_uw used_size;
470 /* Must be aligned to sljit_sw. */
471 sljit_u8 memory[1];
472 };
473
474 struct sljit_label {
475 struct sljit_label *next;
476 union {
477 sljit_uw index;
478 sljit_uw addr;
479 } u;
480 /* The maximum size difference. */
481 sljit_uw size;
482 };
483
484 struct sljit_jump {
485 struct sljit_jump *next;
486 sljit_uw addr;
487 /* Architecture dependent flags. */
488 sljit_uw flags;
489 union {
490 sljit_uw target;
491 struct sljit_label *label;
492 } u;
493 };
494
495 struct sljit_const {
496 struct sljit_const *next;
497 sljit_uw addr;
498 };
499
500 struct sljit_generate_code_buffer {
501 void *buffer;
502 sljit_uw size;
503 sljit_sw executable_offset;
504 };
505
506 struct sljit_read_only_buffer {
507 struct sljit_read_only_buffer *next;
508 sljit_uw size;
509 /* Label can be replaced by address after sljit_generate_code. */
510 union {
511 struct sljit_label *label;
512 sljit_uw addr;
513 } u;
514 };
515
516 struct sljit_compiler {
517 sljit_s32 error;
518 sljit_s32 options;
519
520 struct sljit_label *labels;
521 struct sljit_jump *jumps;
522 struct sljit_const *consts;
523 struct sljit_label *last_label;
524 struct sljit_jump *last_jump;
525 struct sljit_const *last_const;
526
527 void *allocator_data;
528 void *user_data;
529 struct sljit_memory_fragment *buf;
530 struct sljit_memory_fragment *abuf;
531
532 /* Number of labels created by the compiler. */
533 sljit_uw label_count;
534 /* Available scratch registers. */
535 sljit_s32 scratches;
536 /* Available saved registers. */
537 sljit_s32 saveds;
538 /* Available float scratch registers. */
539 sljit_s32 fscratches;
540 /* Available float saved registers. */
541 sljit_s32 fsaveds;
542 #if (defined SLJIT_SEPARATE_VECTOR_REGISTERS && SLJIT_SEPARATE_VECTOR_REGISTERS) \
543 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
544 || (defined SLJIT_DEBUG && SLJIT_DEBUG) \
545 || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
546 /* Available vector scratch registers. */
547 sljit_s32 vscratches;
548 /* Available vector saved registers. */
549 sljit_s32 vsaveds;
550 #endif /* SLJIT_SEPARATE_VECTOR_REGISTERS || SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG || SLJIT_VERBOSE */
551 /* Local stack size. */
552 sljit_s32 local_size;
553 /* Maximum code size. */
554 sljit_uw size;
555 /* Relative offset of the executable mapping from the writable mapping. */
556 sljit_sw executable_offset;
557 /* Executable size for statistical purposes. */
558 sljit_uw executable_size;
559
560 #if (defined SLJIT_HAS_STATUS_FLAGS_STATE && SLJIT_HAS_STATUS_FLAGS_STATE)
561 sljit_s32 status_flags_state;
562 #endif /* SLJIT_HAS_STATUS_FLAGS_STATE */
563
564 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
565 sljit_s32 args_size;
566 #endif /* SLJIT_CONFIG_X86_32 */
567
568 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
569 /* Temporary fields. */
570 sljit_s32 mode32;
571 #endif /* SLJIT_CONFIG_X86_64 */
572
573 #if (defined SLJIT_CONFIG_ARM_V6 && SLJIT_CONFIG_ARM_V6)
574 /* Constant pool handling. */
575 sljit_uw *cpool;
576 sljit_u8 *cpool_unique;
577 sljit_uw cpool_diff;
578 sljit_uw cpool_fill;
579 /* Other members. */
580 /* Contains pointer, "ldr pc, [...]" pairs. */
581 sljit_uw patches;
582 #endif /* SLJIT_CONFIG_ARM_V6 */
583
584 #if (defined SLJIT_CONFIG_ARM_V6 && SLJIT_CONFIG_ARM_V6) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
585 /* Temporary fields. */
586 sljit_uw shift_imm;
587 #endif /* SLJIT_CONFIG_ARM_V6 || SLJIT_CONFIG_ARM_V6 */
588
589 #if (defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32) && (defined __SOFTFP__)
590 sljit_uw args_size;
591 #endif /* SLJIT_CONFIG_ARM_32 && __SOFTFP__ */
592
593 #if (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
594 /* Temporary fields. */
595 sljit_u32 imm;
596 #endif /* SLJIT_CONFIG_PPC */
597
598 #if (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)
599 sljit_s32 delay_slot;
600 /* Temporary fields. */
601 sljit_s32 cache_arg;
602 sljit_sw cache_argw;
603 #endif /* SLJIT_CONFIG_MIPS */
604
605 #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
606 sljit_uw args_size;
607 #endif /* SLJIT_CONFIG_MIPS_32 */
608
609 #if (defined SLJIT_CONFIG_RISCV && SLJIT_CONFIG_RISCV)
610 /* Temporary fields. */
611 sljit_s32 cache_arg;
612 sljit_sw cache_argw;
613 #endif /* SLJIT_CONFIG_RISCV */
614
615 #if (defined SLJIT_CONFIG_S390X && SLJIT_CONFIG_S390X)
616 /* Need to allocate register save area to make calls. */
617 /* Temporary fields. */
618 sljit_s32 mode;
619 #endif /* SLJIT_CONFIG_S390X */
620
621 #if (defined SLJIT_CONFIG_LOONGARCH && SLJIT_CONFIG_LOONGARCH)
622 /* Temporary fields. */
623 sljit_s32 cache_arg;
624 sljit_sw cache_argw;
625 #endif /* SLJIT_CONFIG_LOONGARCH */
626
627 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
628 FILE* verbose;
629 #endif /* SLJIT_VERBOSE */
630
631 /* Note: SLJIT_DEBUG enables SLJIT_ARGUMENT_CHECKS. */
632 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
633 || (defined SLJIT_DEBUG && SLJIT_DEBUG)
634 /* Flags specified by the last arithmetic instruction.
635 It contains the type of the variable flag. */
636 sljit_s32 last_flags;
637 /* Return value type set by entry functions. */
638 sljit_s32 last_return;
639 /* Local size passed to entry functions. */
640 sljit_s32 logical_local_size;
641 #endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG */
642
643 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
644 || (defined SLJIT_DEBUG && SLJIT_DEBUG) \
645 || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
646 #if !(defined SLJIT_SEPARATE_VECTOR_REGISTERS && SLJIT_SEPARATE_VECTOR_REGISTERS)
647 /* Available float scratch registers. */
648 sljit_s32 real_fscratches;
649 /* Available float saved registers. */
650 sljit_s32 real_fsaveds;
651 #endif /* !SLJIT_SEPARATE_VECTOR_REGISTERS */
652
653 /* Trust arguments when an API function is called.
654 Used internally for calling API functions. */
655 sljit_s32 skip_checks;
656 #endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG || SLJIT_VERBOSE */
657 };
658
659 /* --------------------------------------------------------------------- */
660 /* Main functions */
661 /* --------------------------------------------------------------------- */
662
663 /* Creates an SLJIT compiler. The allocator_data is required by some
664 custom memory managers. This pointer is passed to SLJIT_MALLOC
665 and SLJIT_FREE macros. Most allocators (including the default
666 one) ignores this value, and it is recommended to pass NULL
667 as a dummy value for allocator_data.
668
669 Returns NULL if failed. */
670 SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void *allocator_data);
671
672 /* Frees everything except the compiled machine code. */
673 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler);
674
675 /* Returns the current error code. If an error occurres, future calls
676 which uses the same compiler argument returns early with the same
677 error code. Thus there is no need for checking the error after every
678 call, it is enough to do it after the code is compiled. Removing
679 these checks increases the performance of the compiling process. */
680 static SLJIT_INLINE sljit_s32 sljit_get_compiler_error(struct sljit_compiler *compiler) { return compiler->error; }
681
682 /* Sets the compiler error code to SLJIT_ERR_ALLOC_FAILED except
683 if an error was detected before. After the error code is set
684 the compiler behaves as if the allocation failure happened
685 during an SLJIT function call. This can greatly simplify error
686 checking, since it is enough to check the compiler status
687 after the code is compiled. */
688 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_compiler_memory_error(struct sljit_compiler *compiler);
689
690 /* Allocate a small amount of memory. The size must be <= 64 bytes on 32 bit,
691 and <= 128 bytes on 64 bit architectures. The memory area is owned by the
692 compiler, and freed by sljit_free_compiler. The returned pointer is
693 sizeof(sljit_sw) aligned. Excellent for allocating small blocks during
694 compiling, and no need to worry about freeing them. The size is enough
695 to contain at most 16 pointers. If the size is outside of the range,
696 the function will return with NULL. However, this return value does not
697 indicate that there is no more memory (does not set the current error code
698 of the compiler to out-of-memory status). */
699 SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_s32 size);
700
701 /* Returns the allocator data passed to sljit_create_compiler. */
702 static SLJIT_INLINE void* sljit_compiler_get_allocator_data(struct sljit_compiler *compiler) { return compiler->allocator_data; }
703 /* Sets/get the user data for a compiler. */
704 static SLJIT_INLINE void sljit_compiler_set_user_data(struct sljit_compiler *compiler, void *user_data) { compiler->user_data = user_data; }
705 static SLJIT_INLINE void* sljit_compiler_get_user_data(struct sljit_compiler *compiler) { return compiler->user_data; }
706
707 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
708 /* Passing NULL disables verbose. */
709 SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose);
710 #endif /* SLJIT_VERBOSE */
711
712 /* Option bits for sljit_generate_code. */
713
714 /* The exec_allocator_data points to a pre-allocated
715 buffer which type is sljit_generate_code_buffer. */
716 #define SLJIT_GENERATE_CODE_BUFFER 0x1
717
718 /* When SLJIT_INDIRECT_CALL is defined, no function context is
719 created for the generated code (see sljit_set_function_context),
720 so the returned pointer cannot be directly called from C code.
721 The flag is ignored when SLJIT_INDIRECT_CALL is not defined. */
722 #define SLJIT_GENERATE_CODE_NO_CONTEXT 0x2
723
724 /* Create executable code from the instruction stream. This is the final step
725 of the code generation, and no more instructions can be emitted after this call.
726
727 options is the combination of SLJIT_GENERATE_CODE_* bits
728 exec_allocator_data is passed to SLJIT_MALLOC_EXEC and
729 SLJIT_MALLOC_FREE functions */
730
731 SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler, sljit_s32 options, void *exec_allocator_data);
732
733 /* Free executable code. */
734
735 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code, void *exec_allocator_data);
736
737 /* When the protected executable allocator is used the JIT code is mapped
738 twice. The first mapping has read/write and the second mapping has read/exec
739 permissions. This function returns with the relative offset of the executable
740 mapping using the writable mapping as the base after the machine code is
741 successfully generated. The returned value is always 0 for the normal executable
742 allocator, since it uses only one mapping with read/write/exec permissions.
743 Dynamic code modifications requires this value.
744
745 Before a successful code generation, this function returns with 0. */
746 static SLJIT_INLINE sljit_sw sljit_get_executable_offset(struct sljit_compiler *compiler) { return compiler->executable_offset; }
747
748 /* The executable memory consumption of the generated code can be retrieved by
749 this function. The returned value can be used for statistical purposes.
750
751 Before a successful code generation, this function returns with 0. */
752 static SLJIT_INLINE sljit_uw sljit_get_generated_code_size(struct sljit_compiler *compiler) { return compiler->executable_size; }
753
754 /* Returns with non-zero if the feature or limitation type passed as its
755 argument is present on the current CPU. The return value is one, if a
756 feature is fully supported, and it is two, if partially supported.
757
758 Some features (e.g. floating point operations) require hardware (CPU)
759 support while others (e.g. move with update) are emulated if not available.
760 However, even when a feature is emulated, specialized code paths may be
761 faster than the emulation. Some limitations are emulated as well so their
762 general case is supported but it has extra performance costs.
763
764 Note: sljitConfigInternal.h also provides several feature detection macros. */
765
766 /* [Not emulated] Floating-point support is available. */
767 #define SLJIT_HAS_FPU 0
768 /* [Limitation] Some registers are virtual registers. */
769 #define SLJIT_HAS_VIRTUAL_REGISTERS 1
770 /* [Emulated] Has zero register (setting a memory location to zero is efficient). */
771 #define SLJIT_HAS_ZERO_REGISTER 2
772 /* [Emulated] Count leading zero is supported. */
773 #define SLJIT_HAS_CLZ 3
774 /* [Emulated] Count trailing zero is supported. */
775 #define SLJIT_HAS_CTZ 4
776 /* [Emulated] Reverse the order of bytes is supported. */
777 #define SLJIT_HAS_REV 5
778 /* [Emulated] Rotate left/right is supported. */
779 #define SLJIT_HAS_ROT 6
780 /* [Emulated] Conditional move is supported. */
781 #define SLJIT_HAS_CMOV 7
782 /* [Emulated] Prefetch instruction is available (emulated as a nop). */
783 #define SLJIT_HAS_PREFETCH 8
784 /* [Emulated] Copy from/to f32 operation is available (see sljit_emit_fcopy). */
785 #define SLJIT_HAS_COPY_F32 9
786 /* [Emulated] Copy from/to f64 operation is available (see sljit_emit_fcopy). */
787 #define SLJIT_HAS_COPY_F64 10
788 /* [Not emulated] The 64 bit floating point registers can be used as
789 two separate 32 bit floating point registers (e.g. ARM32). The
790 second 32 bit part can be accessed by SLJIT_F64_SECOND. */
791 #define SLJIT_HAS_F64_AS_F32_PAIR 11
792 /* [Not emulated] Some SIMD operations are supported by the compiler. */
793 #define SLJIT_HAS_SIMD 12
794 /* [Not emulated] SIMD registers are mapped to a pair of double precision
795 floating point registers. E.g. passing either SLJIT_FR0 or SLJIT_FR1 to
796 a simd operation represents the same 128 bit register, and both SLJIT_FR0
797 and SLJIT_FR1 are overwritten. */
798 #define SLJIT_SIMD_REGS_ARE_PAIRS 13
799 /* [Not emulated] Atomic support is available. */
800 #define SLJIT_HAS_ATOMIC 14
801 /* [Not emulated] Memory barrier support is available. */
802 #define SLJIT_HAS_MEMORY_BARRIER 15
803
804 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
805 /* [Not emulated] AVX support is available on x86. */
806 #define SLJIT_HAS_AVX 100
807 /* [Not emulated] AVX2 support is available on x86. */
808 #define SLJIT_HAS_AVX2 101
809 #endif /* SLJIT_CONFIG_X86 */
810
811 #if (defined SLJIT_CONFIG_LOONGARCH)
812 /* [Not emulated] LASX support is available on LoongArch */
813 #define SLJIT_HAS_LASX 201
814 #endif /* SLJIT_CONFIG_LOONGARCH */
815
816 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_has_cpu_feature(sljit_s32 feature_type);
817
818 /* If type is between SLJIT_ORDERED_EQUAL and SLJIT_ORDERED_LESS_EQUAL,
819 sljit_cmp_info returns with:
820 zero - if the cpu supports the floating point comparison type
821 one - if the comparison requires two machine instructions
822 two - if the comparison requires more than two machine instructions
823
824 When the result is non-zero, it is recommended to avoid
825 using the specified comparison type if it is easy to do so.
826
827 Otherwise it returns zero. */
828 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_cmp_info(sljit_s32 type);
829
830 /* The following functions generate machine code. If there is no
831 error, they return with SLJIT_SUCCESS, otherwise they return
832 with an error code. */
833
834 /*
835 The executable code is a callable function from the viewpoint
836 of the C language. Function calls must conform with the ABI
837 (Application Binary Interface) of the target platform, which
838 specify the purpose of machine registers and stack handling
839 among other things. The sljit_emit_enter function emits the
840 necessary instructions for setting up an entry point for the
841 executable code. This is often called as function prologue.
842
843 The "options" argument can be used to pass configuration options
844 to the sljit compiler which affects the generated code, until
845 another sljit_emit_enter or sljit_set_context is called. The
846 available options are listed before sljit_emit_enter.
847
848 The function argument list is specified by the SLJIT_ARGSx
849 (SLJIT_ARGS0 .. SLJIT_ARGS4) macros. Currently maximum four
850 arguments are supported. See the description of SLJIT_ARGSx
851 macros about argument passing.
852
853 The register set used by the function must be declared as well.
854 The number of scratch and saved registers available to the
855 function must be passed to sljit_emit_enter. Only R registers
856 between R0 and "scratches" argument can be used later. E.g.
857 if "scratches" is set to two, the scratch register set will
858 be limited to SLJIT_R0 and SLJIT_R1. The S registers are
859 declared in a similar manner, but their count is specified
860 by "saveds" argument. The floating point scratch and saved
861 registers can be set by using "scratches" and "saveds" argument
862 as well, but their value must be passed to the SLJIT_ENTER_FLOAT
863 macro, see below.
864
865 The sljit_emit_enter is also capable of allocating a stack
866 space for local data. The "local_size" argument contains the
867 size in bytes of this local area, and it can be accessed using
868 SLJIT_MEM1(SLJIT_SP). The memory area between SLJIT_SP (inclusive)
869 and SLJIT_SP + local_size (exclusive) can be modified freely
870 until the function returns. The alocated stack space is an
871 uninitialized memory area.
872
873 Floating point scratch and saved registers must be specified
874 by the SLJIT_ENTER_FLOAT macro, which result value should be
875 combined with scratches / saveds argument.
876
877 Examples:
878 To use three scratch and four floating point scratch
879 registers, the "scratches" argument must be set to:
880 3 | SLJIT_ENTER_FLOAT(4)
881
882 To use six saved and five floating point saved
883 registers, the "saveds" argument must be set to:
884 6 | SLJIT_ENTER_FLOAT(5)
885
886 Note: the following conditions must met:
887 0 <= scratches <= SLJIT_NUMBER_OF_REGISTERS
888 0 <= saveds <= SLJIT_NUMBER_OF_SAVED_REGISTERS
889 scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS
890
891 0 <= float scratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS
892 0 <= float saveds <= SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS
893 float scratches + float saveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS
894
895 Note: the compiler can use saved registers as scratch registers,
896 but the opposite is not supported
897
898 Note: every call of sljit_emit_enter and sljit_set_context
899 overwrites the previous context.
900 */
901
902 /* The following options are available for sljit_emit_enter. */
903
904 /* Saved registers between SLJIT_S0 and SLJIT_S(n - 1) (inclusive)
905 are not saved / restored on function enter / return. Instead,
906 these registers can be used to pass / return data (such as
907 global / local context pointers) across function calls. The
908 value of n must be between 1 and 3. This option is only
909 supported by SLJIT_ENTER_REG_ARG calling convention. */
910 #define SLJIT_ENTER_KEEP(n) (n)
911
912 /* The compiled function uses an SLJIT specific register argument
913 calling convention. This is a lightweight function call type where
914 both the caller and the called functions must be compiled by
915 SLJIT. The type argument of the call must be SLJIT_CALL_REG_ARG
916 and all arguments must be stored in scratch registers. */
917 #define SLJIT_ENTER_REG_ARG 0x00000004
918
919 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
920 /* Use VEX prefix for all SIMD operations on x86. */
921 #define SLJIT_ENTER_USE_VEX 0x00010000
922 #endif /* !SLJIT_CONFIG_X86 */
923
924 /* Macros for other sljit_emit_enter arguments. */
925
926 /* Floating point scratch and saved registers can be
927 specified by SLJIT_ENTER_FLOAT. */
928 #define SLJIT_ENTER_FLOAT(regs) ((regs) << 8)
929
930 /* Vector scratch and saved registers can be specified
931 by SLJIT_ENTER_VECTOR. */
932 #define SLJIT_ENTER_VECTOR(regs) ((regs) << 16)
933
934 /* The local_size must be >= 0 and <= SLJIT_MAX_LOCAL_SIZE. */
935 #define SLJIT_MAX_LOCAL_SIZE 1048576
936
937 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_enter(struct sljit_compiler *compiler,
938 sljit_s32 options, sljit_s32 arg_types,
939 sljit_s32 scratches, sljit_s32 saveds, sljit_s32 local_size);
940
941 /* The SLJIT compiler has a current context (which contains the local
942 stack space size, number of used registers, etc.) which is initialized
943 by sljit_emit_enter. Several functions (such as sljit_emit_return)
944 requires this context to be able to generate the appropriate code.
945 However, some code fragments (compiled separately) may have no
946 normal entry point so their context is unknown to the compiler.
947
948 sljit_set_context and sljit_emit_enter have the same arguments,
949 but sljit_set_context does not generate any machine code.
950
951 Note: every call of sljit_emit_enter and sljit_set_context overwrites
952 the previous context. */
953
954 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_set_context(struct sljit_compiler *compiler,
955 sljit_s32 options, sljit_s32 arg_types,
956 sljit_s32 scratches, sljit_s32 saveds, sljit_s32 local_size);
957
958 /* Return to the caller function. The sljit_emit_return_void function
959 does not return with any value. The sljit_emit_return function returns
960 with a single value loaded from its source operand. The load operation
961 can be between SLJIT_MOV and SLJIT_MOV_P (see sljit_emit_op1) and
962 SLJIT_MOV_F32/SLJIT_MOV_F64 (see sljit_emit_fop1) depending on the
963 return value specified by sljit_emit_enter/sljit_set_context. */
964
965 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return_void(struct sljit_compiler *compiler);
966
967 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return(struct sljit_compiler *compiler, sljit_s32 op,
968 sljit_s32 src, sljit_sw srcw);
969
970 /* Restores the saved registers and free the stack area, then the execution
971 continues from the address specified by the source operand. This
972 operation is similar to sljit_emit_return, but it ignores the return
973 address. The code where the exection continues should use the same context
974 as the caller function (see sljit_set_context). A word (pointer) value
975 can be passed in the SLJIT_RETURN_REG register. This function can be used
976 to jump to exception handlers. */
977
978 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return_to(struct sljit_compiler *compiler,
979 sljit_s32 src, sljit_sw srcw);
980
981 /*
982 Source and destination operands for arithmetical instructions
983 imm - a simple immediate value (cannot be used as a destination)
984 reg - any of the available registers (immediate argument must be 0)
985 [imm] - absolute memory address
986 [reg+imm] - indirect memory address
987 [reg+(reg<<imm)] - indirect indexed memory address (shift must be between 0 and 3)
988 useful for accessing arrays (fully supported by both x86 and
989 ARM architectures, and cheap operation on others)
990 */
991
992 /*
993 IMPORTANT NOTE: memory accesses MUST be naturally aligned unless
994 SLJIT_UNALIGNED macro is defined and its value is 1.
995
996 length | alignment
997 ---------+-----------
998 byte | 1 byte (any physical_address is accepted)
999 half | 2 byte (physical_address & 0x1 == 0)
1000 int | 4 byte (physical_address & 0x3 == 0)
1001 word | 4 byte if SLJIT_32BIT_ARCHITECTURE is defined and its value is 1
1002 | 8 byte if SLJIT_64BIT_ARCHITECTURE is defined and its value is 1
1003 pointer | size of sljit_up type (4 byte on 32 bit machines, 4 or 8 byte
1004 | on 64 bit machines)
1005
1006 Note: Different architectures have different addressing limitations.
1007 A single instruction is enough for the following addressing
1008 modes. Other addressing modes are emulated by instruction
1009 sequences. This information could help to improve those code
1010 generators which focuses only a few architectures.
1011
1012 x86: [reg+imm], -2^32+1 <= imm <= 2^32-1 (full address space on x86-32)
1013 [reg+(reg<<imm)] is supported
1014 [imm], -2^32+1 <= imm <= 2^32-1 is supported
1015 Write-back is not supported
1016 arm: [reg+imm], -4095 <= imm <= 4095 or -255 <= imm <= 255 for signed
1017 bytes, any halfs or floating point values)
1018 [reg+(reg<<imm)] is supported
1019 Write-back is supported
1020 arm-t2: [reg+imm], -255 <= imm <= 4095
1021 [reg+(reg<<imm)] is supported
1022 Write back is supported only for [reg+imm], where -255 <= imm <= 255
1023 arm64: [reg+imm], -256 <= imm <= 255, 0 <= aligned imm <= 4095 * alignment
1024 [reg+(reg<<imm)] is supported
1025 Write back is supported only for [reg+imm], where -256 <= imm <= 255
1026 ppc: [reg+imm], -65536 <= imm <= 65535. 64 bit loads/stores and 32 bit
1027 signed load on 64 bit requires immediates divisible by 4.
1028 [reg+imm] is not supported for signed 8 bit values.
1029 [reg+reg] is supported
1030 Write-back is supported except for one instruction: 32 bit signed
1031 load with [reg+imm] addressing mode on 64 bit.
1032 mips: [reg+imm], -65536 <= imm <= 65535
1033 Write-back is not supported
1034 riscv: [reg+imm], -2048 <= imm <= 2047
1035 Write-back is not supported
1036 s390x: [reg+imm], -2^19 <= imm < 2^19
1037 [reg+reg] is supported
1038 Write-back is not supported
1039 loongarch: [reg+imm], -2048 <= imm <= 2047
1040 [reg+reg] is supported
1041 Write-back is not supported
1042 */
1043
1044 /* Macros for specifying operand types. */
1045 #define SLJIT_MEM 0x80
1046 #define SLJIT_MEM0() (SLJIT_MEM)
1047 #define SLJIT_MEM1(r1) (SLJIT_MEM | (r1))
1048 #define SLJIT_MEM2(r1, r2) (SLJIT_MEM | (r1) | ((r2) << 8))
1049 #define SLJIT_IMM 0x7f
1050 #define SLJIT_REG_PAIR(r1, r2) ((r1) | ((r2) << 8))
1051
1052 /* Macros for checking operand types (only for valid arguments). */
1053 #define SLJIT_IS_REG(arg) ((arg) > 0 && (arg) < SLJIT_IMM)
1054 #define SLJIT_IS_MEM(arg) ((arg) & SLJIT_MEM)
1055 #define SLJIT_IS_MEM0(arg) ((arg) == SLJIT_MEM)
1056 #define SLJIT_IS_MEM1(arg) ((arg) > SLJIT_MEM && (arg) < (SLJIT_MEM << 1))
1057 #define SLJIT_IS_MEM2(arg) (((arg) & SLJIT_MEM) && (arg) >= (SLJIT_MEM << 1))
1058 #define SLJIT_IS_IMM(arg) ((arg) == SLJIT_IMM)
1059 #define SLJIT_IS_REG_PAIR(arg) (!((arg) & SLJIT_MEM) && (arg) >= (SLJIT_MEM << 1))
1060
1061 /* Macros for extracting registers from operands. */
1062 /* Support operands which contains a single register or
1063 constructed using SLJIT_MEM1, SLJIT_MEM2, or SLJIT_REG_PAIR. */
1064 #define SLJIT_EXTRACT_REG(arg) ((arg) & 0x7f)
1065 /* Support operands which constructed using SLJIT_MEM2, or SLJIT_REG_PAIR. */
1066 #define SLJIT_EXTRACT_SECOND_REG(arg) ((arg) >> 8)
1067
1068 /* Sets 32 bit operation mode on 64 bit CPUs. This option is ignored on
1069 32 bit CPUs. When this option is set for an arithmetic operation, only
1070 the lower 32 bits of the input registers are used, and the CPU status
1071 flags are set according to the 32 bit result. Although the higher 32 bit
1072 of the input and the result registers are not defined by SLJIT, it might
1073 be defined by the CPU architecture (e.g. MIPS). To satisfy these CPU
1074 requirements all source registers must be the result of those operations
1075 where this option was also set. Memory loads read 32 bit values rather
1076 than 64 bit ones. In other words 32 bit and 64 bit operations cannot be
1077 mixed. The only exception is SLJIT_MOV32 which source register can hold
1078 any 32 or 64 bit value, and it is converted to a 32 bit compatible format
1079 first. When the source and destination registers are the same, this
1080 conversion is free (no instructions are emitted) on most CPUs. A 32 bit
1081 value can also be converted to a 64 bit value by SLJIT_MOV_S32
1082 (sign extension) or SLJIT_MOV_U32 (zero extension).
1083
1084 As for floating-point operations, this option sets 32 bit single
1085 precision mode. Similar to the integer operations, all register arguments
1086 must be the result of those operations where this option was also set.
1087
1088 Note: memory addressing always uses 64 bit values on 64 bit systems so
1089 the result of a 32 bit operation must not be used with SLJIT_MEMx
1090 macros.
1091
1092 This option is part of the instruction name, so there is no need to
1093 manually set it. E.g:
1094
1095 SLJIT_ADD32 == (SLJIT_ADD | SLJIT_32) */
1096 #define SLJIT_32 0x100
1097
1098 /* Many CPUs (x86, ARM, PPC) have status flag bits which can be set according
1099 to the result of an operation. Other CPUs (MIPS) do not have status
1100 flag bits, and results must be stored in registers. To cover both
1101 architecture types efficiently only two flags are defined by SLJIT:
1102
1103 * Zero (equal) flag: it is set if the result is zero
1104 * Variable flag: its value is defined by the arithmetic operation
1105
1106 SLJIT instructions can set any or both of these flags. The value of
1107 these flags is undefined if the instruction does not specify their
1108 value. The description of each instruction contains the list of
1109 allowed flag types.
1110
1111 Note: the logical or operation can be used to set flags.
1112
1113 Example: SLJIT_ADD can set the Z, OVERFLOW, CARRY flags hence
1114
1115 sljit_op2(..., SLJIT_ADD, ...)
1116 Both the zero and variable flags are undefined so they can
1117 have any value after the operation is completed.
1118
1119 sljit_op2(..., SLJIT_ADD | SLJIT_SET_Z, ...)
1120 Sets the zero flag if the result is zero, clears it otherwise.
1121 The variable flag is undefined.
1122
1123 sljit_op2(..., SLJIT_ADD | SLJIT_SET_OVERFLOW, ...)
1124 Sets the variable flag if an integer overflow occurs, clears
1125 it otherwise. The zero flag is undefined.
1126
1127 sljit_op2(..., SLJIT_ADD | SLJIT_SET_Z | SLJIT_SET_CARRY, ...)
1128 Sets the zero flag if the result is zero, clears it otherwise.
1129 Sets the variable flag if unsigned overflow (carry) occurs,
1130 clears it otherwise.
1131
1132 Certain instructions (e.g. SLJIT_MOV) does not modify flags, so
1133 status flags are unchanged.
1134
1135 Example:
1136
1137 sljit_op2(..., SLJIT_ADD | SLJIT_SET_Z, ...)
1138 sljit_op1(..., SLJIT_MOV, ...)
1139 Zero flag is set according to the result of SLJIT_ADD.
1140
1141 sljit_op2(..., SLJIT_ADD | SLJIT_SET_Z, ...)
1142 sljit_op2(..., SLJIT_ADD, ...)
1143 Zero flag has unknown value.
1144
1145 These flags can be used for code optimization. E.g. a fast loop can be
1146 implemented by decreasing a counter register and set the zero flag
1147 using a single instruction. The zero register can be used by a
1148 conditional jump to restart the loop. A single comparison can set a
1149 zero and less flags to check if a value is less, equal, or greater
1150 than another value.
1151
1152 Motivation: although some CPUs can set a large number of flag bits,
1153 usually their values are ignored or only a few of them are used. Emulating
1154 a large number of flags on systems without a flag register is complicated
1155 so SLJIT instructions must specify the flag they want to use and only
1156 that flag is computed. The last arithmetic instruction can be repeated if
1157 multiple flags need to be checked.
1158 */
1159
1160 /* Set Zero status flag. */
1161 #define SLJIT_SET_Z 0x0200
1162 /* Set the variable status flag if condition is true.
1163 See comparison types (e.g. SLJIT_SET_LESS, SLJIT_SET_F_EQUAL). */
1164 #define SLJIT_SET(condition) ((condition) << 10)
1165
1166 /* Starting index of opcodes for sljit_emit_op0. */
1167 #define SLJIT_OP0_BASE 0
1168
1169 /* Flags: - (does not modify flags)
1170 Note: breakpoint instruction is not supported by all architectures (e.g. ppc)
1171 It falls back to SLJIT_NOP in those cases. */
1172 #define SLJIT_BREAKPOINT (SLJIT_OP0_BASE + 0)
1173 /* Flags: - (does not modify flags)
1174 Note: may or may not cause an extra cycle wait
1175 it can even decrease the runtime in a few cases. */
1176 #define SLJIT_NOP (SLJIT_OP0_BASE + 1)
1177 /* Flags: - (may destroy flags)
1178 Unsigned multiplication of SLJIT_R0 and SLJIT_R1.
1179 Result is placed into SLJIT_R1:SLJIT_R0 (high:low) word */
1180 #define SLJIT_LMUL_UW (SLJIT_OP0_BASE + 2)
1181 /* Flags: - (may destroy flags)
1182 Signed multiplication of SLJIT_R0 and SLJIT_R1.
1183 Result is placed into SLJIT_R1:SLJIT_R0 (high:low) word */
1184 #define SLJIT_LMUL_SW (SLJIT_OP0_BASE + 3)
1185 /* Flags: - (may destroy flags)
1186 Unsigned divide of the value in SLJIT_R0 by the value in SLJIT_R1.
1187 The result is placed into SLJIT_R0 and the remainder into SLJIT_R1.
1188 Note: if SLJIT_R1 is 0, the behaviour is undefined. */
1189 #define SLJIT_DIVMOD_UW (SLJIT_OP0_BASE + 4)
1190 #define SLJIT_DIVMOD_U32 (SLJIT_DIVMOD_UW | SLJIT_32)
1191 /* Flags: - (may destroy flags)
1192 Signed divide of the value in SLJIT_R0 by the value in SLJIT_R1.
1193 The result is placed into SLJIT_R0 and the remainder into SLJIT_R1.
1194 Note: if SLJIT_R1 is 0, the behaviour is undefined.
1195 Note: if SLJIT_R1 is -1 and SLJIT_R0 is integer min (0x800..00),
1196 the behaviour is undefined. */
1197 #define SLJIT_DIVMOD_SW (SLJIT_OP0_BASE + 5)
1198 #define SLJIT_DIVMOD_S32 (SLJIT_DIVMOD_SW | SLJIT_32)
1199 /* Flags: - (may destroy flags)
1200 Unsigned divide of the value in SLJIT_R0 by the value in SLJIT_R1.
1201 The result is placed into SLJIT_R0. SLJIT_R1 preserves its value.
1202 Note: if SLJIT_R1 is 0, the behaviour is undefined. */
1203 #define SLJIT_DIV_UW (SLJIT_OP0_BASE + 6)
1204 #define SLJIT_DIV_U32 (SLJIT_DIV_UW | SLJIT_32)
1205 /* Flags: - (may destroy flags)
1206 Signed divide of the value in SLJIT_R0 by the value in SLJIT_R1.
1207 The result is placed into SLJIT_R0. SLJIT_R1 preserves its value.
1208 Note: if SLJIT_R1 is 0, the behaviour is undefined.
1209 Note: if SLJIT_R1 is -1 and SLJIT_R0 is integer min (0x800..00),
1210 the behaviour is undefined. */
1211 #define SLJIT_DIV_SW (SLJIT_OP0_BASE + 7)
1212 #define SLJIT_DIV_S32 (SLJIT_DIV_SW | SLJIT_32)
1213 /* Flags: - (does not modify flags)
1214 May return with SLJIT_ERR_UNSUPPORTED if SLJIT_HAS_MEMORY_BARRIER
1215 feature is not supported (calling sljit_has_cpu_feature() with
1216 this feature option returns with 0). */
1217 #define SLJIT_MEMORY_BARRIER (SLJIT_OP0_BASE + 8)
1218 /* Flags: - (does not modify flags)
1219 ENDBR32 instruction for x86-32 and ENDBR64 instruction for x86-64
1220 when Intel Control-flow Enforcement Technology (CET) is enabled.
1221 No instructions are emitted for other architectures. */
1222 #define SLJIT_ENDBR (SLJIT_OP0_BASE + 9)
1223 /* Flags: - (may destroy flags)
1224 Skip stack frames before return when Intel Control-flow
1225 Enforcement Technology (CET) is enabled. No instructions
1226 are emitted for other architectures. */
1227 #define SLJIT_SKIP_FRAMES_BEFORE_RETURN (SLJIT_OP0_BASE + 10)
1228
1229 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op);
1230
1231 /* Starting index of opcodes for sljit_emit_op1. */
1232 #define SLJIT_OP1_BASE 32
1233
1234 /* The MOV instruction transfers data from source to destination.
1235
1236 MOV instruction suffixes:
1237
1238 U8 - unsigned 8 bit data transfer
1239 S8 - signed 8 bit data transfer
1240 U16 - unsigned 16 bit data transfer
1241 S16 - signed 16 bit data transfer
1242 U32 - unsigned int (32 bit) data transfer
1243 S32 - signed int (32 bit) data transfer
1244 P - pointer (sljit_up) data transfer
1245 */
1246
1247 /* Flags: - (does not modify flags) */
1248 #define SLJIT_MOV (SLJIT_OP1_BASE + 0)
1249 /* Flags: - (does not modify flags) */
1250 #define SLJIT_MOV_U8 (SLJIT_OP1_BASE + 1)
1251 #define SLJIT_MOV32_U8 (SLJIT_MOV_U8 | SLJIT_32)
1252 /* Flags: - (does not modify flags) */
1253 #define SLJIT_MOV_S8 (SLJIT_OP1_BASE + 2)
1254 #define SLJIT_MOV32_S8 (SLJIT_MOV_S8 | SLJIT_32)
1255 /* Flags: - (does not modify flags) */
1256 #define SLJIT_MOV_U16 (SLJIT_OP1_BASE + 3)
1257 #define SLJIT_MOV32_U16 (SLJIT_MOV_U16 | SLJIT_32)
1258 /* Flags: - (does not modify flags) */
1259 #define SLJIT_MOV_S16 (SLJIT_OP1_BASE + 4)
1260 #define SLJIT_MOV32_S16 (SLJIT_MOV_S16 | SLJIT_32)
1261 /* Flags: - (does not modify flags)
1262 Note: no SLJIT_MOV32_U32 form, since it is the same as SLJIT_MOV32 */
1263 #define SLJIT_MOV_U32 (SLJIT_OP1_BASE + 5)
1264 /* Flags: - (does not modify flags)
1265 Note: no SLJIT_MOV32_S32 form, since it is the same as SLJIT_MOV32 */
1266 #define SLJIT_MOV_S32 (SLJIT_OP1_BASE + 6)
1267 /* Flags: - (does not modify flags) */
1268 #define SLJIT_MOV32 (SLJIT_OP1_BASE + 7)
1269 /* Flags: - (does not modify flags)
1270 Note: loads a pointer sized data, useful on x32 mode (a 64 bit mode
1271 on x86-64 which uses 32 bit pointers) or similar compiling modes */
1272 #define SLJIT_MOV_P (SLJIT_OP1_BASE + 8)
1273 /* Count leading zeroes
1274 Flags: - (may destroy flags)
1275 Note: immediate source argument is not supported */
1276 #define SLJIT_CLZ (SLJIT_OP1_BASE + 9)
1277 #define SLJIT_CLZ32 (SLJIT_CLZ | SLJIT_32)
1278 /* Count trailing zeroes
1279 Flags: - (may destroy flags)
1280 Note: immediate source argument is not supported */
1281 #define SLJIT_CTZ (SLJIT_OP1_BASE + 10)
1282 #define SLJIT_CTZ32 (SLJIT_CTZ | SLJIT_32)
1283 /* Reverse the order of bytes
1284 Flags: - (may destroy flags)
1285 Note: converts between little and big endian formats
1286 Note: immediate source argument is not supported */
1287 #define SLJIT_REV (SLJIT_OP1_BASE + 11)
1288 #define SLJIT_REV32 (SLJIT_REV | SLJIT_32)
1289 /* Reverse the order of bytes in the lower 16 bit and extend as unsigned
1290 Flags: - (may destroy flags)
1291 Note: converts between little and big endian formats
1292 Note: immediate source argument is not supported */
1293 #define SLJIT_REV_U16 (SLJIT_OP1_BASE + 12)
1294 #define SLJIT_REV32_U16 (SLJIT_REV_U16 | SLJIT_32)
1295 /* Reverse the order of bytes in the lower 16 bit and extend as signed
1296 Flags: - (may destroy flags)
1297 Note: converts between little and big endian formats
1298 Note: immediate source argument is not supported */
1299 #define SLJIT_REV_S16 (SLJIT_OP1_BASE + 13)
1300 #define SLJIT_REV32_S16 (SLJIT_REV_S16 | SLJIT_32)
1301 /* Reverse the order of bytes in the lower 32 bit and extend as unsigned
1302 Flags: - (may destroy flags)
1303 Note: converts between little and big endian formats
1304 Note: immediate source argument is not supported */
1305 #define SLJIT_REV_U32 (SLJIT_OP1_BASE + 14)
1306 /* Reverse the order of bytes in the lower 32 bit and extend as signed
1307 Flags: - (may destroy flags)
1308 Note: converts between little and big endian formats
1309 Note: immediate source argument is not supported */
1310 #define SLJIT_REV_S32 (SLJIT_OP1_BASE + 15)
1311
1312 /* The following unary operations are supported by using sljit_emit_op2:
1313 - binary not: SLJIT_XOR with immedate -1 as src1 or src2
1314 - negate: SLJIT_SUB with immedate 0 as src1
1315 Note: these operations are optimized by the compiler if the
1316 target CPU has specialized instruction forms for them. */
1317
1318 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op1(struct sljit_compiler *compiler, sljit_s32 op,
1319 sljit_s32 dst, sljit_sw dstw,
1320 sljit_s32 src, sljit_sw srcw);
1321
1322 /* Starting index of opcodes for sljit_emit_op2. */
1323 #define SLJIT_OP2_BASE 64
1324
1325 /* Flags: Z | OVERFLOW | CARRY */
1326 #define SLJIT_ADD (SLJIT_OP2_BASE + 0)
1327 #define SLJIT_ADD32 (SLJIT_ADD | SLJIT_32)
1328 /* Flags: CARRY */
1329 #define SLJIT_ADDC (SLJIT_OP2_BASE + 1)
1330 #define SLJIT_ADDC32 (SLJIT_ADDC | SLJIT_32)
1331 /* Flags: Z | LESS | GREATER_EQUAL | GREATER | LESS_EQUAL
1332 SIG_LESS | SIG_GREATER_EQUAL | SIG_GREATER
1333 SIG_LESS_EQUAL | OVERFLOW | CARRY */
1334 #define SLJIT_SUB (SLJIT_OP2_BASE + 2)
1335 #define SLJIT_SUB32 (SLJIT_SUB | SLJIT_32)
1336 /* Flags: CARRY */
1337 #define SLJIT_SUBC (SLJIT_OP2_BASE + 3)
1338 #define SLJIT_SUBC32 (SLJIT_SUBC | SLJIT_32)
1339 /* Note: integer mul
1340 Flags: OVERFLOW */
1341 #define SLJIT_MUL (SLJIT_OP2_BASE + 4)
1342 #define SLJIT_MUL32 (SLJIT_MUL | SLJIT_32)
1343 /* Flags: Z */
1344 #define SLJIT_AND (SLJIT_OP2_BASE + 5)
1345 #define SLJIT_AND32 (SLJIT_AND | SLJIT_32)
1346 /* Flags: Z */
1347 #define SLJIT_OR (SLJIT_OP2_BASE + 6)
1348 #define SLJIT_OR32 (SLJIT_OR | SLJIT_32)
1349 /* Flags: Z */
1350 #define SLJIT_XOR (SLJIT_OP2_BASE + 7)
1351 #define SLJIT_XOR32 (SLJIT_XOR | SLJIT_32)
1352 /* Flags: Z
1353 Let bit_length be the length of the shift operation: 32 or 64.
1354 If src2 is immediate, src2w is masked by (bit_length - 1).
1355 Otherwise, if the content of src2 is outside the range from 0
1356 to bit_length - 1, the result is undefined. */
1357 #define SLJIT_SHL (SLJIT_OP2_BASE + 8)
1358 #define SLJIT_SHL32 (SLJIT_SHL | SLJIT_32)
1359 /* Flags: Z
1360 Same as SLJIT_SHL, except the the second operand is
1361 always masked by the length of the shift operation. */
1362 #define SLJIT_MSHL (SLJIT_OP2_BASE + 9)
1363 #define SLJIT_MSHL32 (SLJIT_MSHL | SLJIT_32)
1364 /* Flags: Z
1365 Let bit_length be the length of the shift operation: 32 or 64.
1366 If src2 is immediate, src2w is masked by (bit_length - 1).
1367 Otherwise, if the content of src2 is outside the range from 0
1368 to bit_length - 1, the result is undefined. */
1369 #define SLJIT_LSHR (SLJIT_OP2_BASE + 10)
1370 #define SLJIT_LSHR32 (SLJIT_LSHR | SLJIT_32)
1371 /* Flags: Z
1372 Same as SLJIT_LSHR, except the the second operand is
1373 always masked by the length of the shift operation. */
1374 #define SLJIT_MLSHR (SLJIT_OP2_BASE + 11)
1375 #define SLJIT_MLSHR32 (SLJIT_MLSHR | SLJIT_32)
1376 /* Flags: Z
1377 Let bit_length be the length of the shift operation: 32 or 64.
1378 If src2 is immediate, src2w is masked by (bit_length - 1).
1379 Otherwise, if the content of src2 is outside the range from 0
1380 to bit_length - 1, the result is undefined. */
1381 #define SLJIT_ASHR (SLJIT_OP2_BASE + 12)
1382 #define SLJIT_ASHR32 (SLJIT_ASHR | SLJIT_32)
1383 /* Flags: Z
1384 Same as SLJIT_ASHR, except the the second operand is
1385 always masked by the length of the shift operation. */
1386 #define SLJIT_MASHR (SLJIT_OP2_BASE + 13)
1387 #define SLJIT_MASHR32 (SLJIT_MASHR | SLJIT_32)
1388 /* Flags: - (may destroy flags)
1389 Let bit_length be the length of the rotate operation: 32 or 64.
1390 The second operand is always masked by (bit_length - 1). */
1391 #define SLJIT_ROTL (SLJIT_OP2_BASE + 14)
1392 #define SLJIT_ROTL32 (SLJIT_ROTL | SLJIT_32)
1393 /* Flags: - (may destroy flags)
1394 Let bit_length be the length of the rotate operation: 32 or 64.
1395 The second operand is always masked by (bit_length - 1). */
1396 #define SLJIT_ROTR (SLJIT_OP2_BASE + 15)
1397 #define SLJIT_ROTR32 (SLJIT_ROTR | SLJIT_32)
1398
1399 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2(struct sljit_compiler *compiler, sljit_s32 op,
1400 sljit_s32 dst, sljit_sw dstw,
1401 sljit_s32 src1, sljit_sw src1w,
1402 sljit_s32 src2, sljit_sw src2w);
1403
1404 /* The sljit_emit_op2u function is the same as sljit_emit_op2
1405 except the result is discarded. */
1406
1407 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2u(struct sljit_compiler *compiler, sljit_s32 op,
1408 sljit_s32 src1, sljit_sw src1w,
1409 sljit_s32 src2, sljit_sw src2w);
1410
1411 /* Starting index of opcodes for sljit_emit_op2r. */
1412 #define SLJIT_OP2R_BASE 96
1413
1414 /* Flags: - (may destroy flags) */
1415 #define SLJIT_MULADD (SLJIT_OP2R_BASE + 0)
1416 #define SLJIT_MULADD32 (SLJIT_MULADD | SLJIT_32)
1417
1418 /* Similar to sljit_emit_fop2, except the destination is always a register. */
1419 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2r(struct sljit_compiler *compiler, sljit_s32 op,
1420 sljit_s32 dst_reg,
1421 sljit_s32 src1, sljit_sw src1w,
1422 sljit_s32 src2, sljit_sw src2w);
1423
1424 /* Emit a left or right shift operation, where the bits shifted
1425 in comes from a separate source operand. All operands are
1426 interpreted as unsigned integers.
1427
1428 In the followings the value_mask variable is 31 for 32 bit
1429 operations and word_size - 1 otherwise.
1430
1431 op must be one of the following operations:
1432 SLJIT_SHL or SLJIT_SHL32:
1433 dst_reg = src1_reg << src3_reg
1434 dst_reg |= ((src2_reg >> 1) >> (src3 ^ value_mask))
1435 SLJIT_MSHL or SLJIT_MSHL32:
1436 src3 &= value_mask
1437 perform the SLJIT_SHL or SLJIT_SHL32 operation
1438 SLJIT_LSHR or SLJIT_LSHR32:
1439 dst_reg = src1_reg >> src3_reg
1440 dst_reg |= ((src2_reg << 1) << (src3 ^ value_mask))
1441 SLJIT_MLSHR or SLJIT_MLSHR32:
1442 src3 &= value_mask
1443 perform the SLJIT_LSHR or SLJIT_LSHR32 operation
1444
1445 op can be combined (or'ed) with SLJIT_SHIFT_INTO_NON_ZERO
1446
1447 dst_reg specifies the destination register, where dst_reg
1448 and src2_reg cannot be the same registers
1449 src1_reg specifies the source register
1450 src2_reg specifies the register which is shifted into src1_reg
1451 src3 / src3w contains the shift amount
1452
1453 Note: a rotate operation is performed if src1_reg and
1454 src2_reg are the same registers
1455
1456 Flags: - (may destroy flags) */
1457
1458 /* The src3 operand contains a non-zero value. Improves
1459 the generated code on certain architectures, which
1460 provides a small performance improvement. */
1461 #define SLJIT_SHIFT_INTO_NON_ZERO 0x200
1462
1463 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_shift_into(struct sljit_compiler *compiler, sljit_s32 op,
1464 sljit_s32 dst_reg,
1465 sljit_s32 src1_reg,
1466 sljit_s32 src2_reg,
1467 sljit_s32 src3, sljit_sw src3w);
1468
1469 /* The following options are used by sljit_emit_op2_shift. */
1470
1471 /* The src2 argument is shifted left by an immedate value. */
1472 #define SLJIT_SHL_IMM (1 << 9)
1473 /* When src2 argument is a register, its value is undefined after the operation. */
1474 #define SLJIT_SRC2_UNDEFINED (1 << 10)
1475
1476 /* Emits an addition operation, where the second argument is shifted by a value.
1477
1478 op must be SLJIT_ADD | SLJIT_SHL_IMM, where the immedate value is stored in shift_arg
1479
1480 Flags: - (may destroy flags) */
1481 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2_shift(struct sljit_compiler *compiler, sljit_s32 op,
1482 sljit_s32 dst, sljit_sw dstw,
1483 sljit_s32 src1, sljit_sw src1w,
1484 sljit_s32 src2, sljit_sw src2w,
1485 sljit_sw shift_arg);
1486
1487 /* Starting index of opcodes for sljit_emit_op_src
1488 and sljit_emit_op_dst. */
1489 #define SLJIT_OP_SRC_DST_BASE 112
1490
1491 /* Fast return, see SLJIT_FAST_CALL for more details.
1492 Note: src cannot be an immedate value
1493 Flags: - (does not modify flags) */
1494 #define SLJIT_FAST_RETURN (SLJIT_OP_SRC_DST_BASE + 0)
1495 /* Skip stack frames before fast return.
1496 Note: src cannot be an immedate value
1497 Flags: may destroy flags. */
1498 #define SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN (SLJIT_OP_SRC_DST_BASE + 1)
1499 /* Prefetch value into the level 1 data cache
1500 Note: if the target CPU does not support data prefetch,
1501 no instructions are emitted.
1502 Note: this instruction never fails, even if the memory address is invalid.
1503 Flags: - (does not modify flags) */
1504 #define SLJIT_PREFETCH_L1 (SLJIT_OP_SRC_DST_BASE + 2)
1505 /* Prefetch value into the level 2 data cache
1506 Note: same as SLJIT_PREFETCH_L1 if the target CPU
1507 does not support this instruction form.
1508 Note: this instruction never fails, even if the memory address is invalid.
1509 Flags: - (does not modify flags) */
1510 #define SLJIT_PREFETCH_L2 (SLJIT_OP_SRC_DST_BASE + 3)
1511 /* Prefetch value into the level 3 data cache
1512 Note: same as SLJIT_PREFETCH_L2 if the target CPU
1513 does not support this instruction form.
1514 Note: this instruction never fails, even if the memory address is invalid.
1515 Flags: - (does not modify flags) */
1516 #define SLJIT_PREFETCH_L3 (SLJIT_OP_SRC_DST_BASE + 4)
1517 /* Prefetch a value which is only used once (and can be discarded afterwards)
1518 Note: same as SLJIT_PREFETCH_L1 if the target CPU
1519 does not support this instruction form.
1520 Note: this instruction never fails, even if the memory address is invalid.
1521 Flags: - (does not modify flags) */
1522 #define SLJIT_PREFETCH_ONCE (SLJIT_OP_SRC_DST_BASE + 5)
1523
1524 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_src(struct sljit_compiler *compiler, sljit_s32 op,
1525 sljit_s32 src, sljit_sw srcw);
1526
1527 /* Fast enter, see SLJIT_FAST_CALL for more details.
1528 Flags: - (does not modify flags) */
1529 #define SLJIT_FAST_ENTER (SLJIT_OP_SRC_DST_BASE + 6)
1530
1531 /* Copies the return address into dst. The return address is the
1532 address where the execution continues after the called function
1533 returns (see: sljit_emit_return / sljit_emit_return_void).
1534 Flags: - (does not modify flags) */
1535 #define SLJIT_GET_RETURN_ADDRESS (SLJIT_OP_SRC_DST_BASE + 7)
1536
1537 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_dst(struct sljit_compiler *compiler, sljit_s32 op,
1538 sljit_s32 dst, sljit_sw dstw);
1539
1540 /* Starting index of opcodes for sljit_emit_fop1. */
1541 #define SLJIT_FOP1_BASE 144
1542
1543 /* Flags: - (does not modify flags) */
1544 #define SLJIT_MOV_F64 (SLJIT_FOP1_BASE + 0)
1545 #define SLJIT_MOV_F32 (SLJIT_MOV_F64 | SLJIT_32)
1546 /* Convert opcodes: CONV[DST_TYPE].FROM[SRC_TYPE]
1547 SRC/DST TYPE can be: F64, F32, S32, SW
1548 Rounding mode when the destination is SW or S32: round towards zero. */
1549 /* Flags: - (may destroy flags) */
1550 #define SLJIT_CONV_F64_FROM_F32 (SLJIT_FOP1_BASE + 1)
1551 #define SLJIT_CONV_F32_FROM_F64 (SLJIT_CONV_F64_FROM_F32 | SLJIT_32)
1552 /* Flags: - (may destroy flags) */
1553 #define SLJIT_CONV_SW_FROM_F64 (SLJIT_FOP1_BASE + 2)
1554 #define SLJIT_CONV_SW_FROM_F32 (SLJIT_CONV_SW_FROM_F64 | SLJIT_32)
1555 /* Flags: - (may destroy flags) */
1556 #define SLJIT_CONV_S32_FROM_F64 (SLJIT_FOP1_BASE + 3)
1557 #define SLJIT_CONV_S32_FROM_F32 (SLJIT_CONV_S32_FROM_F64 | SLJIT_32)
1558 /* Flags: - (may destroy flags) */
1559 #define SLJIT_CONV_F64_FROM_SW (SLJIT_FOP1_BASE + 4)
1560 #define SLJIT_CONV_F32_FROM_SW (SLJIT_CONV_F64_FROM_SW | SLJIT_32)
1561 /* Flags: - (may destroy flags) */
1562 #define SLJIT_CONV_F64_FROM_S32 (SLJIT_FOP1_BASE + 5)
1563 #define SLJIT_CONV_F32_FROM_S32 (SLJIT_CONV_F64_FROM_S32 | SLJIT_32)
1564 /* Flags: - (may destroy flags) */
1565 #define SLJIT_CONV_F64_FROM_UW (SLJIT_FOP1_BASE + 6)
1566 #define SLJIT_CONV_F32_FROM_UW (SLJIT_CONV_F64_FROM_UW | SLJIT_32)
1567 /* Flags: - (may destroy flags) */
1568 #define SLJIT_CONV_F64_FROM_U32 (SLJIT_FOP1_BASE + 7)
1569 #define SLJIT_CONV_F32_FROM_U32 (SLJIT_CONV_F64_FROM_U32 | SLJIT_32)
1570 /* Note: dst is the left and src is the right operand for SLJIT_CMP_F32/64.
1571 Flags: EQUAL_F | LESS_F | GREATER_EQUAL_F | GREATER_F | LESS_EQUAL_F */
1572 #define SLJIT_CMP_F64 (SLJIT_FOP1_BASE + 8)
1573 #define SLJIT_CMP_F32 (SLJIT_CMP_F64 | SLJIT_32)
1574 /* Flags: - (may destroy flags) */
1575 #define SLJIT_NEG_F64 (SLJIT_FOP1_BASE + 9)
1576 #define SLJIT_NEG_F32 (SLJIT_NEG_F64 | SLJIT_32)
1577 /* Flags: - (may destroy flags) */
1578 #define SLJIT_ABS_F64 (SLJIT_FOP1_BASE + 10)
1579 #define SLJIT_ABS_F32 (SLJIT_ABS_F64 | SLJIT_32)
1580
1581 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop1(struct sljit_compiler *compiler, sljit_s32 op,
1582 sljit_s32 dst, sljit_sw dstw,
1583 sljit_s32 src, sljit_sw srcw);
1584
1585 /* Starting index of opcodes for sljit_emit_fop2. */
1586 #define SLJIT_FOP2_BASE 176
1587
1588 /* Flags: - (may destroy flags) */
1589 #define SLJIT_ADD_F64 (SLJIT_FOP2_BASE + 0)
1590 #define SLJIT_ADD_F32 (SLJIT_ADD_F64 | SLJIT_32)
1591 /* Flags: - (may destroy flags) */
1592 #define SLJIT_SUB_F64 (SLJIT_FOP2_BASE + 1)
1593 #define SLJIT_SUB_F32 (SLJIT_SUB_F64 | SLJIT_32)
1594 /* Flags: - (may destroy flags) */
1595 #define SLJIT_MUL_F64 (SLJIT_FOP2_BASE + 2)
1596 #define SLJIT_MUL_F32 (SLJIT_MUL_F64 | SLJIT_32)
1597 /* Flags: - (may destroy flags) */
1598 #define SLJIT_DIV_F64 (SLJIT_FOP2_BASE + 3)
1599 #define SLJIT_DIV_F32 (SLJIT_DIV_F64 | SLJIT_32)
1600
1601 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop2(struct sljit_compiler *compiler, sljit_s32 op,
1602 sljit_s32 dst, sljit_sw dstw,
1603 sljit_s32 src1, sljit_sw src1w,
1604 sljit_s32 src2, sljit_sw src2w);
1605
1606 /* Starting index of opcodes for sljit_emit_fop2r. */
1607 #define SLJIT_FOP2R_BASE 192
1608
1609 /* Flags: - (may destroy flags) */
1610 #define SLJIT_COPYSIGN_F64 (SLJIT_FOP2R_BASE + 0)
1611 #define SLJIT_COPYSIGN_F32 (SLJIT_COPYSIGN_F64 | SLJIT_32)
1612
1613 /* Similar to sljit_emit_fop2, except the destination is always a register. */
1614 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop2r(struct sljit_compiler *compiler, sljit_s32 op,
1615 sljit_s32 dst_freg,
1616 sljit_s32 src1, sljit_sw src1w,
1617 sljit_s32 src2, sljit_sw src2w);
1618
1619 /* Sets a floating point register to an immediate value. */
1620
1621 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fset32(struct sljit_compiler *compiler,
1622 sljit_s32 freg, sljit_f32 value);
1623 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fset64(struct sljit_compiler *compiler,
1624 sljit_s32 freg, sljit_f64 value);
1625
1626 /* The following opcodes are used by sljit_emit_fcopy(). */
1627
1628 /* 64 bit: copy a 64 bit value from an integer register into a
1629 64 bit floating point register without any modifications.
1630 32 bit: copy a 32 bit register or register pair into a 64 bit
1631 floating point register without any modifications. The
1632 register, or the first register of the register pair
1633 replaces the high order 32 bit of the floating point
1634 register. If a register pair is passed, the low
1635 order 32 bit is replaced by the second register.
1636 Otherwise, the low order 32 bit is unchanged. */
1637 #define SLJIT_COPY_TO_F64 1
1638 /* Copy a 32 bit value from an integer register into a 32 bit
1639 floating point register without any modifications. */
1640 #define SLJIT_COPY32_TO_F32 (SLJIT_COPY_TO_F64 | SLJIT_32)
1641 /* 64 bit: copy the value of a 64 bit floating point register into
1642 an integer register without any modifications.
1643 32 bit: copy a 64 bit floating point register into a 32 bit register
1644 or a 32 bit register pair without any modifications. The
1645 high order 32 bit of the floating point register is copied
1646 into the register, or the first register of the register
1647 pair. If a register pair is passed, the low order 32 bit
1648 is copied into the second register. */
1649 #define SLJIT_COPY_FROM_F64 2
1650 /* Copy the value of a 32 bit floating point register into an integer
1651 register without any modifications. The register should be processed
1652 with 32 bit operations later. */
1653 #define SLJIT_COPY32_FROM_F32 (SLJIT_COPY_FROM_F64 | SLJIT_32)
1654
1655 /* Special data copy which involves floating point registers.
1656
1657 op must be between SLJIT_COPY_TO_F64 and SLJIT_COPY32_FROM_F32
1658 freg must be a floating point register
1659 reg must be a register or register pair */
1660
1661 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fcopy(struct sljit_compiler *compiler, sljit_s32 op,
1662 sljit_s32 freg, sljit_s32 reg);
1663
1664 /* Label and jump instructions. */
1665
1666 /* Emits a label which can be the target of jump / mov_addr instructions. */
1667
1668 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler);
1669
1670 /* Alignment values for sljit_emit_aligned_label. */
1671
1672 #define SLJIT_LABEL_ALIGN_1 0
1673 #define SLJIT_LABEL_ALIGN_2 1
1674 #define SLJIT_LABEL_ALIGN_4 2
1675 #define SLJIT_LABEL_ALIGN_8 3
1676 #define SLJIT_LABEL_ALIGN_16 4
1677 #define SLJIT_LABEL_ALIGN_W SLJIT_WORD_SHIFT
1678 #define SLJIT_LABEL_ALIGN_P SLJIT_POINTER_SHIFT
1679
1680 /* Emits a label which address is aligned to a power of 2 value. When some
1681 extra space needs to be added to align the label, that space is filled
1682 with SLJIT_NOP instructions. These labels usually represent the end of a
1683 compilation block, and a new function or some read-only data (e.g. a
1684 jump table) follows it. In these typical cases the SLJIT_NOPs are never
1685 executed.
1686
1687 Optionally, buffers for storing read-only data or code can be allocated
1688 by this operation. The buffers are passed as a chain list, and a separate
1689 memory area is allocated for each item in the list. All buffers are aligned
1690 to SLJIT_NOP instruction size, and their starting address is returned as
1691 as a label. The sljit_get_label_abs_addr function or the SLJIT_MOV_ABS_ADDR
1692 operation can be used to get the real address. The label of the first buffer
1693 is always the same as the returned label. The buffers are initially
1694 initialized with SLJIT_NOP instructions. The alignment of the buffers can
1695 be controlled by their starting address and sizes. If the starting address
1696 is aligned to N, and size is also divisible by N, the next buffer is aligned
1697 to N. I.e. if a buffer is 16 byte aligned, and its size is divisible by 4,
1698 the next buffer is 4 byte aligned. Note: if a buffer is N (>=2) byte aligned,
1699 it is also N/2 byte aligned.
1700
1701 align represents the alignment, and its value can
1702 be specified by SLJIT_LABEL_* constants
1703
1704 buffers is a list of read-only buffers stored in a chain list.
1705 After calling sljit_generate_code, these buffers can be
1706 modified by sljit_read_only_buffer_start_writing() /
1707 sljit_read_only_buffer_end_writing() functions
1708
1709 Note: the constant pool (if present) may be stored before the label. */
1710 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_aligned_label(struct sljit_compiler *compiler,
1711 sljit_s32 alignment, struct sljit_read_only_buffer *buffers);
1712
1713 /* The SLJIT_FAST_CALL is a calling method for creating lightweight function
1714 calls. This type of calls preserve the values of all registers and stack
1715 frame. Unlike normal function calls, the enter and return operations must
1716 be performed by the SLJIT_FAST_ENTER and SLJIT_FAST_RETURN operations
1717 respectively. The return address is stored in the dst argument of the
1718 SLJIT_FAST_ENTER operation, and this return address should be passed as
1719 the src argument for the SLJIT_FAST_RETURN operation to return from the
1720 called function.
1721
1722 Fast calls are cheap operations (usually only a single call instruction is
1723 emitted) but they do not preserve any registers. However the callee function
1724 can freely use / update any registers and the locals area which can be
1725 efficiently exploited by various optimizations. Registers can be saved
1726 and restored manually if needed.
1727
1728 Although returning to different address by SLJIT_FAST_RETURN is possible,
1729 this address usually cannot be predicted by the return address predictor of
1730 modern CPUs which may reduce performance. Furthermore certain security
1731 enhancement technologies such as Intel Control-flow Enforcement Technology
1732 (CET) may disallow returning to a different address (indirect jumps
1733 can be used instead, see SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN). */
1734
1735 /* Invert (negate) conditional type: xor (^) with 0x1 */
1736
1737 /* Integer comparison types. */
1738 #define SLJIT_EQUAL 0
1739 #define SLJIT_ZERO SLJIT_EQUAL
1740 #define SLJIT_NOT_EQUAL 1
1741 #define SLJIT_NOT_ZERO SLJIT_NOT_EQUAL
1742
1743 #define SLJIT_LESS 2
1744 #define SLJIT_SET_LESS SLJIT_SET(SLJIT_LESS)
1745 #define SLJIT_GREATER_EQUAL 3
1746 #define SLJIT_SET_GREATER_EQUAL SLJIT_SET(SLJIT_LESS)
1747 #define SLJIT_GREATER 4
1748 #define SLJIT_SET_GREATER SLJIT_SET(SLJIT_GREATER)
1749 #define SLJIT_LESS_EQUAL 5
1750 #define SLJIT_SET_LESS_EQUAL SLJIT_SET(SLJIT_GREATER)
1751 #define SLJIT_SIG_LESS 6
1752 #define SLJIT_SET_SIG_LESS SLJIT_SET(SLJIT_SIG_LESS)
1753 #define SLJIT_SIG_GREATER_EQUAL 7
1754 #define SLJIT_SET_SIG_GREATER_EQUAL SLJIT_SET(SLJIT_SIG_LESS)
1755 #define SLJIT_SIG_GREATER 8
1756 #define SLJIT_SET_SIG_GREATER SLJIT_SET(SLJIT_SIG_GREATER)
1757 #define SLJIT_SIG_LESS_EQUAL 9
1758 #define SLJIT_SET_SIG_LESS_EQUAL SLJIT_SET(SLJIT_SIG_GREATER)
1759
1760 #define SLJIT_OVERFLOW 10
1761 #define SLJIT_SET_OVERFLOW SLJIT_SET(SLJIT_OVERFLOW)
1762 #define SLJIT_NOT_OVERFLOW 11
1763
1764 /* Unlike other flags, sljit_emit_jump may destroy the carry flag. */
1765 #define SLJIT_CARRY 12
1766 #define SLJIT_SET_CARRY SLJIT_SET(SLJIT_CARRY)
1767 #define SLJIT_NOT_CARRY 13
1768
1769 #define SLJIT_ATOMIC_STORED 14
1770 #define SLJIT_SET_ATOMIC_STORED SLJIT_SET(SLJIT_ATOMIC_STORED)
1771 #define SLJIT_ATOMIC_NOT_STORED 15
1772
1773 /* Basic floating point comparison types.
1774
1775 Note: when the comparison result is unordered, their behaviour is unspecified. */
1776
1777 #define SLJIT_F_EQUAL 16
1778 #define SLJIT_SET_F_EQUAL SLJIT_SET(SLJIT_F_EQUAL)
1779 #define SLJIT_F_NOT_EQUAL 17
1780 #define SLJIT_SET_F_NOT_EQUAL SLJIT_SET(SLJIT_F_EQUAL)
1781 #define SLJIT_F_LESS 18
1782 #define SLJIT_SET_F_LESS SLJIT_SET(SLJIT_F_LESS)
1783 #define SLJIT_F_GREATER_EQUAL 19
1784 #define SLJIT_SET_F_GREATER_EQUAL SLJIT_SET(SLJIT_F_LESS)
1785 #define SLJIT_F_GREATER 20
1786 #define SLJIT_SET_F_GREATER SLJIT_SET(SLJIT_F_GREATER)
1787 #define SLJIT_F_LESS_EQUAL 21
1788 #define SLJIT_SET_F_LESS_EQUAL SLJIT_SET(SLJIT_F_GREATER)
1789
1790 /* Jumps when either argument contains a NaN value. */
1791 #define SLJIT_UNORDERED 22
1792 #define SLJIT_SET_UNORDERED SLJIT_SET(SLJIT_UNORDERED)
1793 /* Jumps when neither argument contains a NaN value. */
1794 #define SLJIT_ORDERED 23
1795 #define SLJIT_SET_ORDERED SLJIT_SET(SLJIT_UNORDERED)
1796
1797 /* Ordered / unordered floating point comparison types.
1798
1799 Note: each comparison type has an ordered and unordered form. Some
1800 architectures supports only either of them (see: sljit_cmp_info). */
1801
1802 #define SLJIT_ORDERED_EQUAL 24
1803 #define SLJIT_SET_ORDERED_EQUAL SLJIT_SET(SLJIT_ORDERED_EQUAL)
1804 #define SLJIT_UNORDERED_OR_NOT_EQUAL 25
1805 #define SLJIT_SET_UNORDERED_OR_NOT_EQUAL SLJIT_SET(SLJIT_ORDERED_EQUAL)
1806 #define SLJIT_ORDERED_LESS 26
1807 #define SLJIT_SET_ORDERED_LESS SLJIT_SET(SLJIT_ORDERED_LESS)
1808 #define SLJIT_UNORDERED_OR_GREATER_EQUAL 27
1809 #define SLJIT_SET_UNORDERED_OR_GREATER_EQUAL SLJIT_SET(SLJIT_ORDERED_LESS)
1810 #define SLJIT_ORDERED_GREATER 28
1811 #define SLJIT_SET_ORDERED_GREATER SLJIT_SET(SLJIT_ORDERED_GREATER)
1812 #define SLJIT_UNORDERED_OR_LESS_EQUAL 29
1813 #define SLJIT_SET_UNORDERED_OR_LESS_EQUAL SLJIT_SET(SLJIT_ORDERED_GREATER)
1814
1815 #define SLJIT_UNORDERED_OR_EQUAL 30
1816 #define SLJIT_SET_UNORDERED_OR_EQUAL SLJIT_SET(SLJIT_UNORDERED_OR_EQUAL)
1817 #define SLJIT_ORDERED_NOT_EQUAL 31
1818 #define SLJIT_SET_ORDERED_NOT_EQUAL SLJIT_SET(SLJIT_UNORDERED_OR_EQUAL)
1819 #define SLJIT_UNORDERED_OR_LESS 32
1820 #define SLJIT_SET_UNORDERED_OR_LESS SLJIT_SET(SLJIT_UNORDERED_OR_LESS)
1821 #define SLJIT_ORDERED_GREATER_EQUAL 33
1822 #define SLJIT_SET_ORDERED_GREATER_EQUAL SLJIT_SET(SLJIT_UNORDERED_OR_LESS)
1823 #define SLJIT_UNORDERED_OR_GREATER 34
1824 #define SLJIT_SET_UNORDERED_OR_GREATER SLJIT_SET(SLJIT_UNORDERED_OR_GREATER)
1825 #define SLJIT_ORDERED_LESS_EQUAL 35
1826 #define SLJIT_SET_ORDERED_LESS_EQUAL SLJIT_SET(SLJIT_UNORDERED_OR_GREATER)
1827
1828 /* Unconditional jump types. */
1829 #define SLJIT_JUMP 36
1830 /* Fast calling method. See the description above. */
1831 #define SLJIT_FAST_CALL 37
1832 /* Default C calling convention. */
1833 #define SLJIT_CALL 38
1834 /* Called function must be compiled by SLJIT.
1835 See SLJIT_ENTER_REG_ARG option. */
1836 #define SLJIT_CALL_REG_ARG 39
1837
1838 /* The target can be changed during runtime (see: sljit_set_jump_addr). */
1839 #define SLJIT_REWRITABLE_JUMP 0x10000
1840 /* When this flag is passed, the execution of the current function ends and
1841 the called function returns to the caller of the current function. The
1842 stack usage is reduced before the call, but it is not necessarily reduced
1843 to zero. In the latter case the compiler needs to allocate space for some
1844 arguments and the return address must be stored on the stack as well. */
1845 #define SLJIT_CALL_RETURN 0x20000
1846
1847 /* Emit a jump instruction. The destination is not set, only the type of the jump.
1848 type must be between SLJIT_JUMP and SLJIT_FAST_CALL
1849 type can be combined (or'ed) with SLJIT_REWRITABLE_JUMP
1850
1851 Flags: does not modify flags. */
1852 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type);
1853
1854 /* Emit a C compiler (ABI) compatible function call.
1855 type must be SLJIT_CALL or SLJIT_CALL_REG_ARG
1856 type can be combined (or'ed) with SLJIT_REWRITABLE_JUMP and/or SLJIT_CALL_RETURN
1857 arg_types can be specified by SLJIT_ARGSx (SLJIT_ARG_RETURN / SLJIT_ARG_VALUE) macros
1858
1859 Flags: destroy all flags. */
1860 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_call(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 arg_types);
1861
1862 /* Integer comparison operation. In most architectures it is implemented
1863 as a compare (sljit_emit_op2u with SLJIT_SUB) operation followed by
1864 an sljit_emit_jump. However, some architectures (e.g: ARM64 or RISCV)
1865 may optimize the generated code further. It is suggested to use this
1866 comparison form when appropriate.
1867 type must be between SLJIT_EQUAL and SLJIT_SIG_LESS_EQUAL
1868 type can be combined (or'ed) with SLJIT_32 or SLJIT_REWRITABLE_JUMP
1869
1870 Flags: may destroy flags. */
1871 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_s32 type,
1872 sljit_s32 src1, sljit_sw src1w,
1873 sljit_s32 src2, sljit_sw src2w);
1874
1875 /* Floating point comparison operation. In most architectures it is
1876 implemented as a SLJIT_CMP_F32/64 operation (setting appropriate
1877 flags) followed by a sljit_emit_jump. However, some architectures
1878 (e.g: MIPS) may optimize the generated code further. It is suggested
1879 to use this comparison form when appropriate.
1880 type must be between SLJIT_F_EQUAL and SLJIT_ORDERED_LESS_EQUAL
1881 type can be combined (or'ed) with SLJIT_32 or SLJIT_REWRITABLE_JUMP
1882
1883 Flags: destroy flags.
1884 Note: when any operand is NaN the behaviour depends on the comparison type. */
1885 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_s32 type,
1886 sljit_s32 src1, sljit_sw src1w,
1887 sljit_s32 src2, sljit_sw src2w);
1888
1889 /* The following flags are used by sljit_emit_op2cmpz(). */
1890 #define SLJIT_JUMP_IF_NON_ZERO 0
1891 #define SLJIT_JUMP_IF_ZERO SLJIT_SET_Z
1892
1893 /* Perform an integer arithmetic operation, then its result is compared to
1894 zero. In most architectures it is implemented as an sljit_emit_op2
1895 followed by an sljit_emit_jump. However, some architectures (e.g: RISCV)
1896 may optimize the generated code further. It is suggested to use this
1897 operation form when appropriate (e.g. for loops with counters).
1898
1899 op must be an sljit_emit_op2 operation where zero flag can be set,
1900 op can be combined with SLJIT_SET_* status flag setters except
1901 SLJIT_SET_Z, SLJIT_REWRITABLE_JUMP or SLJIT_JUMP_IF_* option bits.
1902
1903 Note: SLJIT_JUMP_IF_NON_ZERO is the default operation if neither
1904 SLJIT_JUMP_IF_ZERO or SLJIT_JUMP_IF_NON_ZERO is specified.
1905 Flags: sets the variable flag depending on op argument, the
1906 zero flag is undefined. */
1907 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_op2cmpz(struct sljit_compiler *compiler, sljit_s32 op,
1908 sljit_s32 dst, sljit_sw dstw,
1909 sljit_s32 src1, sljit_sw src1w,
1910 sljit_s32 src2, sljit_sw src2w);
1911
1912 /* Set the destination of the jump to this label. */
1913 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label);
1914 /* Set the destination address of the jump to this label. */
1915 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target);
1916
1917 /* Emit an indirect jump or fast call.
1918 Direct form: set src to SLJIT_IMM() and srcw to the address
1919 Indirect form: any other valid addressing mode
1920 type must be between SLJIT_JUMP and SLJIT_FAST_CALL
1921
1922 Flags: does not modify flags. */
1923 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw);
1924
1925 /* Emit a C compiler (ABI) compatible function call.
1926 Direct form: set src to SLJIT_IMM() and srcw to the address
1927 Indirect form: any other valid addressing mode
1928 type must be SLJIT_CALL or SLJIT_CALL_REG_ARG
1929 type can be combined (or'ed) with SLJIT_CALL_RETURN
1930 arg_types can be specified by SLJIT_ARGSx (SLJIT_ARG_RETURN / SLJIT_ARG_VALUE) macros
1931
1932 Flags: destroy all flags. */
1933 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_icall(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 arg_types, sljit_s32 src, sljit_sw srcw);
1934
1935 /* Perform an operation using the conditional flags as the second argument.
1936 Type must always be between SLJIT_EQUAL and SLJIT_ORDERED_LESS_EQUAL.
1937 The value represented by the type is 1, if the condition represented
1938 by type is fulfilled, and 0 otherwise.
1939
1940 When op is SLJIT_MOV or SLJIT_MOV32:
1941 Set dst to the value represented by the type (0 or 1).
1942 Flags: - (does not modify flags)
1943 When op is SLJIT_AND, SLJIT_AND32, SLJIT_OR, SLJIT_OR32, SLJIT_XOR, or SLJIT_XOR32
1944 Performs the binary operation using dst as the first, and the value
1945 represented by type as the second argument. Result is written into dst.
1946 Flags: Z (may destroy flags) */
1947 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_s32 op,
1948 sljit_s32 dst, sljit_sw dstw,
1949 sljit_s32 type);
1950
1951 /* The following flags are used by sljit_emit_select(). */
1952
1953 /* Compare src1 and src2_reg operands before executing select
1954 (i.e. converts the select operation to a min/max operation). */
1955 #define SLJIT_COMPARE_SELECT SLJIT_SET_Z
1956
1957 /* Emit a conditional select instruction which moves src1 to dst_reg,
1958 if the conditional flag is set, or src2_reg to dst_reg otherwise.
1959 The conditional flag should be set before executing the select
1960 instruction unless SLJIT_COMPARE_SELECT is specified.
1961
1962 type must be between SLJIT_EQUAL and SLJIT_ORDERED_LESS_EQUAL
1963 when SLJIT_COMPARE_SELECT option is NOT specified
1964 type must be between SLJIT_LESS and SLJIT_SET_SIG_LESS_EQUAL
1965 when SLJIT_COMPARE_SELECT option is specified
1966 type can be combined (or'ed) with SLJIT_32 to move 32 bit
1967 register values instead of word sized ones
1968 type can be combined (or'ed) with SLJIT_COMPARE_SELECT
1969 which compares src1 and src2_reg before executing the select
1970 dst_reg and src2_reg must be valid registers
1971 src1 must be valid operand
1972
1973 Note: if src1 is a memory operand, its value
1974 might be loaded even if the condition is false
1975
1976 Note: when SLJIT_COMPARE_SELECT is specified, the status flag
1977 bits might not represent the result of a normal compare
1978 operation, hence flags are not specified after the operation
1979
1980 Note: if sljit_has_cpu_feature(SLJIT_HAS_CMOV) returns with a non-zero value:
1981 (a) conditional register move (dst_reg==src2_reg, src1 is register)
1982 can be performed using a single instruction, except on RISCV,
1983 where three instructions are needed
1984 (b) conditional clearing (dst_reg==src2_reg, src1==SLJIT_IMM,
1985 src1w==0) can be performed using a single instruction,
1986 except on x86, where two instructions are needed
1987
1988 Flags:
1989 When SLJIT_COMPARE_SELECT is NOT specified: - (does not modify flags)
1990 When SLJIT_COMPARE_SELECT is specified: - (may destroy flags) */
1991 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_select(struct sljit_compiler *compiler, sljit_s32 type,
1992 sljit_s32 dst_reg,
1993 sljit_s32 src1, sljit_sw src1w,
1994 sljit_s32 src2_reg);
1995
1996 /* Emit a conditional floating point select instruction which moves
1997 src1 to dst_reg, if the conditional flag is set, or src2_reg to
1998 dst_reg otherwise. The conditional flag should be set before
1999 executing the select instruction.
2000
2001 type must be between SLJIT_EQUAL and SLJIT_ORDERED_LESS_EQUAL
2002 type can be combined (or'ed) with SLJIT_32 to move 32 bit
2003 floating point values instead of 64 bit ones
2004 dst_freg and src2_freg must be valid floating point registers
2005 src1 must be valid operand
2006
2007 Note: if src1 is a memory operand, its value
2008 might be loaded even if the condition is false.
2009
2010 Flags: - (does not modify flags) */
2011 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fselect(struct sljit_compiler *compiler, sljit_s32 type,
2012 sljit_s32 dst_freg,
2013 sljit_s32 src1, sljit_sw src1w,
2014 sljit_s32 src2_freg);
2015
2016 /* The following flags are used by sljit_emit_mem(), sljit_emit_mem_update(),
2017 sljit_emit_fmem(), and sljit_emit_fmem_update(). */
2018
2019 /* Memory load operation. This is the default. */
2020 #define SLJIT_MEM_LOAD 0x000000
2021 /* Memory store operation. */
2022 #define SLJIT_MEM_STORE 0x000200
2023
2024 /* The following flags are used by sljit_emit_mem() and sljit_emit_fmem(). */
2025
2026 /* Load or stora data from an unaligned (byte aligned) address. */
2027 #define SLJIT_MEM_UNALIGNED 0x000400
2028 /* Load or stora data from a 16 bit aligned address. */
2029 #define SLJIT_MEM_ALIGNED_16 0x000800
2030 /* Load or stora data from a 32 bit aligned address. */
2031 #define SLJIT_MEM_ALIGNED_32 0x001000
2032
2033 /* The following flags are used by sljit_emit_mem_update(),
2034 and sljit_emit_fmem_update(). */
2035
2036 /* Base register is updated before the memory access (default). */
2037 #define SLJIT_MEM_PRE 0x000000
2038 /* Base register is updated after the memory access. */
2039 #define SLJIT_MEM_POST 0x000400
2040
2041 /* When SLJIT_MEM_SUPP is passed, no instructions are emitted.
2042 Instead the function returns with SLJIT_SUCCESS if the instruction
2043 form is supported and SLJIT_ERR_UNSUPPORTED otherwise. This flag
2044 allows runtime checking of available instruction forms. */
2045 #define SLJIT_MEM_SUPP 0x000800
2046
2047 /* The sljit_emit_mem emits instructions for various memory operations:
2048
2049 When SLJIT_MEM_UNALIGNED / SLJIT_MEM_ALIGNED_16 /
2050 SLJIT_MEM_ALIGNED_32 is set in type argument:
2051 Emit instructions for unaligned memory loads or stores. When
2052 SLJIT_UNALIGNED is not defined, the only way to access unaligned
2053 memory data is using sljit_emit_mem. Otherwise all operations (e.g.
2054 sljit_emit_op1/2, or sljit_emit_fop1/2) supports unaligned access.
2055 In general, the performance of unaligned memory accesses are often
2056 lower than aligned and should be avoided.
2057
2058 When a pair of registers is passed in reg argument:
2059 Emit instructions for moving data between a register pair and
2060 memory. The register pair can be specified by the SLJIT_REG_PAIR
2061 macro. The first register is loaded from or stored into the
2062 location specified by the mem/memw arguments, and the end address
2063 of this operation is the starting address of the data transfer
2064 between the second register and memory. The type argument must
2065 be SLJIT_MOV. The SLJIT_MEM_UNALIGNED / SLJIT_MEM_ALIGNED_*
2066 options are allowed for this operation.
2067
2068 type must be between SLJIT_MOV and SLJIT_MOV_P and can be
2069 combined (or'ed) with SLJIT_MEM_* flags
2070 reg is a register or register pair, which is the source or
2071 destination of the operation
2072 mem must be a memory operand
2073
2074 Flags: - (does not modify flags) */
2075 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_mem(struct sljit_compiler *compiler, sljit_s32 type,
2076 sljit_s32 reg,
2077 sljit_s32 mem, sljit_sw memw);
2078
2079 /* Emit a single memory load or store with update instruction.
2080 When the requested instruction form is not supported by the CPU,
2081 it returns with SLJIT_ERR_UNSUPPORTED instead of emulating the
2082 instruction. This allows specializing tight loops based on
2083 the supported instruction forms (see SLJIT_MEM_SUPP flag).
2084 Absolute address (SLJIT_MEM0) forms are never supported
2085 and the base (first) register specified by the mem argument
2086 must not be SLJIT_SP and must also be different from the
2087 register specified by the reg argument.
2088
2089 type must be between SLJIT_MOV and SLJIT_MOV_P and can be
2090 combined (or'ed) with SLJIT_MEM_* flags
2091 reg is the source or destination register of the operation
2092 mem must be a memory operand
2093
2094 Flags: - (does not modify flags) */
2095
2096 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_mem_update(struct sljit_compiler *compiler, sljit_s32 type,
2097 sljit_s32 reg,
2098 sljit_s32 mem, sljit_sw memw);
2099
2100 /* Same as sljit_emit_mem except the followings:
2101
2102 Loading or storing a pair of registers is not supported.
2103
2104 type must be SLJIT_MOV_F64 or SLJIT_MOV_F32 and can be
2105 combined (or'ed) with SLJIT_MEM_* flags.
2106 freg is the source or destination floating point register
2107 of the operation
2108 mem must be a memory operand
2109
2110 Flags: - (does not modify flags) */
2111
2112 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fmem(struct sljit_compiler *compiler, sljit_s32 type,
2113 sljit_s32 freg,
2114 sljit_s32 mem, sljit_sw memw);
2115
2116 /* Same as sljit_emit_mem_update except the followings:
2117
2118 type must be SLJIT_MOV_F64 or SLJIT_MOV_F32 and can be
2119 combined (or'ed) with SLJIT_MEM_* flags
2120 freg is the source or destination floating point register
2121 of the operation
2122 mem must be a memory operand
2123
2124 Flags: - (does not modify flags) */
2125
2126 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fmem_update(struct sljit_compiler *compiler, sljit_s32 type,
2127 sljit_s32 freg,
2128 sljit_s32 mem, sljit_sw memw);
2129
2130 /* The following options are used by several simd operations. */
2131
2132 /* Load data into a vector register, this is the default */
2133 #define SLJIT_SIMD_LOAD 0x000000
2134 /* Store data from a vector register */
2135 #define SLJIT_SIMD_STORE 0x000001
2136 /* The vector register contains floating point values */
2137 #define SLJIT_SIMD_FLOAT 0x000400
2138 /* Tests whether the operation is available */
2139 #define SLJIT_SIMD_TEST 0x000800
2140 /* Move data to/from a 64 bit (8 byte) long vector register */
2141 #define SLJIT_SIMD_REG_64 (3 << 12)
2142 /* Move data to/from a 128 bit (16 byte) long vector register */
2143 #define SLJIT_SIMD_REG_128 (4 << 12)
2144 /* Move data to/from a 256 bit (32 byte) long vector register */
2145 #define SLJIT_SIMD_REG_256 (5 << 12)
2146 /* Move data to/from a 512 bit (64 byte) long vector register */
2147 #define SLJIT_SIMD_REG_512 (6 << 12)
2148 /* Element size is 8 bit long (this is the default), usually cannot be combined with SLJIT_SIMD_FLOAT */
2149 #define SLJIT_SIMD_ELEM_8 (0 << 18)
2150 /* Element size is 16 bit long, usually cannot be combined with SLJIT_SIMD_FLOAT */
2151 #define SLJIT_SIMD_ELEM_16 (1 << 18)
2152 /* Element size is 32 bit long */
2153 #define SLJIT_SIMD_ELEM_32 (2 << 18)
2154 /* Element size is 64 bit long */
2155 #define SLJIT_SIMD_ELEM_64 (3 << 18)
2156 /* Element size is 128 bit long */
2157 #define SLJIT_SIMD_ELEM_128 (4 << 18)
2158 /* Element size is 256 bit long */
2159 #define SLJIT_SIMD_ELEM_256 (5 << 18)
2160
2161 /* The following options are used by sljit_emit_simd_mov()
2162 and sljit_emit_simd_op2(). */
2163
2164 /* Memory address is unaligned (this is the default) */
2165 #define SLJIT_SIMD_MEM_UNALIGNED (0 << 24)
2166 /* Memory address is 16 bit aligned */
2167 #define SLJIT_SIMD_MEM_ALIGNED_16 (1 << 24)
2168 /* Memory address is 32 bit aligned */
2169 #define SLJIT_SIMD_MEM_ALIGNED_32 (2 << 24)
2170 /* Memory address is 64 bit aligned */
2171 #define SLJIT_SIMD_MEM_ALIGNED_64 (3 << 24)
2172 /* Memory address is 128 bit aligned */
2173 #define SLJIT_SIMD_MEM_ALIGNED_128 (4 << 24)
2174 /* Memory address is 256 bit aligned */
2175 #define SLJIT_SIMD_MEM_ALIGNED_256 (5 << 24)
2176 /* Memory address is 512 bit aligned */
2177 #define SLJIT_SIMD_MEM_ALIGNED_512 (6 << 24)
2178
2179 /* Moves data between a vector register and memory.
2180
2181 If the operation is not supported, it returns with
2182 SLJIT_ERR_UNSUPPORTED. If SLJIT_SIMD_TEST is passed,
2183 it does not emit any instructions.
2184
2185 type must be a combination of SLJIT_SIMD_* and
2186 SLJIT_SIMD_MEM_* options
2187 vreg is the source or destination vector register
2188 of the operation
2189 srcdst must be a memory operand or a vector register
2190
2191 Note:
2192 The alignment and element size must be
2193 less or equal than vector register size.
2194
2195 Flags: - (does not modify flags) */
2196
2197 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_mov(struct sljit_compiler *compiler, sljit_s32 type,
2198 sljit_s32 vreg,
2199 sljit_s32 srcdst, sljit_sw srcdstw);
2200
2201 /* Replicates a scalar value to all lanes of a vector
2202 register.
2203
2204 If the operation is not supported, it returns with
2205 SLJIT_ERR_UNSUPPORTED. If SLJIT_SIMD_TEST is passed,
2206 it does not emit any instructions.
2207
2208 type must be a combination of SLJIT_SIMD_* options
2209 except SLJIT_SIMD_STORE.
2210 vreg is the destination vector register of the operation
2211 src is the value which is replicated
2212
2213 Note:
2214 The src == SLJIT_IMM and srcw == 0 can be used to
2215 clear a register even when SLJIT_SIMD_FLOAT is set.
2216
2217 Flags: - (does not modify flags) */
2218
2219 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_replicate(struct sljit_compiler *compiler, sljit_s32 type,
2220 sljit_s32 vreg,
2221 sljit_s32 src, sljit_sw srcw);
2222
2223 /* The following options are used by sljit_emit_simd_lane_mov(). */
2224
2225 /* Clear all bits of the simd register before loading the lane. */
2226 #define SLJIT_SIMD_LANE_ZERO 0x000002
2227 /* Sign extend the integer value stored from the lane. */
2228 #define SLJIT_SIMD_LANE_SIGNED 0x000004
2229
2230 /* Moves data between a vector register lane and a register or
2231 memory. If the srcdst argument is a register, it must be
2232 a floating point register when SLJIT_SIMD_FLOAT is specified,
2233 or a general purpose register otherwise.
2234
2235 If the operation is not supported, it returns with
2236 SLJIT_ERR_UNSUPPORTED. If SLJIT_SIMD_TEST is passed,
2237 it does not emit any instructions.
2238
2239 type must be a combination of SLJIT_SIMD_* options
2240 Further options:
2241 SLJIT_32 - when SLJIT_SIMD_FLOAT is not set
2242 SLJIT_SIMD_LANE_SIGNED - when SLJIT_SIMD_STORE
2243 is set and SLJIT_SIMD_FLOAT is not set
2244 SLJIT_SIMD_LANE_ZERO - when SLJIT_SIMD_LOAD
2245 is specified
2246 vreg is the source or destination vector register
2247 of the operation
2248 lane_index is the index of the lane
2249 srcdst is the destination operand for loads, and
2250 source operand for stores
2251
2252 Note:
2253 The elem size must be lower than register size.
2254
2255 Flags: - (does not modify flags) */
2256
2257 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_lane_mov(struct sljit_compiler *compiler, sljit_s32 type,
2258 sljit_s32 vreg, sljit_s32 lane_index,
2259 sljit_s32 srcdst, sljit_sw srcdstw);
2260
2261 /* Replicates a scalar value from a lane to all lanes
2262 of a vector register.
2263
2264 If the operation is not supported, it returns with
2265 SLJIT_ERR_UNSUPPORTED. If SLJIT_SIMD_TEST is passed,
2266 it does not emit any instructions.
2267
2268 type must be a combination of SLJIT_SIMD_* options
2269 except SLJIT_SIMD_STORE.
2270 vreg is the destination vector register of the operation
2271 src is the vector register which lane is replicated
2272 src_lane_index is the lane index of the src register
2273
2274 Flags: - (does not modify flags) */
2275
2276 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_lane_replicate(struct sljit_compiler *compiler, sljit_s32 type,
2277 sljit_s32 vreg,
2278 sljit_s32 src, sljit_s32 src_lane_index);
2279
2280 /* The following options are used by sljit_emit_simd_load_extend(). */
2281
2282 /* Sign extend the integer elements */
2283 #define SLJIT_SIMD_EXTEND_SIGNED 0x000002
2284 /* Extend data to 16 bit */
2285 #define SLJIT_SIMD_EXTEND_16 (1 << 24)
2286 /* Extend data to 32 bit */
2287 #define SLJIT_SIMD_EXTEND_32 (2 << 24)
2288 /* Extend data to 64 bit */
2289 #define SLJIT_SIMD_EXTEND_64 (3 << 24)
2290
2291 /* Extend elements and stores them in a vector register.
2292 The extension operation increases the size of the
2293 elements (e.g. from 16 bit to 64 bit). For integer
2294 values, the extension can be signed or unsigned.
2295
2296 If the operation is not supported, it returns with
2297 SLJIT_ERR_UNSUPPORTED. If SLJIT_SIMD_TEST is passed,
2298 it does not emit any instructions.
2299
2300 type must be a combination of SLJIT_SIMD_*, and
2301 SLJIT_SIMD_EXTEND_* options except SLJIT_SIMD_STORE
2302 vreg is the destination vector register of the operation
2303 src must be a memory operand or a vector register.
2304 In the latter case, the source elements are stored
2305 in the lower half of the register.
2306
2307 Flags: - (does not modify flags) */
2308
2309 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_extend(struct sljit_compiler *compiler, sljit_s32 type,
2310 sljit_s32 vreg,
2311 sljit_s32 src, sljit_sw srcw);
2312
2313 /* Extract the highest bit (usually the sign bit) from
2314 each elements of a vector.
2315
2316 If the operation is not supported, it returns with
2317 SLJIT_ERR_UNSUPPORTED. If SLJIT_SIMD_TEST is passed,
2318 it does not emit any instructions.
2319
2320 type must be a combination of SLJIT_SIMD_* and SLJIT_32
2321 options except SLJIT_SIMD_LOAD
2322 vreg is the source vector register of the operation
2323 dst is the destination operand
2324
2325 Flags: - (does not modify flags) */
2326
2327 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_sign(struct sljit_compiler *compiler, sljit_s32 type,
2328 sljit_s32 vreg,
2329 sljit_s32 dst, sljit_sw dstw);
2330
2331 /* The following operations are used by sljit_emit_simd_op2(). */
2332
2333 /* Binary 'and' operation */
2334 #define SLJIT_SIMD_OP2_AND 0x000001
2335 /* Binary 'or' operation */
2336 #define SLJIT_SIMD_OP2_OR 0x000002
2337 /* Binary 'xor' operation */
2338 #define SLJIT_SIMD_OP2_XOR 0x000003
2339 /* Shuffle bytes of src1 using the indicies in src2 */
2340 #define SLJIT_SIMD_OP2_SHUFFLE 0x000004
2341
2342 /* Perform simd operations using vector registers.
2343
2344 If the operation is not supported, it returns with
2345 SLJIT_ERR_UNSUPPORTED. If SLJIT_SIMD_TEST is passed,
2346 it does not emit any instructions.
2347
2348 type must be a combination of SLJIT_SIMD_*, SLJIT_SIMD_MEM_*
2349 and SLJIT_SIMD_OP2_* options except SLJIT_SIMD_LOAD
2350 and SLJIT_SIMD_STORE
2351 dst_vreg is the destination register of the operation
2352 src1_vreg is the first source register of the operation
2353 src2 is the second source operand of the operation
2354
2355 Flags: - (does not modify flags) */
2356
2357 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_simd_op2(struct sljit_compiler *compiler, sljit_s32 type,
2358 sljit_s32 dst_vreg, sljit_s32 src1_vreg, sljit_s32 src2, sljit_sw src2w);
2359
2360 /* The following operations are used by sljit_emit_atomic_load() and
2361 sljit_emit_atomic_store() operations. */
2362
2363 /* Tests whether the atomic operation is available (does not generate
2364 any instructions). When a load from is allowed, its corresponding
2365 store form is allowed and vice versa. */
2366 #define SLJIT_ATOMIC_TEST 0x10000
2367 /* The compiler must generate compare and swap instruction.
2368 When this bit is set, calling sljit_emit_atomic_load() is optional. */
2369 #define SLJIT_ATOMIC_USE_CAS 0x20000
2370 /* The compiler must generate load-acquire and store-release instructions.
2371 When this bit is set, the temp_reg for sljit_emit_atomic_store is not used. */
2372 #define SLJIT_ATOMIC_USE_LS 0x40000
2373
2374 /* The sljit_emit_atomic_load and sljit_emit_atomic_store operation pair
2375 can perform an atomic read-modify-write operation. First, an unsigned
2376 value must be loaded from memory using sljit_emit_atomic_load. Then,
2377 the updated value must be written back to the same memory location by
2378 sljit_emit_atomic_store. A thread can only perform a single atomic
2379 operation at a time.
2380
2381 The following conditions must be satisfied, or the operation
2382 is undefined:
2383 - the address provided in mem_reg must be divisible by the size of
2384 the value (only naturally aligned updates are supported)
2385 - no memory operations are allowed between the load and store operations
2386 - the memory operation (op) and the base address (stored in mem_reg)
2387 passed to the load/store operations must be the same (the mem_reg
2388 can be a different register, only its value must be the same)
2389 - a store must always follow a load for the same transaction.
2390
2391 op must be between SLJIT_MOV and SLJIT_MOV_P
2392 dst_reg is the register where the data will be loaded into
2393 mem_reg is the base address of the memory load (it cannot be
2394 SLJIT_SP or a virtual register on x86-32)
2395
2396 Flags: - (does not modify flags) */
2397 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_atomic_load(struct sljit_compiler *compiler, sljit_s32 op,
2398 sljit_s32 dst_reg,
2399 sljit_s32 mem_reg);
2400
2401 /* The sljit_emit_atomic_load and sljit_emit_atomic_store operations
2402 allows performing an atomic read-modify-write operation. See the
2403 description of sljit_emit_atomic_load.
2404
2405 op must be between SLJIT_MOV and SLJIT_MOV_P
2406 src_reg is the register which value is stored into the memory
2407 mem_reg is the base address of the memory store (it cannot be
2408 SLJIT_SP or a virtual register on x86-32)
2409 temp_reg is a scratch register, which must be initialized with
2410 the value loaded into the dst_reg during the corresponding
2411 sljit_emit_atomic_load operation, or the operation is undefined.
2412 The temp_reg register preserves its value, if the memory store
2413 is successful. Otherwise, its value is undefined.
2414
2415 Flags: ATOMIC_STORED
2416 if ATOMIC_STORED flag is set, it represents that the memory
2417 is updated with a new value. Otherwise the memory is unchanged. */
2418 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_atomic_store(struct sljit_compiler *compiler, sljit_s32 op,
2419 sljit_s32 src_reg,
2420 sljit_s32 mem_reg,
2421 sljit_s32 temp_reg);
2422
2423 /* Copies the base address of SLJIT_SP + offset to dst. The offset can
2424 represent the starting address of a value in the local data (stack).
2425 The offset is not limited by the local data limits, it can be any value.
2426 For example if an array of bytes are stored on the stack from
2427 offset 0x40, and R0 contains the offset of an array item plus 0x120,
2428 this item can be changed by two SLJIT instructions:
2429
2430 sljit_get_local_base(compiler, SLJIT_R1, 0, 0x40 - 0x120);
2431 sljit_emit_op1(compiler, SLJIT_MOV_U8, SLJIT_MEM2(SLJIT_R1, SLJIT_R0), 0, SLJIT_IMM, 0x5);
2432
2433 Flags: - (may destroy flags) */
2434 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_local_base(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw offset);
2435
2436 /* Store a value that can be changed at runtime. The constant
2437 can be managed by sljit_get_const_addr and sljit_set_const.
2438
2439 op must be SLJIT_MOV, SLJIT_MOV32, SLJIT_MOV_S32,
2440 SLJIT_MOV_U8, SLJIT_MOV32_U8
2441
2442 Note: when SLJIT_MOV_U8 is used, and dst is a register,
2443 init_value supports a 9 bit signed value between [-256..255]
2444
2445 Flags: - (does not modify flags) */
2446 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_s32 op,
2447 sljit_s32 dst, sljit_sw dstw,
2448 sljit_sw init_value);
2449
2450 /* Opcodes for sljit_emit_mov_addr. */
2451
2452 /* The address is suitable for jump/call target. */
2453 #define SLJIT_MOV_ADDR 0
2454 /* The address is suitable for reading memory. */
2455 #define SLJIT_MOV_ABS_ADDR 1
2456 /* Add absolute address. */
2457 #define SLJIT_ADD_ABS_ADDR 2
2458
2459 /* Store the value of a label (see: sljit_set_label / sljit_set_target)
2460 Flags: - (does not modify flags) */
2461 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_op_addr(struct sljit_compiler *compiler, sljit_s32 op,
2462 sljit_s32 dst, sljit_sw dstw);
2463
2464 /* Returns the address of a label after sljit_generate_code is called, and
2465 before the compiler is freed by sljit_free_compiler. It is recommended
2466 to save these addresses elsewhere before sljit_free_compiler is called.
2467
2468 The address returned by sljit_get_label_addr is suitable for a jump/call
2469 target, and the address returned by sljit_get_label_abs_addr is suitable
2470 for reading memory. */
2471
2472 static SLJIT_INLINE sljit_uw sljit_get_label_addr(struct sljit_label *label) { return label->u.addr; }
2473 #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
2474 static SLJIT_INLINE sljit_uw sljit_get_label_abs_addr(struct sljit_label *label) { return label->u.addr & ~(sljit_uw)1; }
2475 #else /* !SLJIT_CONFIG_ARM_THUMB2 */
2476 static SLJIT_INLINE sljit_uw sljit_get_label_abs_addr(struct sljit_label *label) { return label->u.addr; }
2477 #endif /* SLJIT_CONFIG_ARM_THUMB2 */
2478
2479 /* Returns the address of jump and const instructions after sljit_generate_code
2480 is called, and before the compiler is freed by sljit_free_compiler. It is
2481 recommended to save these addresses elsewhere before sljit_free_compiler is called. */
2482
2483 static SLJIT_INLINE sljit_uw sljit_get_jump_addr(struct sljit_jump *jump) { return jump->addr; }
2484 static SLJIT_INLINE sljit_uw sljit_get_const_addr(struct sljit_const *const_) { return const_->addr; }
2485
2486 /* Only the address and executable offset are required to perform dynamic
2487 code modifications. See sljit_get_executable_offset function. */
2488 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset);
2489 /* The op opcode must be set to the same value that was passed to sljit_emit_const. */
2490 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_s32 op, sljit_sw new_constant, sljit_sw executable_offset);
2491
2492 /* Only a single buffer is writable at a time, so sljit_read_only_buffer_end_writing()
2493 must be called before sljit_read_only_buffer_start_writing() is called again. */
2494 SLJIT_API_FUNC_ATTRIBUTE void* sljit_read_only_buffer_start_writing(sljit_uw addr, sljit_uw size, sljit_sw executable_offset);
2495 SLJIT_API_FUNC_ATTRIBUTE void sljit_read_only_buffer_end_writing(sljit_uw addr, sljit_uw size, sljit_sw executable_offset);
2496
2497 /* --------------------------------------------------------------------- */
2498 /* CPU specific functions */
2499 /* --------------------------------------------------------------------- */
2500
2501 /* Types for sljit_get_register_index */
2502
2503 /* General purpose (integer) registers. */
2504 #define SLJIT_GP_REGISTER 0
2505 /* Floating point registers. */
2506 #define SLJIT_FLOAT_REGISTER 1
2507
2508 /* The following function is a helper function for sljit_emit_op_custom.
2509 It returns with the real machine register index ( >=0 ) of any registers.
2510
2511 When type is SLJIT_GP_REGISTER:
2512 reg must be an SLJIT_R(i), SLJIT_S(i), or SLJIT_SP register
2513
2514 When type is SLJIT_FLOAT_REGISTER:
2515 reg must be an SLJIT_FR(i) or SLJIT_FS(i) register
2516
2517 When type is SLJIT_SIMD_REG_64 / 128 / 256 / 512 :
2518 reg must be an SLJIT_FR(i) or SLJIT_FS(i) register
2519
2520 Note: it returns with -1 for unknown registers, such as virtual
2521 registers on x86-32 or unsupported simd registers. */
2522
2523 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_register_index(sljit_s32 type, sljit_s32 reg);
2524
2525 /* Any instruction can be inserted into the instruction stream by
2526 sljit_emit_op_custom. It has a similar purpose as inline assembly.
2527 The size parameter must match to the instruction size of the target
2528 architecture:
2529
2530 x86: 0 < size <= 15, the instruction argument can be byte aligned.
2531 Thumb2: if size == 2, the instruction argument must be 2 byte aligned.
2532 if size == 4, the instruction argument must be 4 byte aligned.
2533 s390x: size can be 2, 4, or 6, the instruction argument can be byte aligned.
2534 Otherwise: size must be 4 and instruction argument must be 4 byte aligned. */
2535
2536 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_custom(struct sljit_compiler *compiler,
2537 void *instruction, sljit_u32 size);
2538
2539 /* Flags were set by a 32 bit operation. */
2540 #define SLJIT_CURRENT_FLAGS_32 SLJIT_32
2541
2542 /* Flags were set by an ADD or ADDC operations. */
2543 #define SLJIT_CURRENT_FLAGS_ADD 0x01
2544 /* Flags were set by a SUB or SUBC operation. */
2545 #define SLJIT_CURRENT_FLAGS_SUB 0x02
2546
2547 /* Flags were set by sljit_emit_op2u with SLJIT_SUB opcode.
2548 Must be combined with SLJIT_CURRENT_FLAGS_SUB. */
2549 #define SLJIT_CURRENT_FLAGS_COMPARE 0x04
2550
2551 /* Flags were set by sljit_emit_op2cmpz operation. */
2552 #define SLJIT_CURRENT_FLAGS_OP2CMPZ 0x08
2553
2554 /* Define the currently available CPU status flags. It is usually used after
2555 an sljit_emit_label or sljit_emit_op_custom operations to define which CPU
2556 status flags are available.
2557
2558 The current_flags must be a valid combination of SLJIT_SET_* and
2559 SLJIT_CURRENT_FLAGS_* constants. */
2560
2561 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_current_flags(struct sljit_compiler *compiler,
2562 sljit_s32 current_flags);
2563
2564 /* --------------------------------------------------------------------- */
2565 /* Serialization functions */
2566 /* --------------------------------------------------------------------- */
2567
2568 /* Label/jump/const enumeration functions. The items in each group
2569 are enumerated in creation order. Serialization / deserialization
2570 preserves this order for each group. For example the fifth label
2571 after deserialization refers to the same machine code location as
2572 the fifth label before the serialization. */
2573 static SLJIT_INLINE struct sljit_label *sljit_get_first_label(struct sljit_compiler *compiler) { return compiler->labels; }
2574 static SLJIT_INLINE struct sljit_jump *sljit_get_first_jump(struct sljit_compiler *compiler) { return compiler->jumps; }
2575 static SLJIT_INLINE struct sljit_const *sljit_get_first_const(struct sljit_compiler *compiler) { return compiler->consts; }
2576
2577 static SLJIT_INLINE struct sljit_label *sljit_get_next_label(struct sljit_label *label) { return label->next; }
2578 static SLJIT_INLINE struct sljit_jump *sljit_get_next_jump(struct sljit_jump *jump) { return jump->next; }
2579 static SLJIT_INLINE struct sljit_const *sljit_get_next_const(struct sljit_const *const_) { return const_->next; }
2580
2581 /* A number starting from 0 is assigned to each label, which
2582 represents its creation index. The first label created by the
2583 compiler has index 0, the second one has index 1, the third one
2584 has index 2, and so on. The returned value is unspecified after
2585 sljit_generate_code() is called.
2586
2587 It is recommended to use this function to get the creation index
2588 of a label, since sljit_emit_label() may return with the last label,
2589 if no code is generated since the last sljit_emit_label() call. */
2590 SLJIT_API_FUNC_ATTRIBUTE sljit_uw sljit_get_label_index(struct sljit_label *label);
2591
2592 /* The sljit_jump_has_label() and sljit_jump_has_target() functions
2593 returns non-zero value if a label or target is set for the jump
2594 respectively. Both may return with a zero value. The other two
2595 functions return the value assigned to the jump. */
2596 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_jump_has_label(struct sljit_jump *jump);
2597 static SLJIT_INLINE struct sljit_label *sljit_jump_get_label(struct sljit_jump *jump) { return jump->u.label; }
2598 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_jump_has_target(struct sljit_jump *jump);
2599 static SLJIT_INLINE sljit_uw sljit_jump_get_target(struct sljit_jump *jump) { return jump->u.target; }
2600 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_jump_is_mov_addr(struct sljit_jump *jump);
2601
2602 /* Option bits for sljit_serialize_compiler. */
2603
2604 /* When debugging is enabled, the serialized buffer contains
2605 debugging information unless this option is specified. */
2606 #define SLJIT_SERIALIZE_IGNORE_DEBUG 0x1
2607
2608 /* Serialize the internal structure of the compiler into a buffer.
2609 If the serialization is successful, the returned value is a newly
2610 allocated buffer which is allocated by the memory allocator assigned
2611 to the compiler. Otherwise the returned value is NULL. Unlike
2612 sljit_generate_code(), serialization does not modify the internal
2613 state of the compiler, so the code generation can be continued.
2614
2615 options must be the combination of SLJIT_SERIALIZE_* option bits
2616 size is an output argument, which is set to the byte size of
2617 the result buffer if the operation is successful
2618
2619 Notes:
2620 - This function is useful for ahead-of-time compilation (AOT).
2621 - The returned buffer must be freed later by the caller.
2622 The SLJIT_FREE() macro is suitable for this purpose:
2623 SLJIT_FREE(returned_buffer, sljit_get_allocator_data(compiler))
2624 - Memory allocated by sljit_alloc_memory() is not serialized.
2625 - The type of the returned buffer is sljit_uw* to emphasize that
2626 the buffer is word aligned. However, the 'size' output argument
2627 contains the byte size, so this value is always divisible by
2628 sizeof(sljit_uw).
2629 */
2630 SLJIT_API_FUNC_ATTRIBUTE sljit_uw* sljit_serialize_compiler(struct sljit_compiler *compiler,
2631 sljit_s32 options, sljit_uw *size);
2632
2633 /* Construct a new compiler instance from a buffer produced by
2634 sljit_serialize_compiler(). If the operation is successful, the new
2635 compiler instance is returned. Otherwise the returned value is NULL.
2636
2637 buffer points to a word aligned memory data which was
2638 created by sljit_serialize_compiler()
2639 size is the byte size of the buffer
2640 options must be 0
2641 allocator_data specify an allocator specific data, see
2642 sljit_create_compiler() for further details
2643
2644 Notes:
2645 - Labels assigned to jumps are restored with their
2646 corresponding label in the label set created by
2647 the deserializer. Target addresses assigned to
2648 jumps are also restored. Uninitialized jumps
2649 remain uninitialized.
2650 - After the deserialization, sljit_generate_code() does
2651 not need to be the next operation on the returned
2652 compiler, the code generation can be continued.
2653 Even sljit_serialize_compiler() can be called again.
2654 - When debugging is enabled, a buffers without debug
2655 information cannot be deserialized.
2656 */
2657 SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler *sljit_deserialize_compiler(sljit_uw* buffer, sljit_uw size,
2658 sljit_s32 options, void *allocator_data);
2659
2660 /* --------------------------------------------------------------------- */
2661 /* Miscellaneous utility functions */
2662 /* --------------------------------------------------------------------- */
2663
2664 /* Get the human readable name of the platform. Can be useful on platforms
2665 like ARM, where ARM and Thumb2 functions can be mixed, and it is useful
2666 to know the type of the code generator. */
2667 SLJIT_API_FUNC_ATTRIBUTE const char* sljit_get_platform_name(void);
2668
2669 /* Portable helper function to get an offset of a member.
2670 Same as offsetof() macro defined in stddef.h */
2671 #define SLJIT_OFFSETOF(base, member) ((sljit_sw)(&((base*)0x10)->member) - 0x10)
2672
2673 #if (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK)
2674
2675 /* The sljit_stack structure and its manipulation functions provides
2676 an implementation for a top-down stack. The stack top is stored
2677 in the end field of the sljit_stack structure and the stack goes
2678 down to the min_start field, so the memory region reserved for
2679 this stack is between min_start (inclusive) and end (exclusive)
2680 fields. However the application can only use the region between
2681 start (inclusive) and end (exclusive) fields. The sljit_stack_resize
2682 function can be used to extend this region up to min_start.
2683
2684 This feature uses the "address space reserve" feature of modern
2685 operating systems. Instead of allocating a large memory block
2686 applications can allocate a small memory region and extend it
2687 later without moving the content of the memory area. Therefore
2688 after a successful resize by sljit_stack_resize all pointers into
2689 this region are still valid.
2690
2691 Note:
2692 this structure may not be supported by all operating systems.
2693 end and max_limit fields are aligned to PAGE_SIZE bytes (usually
2694 4 Kbyte or more).
2695 stack should grow in larger steps, e.g. 4Kbyte, 16Kbyte or more. */
2696
2697 struct sljit_stack {
2698 /* User data, anything can be stored here.
2699 Initialized to the same value as the end field. */
2700 sljit_u8 *top;
2701 /* These members are read only. */
2702 /* End address of the stack */
2703 sljit_u8 *end;
2704 /* Current start address of the stack. */
2705 sljit_u8 *start;
2706 /* Lowest start address of the stack. */
2707 sljit_u8 *min_start;
2708 };
2709
2710 /* Allocates a new stack. Returns NULL if unsuccessful.
2711 Note: see sljit_create_compiler for the explanation of allocator_data. */
2712 SLJIT_API_FUNC_ATTRIBUTE struct sljit_stack* SLJIT_FUNC sljit_allocate_stack(sljit_uw start_size, sljit_uw max_size, void *allocator_data);
2713 SLJIT_API_FUNC_ATTRIBUTE void SLJIT_FUNC sljit_free_stack(struct sljit_stack *stack, void *allocator_data);
2714
2715 /* Can be used to increase (extend) or decrease (shrink) the stack
2716 memory area. Returns with new_start if successful and NULL otherwise.
2717 It always fails if new_start is less than min_start or greater or equal
2718 than end fields. The fields of the stack are not changed if the returned
2719 value is NULL (the current memory content is never lost). */
2720 SLJIT_API_FUNC_ATTRIBUTE sljit_u8 *SLJIT_FUNC sljit_stack_resize(struct sljit_stack *stack, sljit_u8 *new_start);
2721
2722 #endif /* (defined SLJIT_UTIL_STACK && SLJIT_UTIL_STACK) */
2723
2724 #if !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
2725
2726 /* Get the entry address of a given function (signed, unsigned result). */
2727 #define SLJIT_FUNC_ADDR(func_name) ((sljit_sw)func_name)
2728 #define SLJIT_FUNC_UADDR(func_name) ((sljit_uw)func_name)
2729
2730 #else /* !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) */
2731
2732 /* All JIT related code should be placed in the same context (library, binary, etc.). */
2733
2734 /* Get the entry address of a given function (signed, unsigned result). */
2735 #define SLJIT_FUNC_ADDR(func_name) (*(sljit_sw*)(void*)func_name)
2736 #define SLJIT_FUNC_UADDR(func_name) (*(sljit_uw*)(void*)func_name)
2737
2738 /* For powerpc64, the function pointers point to a context descriptor. */
2739 struct sljit_function_context {
2740 sljit_uw addr;
2741 sljit_uw r2;
2742 sljit_uw r11;
2743 };
2744
2745 /* Fill the context arguments using the addr and the function.
2746 If func_ptr is NULL, it will not be set to the address of context
2747 If addr is NULL, the function address also comes from the func pointer. */
2748 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_function_context(void** func_ptr, struct sljit_function_context* context, sljit_uw addr, void* func);
2749
2750 #endif /* !(defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) */
2751
2752 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
2753 /* Free unused executable memory. The allocator keeps some free memory
2754 around to reduce the number of OS executable memory allocations.
2755 This improves performance since these calls are costly. However
2756 it is sometimes desired to free all unused memory regions, e.g.
2757 before the application terminates. */
2758 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_unused_memory_exec(void);
2759 #endif /* SLJIT_EXECUTABLE_ALLOCATOR */
2760
2761 #ifdef __cplusplus
2762 } /* extern "C" */
2763 #endif /* __cplusplus */
2764
2765 #endif /* SLJIT_LIR_H_ */