"Fossies" - the Fresh Open Source Software Archive

Member "AutoHotkey_L-1.1.33.09/source/lib_pcre/pcre/sljit/sljitLir.c" (8 May 2021, 48900 Bytes) of package /windows/misc/AutoHotkey_L-1.1.33.09.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "sljitLir.c" see the Fossies "Dox" file reference documentation.

    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 #include "sljitLir.h"
   28 
   29 #define CHECK_ERROR() \
   30     do { \
   31         if (SLJIT_UNLIKELY(compiler->error)) \
   32             return compiler->error; \
   33     } while (0)
   34 
   35 #define CHECK_ERROR_PTR() \
   36     do { \
   37         if (SLJIT_UNLIKELY(compiler->error)) \
   38             return NULL; \
   39     } while (0)
   40 
   41 #define CHECK_ERROR_VOID() \
   42     do { \
   43         if (SLJIT_UNLIKELY(compiler->error)) \
   44             return; \
   45     } while (0)
   46 
   47 #define FAIL_IF(expr) \
   48     do { \
   49         if (SLJIT_UNLIKELY(expr)) \
   50             return compiler->error; \
   51     } while (0)
   52 
   53 #define PTR_FAIL_IF(expr) \
   54     do { \
   55         if (SLJIT_UNLIKELY(expr)) \
   56             return NULL; \
   57     } while (0)
   58 
   59 #define FAIL_IF_NULL(ptr) \
   60     do { \
   61         if (SLJIT_UNLIKELY(!(ptr))) { \
   62             compiler->error = SLJIT_ERR_ALLOC_FAILED; \
   63             return SLJIT_ERR_ALLOC_FAILED; \
   64         } \
   65     } while (0)
   66 
   67 #define PTR_FAIL_IF_NULL(ptr) \
   68     do { \
   69         if (SLJIT_UNLIKELY(!(ptr))) { \
   70             compiler->error = SLJIT_ERR_ALLOC_FAILED; \
   71             return NULL; \
   72         } \
   73     } while (0)
   74 
   75 #define PTR_FAIL_WITH_EXEC_IF(ptr) \
   76     do { \
   77         if (SLJIT_UNLIKELY(!(ptr))) { \
   78             compiler->error = SLJIT_ERR_EX_ALLOC_FAILED; \
   79             return NULL; \
   80         } \
   81     } while (0)
   82 
   83 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
   84 
   85 #define GET_OPCODE(op) \
   86     ((op) & ~(SLJIT_INT_OP | SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))
   87 
   88 #define GET_FLAGS(op) \
   89     ((op) & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C))
   90 
   91 #define GET_ALL_FLAGS(op) \
   92     ((op) & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))
   93 
   94 #define BUF_SIZE    4096
   95 
   96 #if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE)
   97 #define ABUF_SIZE   2048
   98 #else
   99 #define ABUF_SIZE   4096
  100 #endif
  101 
  102 /* Jump flags. */
  103 #define JUMP_LABEL  0x1
  104 #define JUMP_ADDR   0x2
  105 /* SLJIT_REWRITABLE_JUMP is 0x1000. */
  106 
  107 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
  108     #define PATCH_MB    0x4
  109     #define PATCH_MW    0x8
  110 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
  111     #define PATCH_MD    0x10
  112 #endif
  113 #endif
  114 
  115 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
  116     #define IS_BL       0x4
  117     #define PATCH_B     0x8
  118 #endif
  119 
  120 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
  121     #define CPOOL_SIZE  512
  122 #endif
  123 
  124 #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
  125     #define IS_CONDITIONAL  0x04
  126     #define IS_BL       0x08
  127     /* cannot be encoded as branch */
  128     #define B_TYPE0     0x00
  129     /* conditional + imm8 */
  130     #define B_TYPE1     0x10
  131     /* conditional + imm20 */
  132     #define B_TYPE2     0x20
  133     /* IT + imm24 */
  134     #define B_TYPE3     0x30
  135     /* imm11 */
  136     #define B_TYPE4     0x40
  137     /* imm24 */
  138     #define B_TYPE5     0x50
  139     /* BL + imm24 */
  140     #define BL_TYPE6    0x60
  141     /* 0xf00 cc code for branches */
  142 #endif
  143 
  144 #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
  145     #define UNCOND_B    0x04
  146     #define PATCH_B     0x08
  147     #define ABSOLUTE_B  0x10
  148 #endif
  149 
  150 #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
  151     #define IS_MOVABLE  0x04
  152     #define IS_JAL      0x08
  153     #define IS_BIT26_COND   0x10
  154     #define IS_BIT16_COND   0x20
  155 
  156     #define IS_COND     (IS_BIT26_COND | IS_BIT16_COND)
  157 
  158     #define PATCH_B     0x40
  159     #define PATCH_J     0x80
  160 
  161     /* instruction types */
  162     #define UNMOVABLE_INS   0
  163     /* 1 - 31 last destination register */
  164     #define FCSR_FCC    32
  165     /* no destination (i.e: store) */
  166     #define MOVABLE_INS 33
  167 #endif
  168 
  169 #endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */
  170 
  171 /* Utils can still be used even if SLJIT_CONFIG_UNSUPPORTED is set. */
  172 #include "sljitUtils.c"
  173 
  174 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
  175 
  176 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
  177 #include "sljitExecAllocator.c"
  178 #endif
  179 
  180 #if (defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO) && !(defined SLJIT_SSE2 && SLJIT_SSE2)
  181 #error SLJIT_SSE2_AUTO cannot be enabled without SLJIT_SSE2
  182 #endif
  183 
  184 /* --------------------------------------------------------------------- */
  185 /*  Public functions                                                     */
  186 /* --------------------------------------------------------------------- */
  187 
  188 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || ((defined SLJIT_SSE2 && SLJIT_SSE2) && ((defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)))
  189 #define SLJIT_NEEDS_COMPILER_INIT 1
  190 static int compiler_initialized = 0;
  191 /* A thread safe initialization. */
  192 static void init_compiler(void);
  193 #endif
  194 
  195 
  196 SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void)
  197 {
  198     struct sljit_compiler *compiler = (struct sljit_compiler*)SLJIT_MALLOC(sizeof(struct sljit_compiler));
  199     if (!compiler)
  200         return NULL;
  201     SLJIT_ZEROMEM(compiler, sizeof(struct sljit_compiler));
  202 
  203     SLJIT_COMPILE_ASSERT(
  204         sizeof(sljit_b) == 1 && sizeof(sljit_ub) == 1
  205         && sizeof(sljit_h) == 2 && sizeof(sljit_uh) == 2
  206         && sizeof(sljit_i) == 4 && sizeof(sljit_ui) == 4
  207         && ((sizeof(sljit_w) == 4 && sizeof(sljit_uw) == 4) || (sizeof(sljit_w) == 8 && sizeof(sljit_uw) == 8)),
  208         invalid_integer_types);
  209 
  210     /* Only the non-zero members must be set. */
  211     compiler->error = SLJIT_SUCCESS;
  212 
  213     compiler->buf = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE);
  214     compiler->abuf = (struct sljit_memory_fragment*)SLJIT_MALLOC(ABUF_SIZE);
  215 
  216     if (!compiler->buf || !compiler->abuf) {
  217         if (compiler->buf)
  218             SLJIT_FREE(compiler->buf);
  219         if (compiler->abuf)
  220             SLJIT_FREE(compiler->abuf);
  221         SLJIT_FREE(compiler);
  222         return NULL;
  223     }
  224 
  225     compiler->buf->next = NULL;
  226     compiler->buf->used_size = 0;
  227     compiler->abuf->next = NULL;
  228     compiler->abuf->used_size = 0;
  229 
  230     compiler->temporaries = -1;
  231     compiler->saveds = -1;
  232 
  233 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
  234     compiler->args = -1;
  235 #endif
  236 
  237 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
  238     compiler->cpool = (sljit_uw*)SLJIT_MALLOC(CPOOL_SIZE * sizeof(sljit_uw) + CPOOL_SIZE * sizeof(sljit_ub));
  239     if (!compiler->cpool) {
  240         SLJIT_FREE(compiler->buf);
  241         SLJIT_FREE(compiler->abuf);
  242         SLJIT_FREE(compiler);
  243         return NULL;
  244     }
  245     compiler->cpool_unique = (sljit_ub*)(compiler->cpool + CPOOL_SIZE);
  246     compiler->cpool_diff = 0xffffffff;
  247 #endif
  248 
  249 #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
  250     compiler->delay_slot = UNMOVABLE_INS;
  251 #endif
  252 
  253 #if (defined SLJIT_NEEDS_COMPILER_INIT && SLJIT_NEEDS_COMPILER_INIT)
  254     if (!compiler_initialized) {
  255         init_compiler();
  256         compiler_initialized = 1;
  257     }
  258 #endif
  259 
  260     return compiler;
  261 }
  262 
  263 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler)
  264 {
  265     struct sljit_memory_fragment *buf;
  266     struct sljit_memory_fragment *curr;
  267 
  268     buf = compiler->buf;
  269     while (buf) {
  270         curr = buf;
  271         buf = buf->next;
  272         SLJIT_FREE(curr);
  273     }
  274 
  275     buf = compiler->abuf;
  276     while (buf) {
  277         curr = buf;
  278         buf = buf->next;
  279         SLJIT_FREE(curr);
  280     }
  281 
  282 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
  283     SLJIT_FREE(compiler->cpool);
  284 #endif
  285     SLJIT_FREE(compiler);
  286 }
  287 
  288 #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
  289 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
  290 {
  291     /* Remove thumb mode flag. */
  292     SLJIT_FREE_EXEC((void*)((sljit_uw)code & ~0x1));
  293 }
  294 #elif (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
  295 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
  296 {
  297     /* Resolve indirection. */
  298     code = (void*)(*(sljit_uw*)code);
  299     SLJIT_FREE_EXEC(code);
  300 }
  301 #else
  302 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
  303 {
  304     SLJIT_FREE_EXEC(code);
  305 }
  306 #endif
  307 
  308 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label)
  309 {
  310     if (SLJIT_LIKELY(!!jump) && SLJIT_LIKELY(!!label)) {
  311         jump->flags &= ~JUMP_ADDR;
  312         jump->flags |= JUMP_LABEL;
  313         jump->u.label = label;
  314     }
  315 }
  316 
  317 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target)
  318 {
  319     if (SLJIT_LIKELY(!!jump)) {
  320         SLJIT_ASSERT(jump->flags & SLJIT_REWRITABLE_JUMP);
  321 
  322         jump->flags &= ~JUMP_LABEL;
  323         jump->flags |= JUMP_ADDR;
  324         jump->u.target = target;
  325     }
  326 }
  327 
  328 /* --------------------------------------------------------------------- */
  329 /*  Private functions                                                    */
  330 /* --------------------------------------------------------------------- */
  331 
  332 static void* ensure_buf(struct sljit_compiler *compiler, int size)
  333 {
  334     sljit_ub *ret;
  335     struct sljit_memory_fragment *new_frag;
  336 
  337     if (compiler->buf->used_size + size <= (int)(BUF_SIZE - sizeof(sljit_uw) - sizeof(void*))) {
  338         ret = compiler->buf->memory + compiler->buf->used_size;
  339         compiler->buf->used_size += size;
  340         return ret;
  341     }
  342     new_frag = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE);
  343     PTR_FAIL_IF_NULL(new_frag);
  344     new_frag->next = compiler->buf;
  345     compiler->buf = new_frag;
  346     new_frag->used_size = size;
  347     return new_frag->memory;
  348 }
  349 
  350 static void* ensure_abuf(struct sljit_compiler *compiler, int size)
  351 {
  352     sljit_ub *ret;
  353     struct sljit_memory_fragment *new_frag;
  354 
  355     if (compiler->abuf->used_size + size <= (int)(ABUF_SIZE - sizeof(sljit_uw) - sizeof(void*))) {
  356         ret = compiler->abuf->memory + compiler->abuf->used_size;
  357         compiler->abuf->used_size += size;
  358         return ret;
  359     }
  360     new_frag = (struct sljit_memory_fragment*)SLJIT_MALLOC(ABUF_SIZE);
  361     PTR_FAIL_IF_NULL(new_frag);
  362     new_frag->next = compiler->abuf;
  363     compiler->abuf = new_frag;
  364     new_frag->used_size = size;
  365     return new_frag->memory;
  366 }
  367 
  368 SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, int size)
  369 {
  370     CHECK_ERROR_PTR();
  371 
  372 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
  373     if (size <= 0 || size > 128)
  374         return NULL;
  375     size = (size + 7) & ~7;
  376 #else
  377     if (size <= 0 || size > 64)
  378         return NULL;
  379     size = (size + 3) & ~3;
  380 #endif
  381     return ensure_abuf(compiler, size);
  382 }
  383 
  384 static SLJIT_INLINE void reverse_buf(struct sljit_compiler *compiler)
  385 {
  386     struct sljit_memory_fragment *buf = compiler->buf;
  387     struct sljit_memory_fragment *prev = NULL;
  388     struct sljit_memory_fragment *tmp;
  389 
  390     do {
  391         tmp = buf->next;
  392         buf->next = prev;
  393         prev = buf;
  394         buf = tmp;
  395     } while (buf != NULL);
  396 
  397     compiler->buf = prev;
  398 }
  399 
  400 static SLJIT_INLINE void set_label(struct sljit_label *label, struct sljit_compiler *compiler)
  401 {
  402     label->next = NULL;
  403     label->size = compiler->size;
  404     if (compiler->last_label)
  405         compiler->last_label->next = label;
  406     else
  407         compiler->labels = label;
  408     compiler->last_label = label;
  409 }
  410 
  411 static SLJIT_INLINE void set_jump(struct sljit_jump *jump, struct sljit_compiler *compiler, int flags)
  412 {
  413     jump->next = NULL;
  414     jump->flags = flags;
  415     if (compiler->last_jump)
  416         compiler->last_jump->next = jump;
  417     else
  418         compiler->jumps = jump;
  419     compiler->last_jump = jump;
  420 }
  421 
  422 static SLJIT_INLINE void set_const(struct sljit_const *const_, struct sljit_compiler *compiler)
  423 {
  424     const_->next = NULL;
  425     const_->addr = compiler->size;
  426     if (compiler->last_const)
  427         compiler->last_const->next = const_;
  428     else
  429         compiler->consts = const_;
  430     compiler->last_const = const_;
  431 }
  432 
  433 #define ADDRESSING_DEPENDS_ON(exp, reg) \
  434     (((exp) & SLJIT_MEM) && (((exp) & 0xf) == reg || (((exp) >> 4) & 0xf) == reg))
  435 
  436 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  437 #define FUNCTION_CHECK_OP() \
  438     SLJIT_ASSERT(!GET_FLAGS(op) || !(op & SLJIT_KEEP_FLAGS)); \
  439     switch (GET_OPCODE(op)) { \
  440     case SLJIT_NOT: \
  441     case SLJIT_CLZ: \
  442     case SLJIT_AND: \
  443     case SLJIT_OR: \
  444     case SLJIT_XOR: \
  445     case SLJIT_SHL: \
  446     case SLJIT_LSHR: \
  447     case SLJIT_ASHR: \
  448         SLJIT_ASSERT(!(op & (SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C))); \
  449         break; \
  450     case SLJIT_NEG: \
  451         SLJIT_ASSERT(!(op & (SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_C))); \
  452         break; \
  453     case SLJIT_MUL: \
  454         SLJIT_ASSERT(!(op & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_C))); \
  455         break; \
  456     case SLJIT_FCMP: \
  457         SLJIT_ASSERT(!(op & (SLJIT_INT_OP | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \
  458         SLJIT_ASSERT((op & (SLJIT_SET_E | SLJIT_SET_S))); \
  459         break; \
  460     case SLJIT_ADD: \
  461         SLJIT_ASSERT(!(op & (SLJIT_SET_S | SLJIT_SET_U))); \
  462         break; \
  463     case SLJIT_SUB: \
  464         break; \
  465     case SLJIT_ADDC: \
  466     case SLJIT_SUBC: \
  467         SLJIT_ASSERT(!(op & (SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O))); \
  468         break; \
  469     default: \
  470         /* Nothing allowed */ \
  471         SLJIT_ASSERT(!(op & (SLJIT_INT_OP | SLJIT_SET_E | SLJIT_SET_S | SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \
  472         break; \
  473     }
  474 
  475 #define FUNCTION_CHECK_IS_REG(r) \
  476     ((r) == SLJIT_UNUSED || (r) == SLJIT_LOCALS_REG || \
  477     ((r) >= SLJIT_TEMPORARY_REG1 && (r) <= SLJIT_TEMPORARY_REG3 && (r) <= SLJIT_TEMPORARY_REG1 - 1 + compiler->temporaries) || \
  478     ((r) >= SLJIT_SAVED_REG1 && (r) <= SLJIT_SAVED_REG3 && (r) <= SLJIT_SAVED_REG1 - 1 + compiler->saveds)) \
  479 
  480 #define FUNCTION_CHECK_SRC(p, i) \
  481     SLJIT_ASSERT(compiler->temporaries != -1 && compiler->saveds != -1); \
  482     if (((p) >= SLJIT_TEMPORARY_REG1 && (p) <= SLJIT_TEMPORARY_REG1 - 1 + compiler->temporaries) || \
  483             ((p) >= SLJIT_SAVED_REG1 && (p) <= SLJIT_SAVED_REG1 - 1 + compiler->saveds) || \
  484             (p) == SLJIT_LOCALS_REG) \
  485         SLJIT_ASSERT(i == 0); \
  486     else if ((p) == SLJIT_IMM) \
  487         ; \
  488     else if ((p) & SLJIT_MEM) { \
  489         SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & 0xf)); \
  490         if ((p) & 0xf0) { \
  491             SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(((p) >> 4) & 0xf)); \
  492             SLJIT_ASSERT(((p) & 0xf0) != (SLJIT_LOCALS_REG << 4) && !(i & ~0x3)); \
  493         } else \
  494             SLJIT_ASSERT((((p) >> 4) & 0xf) == 0); \
  495         SLJIT_ASSERT(((p) >> 9) == 0); \
  496     } \
  497     else \
  498         SLJIT_ASSERT_STOP();
  499 
  500 #define FUNCTION_CHECK_DST(p, i) \
  501     SLJIT_ASSERT(compiler->temporaries != -1 && compiler->saveds != -1); \
  502     if (((p) >= SLJIT_TEMPORARY_REG1 && (p) <= SLJIT_TEMPORARY_REG1 - 1 + compiler->temporaries) || \
  503             ((p) >= SLJIT_SAVED_REG1 && (p) <= SLJIT_SAVED_REG1 - 1 + compiler->saveds) || \
  504             (p) == SLJIT_UNUSED) \
  505         SLJIT_ASSERT(i == 0); \
  506     else if ((p) & SLJIT_MEM) { \
  507         SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & 0xf)); \
  508         if ((p) & 0xf0) { \
  509             SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(((p) >> 4) & 0xf)); \
  510             SLJIT_ASSERT(((p) & 0xf0) != (SLJIT_LOCALS_REG << 4) && !(i & ~0x3)); \
  511         } else \
  512             SLJIT_ASSERT((((p) >> 4) & 0xf) == 0); \
  513         SLJIT_ASSERT(((p) >> 9) == 0); \
  514     } \
  515     else \
  516         SLJIT_ASSERT_STOP();
  517 
  518 #define FUNCTION_FCHECK(p, i) \
  519     if ((p) >= SLJIT_FLOAT_REG1 && (p) <= SLJIT_FLOAT_REG4) \
  520         SLJIT_ASSERT(i == 0); \
  521     else if ((p) & SLJIT_MEM) { \
  522         SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & 0xf)); \
  523         if ((p) & 0xf0) { \
  524             SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(((p) >> 4) & 0xf)); \
  525             SLJIT_ASSERT(((p) & 0xf0) != (SLJIT_LOCALS_REG << 4) && !(i & ~0x3)); \
  526         } else \
  527             SLJIT_ASSERT((((p) >> 4) & 0xf) == 0); \
  528         SLJIT_ASSERT(((p) >> 9) == 0); \
  529     } \
  530     else \
  531         SLJIT_ASSERT_STOP();
  532 
  533 #define FUNCTION_CHECK_OP1() \
  534     if (GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_MOVU_SI) { \
  535         SLJIT_ASSERT(!GET_ALL_FLAGS(op)); \
  536     } \
  537         if (GET_OPCODE(op) >= SLJIT_MOVU && GET_OPCODE(op) <= SLJIT_MOVU_SI) { \
  538         SLJIT_ASSERT(!(src & SLJIT_MEM) || (src & 0xf) != SLJIT_LOCALS_REG); \
  539         SLJIT_ASSERT(!(dst & SLJIT_MEM) || (dst & 0xf) != SLJIT_LOCALS_REG); \
  540         if ((src & SLJIT_MEM) && (src & 0xf)) \
  541             SLJIT_ASSERT((dst & 0xf) != (src & 0xf) && ((dst >> 4) & 0xf) != (src & 0xf)); \
  542     }
  543 
  544 #endif
  545 
  546 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  547 
  548 SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose)
  549 {
  550     compiler->verbose = verbose;
  551 }
  552 
  553 static char* reg_names[] = {
  554     (char*)"<noreg>", (char*)"t1", (char*)"t2", (char*)"t3",
  555     (char*)"te1", (char*)"te2", (char*)"s1", (char*)"s2",
  556     (char*)"s3", (char*)"se1", (char*)"se2", (char*)"lcr"
  557 };
  558 
  559 static char* freg_names[] = {
  560     (char*)"<noreg>", (char*)"float_r1", (char*)"float_r2", (char*)"float_r3", (char*)"float_r4"
  561 };
  562 
  563 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) || (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
  564 #ifdef _WIN64
  565     #define SLJIT_PRINT_D   "I64"
  566 #else
  567     #define SLJIT_PRINT_D   "l"
  568 #endif
  569 #else
  570     #define SLJIT_PRINT_D   ""
  571 #endif
  572 
  573 #define sljit_verbose_param(p, i) \
  574     if ((p) & SLJIT_IMM) \
  575         fprintf(compiler->verbose, "#%"SLJIT_PRINT_D"d", (i)); \
  576     else if ((p) & SLJIT_MEM) { \
  577         if ((p) & 0xf) { \
  578             if (i) { \
  579                 if (((p) >> 4) & 0xf) \
  580                     fprintf(compiler->verbose, "[%s + %s * %d]", reg_names[(p) & 0xF], reg_names[((p) >> 4)& 0xF], 1 << (i)); \
  581                 else \
  582                     fprintf(compiler->verbose, "[%s + #%"SLJIT_PRINT_D"d]", reg_names[(p) & 0xF], (i)); \
  583             } \
  584             else { \
  585                 if (((p) >> 4) & 0xf) \
  586                     fprintf(compiler->verbose, "[%s + %s]", reg_names[(p) & 0xF], reg_names[((p) >> 4)& 0xF]); \
  587                 else \
  588                     fprintf(compiler->verbose, "[%s]", reg_names[(p) & 0xF]); \
  589             } \
  590         } \
  591         else \
  592             fprintf(compiler->verbose, "[#%"SLJIT_PRINT_D"d]", (i)); \
  593     } else \
  594         fprintf(compiler->verbose, "%s", reg_names[p]);
  595 #define sljit_verbose_fparam(p, i) \
  596     if ((p) & SLJIT_MEM) { \
  597         if ((p) & 0xf) { \
  598             if (i) { \
  599                 if (((p) >> 4) & 0xf) \
  600                     fprintf(compiler->verbose, "[%s + %s * %d]", reg_names[(p) & 0xF], reg_names[((p) >> 4)& 0xF], 1 << (i)); \
  601                 else \
  602                     fprintf(compiler->verbose, "[%s + #%"SLJIT_PRINT_D"d]", reg_names[(p) & 0xF], (i)); \
  603             } \
  604             else { \
  605                 if (((p) >> 4) & 0xF) \
  606                     fprintf(compiler->verbose, "[%s + %s]", reg_names[(p) & 0xF], reg_names[((p) >> 4)& 0xF]); \
  607                 else \
  608                     fprintf(compiler->verbose, "[%s]", reg_names[(p) & 0xF]); \
  609             } \
  610         } \
  611         else \
  612             fprintf(compiler->verbose, "[#%"SLJIT_PRINT_D"d]", (i)); \
  613     } else \
  614         fprintf(compiler->verbose, "%s", freg_names[p]);
  615 
  616 static SLJIT_CONST char* op_names[] = {
  617     /* op0 */
  618     (char*)"breakpoint", (char*)"nop",
  619     (char*)"umul", (char*)"smul", (char*)"udiv", (char*)"sdiv",
  620     /* op1 */
  621     (char*)"mov", (char*)"mov.ub", (char*)"mov.sb", (char*)"mov.uh",
  622     (char*)"mov.sh", (char*)"mov.ui", (char*)"mov.si", (char*)"movu",
  623     (char*)"movu.ub", (char*)"movu.sb", (char*)"movu.uh", (char*)"movu.sh",
  624     (char*)"movu.ui", (char*)"movu.si", (char*)"not", (char*)"neg",
  625     (char*)"clz",
  626     /* op2 */
  627     (char*)"add", (char*)"addc", (char*)"sub", (char*)"subc",
  628     (char*)"mul", (char*)"and", (char*)"or", (char*)"xor",
  629     (char*)"shl", (char*)"lshr", (char*)"ashr",
  630     /* fop1 */
  631     (char*)"fcmp", (char*)"fmov", (char*)"fneg", (char*)"fabs",
  632     /* fop2 */
  633     (char*)"fadd", (char*)"fsub", (char*)"fmul", (char*)"fdiv"
  634 };
  635 
  636 static char* jump_names[] = {
  637     (char*)"c_equal", (char*)"c_not_equal",
  638     (char*)"c_less", (char*)"c_greater_equal",
  639     (char*)"c_greater", (char*)"c_less_equal",
  640     (char*)"c_sig_less", (char*)"c_sig_greater_equal",
  641     (char*)"c_sig_greater", (char*)"c_sig_less_equal",
  642     (char*)"c_overflow", (char*)"c_not_overflow",
  643     (char*)"c_mul_overflow", (char*)"c_mul_not_overflow",
  644     (char*)"c_float_equal", (char*)"c_float_not_equal",
  645     (char*)"c_float_less", (char*)"c_float_greater_equal",
  646     (char*)"c_float_greater", (char*)"c_float_less_equal",
  647     (char*)"c_float_nan", (char*)"c_float_not_nan",
  648     (char*)"jump", (char*)"fast_call",
  649     (char*)"call0", (char*)"call1", (char*)"call2", (char*)"call3"
  650 };
  651 
  652 #endif
  653 
  654 /* --------------------------------------------------------------------- */
  655 /*  Arch dependent                                                       */
  656 /* --------------------------------------------------------------------- */
  657 
  658 static SLJIT_INLINE void check_sljit_generate_code(struct sljit_compiler *compiler)
  659 {
  660 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  661     struct sljit_jump *jump;
  662 #endif
  663     /* If debug and verbose are disabled, all arguments are unused. */
  664     SLJIT_UNUSED_ARG(compiler);
  665 
  666     SLJIT_ASSERT(compiler->size > 0);
  667 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  668     jump = compiler->jumps;
  669     while (jump) {
  670         /* All jumps have target. */
  671         SLJIT_ASSERT(jump->flags & (JUMP_LABEL | JUMP_ADDR));
  672         jump = jump->next;
  673     }
  674 #endif
  675 }
  676 
  677 static SLJIT_INLINE void check_sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
  678 {
  679     /* If debug and verbose are disabled, all arguments are unused. */
  680     SLJIT_UNUSED_ARG(compiler);
  681     SLJIT_UNUSED_ARG(args);
  682     SLJIT_UNUSED_ARG(temporaries);
  683     SLJIT_UNUSED_ARG(saveds);
  684     SLJIT_UNUSED_ARG(local_size);
  685 
  686     SLJIT_ASSERT(args >= 0 && args <= 3);
  687     SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
  688     SLJIT_ASSERT(saveds >= 0 && saveds <= SLJIT_NO_GEN_REGISTERS);
  689     SLJIT_ASSERT(args <= saveds);
  690     SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
  691 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  692     if (SLJIT_UNLIKELY(!!compiler->verbose))
  693         fprintf(compiler->verbose, "  enter args=%d temporaries=%d saveds=%d local_size=%d\n", args, temporaries, saveds, local_size);
  694 #endif
  695 }
  696 
  697 static SLJIT_INLINE void check_sljit_set_context(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
  698 {
  699     /* If debug and verbose are disabled, all arguments are unused. */
  700     SLJIT_UNUSED_ARG(compiler);
  701     SLJIT_UNUSED_ARG(args);
  702     SLJIT_UNUSED_ARG(temporaries);
  703     SLJIT_UNUSED_ARG(saveds);
  704     SLJIT_UNUSED_ARG(local_size);
  705 
  706     SLJIT_ASSERT(args >= 0 && args <= 3);
  707     SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
  708     SLJIT_ASSERT(saveds >= 0 && saveds <= SLJIT_NO_GEN_REGISTERS);
  709     SLJIT_ASSERT(args <= saveds);
  710     SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
  711 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  712     if (SLJIT_UNLIKELY(!!compiler->verbose))
  713         fprintf(compiler->verbose, "  fake_enter args=%d temporaries=%d saveds=%d local_size=%d\n", args, temporaries, saveds, local_size);
  714 #endif
  715 }
  716 
  717 static SLJIT_INLINE void check_sljit_emit_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)
  718 {
  719     /* If debug and verbose are disabled, all arguments are unused. */
  720     SLJIT_UNUSED_ARG(compiler);
  721     SLJIT_UNUSED_ARG(op);
  722     SLJIT_UNUSED_ARG(src);
  723     SLJIT_UNUSED_ARG(srcw);
  724 
  725 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  726     if (op != SLJIT_UNUSED) {
  727         SLJIT_ASSERT(op >= SLJIT_MOV && op <= SLJIT_MOV_SI);
  728         FUNCTION_CHECK_SRC(src, srcw);
  729     }
  730     else
  731         SLJIT_ASSERT(src == 0 && srcw == 0);
  732 #endif
  733 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  734     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
  735         if (op == SLJIT_UNUSED)
  736             fprintf(compiler->verbose, "  return\n");
  737         else {
  738             fprintf(compiler->verbose, "  return %s ", op_names[op]);
  739             sljit_verbose_param(src, srcw);
  740             fprintf(compiler->verbose, "\n");
  741         }
  742     }
  743 #endif
  744 }
  745 
  746 static SLJIT_INLINE void check_sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw, int args, int temporaries, int saveds, int local_size)
  747 {
  748     /* If debug and verbose are disabled, all arguments are unused. */
  749     SLJIT_UNUSED_ARG(compiler);
  750     SLJIT_UNUSED_ARG(dst);
  751     SLJIT_UNUSED_ARG(dstw);
  752     SLJIT_UNUSED_ARG(args);
  753     SLJIT_UNUSED_ARG(temporaries);
  754     SLJIT_UNUSED_ARG(saveds);
  755     SLJIT_UNUSED_ARG(local_size);
  756 
  757     SLJIT_ASSERT(args >= 0 && args <= 3);
  758     SLJIT_ASSERT(temporaries >= 0 && temporaries <= SLJIT_NO_TMP_REGISTERS);
  759     SLJIT_ASSERT(saveds >= 0 && saveds <= SLJIT_NO_GEN_REGISTERS);
  760     SLJIT_ASSERT(args <= saveds);
  761     SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
  762 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  763     compiler->temporaries = temporaries;
  764     compiler->saveds = saveds;
  765     FUNCTION_CHECK_DST(dst, dstw);
  766     compiler->temporaries = -1;
  767     compiler->saveds = -1;
  768 #endif
  769 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  770     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
  771         fprintf(compiler->verbose, "  fast_enter ");
  772         sljit_verbose_param(dst, dstw);
  773         fprintf(compiler->verbose, " args=%d temporaries=%d saveds=%d local_size=%d\n", args, temporaries, saveds, local_size);
  774     }
  775 #endif
  776 }
  777 
  778 static SLJIT_INLINE void check_sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
  779 {
  780     /* If debug and verbose are disabled, all arguments are unused. */
  781     SLJIT_UNUSED_ARG(compiler);
  782     SLJIT_UNUSED_ARG(src);
  783     SLJIT_UNUSED_ARG(srcw);
  784 
  785 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  786     FUNCTION_CHECK_SRC(src, srcw);
  787 #endif
  788 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  789     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
  790         fprintf(compiler->verbose, "  fast_return ");
  791         sljit_verbose_param(src, srcw);
  792         fprintf(compiler->verbose, "\n");
  793     }
  794 #endif
  795 }
  796 
  797 static SLJIT_INLINE void check_sljit_emit_op0(struct sljit_compiler *compiler, int op)
  798 {
  799     /* If debug and verbose are disabled, all arguments are unused. */
  800     SLJIT_UNUSED_ARG(compiler);
  801     SLJIT_UNUSED_ARG(op);
  802 
  803     SLJIT_ASSERT((op >= SLJIT_BREAKPOINT && op <= SLJIT_SMUL)
  804         || ((op & ~SLJIT_INT_OP) >= SLJIT_UDIV && (op & ~SLJIT_INT_OP) <= SLJIT_SDIV));
  805 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  806     if (SLJIT_UNLIKELY(!!compiler->verbose))
  807         fprintf(compiler->verbose, "  %s%s\n", !(op & SLJIT_INT_OP) ? "" : "i", op_names[GET_OPCODE(op)]);
  808 #endif
  809 }
  810 
  811 static SLJIT_INLINE void check_sljit_emit_op1(struct sljit_compiler *compiler, int op,
  812     int dst, sljit_w dstw,
  813     int src, sljit_w srcw)
  814 {
  815     /* If debug and verbose are disabled, all arguments are unused. */
  816     SLJIT_UNUSED_ARG(compiler);
  817     SLJIT_UNUSED_ARG(op);
  818     SLJIT_UNUSED_ARG(dst);
  819     SLJIT_UNUSED_ARG(dstw);
  820     SLJIT_UNUSED_ARG(src);
  821     SLJIT_UNUSED_ARG(srcw);
  822 
  823 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
  824     if (SLJIT_UNLIKELY(compiler->skip_checks)) {
  825         compiler->skip_checks = 0;
  826         return;
  827     }
  828 #endif
  829 
  830     SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_CLZ);
  831 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  832     FUNCTION_CHECK_OP();
  833     FUNCTION_CHECK_SRC(src, srcw);
  834     FUNCTION_CHECK_DST(dst, dstw);
  835     FUNCTION_CHECK_OP1();
  836 #endif
  837 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  838     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
  839         fprintf(compiler->verbose, "  %s%s%s%s%s%s%s%s ", !(op & SLJIT_INT_OP) ? "" : "i", op_names[GET_OPCODE(op)],
  840             !(op & SLJIT_SET_E) ? "" : "E", !(op & SLJIT_SET_S) ? "" : "S", !(op & SLJIT_SET_U) ? "" : "U", !(op & SLJIT_SET_O) ? "" : "O", !(op & SLJIT_SET_C) ? "" : "C", !(op & SLJIT_KEEP_FLAGS) ? "" : "K");
  841         sljit_verbose_param(dst, dstw);
  842         fprintf(compiler->verbose, ", ");
  843         sljit_verbose_param(src, srcw);
  844         fprintf(compiler->verbose, "\n");
  845     }
  846 #endif
  847 }
  848 
  849 static SLJIT_INLINE void check_sljit_emit_op2(struct sljit_compiler *compiler, int op,
  850     int dst, sljit_w dstw,
  851     int src1, sljit_w src1w,
  852     int src2, sljit_w src2w)
  853 {
  854     /* If debug and verbose are disabled, all arguments are unused. */
  855     SLJIT_UNUSED_ARG(compiler);
  856     SLJIT_UNUSED_ARG(op);
  857     SLJIT_UNUSED_ARG(dst);
  858     SLJIT_UNUSED_ARG(dstw);
  859     SLJIT_UNUSED_ARG(src1);
  860     SLJIT_UNUSED_ARG(src1w);
  861     SLJIT_UNUSED_ARG(src2);
  862     SLJIT_UNUSED_ARG(src2w);
  863 
  864 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
  865     if (SLJIT_UNLIKELY(compiler->skip_checks)) {
  866         compiler->skip_checks = 0;
  867         return;
  868     }
  869 #endif
  870 
  871     SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_ADD && GET_OPCODE(op) <= SLJIT_ASHR);
  872 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  873     FUNCTION_CHECK_OP();
  874     FUNCTION_CHECK_SRC(src1, src1w);
  875     FUNCTION_CHECK_SRC(src2, src2w);
  876     FUNCTION_CHECK_DST(dst, dstw);
  877 #endif
  878 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  879     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
  880         fprintf(compiler->verbose, "  %s%s%s%s%s%s%s%s ", !(op & SLJIT_INT_OP) ? "" : "i", op_names[GET_OPCODE(op)],
  881             !(op & SLJIT_SET_E) ? "" : "E", !(op & SLJIT_SET_S) ? "" : "S", !(op & SLJIT_SET_U) ? "" : "U", !(op & SLJIT_SET_O) ? "" : "O", !(op & SLJIT_SET_C) ? "" : "C", !(op & SLJIT_KEEP_FLAGS) ? "" : "K");
  882         sljit_verbose_param(dst, dstw);
  883         fprintf(compiler->verbose, ", ");
  884         sljit_verbose_param(src1, src1w);
  885         fprintf(compiler->verbose, ", ");
  886         sljit_verbose_param(src2, src2w);
  887         fprintf(compiler->verbose, "\n");
  888     }
  889 #endif
  890 }
  891 
  892 static SLJIT_INLINE void check_sljit_get_register_index(int reg)
  893 {
  894     SLJIT_UNUSED_ARG(reg);
  895     SLJIT_ASSERT(reg > 0 && reg <= SLJIT_NO_REGISTERS);
  896 }
  897 
  898 static SLJIT_INLINE void check_sljit_emit_op_custom(struct sljit_compiler *compiler,
  899     void *instruction, int size)
  900 {
  901     SLJIT_UNUSED_ARG(compiler);
  902     SLJIT_UNUSED_ARG(instruction);
  903     SLJIT_UNUSED_ARG(size);
  904     SLJIT_ASSERT(instruction);
  905 }
  906 
  907 static SLJIT_INLINE void check_sljit_emit_fop1(struct sljit_compiler *compiler, int op,
  908     int dst, sljit_w dstw,
  909     int src, sljit_w srcw)
  910 {
  911     /* If debug and verbose are disabled, all arguments are unused. */
  912     SLJIT_UNUSED_ARG(compiler);
  913     SLJIT_UNUSED_ARG(op);
  914     SLJIT_UNUSED_ARG(dst);
  915     SLJIT_UNUSED_ARG(dstw);
  916     SLJIT_UNUSED_ARG(src);
  917     SLJIT_UNUSED_ARG(srcw);
  918 
  919 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
  920     if (SLJIT_UNLIKELY(compiler->skip_checks)) {
  921         compiler->skip_checks = 0;
  922         return;
  923     }
  924 #endif
  925 
  926     SLJIT_ASSERT(sljit_is_fpu_available());
  927     SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_FCMP && GET_OPCODE(op) <= SLJIT_FABS);
  928 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  929     FUNCTION_CHECK_OP();
  930     FUNCTION_FCHECK(src, srcw);
  931     FUNCTION_FCHECK(dst, dstw);
  932 #endif
  933 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  934     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
  935         fprintf(compiler->verbose, "  %s%s%s ", op_names[GET_OPCODE(op)],
  936             !(op & SLJIT_SET_E) ? "" : "E", !(op & SLJIT_SET_S) ? "" : "S");
  937         sljit_verbose_fparam(dst, dstw);
  938         fprintf(compiler->verbose, ", ");
  939         sljit_verbose_fparam(src, srcw);
  940         fprintf(compiler->verbose, "\n");
  941     }
  942 #endif
  943 }
  944 
  945 static SLJIT_INLINE void check_sljit_emit_fop2(struct sljit_compiler *compiler, int op,
  946     int dst, sljit_w dstw,
  947     int src1, sljit_w src1w,
  948     int src2, sljit_w src2w)
  949 {
  950     /* If debug and verbose are disabled, all arguments are unused. */
  951     SLJIT_UNUSED_ARG(compiler);
  952     SLJIT_UNUSED_ARG(op);
  953     SLJIT_UNUSED_ARG(dst);
  954     SLJIT_UNUSED_ARG(dstw);
  955     SLJIT_UNUSED_ARG(src1);
  956     SLJIT_UNUSED_ARG(src1w);
  957     SLJIT_UNUSED_ARG(src2);
  958     SLJIT_UNUSED_ARG(src2w);
  959 
  960     SLJIT_ASSERT(sljit_is_fpu_available());
  961     SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_FADD && GET_OPCODE(op) <= SLJIT_FDIV);
  962 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
  963     FUNCTION_CHECK_OP();
  964     FUNCTION_FCHECK(src1, src1w);
  965     FUNCTION_FCHECK(src2, src2w);
  966     FUNCTION_FCHECK(dst, dstw);
  967 #endif
  968 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  969     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
  970         fprintf(compiler->verbose, "  %s ", op_names[GET_OPCODE(op)]);
  971         sljit_verbose_fparam(dst, dstw);
  972         fprintf(compiler->verbose, ", ");
  973         sljit_verbose_fparam(src1, src1w);
  974         fprintf(compiler->verbose, ", ");
  975         sljit_verbose_fparam(src2, src2w);
  976         fprintf(compiler->verbose, "\n");
  977     }
  978 #endif
  979 }
  980 
  981 static SLJIT_INLINE void check_sljit_emit_label(struct sljit_compiler *compiler)
  982 {
  983     /* If debug and verbose are disabled, all arguments are unused. */
  984     SLJIT_UNUSED_ARG(compiler);
  985 
  986 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
  987     if (SLJIT_UNLIKELY(!!compiler->verbose))
  988         fprintf(compiler->verbose, "label:\n");
  989 #endif
  990 }
  991 
  992 static SLJIT_INLINE void check_sljit_emit_jump(struct sljit_compiler *compiler, int type)
  993 {
  994     /* If debug and verbose are disabled, all arguments are unused. */
  995     SLJIT_UNUSED_ARG(compiler);
  996     SLJIT_UNUSED_ARG(type);
  997 
  998 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
  999     if (SLJIT_UNLIKELY(compiler->skip_checks)) {
 1000         compiler->skip_checks = 0;
 1001         return;
 1002     }
 1003 #endif
 1004 
 1005     SLJIT_ASSERT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP)));
 1006     SLJIT_ASSERT((type & 0xff) >= SLJIT_C_EQUAL && (type & 0xff) <= SLJIT_CALL3);
 1007 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 1008     if (SLJIT_UNLIKELY(!!compiler->verbose))
 1009         fprintf(compiler->verbose, "  jump%s <%s>\n", !(type & SLJIT_REWRITABLE_JUMP) ? "" : "R", jump_names[type & 0xff]);
 1010 #endif
 1011 }
 1012 
 1013 static SLJIT_INLINE void check_sljit_emit_cmp(struct sljit_compiler *compiler, int type,
 1014     int src1, sljit_w src1w,
 1015     int src2, sljit_w src2w)
 1016 {
 1017     SLJIT_UNUSED_ARG(compiler);
 1018     SLJIT_UNUSED_ARG(type);
 1019     SLJIT_UNUSED_ARG(src1);
 1020     SLJIT_UNUSED_ARG(src1w);
 1021     SLJIT_UNUSED_ARG(src2);
 1022     SLJIT_UNUSED_ARG(src2w);
 1023 
 1024     SLJIT_ASSERT(!(type & ~(0xff | SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP)));
 1025     SLJIT_ASSERT((type & 0xff) >= SLJIT_C_EQUAL && (type & 0xff) <= SLJIT_C_SIG_LESS_EQUAL);
 1026 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1027     FUNCTION_CHECK_SRC(src1, src1w);
 1028     FUNCTION_CHECK_SRC(src2, src2w);
 1029 #endif
 1030 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 1031     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 1032         fprintf(compiler->verbose, "  %scmp%s <%s> ", !(type & SLJIT_INT_OP) ? "" : "i", !(type & SLJIT_REWRITABLE_JUMP) ? "" : "R", jump_names[type & 0xff]);
 1033         sljit_verbose_param(src1, src1w);
 1034         fprintf(compiler->verbose, ", ");
 1035         sljit_verbose_param(src2, src2w);
 1036         fprintf(compiler->verbose, "\n");
 1037     }
 1038 #endif
 1039 }
 1040 
 1041 static SLJIT_INLINE void check_sljit_emit_fcmp(struct sljit_compiler *compiler, int type,
 1042     int src1, sljit_w src1w,
 1043     int src2, sljit_w src2w)
 1044 {
 1045     SLJIT_UNUSED_ARG(compiler);
 1046     SLJIT_UNUSED_ARG(type);
 1047     SLJIT_UNUSED_ARG(src1);
 1048     SLJIT_UNUSED_ARG(src1w);
 1049     SLJIT_UNUSED_ARG(src2);
 1050     SLJIT_UNUSED_ARG(src2w);
 1051 
 1052     SLJIT_ASSERT(sljit_is_fpu_available());
 1053     SLJIT_ASSERT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP)));
 1054     SLJIT_ASSERT((type & 0xff) >= SLJIT_C_FLOAT_EQUAL && (type & 0xff) <= SLJIT_C_FLOAT_NOT_NAN);
 1055 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1056     FUNCTION_FCHECK(src1, src1w);
 1057     FUNCTION_FCHECK(src2, src2w);
 1058 #endif
 1059 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 1060     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 1061         fprintf(compiler->verbose, "  fcmp%s <%s> ", !(type & SLJIT_REWRITABLE_JUMP) ? "" : "R", jump_names[type & 0xff]);
 1062         sljit_verbose_fparam(src1, src1w);
 1063         fprintf(compiler->verbose, ", ");
 1064         sljit_verbose_fparam(src2, src2w);
 1065         fprintf(compiler->verbose, "\n");
 1066     }
 1067 #endif
 1068 }
 1069 
 1070 static SLJIT_INLINE void check_sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)
 1071 {
 1072     /* If debug and verbose are disabled, all arguments are unused. */
 1073     SLJIT_UNUSED_ARG(compiler);
 1074     SLJIT_UNUSED_ARG(type);
 1075     SLJIT_UNUSED_ARG(src);
 1076     SLJIT_UNUSED_ARG(srcw);
 1077 
 1078     SLJIT_ASSERT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);
 1079 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1080     FUNCTION_CHECK_SRC(src, srcw);
 1081 #endif
 1082 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 1083     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 1084         fprintf(compiler->verbose, "  ijump <%s> ", jump_names[type]);
 1085         sljit_verbose_param(src, srcw);
 1086         fprintf(compiler->verbose, "\n");
 1087     }
 1088 #endif
 1089 }
 1090 
 1091 static SLJIT_INLINE void check_sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)
 1092 {
 1093     /* If debug and verbose are disabled, all arguments are unused. */
 1094     SLJIT_UNUSED_ARG(compiler);
 1095     SLJIT_UNUSED_ARG(op);
 1096     SLJIT_UNUSED_ARG(dst);
 1097     SLJIT_UNUSED_ARG(dstw);
 1098     SLJIT_UNUSED_ARG(type);
 1099 
 1100     SLJIT_ASSERT(type >= SLJIT_C_EQUAL && type < SLJIT_JUMP);
 1101     SLJIT_ASSERT(op == SLJIT_MOV || GET_OPCODE(op) == SLJIT_OR);
 1102     SLJIT_ASSERT(GET_ALL_FLAGS(op) == 0 || GET_ALL_FLAGS(op) == SLJIT_SET_E || GET_ALL_FLAGS(op) == SLJIT_KEEP_FLAGS);
 1103 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1104     FUNCTION_CHECK_DST(dst, dstw);
 1105 #endif
 1106 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 1107     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 1108         fprintf(compiler->verbose, "  cond_set%s%s <%s> ", !(op & SLJIT_SET_E) ? "" : "E",
 1109             !(op & SLJIT_KEEP_FLAGS) ? "" : "K", op_names[GET_OPCODE(op)]);
 1110         sljit_verbose_param(dst, dstw);
 1111         fprintf(compiler->verbose, ", <%s>\n", jump_names[type]);
 1112     }
 1113 #endif
 1114 }
 1115 
 1116 static SLJIT_INLINE void check_sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w init_value)
 1117 {
 1118     /* If debug and verbose are disabled, all arguments are unused. */
 1119     SLJIT_UNUSED_ARG(compiler);
 1120     SLJIT_UNUSED_ARG(dst);
 1121     SLJIT_UNUSED_ARG(dstw);
 1122     SLJIT_UNUSED_ARG(init_value);
 1123 
 1124 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1125     FUNCTION_CHECK_DST(dst, dstw);
 1126 #endif
 1127 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 1128     if (SLJIT_UNLIKELY(!!compiler->verbose)) {
 1129         fprintf(compiler->verbose, "  const ");
 1130         sljit_verbose_param(dst, dstw);
 1131         fprintf(compiler->verbose, ", #%"SLJIT_PRINT_D"d\n", init_value);
 1132     }
 1133 #endif
 1134 }
 1135 
 1136 static SLJIT_INLINE int emit_mov_before_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)
 1137 {
 1138     /* Return if don't need to do anything. */
 1139     if (op == SLJIT_UNUSED)
 1140         return SLJIT_SUCCESS;
 1141 
 1142 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 1143     if (src == SLJIT_RETURN_REG && op == SLJIT_MOV)
 1144         return SLJIT_SUCCESS;
 1145 #else
 1146     if (src == SLJIT_RETURN_REG && (op == SLJIT_MOV || op == SLJIT_MOV_UI || op == SLJIT_MOV_SI))
 1147         return SLJIT_SUCCESS;
 1148 #endif
 1149 
 1150 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1151     compiler->skip_checks = 1;
 1152 #endif
 1153     return sljit_emit_op1(compiler, op, SLJIT_RETURN_REG, 0, src, srcw);
 1154 }
 1155 
 1156 /* CPU description section */
 1157 
 1158 #if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE)
 1159 #define SLJIT_CPUINFO_PART1 " 32bit ("
 1160 #elif (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 1161 #define SLJIT_CPUINFO_PART1 " 64bit ("
 1162 #else
 1163 #error "Internal error: CPU type info missing"
 1164 #endif
 1165 
 1166 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
 1167 #define SLJIT_CPUINFO_PART2 "little endian + "
 1168 #elif (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN)
 1169 #define SLJIT_CPUINFO_PART2 "big endian + "
 1170 #else
 1171 #error "Internal error: CPU type info missing"
 1172 #endif
 1173 
 1174 #if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED)
 1175 #define SLJIT_CPUINFO_PART3 "unaligned)"
 1176 #else
 1177 #define SLJIT_CPUINFO_PART3 "aligned)"
 1178 #endif
 1179 
 1180 #define SLJIT_CPUINFO SLJIT_CPUINFO_PART1 SLJIT_CPUINFO_PART2 SLJIT_CPUINFO_PART3
 1181 
 1182 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
 1183     #include "sljitNativeX86_common.c"
 1184 #elif (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
 1185     #include "sljitNativeX86_common.c"
 1186 #elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
 1187     #include "sljitNativeARM_v5.c"
 1188 #elif (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
 1189     #include "sljitNativeARM_v5.c"
 1190 #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
 1191     #include "sljitNativeARM_Thumb2.c"
 1192 #elif (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
 1193     #include "sljitNativePPC_common.c"
 1194 #elif (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
 1195     #include "sljitNativePPC_common.c"
 1196 #elif (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
 1197     #include "sljitNativeMIPS_common.c"
 1198 #endif
 1199 
 1200 #if !(defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
 1201 
 1202 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, int type,
 1203     int src1, sljit_w src1w,
 1204     int src2, sljit_w src2w)
 1205 {
 1206     /* Default compare for most architectures. */
 1207     int flags, tmp_src, condition;
 1208     sljit_w tmp_srcw;
 1209 
 1210     CHECK_ERROR_PTR();
 1211     check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);
 1212 
 1213     condition = type & 0xff;
 1214     if (SLJIT_UNLIKELY((src1 & SLJIT_IMM) && !(src2 & SLJIT_IMM))) {
 1215         /* Immediate is prefered as second argument by most architectures. */
 1216         switch (condition) {
 1217         case SLJIT_C_LESS:
 1218             condition = SLJIT_C_GREATER;
 1219             break;
 1220         case SLJIT_C_GREATER_EQUAL:
 1221             condition = SLJIT_C_LESS_EQUAL;
 1222             break;
 1223         case SLJIT_C_GREATER:
 1224             condition = SLJIT_C_LESS;
 1225             break;
 1226         case SLJIT_C_LESS_EQUAL:
 1227             condition = SLJIT_C_GREATER_EQUAL;
 1228             break;
 1229         case SLJIT_C_SIG_LESS:
 1230             condition = SLJIT_C_SIG_GREATER;
 1231             break;
 1232         case SLJIT_C_SIG_GREATER_EQUAL:
 1233             condition = SLJIT_C_SIG_LESS_EQUAL;
 1234             break;
 1235         case SLJIT_C_SIG_GREATER:
 1236             condition = SLJIT_C_SIG_LESS;
 1237             break;
 1238         case SLJIT_C_SIG_LESS_EQUAL:
 1239             condition = SLJIT_C_SIG_GREATER_EQUAL;
 1240             break;
 1241         }
 1242         type = condition | (type & (SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP));
 1243         tmp_src = src1;
 1244         src1 = src2;
 1245         src2 = tmp_src;
 1246         tmp_srcw = src1w;
 1247         src1w = src2w;
 1248         src2w = tmp_srcw;
 1249     }
 1250 
 1251     if (condition <= SLJIT_C_NOT_ZERO)
 1252         flags = SLJIT_SET_E;
 1253     else if (condition <= SLJIT_C_LESS_EQUAL)
 1254         flags = SLJIT_SET_U;
 1255     else
 1256         flags = SLJIT_SET_S;
 1257 
 1258 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1259     compiler->skip_checks = 1;
 1260 #endif
 1261     PTR_FAIL_IF(sljit_emit_op2(compiler, SLJIT_SUB | flags | (type & SLJIT_INT_OP),
 1262         SLJIT_UNUSED, 0, src1, src1w, src2, src2w));
 1263 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1264     compiler->skip_checks = 1;
 1265 #endif
 1266     return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
 1267 }
 1268 
 1269 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, int type,
 1270     int src1, sljit_w src1w,
 1271     int src2, sljit_w src2w)
 1272 {
 1273     int flags, condition;
 1274 
 1275     check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w);
 1276 
 1277     condition = type & 0xff;
 1278     if (condition <= SLJIT_C_FLOAT_NOT_EQUAL)
 1279         flags = SLJIT_SET_E;
 1280     else
 1281         flags = SLJIT_SET_S;
 1282 
 1283 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1284     compiler->skip_checks = 1;
 1285 #endif
 1286     sljit_emit_fop1(compiler, SLJIT_FCMP | flags, src1, src1w, src2, src2w);
 1287 
 1288 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 1289     compiler->skip_checks = 1;
 1290 #endif
 1291     return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
 1292 }
 1293 
 1294 #endif
 1295 
 1296 #else /* SLJIT_CONFIG_UNSUPPORTED */
 1297 
 1298 /* Empty function bodies for those machines, which are not (yet) supported. */
 1299 
 1300 SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char* sljit_get_platform_name()
 1301 {
 1302     return "unsupported";
 1303 }
 1304 
 1305 SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void)
 1306 {
 1307     SLJIT_ASSERT_STOP();
 1308     return NULL;
 1309 }
 1310 
 1311 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler)
 1312 {
 1313     SLJIT_UNUSED_ARG(compiler);
 1314     SLJIT_ASSERT_STOP();
 1315 }
 1316 
 1317 SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, int size)
 1318 {
 1319     SLJIT_UNUSED_ARG(compiler);
 1320     SLJIT_UNUSED_ARG(size);
 1321     SLJIT_ASSERT_STOP();
 1322     return NULL;
 1323 }
 1324 
 1325 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 1326 SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose)
 1327 {
 1328     SLJIT_UNUSED_ARG(compiler);
 1329     SLJIT_UNUSED_ARG(verbose);
 1330     SLJIT_ASSERT_STOP();
 1331 }
 1332 #endif
 1333 
 1334 SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
 1335 {
 1336     SLJIT_UNUSED_ARG(compiler);
 1337     SLJIT_ASSERT_STOP();
 1338     return NULL;
 1339 }
 1340 
 1341 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code)
 1342 {
 1343     SLJIT_UNUSED_ARG(code);
 1344     SLJIT_ASSERT_STOP();
 1345 }
 1346 
 1347 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
 1348 {
 1349     SLJIT_UNUSED_ARG(compiler);
 1350     SLJIT_UNUSED_ARG(args);
 1351     SLJIT_UNUSED_ARG(temporaries);
 1352     SLJIT_UNUSED_ARG(saveds);
 1353     SLJIT_UNUSED_ARG(local_size);
 1354     SLJIT_ASSERT_STOP();
 1355     return SLJIT_ERR_UNSUPPORTED;
 1356 }
 1357 
 1358 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)
 1359 {
 1360     SLJIT_UNUSED_ARG(compiler);
 1361     SLJIT_UNUSED_ARG(args);
 1362     SLJIT_UNUSED_ARG(temporaries);
 1363     SLJIT_UNUSED_ARG(saveds);
 1364     SLJIT_UNUSED_ARG(local_size);
 1365     SLJIT_ASSERT_STOP();
 1366 }
 1367 
 1368 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)
 1369 {
 1370     SLJIT_UNUSED_ARG(compiler);
 1371     SLJIT_UNUSED_ARG(op);
 1372     SLJIT_UNUSED_ARG(src);
 1373     SLJIT_UNUSED_ARG(srcw);
 1374     SLJIT_ASSERT_STOP();
 1375     return SLJIT_ERR_UNSUPPORTED;
 1376 }
 1377 
 1378 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)
 1379 {
 1380     SLJIT_UNUSED_ARG(compiler);
 1381     SLJIT_UNUSED_ARG(dst);
 1382     SLJIT_UNUSED_ARG(dstw);
 1383     SLJIT_UNUSED_ARG(args);
 1384     SLJIT_UNUSED_ARG(temporaries);
 1385     SLJIT_UNUSED_ARG(saveds);
 1386     SLJIT_UNUSED_ARG(local_size);
 1387     SLJIT_ASSERT_STOP();
 1388     return SLJIT_ERR_UNSUPPORTED;
 1389 }
 1390 
 1391 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
 1392 {
 1393     SLJIT_UNUSED_ARG(compiler);
 1394     SLJIT_UNUSED_ARG(src);
 1395     SLJIT_UNUSED_ARG(srcw);
 1396     SLJIT_ASSERT_STOP();
 1397     return SLJIT_ERR_UNSUPPORTED;
 1398 }
 1399 
 1400 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op0(struct sljit_compiler *compiler, int op)
 1401 {
 1402     SLJIT_UNUSED_ARG(compiler);
 1403     SLJIT_UNUSED_ARG(op);
 1404     SLJIT_ASSERT_STOP();
 1405     return SLJIT_ERR_UNSUPPORTED;
 1406 }
 1407 
 1408 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct sljit_compiler *compiler, int op,
 1409     int dst, sljit_w dstw,
 1410     int src, sljit_w srcw)
 1411 {
 1412     SLJIT_UNUSED_ARG(compiler);
 1413     SLJIT_UNUSED_ARG(op);
 1414     SLJIT_UNUSED_ARG(dst);
 1415     SLJIT_UNUSED_ARG(dstw);
 1416     SLJIT_UNUSED_ARG(src);
 1417     SLJIT_UNUSED_ARG(srcw);
 1418     SLJIT_ASSERT_STOP();
 1419     return SLJIT_ERR_UNSUPPORTED;
 1420 }
 1421 
 1422 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct sljit_compiler *compiler, int op,
 1423     int dst, sljit_w dstw,
 1424     int src1, sljit_w src1w,
 1425     int src2, sljit_w src2w)
 1426 {
 1427     SLJIT_UNUSED_ARG(compiler);
 1428     SLJIT_UNUSED_ARG(op);
 1429     SLJIT_UNUSED_ARG(dst);
 1430     SLJIT_UNUSED_ARG(dstw);
 1431     SLJIT_UNUSED_ARG(src1);
 1432     SLJIT_UNUSED_ARG(src1w);
 1433     SLJIT_UNUSED_ARG(src2);
 1434     SLJIT_UNUSED_ARG(src2w);
 1435     SLJIT_ASSERT_STOP();
 1436     return SLJIT_ERR_UNSUPPORTED;
 1437 }
 1438 
 1439 SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg)
 1440 {
 1441     SLJIT_ASSERT_STOP();
 1442     return reg;
 1443 }
 1444 
 1445 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op_custom(struct sljit_compiler *compiler,
 1446     void *instruction, int size)
 1447 {
 1448     SLJIT_UNUSED_ARG(compiler);
 1449     SLJIT_UNUSED_ARG(instruction);
 1450     SLJIT_UNUSED_ARG(size);
 1451     SLJIT_ASSERT_STOP();
 1452     return SLJIT_ERR_UNSUPPORTED;
 1453 }
 1454 
 1455 SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)
 1456 {
 1457     SLJIT_ASSERT_STOP();
 1458     return 0;
 1459 }
 1460 
 1461 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,
 1462     int dst, sljit_w dstw,
 1463     int src, sljit_w srcw)
 1464 {
 1465     SLJIT_UNUSED_ARG(compiler);
 1466     SLJIT_UNUSED_ARG(op);
 1467     SLJIT_UNUSED_ARG(dst);
 1468     SLJIT_UNUSED_ARG(dstw);
 1469     SLJIT_UNUSED_ARG(src);
 1470     SLJIT_UNUSED_ARG(srcw);
 1471     SLJIT_ASSERT_STOP();
 1472     return SLJIT_ERR_UNSUPPORTED;
 1473 }
 1474 
 1475 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,
 1476     int dst, sljit_w dstw,
 1477     int src1, sljit_w src1w,
 1478     int src2, sljit_w src2w)
 1479 {
 1480     SLJIT_UNUSED_ARG(compiler);
 1481     SLJIT_UNUSED_ARG(op);
 1482     SLJIT_UNUSED_ARG(dst);
 1483     SLJIT_UNUSED_ARG(dstw);
 1484     SLJIT_UNUSED_ARG(src1);
 1485     SLJIT_UNUSED_ARG(src1w);
 1486     SLJIT_UNUSED_ARG(src2);
 1487     SLJIT_UNUSED_ARG(src2w);
 1488     SLJIT_ASSERT_STOP();
 1489     return SLJIT_ERR_UNSUPPORTED;
 1490 }
 1491 
 1492 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
 1493 {
 1494     SLJIT_UNUSED_ARG(compiler);
 1495     SLJIT_ASSERT_STOP();
 1496     return NULL;
 1497 }
 1498 
 1499 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type)
 1500 {
 1501     SLJIT_UNUSED_ARG(compiler);
 1502     SLJIT_UNUSED_ARG(type);
 1503     SLJIT_ASSERT_STOP();
 1504     return NULL;
 1505 }
 1506 
 1507 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, int type,
 1508     int src1, sljit_w src1w,
 1509     int src2, sljit_w src2w)
 1510 {
 1511     SLJIT_UNUSED_ARG(compiler);
 1512     SLJIT_UNUSED_ARG(type);
 1513     SLJIT_UNUSED_ARG(src1);
 1514     SLJIT_UNUSED_ARG(src1w);
 1515     SLJIT_UNUSED_ARG(src2);
 1516     SLJIT_UNUSED_ARG(src2w);
 1517     SLJIT_ASSERT_STOP();
 1518     return NULL;
 1519 }
 1520 
 1521 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, int type,
 1522     int src1, sljit_w src1w,
 1523     int src2, sljit_w src2w)
 1524 {
 1525     SLJIT_UNUSED_ARG(compiler);
 1526     SLJIT_UNUSED_ARG(type);
 1527     SLJIT_UNUSED_ARG(src1);
 1528     SLJIT_UNUSED_ARG(src1w);
 1529     SLJIT_UNUSED_ARG(src2);
 1530     SLJIT_UNUSED_ARG(src2w);
 1531     SLJIT_ASSERT_STOP();
 1532     return NULL;
 1533 }
 1534 
 1535 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label)
 1536 {
 1537     SLJIT_UNUSED_ARG(jump);
 1538     SLJIT_UNUSED_ARG(label);
 1539     SLJIT_ASSERT_STOP();
 1540 }
 1541 
 1542 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target)
 1543 {
 1544     SLJIT_UNUSED_ARG(jump);
 1545     SLJIT_UNUSED_ARG(target);
 1546     SLJIT_ASSERT_STOP();
 1547 }
 1548 
 1549 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)
 1550 {
 1551     SLJIT_UNUSED_ARG(compiler);
 1552     SLJIT_UNUSED_ARG(type);
 1553     SLJIT_UNUSED_ARG(src);
 1554     SLJIT_UNUSED_ARG(srcw);
 1555     SLJIT_ASSERT_STOP();
 1556     return SLJIT_ERR_UNSUPPORTED;
 1557 }
 1558 
 1559 SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)
 1560 {
 1561     SLJIT_UNUSED_ARG(compiler);
 1562     SLJIT_UNUSED_ARG(op);
 1563     SLJIT_UNUSED_ARG(dst);
 1564     SLJIT_UNUSED_ARG(dstw);
 1565     SLJIT_UNUSED_ARG(type);
 1566     SLJIT_ASSERT_STOP();
 1567     return SLJIT_ERR_UNSUPPORTED;
 1568 }
 1569 
 1570 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w initval)
 1571 {
 1572     SLJIT_UNUSED_ARG(compiler);
 1573     SLJIT_UNUSED_ARG(dst);
 1574     SLJIT_UNUSED_ARG(dstw);
 1575     SLJIT_UNUSED_ARG(initval);
 1576     SLJIT_ASSERT_STOP();
 1577     return NULL;
 1578 }
 1579 
 1580 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)
 1581 {
 1582     SLJIT_UNUSED_ARG(addr);
 1583     SLJIT_UNUSED_ARG(new_addr);
 1584     SLJIT_ASSERT_STOP();
 1585 }
 1586 
 1587 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_w new_constant)
 1588 {
 1589     SLJIT_UNUSED_ARG(addr);
 1590     SLJIT_UNUSED_ARG(new_constant);
 1591     SLJIT_ASSERT_STOP();
 1592 }
 1593 
 1594 #endif