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