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