sljit/sljitLir.h

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