sljit_src/sljitLir.c

   1 /*
   2  *    Stack-less Just-In-Time compiler
   3  *
   4  *    Copyright 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 #ifdef _WIN32
  30
  31 #include <windows.h>
  32
  33 #endif /* _WIN32 */
  34
  35 #if !(defined SLJIT_STD_MACROS_DEFINED && SLJIT_STD_MACROS_DEFINED)
  36
  37 /* These libraries are needed for the macros below. */
  38 #include <stdlib.h>
  39 #include <string.h>
  40
  41 #endif /* SLJIT_STD_MACROS_DEFINED */
  42
  43 #define CHECK_ERROR() \
  44         do { \
  45                 if (SLJIT_UNLIKELY(compiler->error)) \
  46                         return compiler->error; \
  47         } while (0)
  48
  49 #define CHECK_ERROR_PTR() \
  50         do { \
  51                 if (SLJIT_UNLIKELY(compiler->error)) \
  52                         return NULL; \
  53         } while (0)
  54
  55 #define FAIL_IF(expr) \
  56         do { \
  57                 if (SLJIT_UNLIKELY(expr)) \
  58                         return compiler->error; \
  59         } while (0)
  60
  61 #define PTR_FAIL_IF(expr) \
  62         do { \
  63                 if (SLJIT_UNLIKELY(expr)) \
  64                         return NULL; \
  65         } while (0)
  66
  67 #define FAIL_IF_NULL(ptr) \
  68         do { \
  69                 if (SLJIT_UNLIKELY(!(ptr))) { \
  70                         compiler->error = SLJIT_ERR_ALLOC_FAILED; \
  71                         return SLJIT_ERR_ALLOC_FAILED; \
  72                 } \
  73         } while (0)
  74
  75 #define PTR_FAIL_IF_NULL(ptr) \
  76         do { \
  77                 if (SLJIT_UNLIKELY(!(ptr))) { \
  78                         compiler->error = SLJIT_ERR_ALLOC_FAILED; \
  79                         return NULL; \
  80                 } \
  81         } while (0)
  82
  83 #define PTR_FAIL_WITH_EXEC_IF(ptr) \
  84         do { \
  85                 if (SLJIT_UNLIKELY(!(ptr))) { \
  86                         compiler->error = SLJIT_ERR_EX_ALLOC_FAILED; \
  87                         return NULL; \
  88                 } \
  89         } while (0)
  90
  91 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
  92
  93 #define SSIZE_OF(type) ((sljit_s32)sizeof(sljit_ ## type))
  94
  95 #define VARIABLE_FLAG_SHIFT (10)
  96 #define VARIABLE_FLAG_MASK (0x3f << VARIABLE_FLAG_SHIFT)
  97 #define GET_FLAG_TYPE(op) ((op) >> VARIABLE_FLAG_SHIFT)
  98
  99 #define GET_OPCODE(op) \
 100         ((op) & ~(SLJIT_32 | SLJIT_SET_Z | VARIABLE_FLAG_MASK))
 101
 102 #define HAS_FLAGS(op) \
 103         ((op) & (SLJIT_SET_Z | VARIABLE_FLAG_MASK))
 104
 105 #define GET_ALL_FLAGS(op) \
 106         ((op) & (SLJIT_32 | SLJIT_SET_Z | VARIABLE_FLAG_MASK))
 107
 108 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 109 #define TYPE_CAST_NEEDED(op) \
 110         ((op) >= SLJIT_MOV_U8 && (op) <= SLJIT_MOV_S32)
 111 #else /* !SLJIT_64BIT_ARCHITECTURE */
 112 #define TYPE_CAST_NEEDED(op) \
 113         ((op) >= SLJIT_MOV_U8 && (op) <= SLJIT_MOV_S16)
 114 #endif /* SLJIT_64BIT_ARCHITECTURE */
 115
 116 #define BUF_SIZE        4096
 117
 118 #if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE)
 119 #define ABUF_SIZE       2048
 120 #else
 121 #define ABUF_SIZE       4096
 122 #endif
 123
 124 /* Parameter parsing. */
 125 #define REG_MASK                0x3f
 126 #define OFFS_REG(reg)           (((reg) >> 8) & REG_MASK)
 127 #define OFFS_REG_MASK           (REG_MASK << 8)
 128 #define TO_OFFS_REG(reg)        ((reg) << 8)
 129 /* When reg cannot be unused. */
 130 #define FAST_IS_REG(reg)        ((reg) <= REG_MASK)
 131
 132 /* Mask for argument types. */
 133 #define SLJIT_ARG_MASK          0x7
 134 #define SLJIT_ARG_FULL_MASK     (SLJIT_ARG_MASK | SLJIT_ARG_TYPE_SCRATCH_REG)
 135
 136 /* Mask for sljit_emit_enter. */
 137 #define SLJIT_KEPT_SAVEDS_COUNT(options) ((options) & 0x3)
 138
 139 /* Jump flags. */
 140 #define JUMP_LABEL      0x1
 141 #define JUMP_ADDR       0x2
 142 /* SLJIT_REWRITABLE_JUMP is 0x1000. */
 143
 144 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
 145 #       define PATCH_MB         0x4
 146 #       define PATCH_MW         0x8
 147 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
 148 #       define PATCH_MD         0x10
 149 #endif
 150 #       define TYPE_SHIFT       13
 151 #endif
 152
 153 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
 154 #       define IS_BL            0x4
 155 #       define PATCH_B          0x8
 156 #endif
 157
 158 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
 159 #       define CPOOL_SIZE       512
 160 #endif
 161
 162 #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
 163 #       define IS_COND          0x04
 164 #       define IS_BL            0x08
 165         /* conditional + imm8 */
 166 #       define PATCH_TYPE1      0x10
 167         /* conditional + imm20 */
 168 #       define PATCH_TYPE2      0x20
 169         /* IT + imm24 */
 170 #       define PATCH_TYPE3      0x30
 171         /* imm11 */
 172 #       define PATCH_TYPE4      0x40
 173         /* imm24 */
 174 #       define PATCH_TYPE5      0x50
 175         /* BL + imm24 */
 176 #       define PATCH_BL         0x60
 177         /* 0xf00 cc code for branches */
 178 #endif
 179
 180 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
 181 #       define IS_COND          0x004
 182 #       define IS_CBZ           0x008
 183 #       define IS_BL            0x010
 184 #       define PATCH_B          0x020
 185 #       define PATCH_COND       0x040
 186 #       define PATCH_ABS48      0x080
 187 #       define PATCH_ABS64      0x100
 188 #endif
 189
 190 #if (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
 191 #       define IS_COND          0x004
 192 #       define IS_CALL          0x008
 193 #       define PATCH_B          0x010
 194 #       define PATCH_ABS_B      0x020
 195 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
 196 #       define PATCH_ABS32      0x040
 197 #       define PATCH_ABS48      0x080
 198 #endif
 199 #       define REMOVE_COND      0x100
 200 #endif
 201
 202 #if (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)
 203 #       define IS_MOVABLE       0x004
 204 #       define IS_JAL           0x008
 205 #       define IS_CALL          0x010
 206 #       define IS_BIT26_COND    0x020
 207 #       define IS_BIT16_COND    0x040
 208 #       define IS_BIT23_COND    0x080
 209
 210 #       define IS_COND          (IS_BIT26_COND | IS_BIT16_COND | IS_BIT23_COND)
 211
 212 #       define PATCH_B          0x100
 213 #       define PATCH_J          0x200
 214
 215 #if (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64)
 216 #       define PATCH_ABS32      0x400
 217 #       define PATCH_ABS48      0x800
 218 #endif
 219
 220         /* instruction types */
 221 #       define MOVABLE_INS      0
 222         /* 1 - 31 last destination register */
 223         /* no destination (i.e: store) */
 224 #       define UNMOVABLE_INS    32
 225         /* FPU status register */
 226 #       define FCSR_FCC         33
 227 #endif
 228
 229 #if (defined SLJIT_CONFIG_RISCV && SLJIT_CONFIG_RISCV)
 230 #       define IS_COND          0x004
 231 #       define IS_CALL          0x008
 232
 233 #       define PATCH_B          0x010
 234 #       define PATCH_J          0x020
 235
 236 #if (defined SLJIT_CONFIG_RISCV_64 && SLJIT_CONFIG_RISCV_64)
 237 #       define PATCH_REL32      0x040
 238 #       define PATCH_ABS32      0x080
 239 #       define PATCH_ABS44      0x100
 240 #       define PATCH_ABS52      0x200
 241 #else /* !SLJIT_CONFIG_RISCV_64 */
 242 #       define PATCH_REL32      0x0
 243 #endif /* SLJIT_CONFIG_RISCV_64 */
 244 #endif
 245
 246 #if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
 247 #       define IS_MOVABLE       0x04
 248 #       define IS_COND          0x08
 249 #       define IS_CALL          0x10
 250
 251 #       define PATCH_B          0x20
 252 #       define PATCH_CALL       0x40
 253
 254         /* instruction types */
 255 #       define MOVABLE_INS      0
 256         /* 1 - 31 last destination register */
 257         /* no destination (i.e: store) */
 258 #       define UNMOVABLE_INS    32
 259
 260 #       define DST_INS_MASK     0xff
 261
 262         /* ICC_SET is the same as SET_FLAGS. */
 263 #       define ICC_IS_SET       (1 << 23)
 264 #       define FCC_IS_SET       (1 << 24)
 265 #endif
 266
 267 /* Stack management. */
 268
 269 #define GET_SAVED_REGISTERS_SIZE(scratches, saveds, extra) \
 270         (((scratches < SLJIT_NUMBER_OF_SCRATCH_REGISTERS ? 0 : (scratches - SLJIT_NUMBER_OF_SCRATCH_REGISTERS)) + \
 271                 (saveds) + (sljit_s32)(extra)) * (sljit_s32)sizeof(sljit_sw))
 272
 273 #define GET_SAVED_FLOAT_REGISTERS_SIZE(fscratches, fsaveds, size) \
 274         (((fscratches < SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS ? 0 : (fscratches - SLJIT_NUMBER_OF_SCRATCH_FLOAT_REGISTERS)) + \
 275                 (fsaveds)) * (sljit_s32)(size))
 276
 277 #define ADJUST_LOCAL_OFFSET(p, i) \
 278         if ((p) == (SLJIT_MEM1(SLJIT_SP))) \
 279                 (i) += SLJIT_LOCALS_OFFSET;
 280
 281 #endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */
 282
 283 /* Utils can still be used even if SLJIT_CONFIG_UNSUPPORTED is set. */
 284 #include "sljitUtils.c"
 285
 286 #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
 287
 288 #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
 289
 290 #if (defined SLJIT_PROT_EXECUTABLE_ALLOCATOR && SLJIT_PROT_EXECUTABLE_ALLOCATOR)
 291 #include "sljitProtExecAllocator.c"
 292 #elif (defined SLJIT_WX_EXECUTABLE_ALLOCATOR && SLJIT_WX_EXECUTABLE_ALLOCATOR)
 293 #include "sljitWXExecAllocator.c"
 294 #else
 295 #include "sljitExecAllocator.c"
 296 #endif
 297
 298 #endif
 299
 300 #if (defined SLJIT_PROT_EXECUTABLE_ALLOCATOR && SLJIT_PROT_EXECUTABLE_ALLOCATOR)
 301 #define SLJIT_ADD_EXEC_OFFSET(ptr, exec_offset) ((sljit_u8 *)(ptr) + (exec_offset))
 302 #else
 303 #define SLJIT_ADD_EXEC_OFFSET(ptr, exec_offset) ((sljit_u8 *)(ptr))
 304 #endif
 305
 306 #ifndef SLJIT_UPDATE_WX_FLAGS
 307 #define SLJIT_UPDATE_WX_FLAGS(from, to, enable_exec)
 308 #endif
 309
 310 /* Argument checking features. */
 311
 312 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
 313
 314 /* Returns with error when an invalid argument is passed. */
 315
 316 #define CHECK_ARGUMENT(x) \
 317         do { \
 318                 if (SLJIT_UNLIKELY(!(x))) \
 319                         return 1; \
 320         } while (0)
 321
 322 #define CHECK_RETURN_TYPE sljit_s32
 323 #define CHECK_RETURN_OK return 0
 324
 325 #define CHECK(x) \
 326         do { \
 327                 if (SLJIT_UNLIKELY(x)) { \
 328                         compiler->error = SLJIT_ERR_BAD_ARGUMENT; \
 329                         return SLJIT_ERR_BAD_ARGUMENT; \
 330                 } \
 331         } while (0)
 332
 333 #define CHECK_PTR(x) \
 334         do { \
 335                 if (SLJIT_UNLIKELY(x)) { \
 336                         compiler->error = SLJIT_ERR_BAD_ARGUMENT; \
 337                         return NULL; \
 338                 } \
 339         } while (0)
 340
 341 #define CHECK_REG_INDEX(x) \
 342         do { \
 343                 if (SLJIT_UNLIKELY(x)) { \
 344                         return -2; \
 345                 } \
 346         } while (0)
 347
 348 #elif (defined SLJIT_DEBUG && SLJIT_DEBUG)
 349
 350 /* Assertion failure occures if an invalid argument is passed. */
 351 #undef SLJIT_ARGUMENT_CHECKS
 352 #define SLJIT_ARGUMENT_CHECKS 1
 353
 354 #define CHECK_ARGUMENT(x) SLJIT_ASSERT(x)
 355 #define CHECK_RETURN_TYPE void
 356 #define CHECK_RETURN_OK return
 357 #define CHECK(x) x
 358 #define CHECK_PTR(x) x
 359 #define CHECK_REG_INDEX(x) x
 360
 361 #elif (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 362
 363 /* Arguments are not checked. */
 364 #define CHECK_RETURN_TYPE void
 365 #define CHECK_RETURN_OK return
 366 #define CHECK(x) x
 367 #define CHECK_PTR(x) x
 368 #define CHECK_REG_INDEX(x) x
 369
 370 #else
 371
 372 /* Arguments are not checked. */
 373 #define CHECK(x)
 374 #define CHECK_PTR(x)
 375 #define CHECK_REG_INDEX(x)
 376
 377 #endif /* SLJIT_ARGUMENT_CHECKS */
 378
 379 /* --------------------------------------------------------------------- */
 380 /*  Public functions                                                     */
 381 /* --------------------------------------------------------------------- */
 382
 383 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
 384 #define SLJIT_NEEDS_COMPILER_INIT 1
 385 static sljit_s32 compiler_initialized = 0;
 386 /* A thread safe initialization. */
 387 static void init_compiler(void);
 388 #endif
 389
 390 SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void *allocator_data, void *exec_allocator_data)
 391 {
 392         struct sljit_compiler *compiler = (struct sljit_compiler*)SLJIT_MALLOC(sizeof(struct sljit_compiler), allocator_data);
 393         if (!compiler)
 394                 return NULL;
 395         SLJIT_ZEROMEM(compiler, sizeof(struct sljit_compiler));
 396
 397         SLJIT_COMPILE_ASSERT(
 398                 sizeof(sljit_s8) == 1 && sizeof(sljit_u8) == 1
 399                 && sizeof(sljit_s16) == 2 && sizeof(sljit_u16) == 2
 400                 && sizeof(sljit_s32) == 4 && sizeof(sljit_u32) == 4
 401                 && (sizeof(sljit_p) == 4 || sizeof(sljit_p) == 8)
 402                 && sizeof(sljit_p) <= sizeof(sljit_sw)
 403                 && (sizeof(sljit_sw) == 4 || sizeof(sljit_sw) == 8)
 404                 && (sizeof(sljit_uw) == 4 || sizeof(sljit_uw) == 8),
 405                 invalid_integer_types);
 406         SLJIT_COMPILE_ASSERT(SLJIT_REWRITABLE_JUMP != SLJIT_32,
 407                 rewritable_jump_and_single_op_must_not_be_the_same);
 408         SLJIT_COMPILE_ASSERT(!(SLJIT_EQUAL & 0x1) && !(SLJIT_LESS & 0x1) && !(SLJIT_F_EQUAL & 0x1) && !(SLJIT_JUMP & 0x1),
 409                 conditional_flags_must_be_even_numbers);
 410
 411         /* Only the non-zero members must be set. */
 412         compiler->error = SLJIT_SUCCESS;
 413
 414         compiler->allocator_data = allocator_data;
 415         compiler->exec_allocator_data = exec_allocator_data;
 416         compiler->buf = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE, allocator_data);
 417         compiler->abuf = (struct sljit_memory_fragment*)SLJIT_MALLOC(ABUF_SIZE, allocator_data);
 418
 419         if (!compiler->buf || !compiler->abuf) {
 420                 if (compiler->buf)
 421                         SLJIT_FREE(compiler->buf, allocator_data);
 422                 if (compiler->abuf)
 423                         SLJIT_FREE(compiler->abuf, allocator_data);
 424                 SLJIT_FREE(compiler, allocator_data);
 425                 return NULL;
 426         }
 427
 428         compiler->buf->next = NULL;
 429         compiler->buf->used_size = 0;
 430         compiler->abuf->next = NULL;
 431         compiler->abuf->used_size = 0;
 432
 433         compiler->scratches = -1;
 434         compiler->saveds = -1;
 435         compiler->fscratches = -1;
 436         compiler->fsaveds = -1;
 437         compiler->local_size = -1;
 438
 439 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
 440         compiler->args_size = -1;
 441 #endif
 442
 443 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
 444         compiler->cpool = (sljit_uw*)SLJIT_MALLOC(CPOOL_SIZE * sizeof(sljit_uw)
 445                 + CPOOL_SIZE * sizeof(sljit_u8), allocator_data);
 446         if (!compiler->cpool) {
 447                 SLJIT_FREE(compiler->buf, allocator_data);
 448                 SLJIT_FREE(compiler->abuf, allocator_data);
 449                 SLJIT_FREE(compiler, allocator_data);
 450                 return NULL;
 451         }
 452         compiler->cpool_unique = (sljit_u8*)(compiler->cpool + CPOOL_SIZE);
 453         compiler->cpool_diff = 0xffffffff;
 454 #endif
 455
 456 #if (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)
 457         compiler->delay_slot = UNMOVABLE_INS;
 458 #endif
 459
 460 #if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)
 461         compiler->delay_slot = UNMOVABLE_INS;
 462 #endif
 463
 464 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
 465                 || (defined SLJIT_DEBUG && SLJIT_DEBUG)
 466         compiler->last_flags = 0;
 467         compiler->last_return = -1;
 468         compiler->logical_local_size = 0;
 469 #endif
 470
 471 #if (defined SLJIT_NEEDS_COMPILER_INIT && SLJIT_NEEDS_COMPILER_INIT)
 472         if (!compiler_initialized) {
 473                 init_compiler();
 474                 compiler_initialized = 1;
 475         }
 476 #endif
 477
 478         return compiler;
 479 }
 480
 481 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler)
 482 {
 483         struct sljit_memory_fragment *buf;
 484         struct sljit_memory_fragment *curr;
 485         void *allocator_data = compiler->allocator_data;
 486         SLJIT_UNUSED_ARG(allocator_data);
 487
 488         buf = compiler->buf;
 489         while (buf) {
 490                 curr = buf;
 491                 buf = buf->next;
 492                 SLJIT_FREE(curr, allocator_data);
 493         }
 494
 495         buf = compiler->abuf;
 496         while (buf) {
 497                 curr = buf;
 498                 buf = buf->next;
 499                 SLJIT_FREE(curr, allocator_data);
 500         }
 501
 502 #if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
 503         SLJIT_FREE(compiler->cpool, allocator_data);
 504 #endif
 505         SLJIT_FREE(compiler, allocator_data);
 506 }
 507
 508 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_compiler_memory_error(struct sljit_compiler *compiler)
 509 {
 510         if (compiler->error == SLJIT_SUCCESS)
 511                 compiler->error = SLJIT_ERR_ALLOC_FAILED;
 512 }
 513
 514 #if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
 515 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code, void *exec_allocator_data)
 516 {
 517         SLJIT_UNUSED_ARG(exec_allocator_data);
 518
 519         /* Remove thumb mode flag. */
 520         SLJIT_FREE_EXEC((void*)((sljit_uw)code & ~(sljit_uw)0x1), exec_allocator_data);
 521 }
 522 #elif (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
 523 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code, void *exec_allocator_data)
 524 {
 525         SLJIT_UNUSED_ARG(exec_allocator_data);
 526
 527         /* Resolve indirection. */
 528         code = (void*)(*(sljit_uw*)code);
 529         SLJIT_FREE_EXEC(code, exec_allocator_data);
 530 }
 531 #else
 532 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code, void *exec_allocator_data)
 533 {
 534         SLJIT_UNUSED_ARG(exec_allocator_data);
 535
 536         SLJIT_FREE_EXEC(code, exec_allocator_data);
 537 }
 538 #endif
 539
 540 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label)
 541 {
 542         if (SLJIT_LIKELY(!!jump) && SLJIT_LIKELY(!!label)) {
 543                 jump->flags &= (sljit_uw)~JUMP_ADDR;
 544                 jump->flags |= JUMP_LABEL;
 545                 jump->u.label = label;
 546         }
 547 }
 548
 549 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target)
 550 {
 551         if (SLJIT_LIKELY(!!jump)) {
 552                 jump->flags &= (sljit_uw)~JUMP_LABEL;
 553                 jump->flags |= JUMP_ADDR;
 554                 jump->u.target = target;
 555         }
 556 }
 557
 558 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_put_label(struct sljit_put_label *put_label, struct sljit_label *label)
 559 {
 560         if (SLJIT_LIKELY(!!put_label))
 561                 put_label->label = label;
 562 }
 563
 564 #define SLJIT_CURRENT_FLAGS_ALL \
 565         (SLJIT_CURRENT_FLAGS_32 | SLJIT_CURRENT_FLAGS_ADD | SLJIT_CURRENT_FLAGS_SUB | SLJIT_CURRENT_FLAGS_COMPARE)
 566
 567 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_current_flags(struct sljit_compiler *compiler, sljit_s32 current_flags)
 568 {
 569         SLJIT_UNUSED_ARG(compiler);
 570         SLJIT_UNUSED_ARG(current_flags);
 571
 572 #if (defined SLJIT_HAS_STATUS_FLAGS_STATE && SLJIT_HAS_STATUS_FLAGS_STATE)
 573         compiler->status_flags_state = current_flags;
 574 #endif
 575
 576 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
 577         compiler->last_flags = 0;
 578         if ((current_flags & ~(VARIABLE_FLAG_MASK | SLJIT_SET_Z | SLJIT_CURRENT_FLAGS_ALL)) == 0) {
 579                 compiler->last_flags = GET_FLAG_TYPE(current_flags) | (current_flags & (SLJIT_32 | SLJIT_SET_Z));
 580         }
 581 #endif
 582 }
 583
 584 /* --------------------------------------------------------------------- */
 585 /*  Private functions                                                    */
 586 /* --------------------------------------------------------------------- */
 587
 588 static void* ensure_buf(struct sljit_compiler *compiler, sljit_uw size)
 589 {
 590         sljit_u8 *ret;
 591         struct sljit_memory_fragment *new_frag;
 592
 593         SLJIT_ASSERT(size <= 256);
 594         if (compiler->buf->used_size + size <= (BUF_SIZE - (sljit_uw)SLJIT_OFFSETOF(struct sljit_memory_fragment, memory))) {
 595                 ret = compiler->buf->memory + compiler->buf->used_size;
 596                 compiler->buf->used_size += size;
 597                 return ret;
 598         }
 599         new_frag = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE, compiler->allocator_data);
 600         PTR_FAIL_IF_NULL(new_frag);
 601         new_frag->next = compiler->buf;
 602         compiler->buf = new_frag;
 603         new_frag->used_size = size;
 604         return new_frag->memory;
 605 }
 606
 607 static void* ensure_abuf(struct sljit_compiler *compiler, sljit_uw size)
 608 {
 609         sljit_u8 *ret;
 610         struct sljit_memory_fragment *new_frag;
 611
 612         SLJIT_ASSERT(size <= 256);
 613         if (compiler->abuf->used_size + size <= (ABUF_SIZE - (sljit_uw)SLJIT_OFFSETOF(struct sljit_memory_fragment, memory))) {
 614                 ret = compiler->abuf->memory + compiler->abuf->used_size;
 615                 compiler->abuf->used_size += size;
 616                 return ret;
 617         }
 618         new_frag = (struct sljit_memory_fragment*)SLJIT_MALLOC(ABUF_SIZE, compiler->allocator_data);
 619         PTR_FAIL_IF_NULL(new_frag);
 620         new_frag->next = compiler->abuf;
 621         compiler->abuf = new_frag;
 622         new_frag->used_size = size;
 623         return new_frag->memory;
 624 }
 625
 626 SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_s32 size)
 627 {
 628         CHECK_ERROR_PTR();
 629
 630 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 631         if (size <= 0 || size > 128)
 632                 return NULL;
 633         size = (size + 7) & ~7;
 634 #else
 635         if (size <= 0 || size > 64)
 636                 return NULL;
 637         size = (size + 3) & ~3;
 638 #endif
 639         return ensure_abuf(compiler, (sljit_uw)size);
 640 }
 641
 642 static SLJIT_INLINE void reverse_buf(struct sljit_compiler *compiler)
 643 {
 644         struct sljit_memory_fragment *buf = compiler->buf;
 645         struct sljit_memory_fragment *prev = NULL;
 646         struct sljit_memory_fragment *tmp;
 647
 648         do {
 649                 tmp = buf->next;
 650                 buf->next = prev;
 651                 prev = buf;
 652                 buf = tmp;
 653         } while (buf != NULL);
 654
 655         compiler->buf = prev;
 656 }
 657
 658 /* Only used in RISC architectures where the instruction size is constant */
 659 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) \
 660         && !(defined SLJIT_CONFIG_S390X && SLJIT_CONFIG_S390X)
 661
 662 static SLJIT_INLINE sljit_uw compute_next_addr(struct sljit_label *label, struct sljit_jump *jump,
 663         struct sljit_const *const_, struct sljit_put_label *put_label)
 664 {
 665         sljit_uw result = ~(sljit_uw)0;
 666
 667         if (label)
 668                 result = label->size;
 669
 670         if (jump && jump->addr < result)
 671                 result = jump->addr;
 672
 673         if (const_ && const_->addr < result)
 674                 result = const_->addr;
 675
 676         if (put_label && put_label->addr < result)
 677                 result = put_label->addr;
 678
 679         return result;
 680 }
 681
 682 #endif /* !SLJIT_CONFIG_X86 && !SLJIT_CONFIG_S390X */
 683
 684 static SLJIT_INLINE void set_emit_enter(struct sljit_compiler *compiler,
 685         sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds,
 686         sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
 687 {
 688         SLJIT_UNUSED_ARG(args);
 689         SLJIT_UNUSED_ARG(local_size);
 690
 691         compiler->options = options;
 692         compiler->scratches = scratches;
 693         compiler->saveds = saveds;
 694         compiler->fscratches = fscratches;
 695         compiler->fsaveds = fsaveds;
 696 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
 697         compiler->last_return = args & SLJIT_ARG_MASK;
 698         compiler->logical_local_size = local_size;
 699 #endif
 700 }
 701
 702 static SLJIT_INLINE void set_set_context(struct sljit_compiler *compiler,
 703         sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds,
 704         sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
 705 {
 706         SLJIT_UNUSED_ARG(args);
 707         SLJIT_UNUSED_ARG(local_size);
 708
 709         compiler->options = options;
 710         compiler->scratches = scratches;
 711         compiler->saveds = saveds;
 712         compiler->fscratches = fscratches;
 713         compiler->fsaveds = fsaveds;
 714 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
 715         compiler->last_return = args & SLJIT_ARG_MASK;
 716         compiler->logical_local_size = local_size;
 717 #endif
 718 }
 719
 720 static SLJIT_INLINE void set_label(struct sljit_label *label, struct sljit_compiler *compiler)
 721 {
 722         label->next = NULL;
 723         label->size = compiler->size;
 724         if (compiler->last_label)
 725                 compiler->last_label->next = label;
 726         else
 727                 compiler->labels = label;
 728         compiler->last_label = label;
 729 }
 730
 731 static SLJIT_INLINE void set_jump(struct sljit_jump *jump, struct sljit_compiler *compiler, sljit_u32 flags)
 732 {
 733         jump->next = NULL;
 734         jump->flags = flags;
 735         if (compiler->last_jump)
 736                 compiler->last_jump->next = jump;
 737         else
 738                 compiler->jumps = jump;
 739         compiler->last_jump = jump;
 740 }
 741
 742 static SLJIT_INLINE void set_const(struct sljit_const *const_, struct sljit_compiler *compiler)
 743 {
 744         const_->next = NULL;
 745         const_->addr = compiler->size;
 746         if (compiler->last_const)
 747                 compiler->last_const->next = const_;
 748         else
 749                 compiler->consts = const_;
 750         compiler->last_const = const_;
 751 }
 752
 753 static SLJIT_INLINE void set_put_label(struct sljit_put_label *put_label, struct sljit_compiler *compiler, sljit_uw offset)
 754 {
 755         put_label->next = NULL;
 756         put_label->label = NULL;
 757         put_label->addr = compiler->size - offset;
 758         put_label->flags = 0;
 759         if (compiler->last_put_label)
 760                 compiler->last_put_label->next = put_label;
 761         else
 762                 compiler->put_labels = put_label;
 763         compiler->last_put_label = put_label;
 764 }
 765
 766 #define ADDRESSING_DEPENDS_ON(exp, reg) \
 767         (((exp) & SLJIT_MEM) && (((exp) & REG_MASK) == reg || OFFS_REG(exp) == reg))
 768
 769 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
 770
 771 static sljit_s32 function_check_arguments(sljit_s32 arg_types, sljit_s32 scratches, sljit_s32 saveds, sljit_s32 fscratches)
 772 {
 773         sljit_s32 word_arg_count, scratch_arg_end, saved_arg_count, float_arg_count, curr_type;
 774
 775         curr_type = (arg_types & SLJIT_ARG_FULL_MASK);
 776
 777         if (curr_type >= SLJIT_ARG_TYPE_F64) {
 778                 if (curr_type > SLJIT_ARG_TYPE_F32 || fscratches == 0)
 779                         return 0;
 780         } else if (curr_type >= SLJIT_ARG_TYPE_W) {
 781                 if (scratches == 0)
 782                         return 0;
 783         }
 784
 785         arg_types >>= SLJIT_ARG_SHIFT;
 786
 787         word_arg_count = 0;
 788         scratch_arg_end = 0;
 789         saved_arg_count = 0;
 790         float_arg_count = 0;
 791         while (arg_types != 0) {
 792                 if (word_arg_count + float_arg_count >= 4)
 793                         return 0;
 794
 795                 curr_type = (arg_types & SLJIT_ARG_MASK);
 796
 797                 if (arg_types & SLJIT_ARG_TYPE_SCRATCH_REG) {
 798                         if (saveds == -1 || curr_type < SLJIT_ARG_TYPE_W || curr_type > SLJIT_ARG_TYPE_P)
 799                                 return 0;
 800
 801                         word_arg_count++;
 802                         scratch_arg_end = word_arg_count;
 803                 } else {
 804                         if (curr_type < SLJIT_ARG_TYPE_W || curr_type > SLJIT_ARG_TYPE_F32)
 805                                 return 0;
 806
 807                         if (curr_type < SLJIT_ARG_TYPE_F64) {
 808                                 word_arg_count++;
 809                                 saved_arg_count++;
 810                         } else
 811                                 float_arg_count++;
 812                 }
 813
 814                 arg_types >>= SLJIT_ARG_SHIFT;
 815         }
 816
 817         if (saveds == -1)
 818                 return (word_arg_count <= scratches && float_arg_count <= fscratches);
 819
 820         return (saved_arg_count <= saveds && scratch_arg_end <= scratches && float_arg_count <= fscratches);
 821 }
 822
 823 #define FUNCTION_CHECK_IS_REG(r) \
 824         (((r) >= SLJIT_R0 && (r) < (SLJIT_R0 + compiler->scratches)) \
 825         || ((r) > (SLJIT_S0 - compiler->saveds) && (r) <= SLJIT_S0))
 826
 827 #define FUNCTION_CHECK_IS_FREG(fr) \
 828         (((fr) >= SLJIT_FR0 && (fr) < (SLJIT_FR0 + compiler->fscratches)) \
 829         || ((fr) > (SLJIT_FS0 - compiler->fsaveds) && (fr) <= SLJIT_FS0))
 830
 831 #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
 832 #define CHECK_IF_VIRTUAL_REGISTER(p) ((p) <= SLJIT_S3 && (p) >= SLJIT_S8)
 833 #else
 834 #define CHECK_IF_VIRTUAL_REGISTER(p) 0
 835 #endif
 836
 837 static sljit_s32 function_check_src_mem(struct sljit_compiler *compiler, sljit_s32 p, sljit_sw i)
 838 {
 839         if (compiler->scratches == -1 || compiler->saveds == -1)
 840                 return 0;
 841
 842         if (!(p & SLJIT_MEM))
 843                 return 0;
 844
 845         if (!(!(p & REG_MASK) || FUNCTION_CHECK_IS_REG(p & REG_MASK)))
 846                 return 0;
 847
 848         if (CHECK_IF_VIRTUAL_REGISTER(p & REG_MASK))
 849                 return 0;
 850
 851         if (p & OFFS_REG_MASK) {
 852                 if (!(p & REG_MASK))
 853                         return 0;
 854
 855                 if (!(FUNCTION_CHECK_IS_REG(OFFS_REG(p))))
 856                         return 0;
 857
 858                 if (CHECK_IF_VIRTUAL_REGISTER(OFFS_REG(p)))
 859                         return 0;
 860
 861                 if ((i & ~0x3) != 0)
 862                         return 0;
 863         }
 864
 865         return (p & ~(SLJIT_MEM | REG_MASK | OFFS_REG_MASK)) == 0;
 866 }
 867
 868 #define FUNCTION_CHECK_SRC_MEM(p, i) \
 869         CHECK_ARGUMENT(function_check_src_mem(compiler, p, i));
 870
 871 static sljit_s32 function_check_src(struct sljit_compiler *compiler, sljit_s32 p, sljit_sw i)
 872 {
 873         if (compiler->scratches == -1 || compiler->saveds == -1)
 874                 return 0;
 875
 876         if (FUNCTION_CHECK_IS_REG(p))
 877                 return (i == 0);
 878
 879         if (p == SLJIT_IMM)
 880                 return 1;
 881
 882         if (p == SLJIT_MEM1(SLJIT_SP))
 883                 return (i >= 0 && i < compiler->logical_local_size);
 884
 885         return function_check_src_mem(compiler, p, i);
 886 }
 887
 888 #define FUNCTION_CHECK_SRC(p, i) \
 889         CHECK_ARGUMENT(function_check_src(compiler, p, i));
 890
 891 static sljit_s32 function_check_dst(struct sljit_compiler *compiler, sljit_s32 p, sljit_sw i)
 892 {
 893         if (compiler->scratches == -1 || compiler->saveds == -1)
 894                 return 0;
 895
 896         if (FUNCTION_CHECK_IS_REG(p))
 897                 return (i == 0);
 898
 899         if (p == SLJIT_MEM1(SLJIT_SP))
 900                 return (i >= 0 && i < compiler->logical_local_size);
 901
 902         return function_check_src_mem(compiler, p, i);
 903 }
 904
 905 #define FUNCTION_CHECK_DST(p, i) \
 906         CHECK_ARGUMENT(function_check_dst(compiler, p, i));
 907
 908 static sljit_s32 function_fcheck(struct sljit_compiler *compiler, sljit_s32 p, sljit_sw i)
 909 {
 910         if (compiler->scratches == -1 || compiler->saveds == -1)
 911                 return 0;
 912
 913         if (FUNCTION_CHECK_IS_FREG(p))
 914                 return (i == 0);
 915
 916         if (p == SLJIT_MEM1(SLJIT_SP))
 917                 return (i >= 0 && i < compiler->logical_local_size);
 918
 919         return function_check_src_mem(compiler, p, i);
 920 }
 921
 922 #define FUNCTION_FCHECK(p, i) \
 923         CHECK_ARGUMENT(function_fcheck(compiler, p, i));
 924
 925 #endif /* SLJIT_ARGUMENT_CHECKS */
 926
 927 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
 928
 929 SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose)
 930 {
 931         compiler->verbose = verbose;
 932 }
 933
 934 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
 935 #ifdef _WIN64
 936 #ifdef __GNUC__
 937 #       define SLJIT_PRINT_D    "ll"
 938 #else
 939 #       define SLJIT_PRINT_D    "I64"
 940 #endif
 941 #else
 942 #       define SLJIT_PRINT_D    "l"
 943 #endif
 944 #else
 945 #       define SLJIT_PRINT_D    ""
 946 #endif
 947
 948 static void sljit_verbose_reg(struct sljit_compiler *compiler, sljit_s32 r)
 949 {
 950         if (r < (SLJIT_R0 + compiler->scratches))
 951                 fprintf(compiler->verbose, "r%d", r - SLJIT_R0);
 952         else if (r != SLJIT_SP)
 953                 fprintf(compiler->verbose, "s%d", SLJIT_NUMBER_OF_REGISTERS - r);
 954         else
 955                 fprintf(compiler->verbose, "sp");
 956 }
 957
 958 static void sljit_verbose_freg(struct sljit_compiler *compiler, sljit_s32 r)
 959 {
 960         if (r < (SLJIT_FR0 + compiler->fscratches))
 961                 fprintf(compiler->verbose, "fr%d", r - SLJIT_FR0);
 962         else
 963                 fprintf(compiler->verbose, "fs%d", SLJIT_NUMBER_OF_FLOAT_REGISTERS - r);
 964 }
 965
 966 static void sljit_verbose_param(struct sljit_compiler *compiler, sljit_s32 p, sljit_sw i)
 967 {
 968         if ((p) & SLJIT_IMM)
 969                 fprintf(compiler->verbose, "#%" SLJIT_PRINT_D "d", (i));
 970         else if ((p) & SLJIT_MEM) {
 971                 if ((p) & REG_MASK) {
 972                         fputc('[', compiler->verbose);
 973                         sljit_verbose_reg(compiler, (p) & REG_MASK);
 974                         if ((p) & OFFS_REG_MASK) {
 975                                 fprintf(compiler->verbose, " + ");
 976                                 sljit_verbose_reg(compiler, OFFS_REG(p));
 977                                 if (i)
 978                                         fprintf(compiler->verbose, " * %d", 1 << (i));
 979                         }
 980                         else if (i)
 981                                 fprintf(compiler->verbose, " + %" SLJIT_PRINT_D "d", (i));
 982                         fputc(']', compiler->verbose);
 983                 }
 984                 else
 985                         fprintf(compiler->verbose, "[#%" SLJIT_PRINT_D "d]", (i));
 986         } else
 987                 sljit_verbose_reg(compiler, p);
 988 }
 989
 990 static void sljit_verbose_fparam(struct sljit_compiler *compiler, sljit_s32 p, sljit_sw i)
 991 {
 992         if ((p) & SLJIT_MEM) {
 993                 if ((p) & REG_MASK) {
 994                         fputc('[', compiler->verbose);
 995                         sljit_verbose_reg(compiler, (p) & REG_MASK);
 996                         if ((p) & OFFS_REG_MASK) {
 997                                 fprintf(compiler->verbose, " + ");
 998                                 sljit_verbose_reg(compiler, OFFS_REG(p));
 999                                 if (i)
1000                                         fprintf(compiler->verbose, "%d", 1 << (i));
1001                         }
1002                         else if (i)
1003                                 fprintf(compiler->verbose, " + %" SLJIT_PRINT_D "d", (i));
1004                         fputc(']', compiler->verbose);
1005                 }
1006                 else
1007                         fprintf(compiler->verbose, "[#%" SLJIT_PRINT_D "d]", (i));
1008         }
1009         else
1010                 sljit_verbose_freg(compiler, p);
1011 }
1012
1013 static const char* op0_names[] = {
1014         "breakpoint", "nop", "lmul.uw", "lmul.sw",
1015         "divmod.u", "divmod.s", "div.u", "div.s",
1016         "endbr", "skip_frames_before_return"
1017 };
1018
1019 static const char* op1_names[] = {
1020         "", ".u8", ".s8", ".u16",
1021         ".s16", ".u32", ".s32", "32",
1022         ".p", "not", "clz",
1023 };
1024
1025 static const char* op2_names[] = {
1026         "add", "addc", "sub", "subc",
1027         "mul", "and", "or", "xor",
1028         "shl", "lshr", "ashr",
1029 };
1030
1031 static const char* op_src_names[] = {
1032         "fast_return", "skip_frames_before_fast_return",
1033         "prefetch_l1", "prefetch_l2",
1034         "prefetch_l3", "prefetch_once",
1035 };
1036
1037 static const char* fop1_names[] = {
1038         "mov", "conv", "conv", "conv",
1039         "conv", "conv", "cmp", "neg",
1040         "abs",
1041 };
1042
1043 static const char* fop2_names[] = {
1044         "add", "sub", "mul", "div"
1045 };
1046
1047 static const char* jump_names[] = {
1048         "equal", "not_equal",
1049         "less", "greater_equal",
1050         "greater", "less_equal",
1051         "sig_less", "sig_greater_equal",
1052         "sig_greater", "sig_less_equal",
1053         "overflow", "not_overflow",
1054         "carry", "",
1055         "f_equal", "f_not_equal",
1056         "f_less", "f_greater_equal",
1057         "f_greater", "f_less_equal",
1058         "unordered", "ordered",
1059         "ordered_equal", "unordered_or_not_equal",
1060         "ordered_less", "unordered_or_greater_equal",
1061         "ordered_greater", "unordered_or_less_equal",
1062         "unordered_or_equal", "ordered_not_equal",
1063         "unordered_or_less", "ordered_greater_equal",
1064         "unordered_or_greater", "ordered_less_equal",
1065         "jump", "fast_call",
1066         "call", "call.cdecl"
1067 };
1068
1069 static const char* call_arg_names[] = {
1070         "void", "w", "32", "p", "f64", "f32"
1071 };
1072
1073 #endif /* SLJIT_VERBOSE */
1074
1075 /* --------------------------------------------------------------------- */
1076 /*  Arch dependent                                                       */
1077 /* --------------------------------------------------------------------- */
1078
1079 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
1080         || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1081
1082 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_generate_code(struct sljit_compiler *compiler)
1083 {
1084 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1085         struct sljit_jump *jump;
1086 #endif
1087
1088         SLJIT_UNUSED_ARG(compiler);
1089
1090 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1091         CHECK_ARGUMENT(compiler->size > 0);
1092         jump = compiler->jumps;
1093         while (jump) {
1094                 /* All jumps have target. */
1095                 CHECK_ARGUMENT(jump->flags & (JUMP_LABEL | JUMP_ADDR));
1096                 jump = jump->next;
1097         }
1098 #endif
1099         CHECK_RETURN_OK;
1100 }
1101
1102 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_enter(struct sljit_compiler *compiler,
1103         sljit_s32 options, sljit_s32 arg_types, sljit_s32 scratches, sljit_s32 saveds,
1104         sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
1105 {
1106         SLJIT_UNUSED_ARG(compiler);
1107
1108 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1109         CHECK_ARGUMENT(!(options & ~(SLJIT_ENTER_KEEP_S0 | SLJIT_ENTER_KEEP_S0_S1 | SLJIT_ENTER_CDECL)));
1110         CHECK_ARGUMENT(SLJIT_KEPT_SAVEDS_COUNT(options) <= 2 && SLJIT_KEPT_SAVEDS_COUNT(options) <= saveds);
1111         CHECK_ARGUMENT(scratches >= 0 && scratches <= SLJIT_NUMBER_OF_REGISTERS);
1112         CHECK_ARGUMENT(saveds >= 0 && saveds <= SLJIT_NUMBER_OF_SAVED_REGISTERS);
1113         CHECK_ARGUMENT(scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS);
1114         CHECK_ARGUMENT(fscratches >= 0 && fscratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
1115         CHECK_ARGUMENT(fsaveds >= 0 && fsaveds <= SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS);
1116         CHECK_ARGUMENT(fscratches + fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
1117         CHECK_ARGUMENT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
1118         CHECK_ARGUMENT((arg_types & SLJIT_ARG_FULL_MASK) < SLJIT_ARG_TYPE_F64);
1119         CHECK_ARGUMENT(function_check_arguments(arg_types, scratches, saveds - SLJIT_KEPT_SAVEDS_COUNT(options), fscratches));
1120
1121         compiler->last_flags = 0;
1122 #endif
1123 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1124         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1125                 fprintf(compiler->verbose, "  enter ret[%s", call_arg_names[arg_types & SLJIT_ARG_MASK]);
1126
1127                 arg_types >>= SLJIT_ARG_SHIFT;
1128                 if (arg_types) {
1129                         fprintf(compiler->verbose, "], args[");
1130                         do {
1131                                 fprintf(compiler->verbose, "%s%s", call_arg_names[arg_types & SLJIT_ARG_MASK],
1132                                         (arg_types & SLJIT_ARG_TYPE_SCRATCH_REG) ? "_r" : "");
1133                                 arg_types >>= SLJIT_ARG_SHIFT;
1134                                 if (arg_types)
1135                                         fprintf(compiler->verbose, ",");
1136                         } while (arg_types);
1137                 }
1138
1139                 fprintf(compiler->verbose, "],");
1140
1141                 if (options & SLJIT_ENTER_CDECL)
1142                         fprintf(compiler->verbose, " enter:cdecl,");
1143                 if (SLJIT_KEPT_SAVEDS_COUNT(options) > 0)
1144                         fprintf(compiler->verbose, " keep:%d,", SLJIT_KEPT_SAVEDS_COUNT(options));
1145
1146                 fprintf(compiler->verbose, "scratches:%d, saveds:%d, fscratches:%d, fsaveds:%d, local_size:%d\n",
1147                         scratches, saveds, fscratches, fsaveds, local_size);
1148         }
1149 #endif
1150         CHECK_RETURN_OK;
1151 }
1152
1153 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_set_context(struct sljit_compiler *compiler,
1154         sljit_s32 options, sljit_s32 arg_types, sljit_s32 scratches, sljit_s32 saveds,
1155         sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
1156 {
1157         SLJIT_UNUSED_ARG(compiler);
1158
1159 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1160         CHECK_ARGUMENT(!(options & ~(SLJIT_ENTER_KEEP_S0 | SLJIT_ENTER_KEEP_S0_S1 | SLJIT_ENTER_CDECL)));
1161         CHECK_ARGUMENT(SLJIT_KEPT_SAVEDS_COUNT(options) <= 2 && SLJIT_KEPT_SAVEDS_COUNT(options) <= saveds);
1162         CHECK_ARGUMENT(scratches >= 0 && scratches <= SLJIT_NUMBER_OF_REGISTERS);
1163         CHECK_ARGUMENT(saveds >= 0 && saveds <= SLJIT_NUMBER_OF_SAVED_REGISTERS);
1164         CHECK_ARGUMENT(scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS);
1165         CHECK_ARGUMENT(fscratches >= 0 && fscratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
1166         CHECK_ARGUMENT(fsaveds >= 0 && fsaveds <= SLJIT_NUMBER_OF_SAVED_FLOAT_REGISTERS);
1167         CHECK_ARGUMENT(fscratches + fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
1168         CHECK_ARGUMENT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
1169         CHECK_ARGUMENT((arg_types & SLJIT_ARG_FULL_MASK) < SLJIT_ARG_TYPE_F64);
1170         CHECK_ARGUMENT(function_check_arguments(arg_types, scratches, saveds - SLJIT_KEPT_SAVEDS_COUNT(options), fscratches));
1171
1172         compiler->last_flags = 0;
1173 #endif
1174 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1175         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1176                 fprintf(compiler->verbose, "  set_context ret[%s", call_arg_names[arg_types & SLJIT_ARG_MASK]);
1177
1178                 arg_types >>= SLJIT_ARG_SHIFT;
1179                 if (arg_types) {
1180                         fprintf(compiler->verbose, "], args[");
1181                         do {
1182                                 fprintf(compiler->verbose, "%s%s", call_arg_names[arg_types & SLJIT_ARG_MASK],
1183                                         (arg_types & SLJIT_ARG_TYPE_SCRATCH_REG) ? "_r" : "");
1184                                 arg_types >>= SLJIT_ARG_SHIFT;
1185                                 if (arg_types)
1186                                         fprintf(compiler->verbose, ",");
1187                         } while (arg_types);
1188                 }
1189
1190                 fprintf(compiler->verbose, "],");
1191
1192                 if (options & SLJIT_ENTER_CDECL)
1193                         fprintf(compiler->verbose, " enter:cdecl,");
1194                 if (SLJIT_KEPT_SAVEDS_COUNT(options) > 0)
1195                         fprintf(compiler->verbose, " keep:%d,", SLJIT_KEPT_SAVEDS_COUNT(options));
1196
1197                 fprintf(compiler->verbose, " scratches:%d, saveds:%d, fscratches:%d, fsaveds:%d, local_size:%d\n",
1198                         scratches, saveds, fscratches, fsaveds, local_size);
1199         }
1200 #endif
1201         CHECK_RETURN_OK;
1202 }
1203
1204 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_return_void(struct sljit_compiler *compiler)
1205 {
1206         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1207                 compiler->skip_checks = 0;
1208                 CHECK_RETURN_OK;
1209         }
1210
1211 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1212         CHECK_ARGUMENT(compiler->last_return == SLJIT_ARG_TYPE_VOID);
1213 #endif
1214
1215 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1216         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1217                 fprintf(compiler->verbose, "  return_void\n");
1218         }
1219 #endif
1220         CHECK_RETURN_OK;
1221 }
1222
1223 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw)
1224 {
1225 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1226         CHECK_ARGUMENT(compiler->scratches >= 0);
1227
1228         switch (compiler->last_return) {
1229         case SLJIT_ARG_TYPE_W:
1230                 CHECK_ARGUMENT(op >= SLJIT_MOV && op <= SLJIT_MOV_S32);
1231                 break;
1232         case SLJIT_ARG_TYPE_32:
1233                 CHECK_ARGUMENT(op == SLJIT_MOV32 || (op >= SLJIT_MOV32_U8 && op <= SLJIT_MOV32_S16));
1234                 break;
1235         case SLJIT_ARG_TYPE_P:
1236                 CHECK_ARGUMENT(op == SLJIT_MOV_P);
1237                 break;
1238         default:
1239                 /* Context not initialized, void, etc. */
1240                 CHECK_ARGUMENT(0);
1241                 break;
1242         }
1243         FUNCTION_CHECK_SRC(src, srcw);
1244         compiler->last_flags = 0;
1245 #endif
1246 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1247         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1248                 fprintf(compiler->verbose, "  return%s%s ", !(op & SLJIT_32) ? "" : "32",
1249                         op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE]);
1250                 sljit_verbose_param(compiler, src, srcw);
1251                 fprintf(compiler->verbose, "\n");
1252         }
1253 #endif
1254         CHECK_RETURN_OK;
1255 }
1256
1257 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
1258 {
1259 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1260         FUNCTION_CHECK_DST(dst, dstw);
1261         compiler->last_flags = 0;
1262 #endif
1263 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1264         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1265                 fprintf(compiler->verbose, "  fast_enter ");
1266                 sljit_verbose_param(compiler, dst, dstw);
1267                 fprintf(compiler->verbose, "\n");
1268         }
1269 #endif
1270         CHECK_RETURN_OK;
1271 }
1272
1273 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op)
1274 {
1275 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1276         CHECK_ARGUMENT((op >= SLJIT_BREAKPOINT && op <= SLJIT_LMUL_SW)
1277                 || ((op & ~SLJIT_32) >= SLJIT_DIVMOD_UW && (op & ~SLJIT_32) <= SLJIT_DIV_SW)
1278                 || (op >= SLJIT_ENDBR && op <= SLJIT_SKIP_FRAMES_BEFORE_RETURN));
1279         CHECK_ARGUMENT(GET_OPCODE(op) < SLJIT_LMUL_UW || GET_OPCODE(op) >= SLJIT_ENDBR || compiler->scratches >= 2);
1280         if ((GET_OPCODE(op) >= SLJIT_LMUL_UW && GET_OPCODE(op) <= SLJIT_DIV_SW) || op == SLJIT_SKIP_FRAMES_BEFORE_RETURN)
1281                 compiler->last_flags = 0;
1282 #endif
1283 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1284         if (SLJIT_UNLIKELY(!!compiler->verbose))
1285         {
1286                 fprintf(compiler->verbose, "  %s", op0_names[GET_OPCODE(op) - SLJIT_OP0_BASE]);
1287                 if (GET_OPCODE(op) >= SLJIT_DIVMOD_UW && GET_OPCODE(op) <= SLJIT_DIV_SW) {
1288                         fprintf(compiler->verbose, (op & SLJIT_32) ? "32" : "w");
1289                 }
1290                 fprintf(compiler->verbose, "\n");
1291         }
1292 #endif
1293         CHECK_RETURN_OK;
1294 }
1295
1296 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op1(struct sljit_compiler *compiler, sljit_s32 op,
1297         sljit_s32 dst, sljit_sw dstw,
1298         sljit_s32 src, sljit_sw srcw)
1299 {
1300         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1301                 compiler->skip_checks = 0;
1302                 CHECK_RETURN_OK;
1303         }
1304
1305 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1306         CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_CLZ);
1307
1308         switch (GET_OPCODE(op)) {
1309         case SLJIT_NOT:
1310                 /* Only SLJIT_32 and SLJIT_SET_Z are allowed. */
1311                 CHECK_ARGUMENT(!(op & VARIABLE_FLAG_MASK));
1312                 break;
1313         case SLJIT_MOV:
1314         case SLJIT_MOV_U32:
1315         case SLJIT_MOV_P:
1316                 /* Nothing allowed */
1317                 CHECK_ARGUMENT(!(op & (SLJIT_32 | SLJIT_SET_Z | VARIABLE_FLAG_MASK)));
1318                 break;
1319         default:
1320                 /* Only SLJIT_32 is allowed. */
1321                 CHECK_ARGUMENT(!(op & (SLJIT_SET_Z | VARIABLE_FLAG_MASK)));
1322                 break;
1323         }
1324
1325         FUNCTION_CHECK_DST(dst, dstw);
1326         FUNCTION_CHECK_SRC(src, srcw);
1327
1328         if (GET_OPCODE(op) >= SLJIT_NOT) {
1329                 CHECK_ARGUMENT(src != SLJIT_IMM);
1330                 compiler->last_flags = GET_FLAG_TYPE(op) | (op & (SLJIT_32 | SLJIT_SET_Z));
1331         }
1332 #endif
1333 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1334         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1335                 if (GET_OPCODE(op) <= SLJIT_MOV_P)
1336                 {
1337                         fprintf(compiler->verbose, "  mov%s%s ", !(op & SLJIT_32) ? "" : "32",
1338                                 op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE]);
1339                 }
1340                 else
1341                 {
1342                         fprintf(compiler->verbose, "  %s%s%s%s%s ", op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE], !(op & SLJIT_32) ? "" : "32",
1343                                 !(op & SLJIT_SET_Z) ? "" : ".z", !(op & VARIABLE_FLAG_MASK) ? "" : ".",
1344                                 !(op & VARIABLE_FLAG_MASK) ? "" : jump_names[GET_FLAG_TYPE(op)]);
1345                 }
1346
1347                 sljit_verbose_param(compiler, dst, dstw);
1348                 fprintf(compiler->verbose, ", ");
1349                 sljit_verbose_param(compiler, src, srcw);
1350                 fprintf(compiler->verbose, "\n");
1351         }
1352 #endif
1353         CHECK_RETURN_OK;
1354 }
1355
1356 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op2(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 unset,
1357         sljit_s32 dst, sljit_sw dstw,
1358         sljit_s32 src1, sljit_sw src1w,
1359         sljit_s32 src2, sljit_sw src2w)
1360 {
1361         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1362                 compiler->skip_checks = 0;
1363                 CHECK_RETURN_OK;
1364         }
1365
1366 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1367         CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_ADD && GET_OPCODE(op) <= SLJIT_ASHR);
1368
1369         switch (GET_OPCODE(op)) {
1370         case SLJIT_AND:
1371         case SLJIT_OR:
1372         case SLJIT_XOR:
1373         case SLJIT_SHL:
1374         case SLJIT_LSHR:
1375         case SLJIT_ASHR:
1376                 CHECK_ARGUMENT(!(op & VARIABLE_FLAG_MASK));
1377                 break;
1378         case SLJIT_MUL:
1379                 CHECK_ARGUMENT(!(op & SLJIT_SET_Z));
1380                 CHECK_ARGUMENT(!(op & VARIABLE_FLAG_MASK)
1381                         || GET_FLAG_TYPE(op) == SLJIT_OVERFLOW);
1382                 break;
1383         case SLJIT_ADD:
1384                 CHECK_ARGUMENT(!(op & VARIABLE_FLAG_MASK)
1385                         || GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY)
1386                         || GET_FLAG_TYPE(op) == SLJIT_OVERFLOW);
1387                 break;
1388         case SLJIT_SUB:
1389                 CHECK_ARGUMENT(!(op & VARIABLE_FLAG_MASK)
1390                         || (GET_FLAG_TYPE(op) >= SLJIT_LESS && GET_FLAG_TYPE(op) <= SLJIT_OVERFLOW)
1391                         || GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY));
1392                 break;
1393         case SLJIT_ADDC:
1394         case SLJIT_SUBC:
1395                 CHECK_ARGUMENT(!(op & VARIABLE_FLAG_MASK)
1396                         || GET_FLAG_TYPE(op) == GET_FLAG_TYPE(SLJIT_SET_CARRY));
1397                 CHECK_ARGUMENT((compiler->last_flags & 0xff) == GET_FLAG_TYPE(SLJIT_SET_CARRY));
1398                 CHECK_ARGUMENT((op & SLJIT_32) == (compiler->last_flags & SLJIT_32));
1399                 break;
1400         default:
1401                 SLJIT_UNREACHABLE();
1402                 break;
1403         }
1404
1405         if (unset) {
1406                 CHECK_ARGUMENT(HAS_FLAGS(op));
1407         } else {
1408                 FUNCTION_CHECK_DST(dst, dstw);
1409         }
1410         FUNCTION_CHECK_SRC(src1, src1w);
1411         FUNCTION_CHECK_SRC(src2, src2w);
1412         compiler->last_flags = GET_FLAG_TYPE(op) | (op & (SLJIT_32 | SLJIT_SET_Z));
1413 #endif
1414 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1415         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1416                 fprintf(compiler->verbose, "  %s%s%s%s%s ", op2_names[GET_OPCODE(op) - SLJIT_OP2_BASE], !(op & SLJIT_32) ? "" : "32",
1417                         !(op & SLJIT_SET_Z) ? "" : ".z", !(op & VARIABLE_FLAG_MASK) ? "" : ".",
1418                         !(op & VARIABLE_FLAG_MASK) ? "" : jump_names[GET_FLAG_TYPE(op)]);
1419                 if (unset)
1420                         fprintf(compiler->verbose, "unset");
1421                 else
1422                         sljit_verbose_param(compiler, dst, dstw);
1423                 fprintf(compiler->verbose, ", ");
1424                 sljit_verbose_param(compiler, src1, src1w);
1425                 fprintf(compiler->verbose, ", ");
1426                 sljit_verbose_param(compiler, src2, src2w);
1427                 fprintf(compiler->verbose, "\n");
1428         }
1429 #endif
1430         CHECK_RETURN_OK;
1431 }
1432
1433 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op_src(struct sljit_compiler *compiler, sljit_s32 op,
1434         sljit_s32 src, sljit_sw srcw)
1435 {
1436 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1437         CHECK_ARGUMENT(op >= SLJIT_FAST_RETURN && op <= SLJIT_PREFETCH_ONCE);
1438         FUNCTION_CHECK_SRC(src, srcw);
1439
1440         if (op == SLJIT_FAST_RETURN || op == SLJIT_SKIP_FRAMES_BEFORE_FAST_RETURN)
1441         {
1442                 CHECK_ARGUMENT(src != SLJIT_IMM);
1443                 compiler->last_flags = 0;
1444         }
1445         else if (op >= SLJIT_PREFETCH_L1 && op <= SLJIT_PREFETCH_ONCE)
1446         {
1447                 CHECK_ARGUMENT(src & SLJIT_MEM);
1448         }
1449 #endif
1450 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1451         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1452                 fprintf(compiler->verbose, "  %s ", op_src_names[op - SLJIT_OP_SRC_BASE]);
1453                 sljit_verbose_param(compiler, src, srcw);
1454                 fprintf(compiler->verbose, "\n");
1455         }
1456 #endif
1457         CHECK_RETURN_OK;
1458 }
1459
1460 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_register_index(sljit_s32 reg)
1461 {
1462         SLJIT_UNUSED_ARG(reg);
1463 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1464         CHECK_ARGUMENT(reg > 0 && reg <= SLJIT_NUMBER_OF_REGISTERS);
1465 #endif
1466         CHECK_RETURN_OK;
1467 }
1468
1469 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_float_register_index(sljit_s32 reg)
1470 {
1471         SLJIT_UNUSED_ARG(reg);
1472 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1473         CHECK_ARGUMENT(reg > 0 && reg <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
1474 #endif
1475         CHECK_RETURN_OK;
1476 }
1477
1478 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op_custom(struct sljit_compiler *compiler,
1479         void *instruction, sljit_u32 size)
1480 {
1481 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1482         sljit_u32 i;
1483 #endif
1484
1485         SLJIT_UNUSED_ARG(compiler);
1486
1487 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1488         CHECK_ARGUMENT(instruction);
1489
1490 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
1491         CHECK_ARGUMENT(size > 0 && size < 16);
1492 #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
1493         CHECK_ARGUMENT((size == 2 && (((sljit_sw)instruction) & 0x1) == 0)
1494                 || (size == 4 && (((sljit_sw)instruction) & 0x3) == 0));
1495 #elif (defined SLJIT_CONFIG_S390X && SLJIT_CONFIG_S390X)
1496         CHECK_ARGUMENT(size == 2 || size == 4 || size == 6);
1497 #else
1498         CHECK_ARGUMENT(size == 4 && (((sljit_sw)instruction) & 0x3) == 0);
1499 #endif
1500
1501         compiler->last_flags = 0;
1502 #endif
1503 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1504         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1505                 fprintf(compiler->verbose, "  op_custom");
1506                 for (i = 0; i < size; i++)
1507                         fprintf(compiler->verbose, " 0x%x", ((sljit_u8*)instruction)[i]);
1508                 fprintf(compiler->verbose, "\n");
1509         }
1510 #endif
1511         CHECK_RETURN_OK;
1512 }
1513
1514 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1(struct sljit_compiler *compiler, sljit_s32 op,
1515         sljit_s32 dst, sljit_sw dstw,
1516         sljit_s32 src, sljit_sw srcw)
1517 {
1518         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1519                 compiler->skip_checks = 0;
1520                 CHECK_RETURN_OK;
1521         }
1522
1523 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1524         CHECK_ARGUMENT(sljit_has_cpu_feature(SLJIT_HAS_FPU));
1525         CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_MOV_F64 && GET_OPCODE(op) <= SLJIT_ABS_F64);
1526         CHECK_ARGUMENT(!(op & (SLJIT_SET_Z | VARIABLE_FLAG_MASK)));
1527         FUNCTION_FCHECK(src, srcw);
1528         FUNCTION_FCHECK(dst, dstw);
1529 #endif
1530 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1531         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1532                 if (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_F32)
1533                         fprintf(compiler->verbose, "  %s%s ", fop1_names[SLJIT_CONV_F64_FROM_F32 - SLJIT_FOP1_BASE],
1534                                 (op & SLJIT_32) ? ".f32.from.f64" : ".f64.from.f32");
1535                 else
1536                         fprintf(compiler->verbose, "  %s%s ", fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE],
1537                                 (op & SLJIT_32) ? ".f32" : ".f64");
1538
1539                 sljit_verbose_fparam(compiler, dst, dstw);
1540                 fprintf(compiler->verbose, ", ");
1541                 sljit_verbose_fparam(compiler, src, srcw);
1542                 fprintf(compiler->verbose, "\n");
1543         }
1544 #endif
1545         CHECK_RETURN_OK;
1546 }
1547
1548 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_cmp(struct sljit_compiler *compiler, sljit_s32 op,
1549         sljit_s32 src1, sljit_sw src1w,
1550         sljit_s32 src2, sljit_sw src2w)
1551 {
1552 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1553         compiler->last_flags = GET_FLAG_TYPE(op) | (op & SLJIT_32);
1554 #endif
1555
1556         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1557                 compiler->skip_checks = 0;
1558                 CHECK_RETURN_OK;
1559         }
1560
1561 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1562         CHECK_ARGUMENT(sljit_has_cpu_feature(SLJIT_HAS_FPU));
1563         CHECK_ARGUMENT(GET_OPCODE(op) == SLJIT_CMP_F64);
1564         CHECK_ARGUMENT(!(op & SLJIT_SET_Z));
1565         CHECK_ARGUMENT((op & VARIABLE_FLAG_MASK)
1566                 || (GET_FLAG_TYPE(op) >= SLJIT_F_EQUAL && GET_FLAG_TYPE(op) <= SLJIT_ORDERED_LESS_EQUAL));
1567         FUNCTION_FCHECK(src1, src1w);
1568         FUNCTION_FCHECK(src2, src2w);
1569 #endif
1570 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1571         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1572                 fprintf(compiler->verbose, "  %s%s", fop1_names[SLJIT_CMP_F64 - SLJIT_FOP1_BASE], (op & SLJIT_32) ? ".f32" : ".f64");
1573                 if (op & VARIABLE_FLAG_MASK) {
1574                         fprintf(compiler->verbose, ".%s", jump_names[GET_FLAG_TYPE(op)]);
1575                 }
1576                 fprintf(compiler->verbose, " ");
1577                 sljit_verbose_fparam(compiler, src1, src1w);
1578                 fprintf(compiler->verbose, ", ");
1579                 sljit_verbose_fparam(compiler, src2, src2w);
1580                 fprintf(compiler->verbose, "\n");
1581         }
1582 #endif
1583         CHECK_RETURN_OK;
1584 }
1585
1586 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_conv_sw_from_f64(struct sljit_compiler *compiler, sljit_s32 op,
1587         sljit_s32 dst, sljit_sw dstw,
1588         sljit_s32 src, sljit_sw srcw)
1589 {
1590         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1591                 compiler->skip_checks = 0;
1592                 CHECK_RETURN_OK;
1593         }
1594
1595 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1596         CHECK_ARGUMENT(sljit_has_cpu_feature(SLJIT_HAS_FPU));
1597         CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_CONV_SW_FROM_F64 && GET_OPCODE(op) <= SLJIT_CONV_S32_FROM_F64);
1598         CHECK_ARGUMENT(!(op & (SLJIT_SET_Z | VARIABLE_FLAG_MASK)));
1599         FUNCTION_FCHECK(src, srcw);
1600         FUNCTION_CHECK_DST(dst, dstw);
1601 #endif
1602 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1603         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1604                 fprintf(compiler->verbose, "  %s%s.from%s ", fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE],
1605                         (GET_OPCODE(op) == SLJIT_CONV_S32_FROM_F64) ? ".s32" : ".sw",
1606                         (op & SLJIT_32) ? ".f32" : ".f64");
1607                 sljit_verbose_param(compiler, dst, dstw);
1608                 fprintf(compiler->verbose, ", ");
1609                 sljit_verbose_fparam(compiler, src, srcw);
1610                 fprintf(compiler->verbose, "\n");
1611         }
1612 #endif
1613         CHECK_RETURN_OK;
1614 }
1615
1616 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_conv_f64_from_sw(struct sljit_compiler *compiler, sljit_s32 op,
1617         sljit_s32 dst, sljit_sw dstw,
1618         sljit_s32 src, sljit_sw srcw)
1619 {
1620         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1621                 compiler->skip_checks = 0;
1622                 CHECK_RETURN_OK;
1623         }
1624
1625 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1626         CHECK_ARGUMENT(sljit_has_cpu_feature(SLJIT_HAS_FPU));
1627         CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_CONV_F64_FROM_SW && GET_OPCODE(op) <= SLJIT_CONV_F64_FROM_S32);
1628         CHECK_ARGUMENT(!(op & (SLJIT_SET_Z | VARIABLE_FLAG_MASK)));
1629         FUNCTION_CHECK_SRC(src, srcw);
1630         FUNCTION_FCHECK(dst, dstw);
1631 #endif
1632 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1633         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1634                 fprintf(compiler->verbose, "  %s%s.from%s ", fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE],
1635                         (op & SLJIT_32) ? ".f32" : ".f64",
1636                         (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_S32) ? ".s32" : ".sw");
1637                 sljit_verbose_fparam(compiler, dst, dstw);
1638                 fprintf(compiler->verbose, ", ");
1639                 sljit_verbose_param(compiler, src, srcw);
1640                 fprintf(compiler->verbose, "\n");
1641         }
1642 #endif
1643         CHECK_RETURN_OK;
1644 }
1645
1646 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop2(struct sljit_compiler *compiler, sljit_s32 op,
1647         sljit_s32 dst, sljit_sw dstw,
1648         sljit_s32 src1, sljit_sw src1w,
1649         sljit_s32 src2, sljit_sw src2w)
1650 {
1651 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1652         CHECK_ARGUMENT(sljit_has_cpu_feature(SLJIT_HAS_FPU));
1653         CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_ADD_F64 && GET_OPCODE(op) <= SLJIT_DIV_F64);
1654         CHECK_ARGUMENT(!(op & (SLJIT_SET_Z | VARIABLE_FLAG_MASK)));
1655         FUNCTION_FCHECK(src1, src1w);
1656         FUNCTION_FCHECK(src2, src2w);
1657         FUNCTION_FCHECK(dst, dstw);
1658 #endif
1659 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1660         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1661                 fprintf(compiler->verbose, "  %s%s ", fop2_names[GET_OPCODE(op) - SLJIT_FOP2_BASE], (op & SLJIT_32) ? ".f32" : ".f64");
1662                 sljit_verbose_fparam(compiler, dst, dstw);
1663                 fprintf(compiler->verbose, ", ");
1664                 sljit_verbose_fparam(compiler, src1, src1w);
1665                 fprintf(compiler->verbose, ", ");
1666                 sljit_verbose_fparam(compiler, src2, src2w);
1667                 fprintf(compiler->verbose, "\n");
1668         }
1669 #endif
1670         CHECK_RETURN_OK;
1671 }
1672
1673 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_label(struct sljit_compiler *compiler)
1674 {
1675         SLJIT_UNUSED_ARG(compiler);
1676
1677         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1678                 compiler->skip_checks = 0;
1679                 CHECK_RETURN_OK;
1680         }
1681
1682 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1683         compiler->last_flags = 0;
1684 #endif
1685
1686 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1687         if (SLJIT_UNLIKELY(!!compiler->verbose))
1688                 fprintf(compiler->verbose, "label:\n");
1689 #endif
1690         CHECK_RETURN_OK;
1691 }
1692
1693 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1694 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) \
1695         || (defined SLJIT_CONFIG_ARM && SLJIT_CONFIG_ARM)
1696 #define CHECK_UNORDERED(type, last_flags) \
1697         ((((type) & 0xff) == SLJIT_UNORDERED || ((type) & 0xff) == SLJIT_ORDERED) && \
1698                 ((last_flags) & 0xff) >= SLJIT_UNORDERED && ((last_flags) & 0xff) <= SLJIT_ORDERED_LESS_EQUAL)
1699 #else
1700 #define CHECK_UNORDERED(type, last_flags) 0
1701 #endif
1702 #endif /* SLJIT_ARGUMENT_CHECKS */
1703
1704 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type)
1705 {
1706         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1707                 compiler->skip_checks = 0;
1708                 CHECK_RETURN_OK;
1709         }
1710
1711 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1712         CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP)));
1713         CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_FAST_CALL);
1714
1715         if ((type & 0xff) < SLJIT_JUMP) {
1716                 if ((type & 0xff) <= SLJIT_NOT_ZERO)
1717                         CHECK_ARGUMENT(compiler->last_flags & SLJIT_SET_Z);
1718                 else if ((compiler->last_flags & 0xff) == SLJIT_CARRY) {
1719                         CHECK_ARGUMENT((type & 0xff) == SLJIT_CARRY || (type & 0xff) == SLJIT_NOT_CARRY);
1720                         compiler->last_flags = 0;
1721                 } else
1722                         CHECK_ARGUMENT((type & 0xff) == (compiler->last_flags & 0xff)
1723                                 || ((type & 0xff) == SLJIT_NOT_OVERFLOW && (compiler->last_flags & 0xff) == SLJIT_OVERFLOW)
1724                                 || CHECK_UNORDERED(type, compiler->last_flags));
1725         }
1726 #endif
1727 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1728         if (SLJIT_UNLIKELY(!!compiler->verbose))
1729                 fprintf(compiler->verbose, "  jump%s %s\n", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r",
1730                         jump_names[type & 0xff]);
1731 #endif
1732         CHECK_RETURN_OK;
1733 }
1734
1735 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_call(struct sljit_compiler *compiler, sljit_s32 type,
1736         sljit_s32 arg_types)
1737 {
1738 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1739         CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_CALL_RETURN)));
1740         CHECK_ARGUMENT((type & 0xff) == SLJIT_CALL || (type & 0xff) == SLJIT_CALL_CDECL);
1741         CHECK_ARGUMENT(function_check_arguments(arg_types, compiler->scratches, -1, compiler->fscratches));
1742
1743         if (type & SLJIT_CALL_RETURN) {
1744                 CHECK_ARGUMENT((arg_types & SLJIT_ARG_MASK) == compiler->last_return);
1745         }
1746 #endif
1747 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1748         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1749                 fprintf(compiler->verbose, "  %s%s%s ret[%s", jump_names[type & 0xff],
1750                         !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r",
1751                         !(type & SLJIT_CALL_RETURN) ? "" : ".ret",
1752                         call_arg_names[arg_types & SLJIT_ARG_MASK]);
1753
1754                 arg_types >>= SLJIT_ARG_SHIFT;
1755                 if (arg_types) {
1756                         fprintf(compiler->verbose, "], args[");
1757                         do {
1758                                 fprintf(compiler->verbose, "%s", call_arg_names[arg_types & SLJIT_ARG_MASK]);
1759                                 arg_types >>= SLJIT_ARG_SHIFT;
1760                                 if (arg_types)
1761                                         fprintf(compiler->verbose, ",");
1762                         } while (arg_types);
1763                 }
1764                 fprintf(compiler->verbose, "]\n");
1765         }
1766 #endif
1767         CHECK_RETURN_OK;
1768 }
1769
1770 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_cmp(struct sljit_compiler *compiler, sljit_s32 type,
1771         sljit_s32 src1, sljit_sw src1w,
1772         sljit_s32 src2, sljit_sw src2w)
1773 {
1774 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1775         CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_32)));
1776         CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_SIG_LESS_EQUAL);
1777         FUNCTION_CHECK_SRC(src1, src1w);
1778         FUNCTION_CHECK_SRC(src2, src2w);
1779         compiler->last_flags = 0;
1780 #endif
1781 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1782         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1783                 fprintf(compiler->verbose, "  cmp%s%s %s, ", (type & SLJIT_32) ? "32" : "",
1784                         !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r", jump_names[type & 0xff]);
1785                 sljit_verbose_param(compiler, src1, src1w);
1786                 fprintf(compiler->verbose, ", ");
1787                 sljit_verbose_param(compiler, src2, src2w);
1788                 fprintf(compiler->verbose, "\n");
1789         }
1790 #endif
1791         CHECK_RETURN_OK;
1792 }
1793
1794 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_s32 type,
1795         sljit_s32 src1, sljit_sw src1w,
1796         sljit_s32 src2, sljit_sw src2w)
1797 {
1798 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1799         CHECK_ARGUMENT(sljit_has_cpu_feature(SLJIT_HAS_FPU));
1800         CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_32)));
1801         CHECK_ARGUMENT((type & 0xff) >= SLJIT_F_EQUAL && (type & 0xff) <= SLJIT_ORDERED_LESS_EQUAL
1802                                 && ((type & 0xff) <= SLJIT_ORDERED || sljit_cmp_info(type & 0xff)));
1803         FUNCTION_FCHECK(src1, src1w);
1804         FUNCTION_FCHECK(src2, src2w);
1805         compiler->last_flags = 0;
1806 #endif
1807 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1808         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1809                 fprintf(compiler->verbose, "  fcmp%s%s %s, ", (type & SLJIT_32) ? ".f32" : ".f64",
1810                         !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r", jump_names[type & 0xff]);
1811                 sljit_verbose_fparam(compiler, src1, src1w);
1812                 fprintf(compiler->verbose, ", ");
1813                 sljit_verbose_fparam(compiler, src2, src2w);
1814                 fprintf(compiler->verbose, "\n");
1815         }
1816 #endif
1817         CHECK_RETURN_OK;
1818 }
1819
1820 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type,
1821         sljit_s32 src, sljit_sw srcw)
1822 {
1823         if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1824                 compiler->skip_checks = 0;
1825                 CHECK_RETURN_OK;
1826         }
1827
1828 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1829         CHECK_ARGUMENT(type >= SLJIT_JUMP && type <= SLJIT_FAST_CALL);
1830         FUNCTION_CHECK_SRC(src, srcw);
1831 #endif
1832 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1833         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1834                 fprintf(compiler->verbose, "  ijump.%s ", jump_names[type]);
1835                 sljit_verbose_param(compiler, src, srcw);
1836                 fprintf(compiler->verbose, "\n");
1837         }
1838 #endif
1839         CHECK_RETURN_OK;
1840 }
1841
1842 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_icall(struct sljit_compiler *compiler, sljit_s32 type,
1843         sljit_s32 arg_types,
1844         sljit_s32 src, sljit_sw srcw)
1845 {
1846 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1847         CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_CALL_RETURN)));
1848         CHECK_ARGUMENT((type & 0xff) == SLJIT_CALL || (type & 0xff) == SLJIT_CALL_CDECL);
1849         CHECK_ARGUMENT(function_check_arguments(arg_types, compiler->scratches, -1, compiler->fscratches));
1850         FUNCTION_CHECK_SRC(src, srcw);
1851
1852         if (type & SLJIT_CALL_RETURN) {
1853                 CHECK_ARGUMENT((arg_types & SLJIT_ARG_MASK) == compiler->last_return);
1854         }
1855 #endif
1856 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1857         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1858                 fprintf(compiler->verbose, "  i%s%s ret[%s", jump_names[type & 0xff],
1859                         !(type & SLJIT_CALL_RETURN) ? "" : ".ret",
1860                         call_arg_names[arg_types & SLJIT_ARG_MASK]);
1861
1862                 arg_types >>= SLJIT_ARG_SHIFT;
1863                 if (arg_types) {
1864                         fprintf(compiler->verbose, "], args[");
1865                         do {
1866                                 fprintf(compiler->verbose, "%s", call_arg_names[arg_types & SLJIT_ARG_MASK]);
1867                                 arg_types >>= SLJIT_ARG_SHIFT;
1868                                 if (arg_types)
1869                                         fprintf(compiler->verbose, ",");
1870                         } while (arg_types);
1871                 }
1872                 fprintf(compiler->verbose, "], ");
1873                 sljit_verbose_param(compiler, src, srcw);
1874                 fprintf(compiler->verbose, "\n");
1875         }
1876 #endif
1877         CHECK_RETURN_OK;
1878 }
1879
1880 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_s32 op,
1881         sljit_s32 dst, sljit_sw dstw,
1882         sljit_s32 type)
1883 {
1884 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1885         CHECK_ARGUMENT(type >= SLJIT_EQUAL && type <= SLJIT_ORDERED_LESS_EQUAL);
1886         CHECK_ARGUMENT(op == SLJIT_MOV || op == SLJIT_MOV32
1887                 || (GET_OPCODE(op) >= SLJIT_AND && GET_OPCODE(op) <= SLJIT_XOR));
1888         CHECK_ARGUMENT(!(op & VARIABLE_FLAG_MASK));
1889
1890         if (type <= SLJIT_NOT_ZERO)
1891                 CHECK_ARGUMENT(compiler->last_flags & SLJIT_SET_Z);
1892         else
1893                 CHECK_ARGUMENT(type == (compiler->last_flags & 0xff)
1894                         || (type == SLJIT_NOT_CARRY && (compiler->last_flags & 0xff) == SLJIT_CARRY)
1895                         || (type == SLJIT_NOT_OVERFLOW && (compiler->last_flags & 0xff) == SLJIT_OVERFLOW)
1896                         || CHECK_UNORDERED(type, compiler->last_flags));
1897
1898         FUNCTION_CHECK_DST(dst, dstw);
1899
1900         if (GET_OPCODE(op) >= SLJIT_ADD)
1901                 compiler->last_flags = GET_FLAG_TYPE(op) | (op & (SLJIT_32 | SLJIT_SET_Z));
1902 #endif
1903 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1904         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1905                 fprintf(compiler->verbose, "  flags.%s%s%s ",
1906                         GET_OPCODE(op) < SLJIT_OP2_BASE ? "mov" : op2_names[GET_OPCODE(op) - SLJIT_OP2_BASE],
1907                         GET_OPCODE(op) < SLJIT_OP2_BASE ? op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE] : ((op & SLJIT_32) ? "32" : ""),
1908                         !(op & SLJIT_SET_Z) ? "" : ".z");
1909                 sljit_verbose_param(compiler, dst, dstw);
1910                 fprintf(compiler->verbose, ", %s\n", jump_names[type]);
1911         }
1912 #endif
1913         CHECK_RETURN_OK;
1914 }
1915
1916 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_cmov(struct sljit_compiler *compiler, sljit_s32 type,
1917         sljit_s32 dst_reg,
1918         sljit_s32 src, sljit_sw srcw)
1919 {
1920 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1921         CHECK_ARGUMENT(type >= SLJIT_EQUAL && type <= SLJIT_ORDERED_LESS_EQUAL);
1922
1923         CHECK_ARGUMENT(compiler->scratches != -1 && compiler->saveds != -1);
1924         CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(dst_reg & ~SLJIT_32));
1925         if (src != SLJIT_IMM) {
1926                 CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(src));
1927                 CHECK_ARGUMENT(srcw == 0);
1928         }
1929
1930         if (type <= SLJIT_NOT_ZERO)
1931                 CHECK_ARGUMENT(compiler->last_flags & SLJIT_SET_Z);
1932         else
1933                 CHECK_ARGUMENT(type == (compiler->last_flags & 0xff)
1934                         || (type == SLJIT_NOT_CARRY && (compiler->last_flags & 0xff) == SLJIT_CARRY)
1935                         || (type == SLJIT_NOT_OVERFLOW && (compiler->last_flags & 0xff) == SLJIT_OVERFLOW)
1936                         || CHECK_UNORDERED(type, compiler->last_flags));
1937 #endif
1938 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1939         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1940                 fprintf(compiler->verbose, "  cmov%s %s, ",
1941                         !(dst_reg & SLJIT_32) ? "" : "32",
1942                         jump_names[type]);
1943                 sljit_verbose_reg(compiler, dst_reg & ~SLJIT_32);
1944                 fprintf(compiler->verbose, ", ");
1945                 sljit_verbose_param(compiler, src, srcw);
1946                 fprintf(compiler->verbose, "\n");
1947         }
1948 #endif
1949         CHECK_RETURN_OK;
1950 }
1951
1952 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_mem(struct sljit_compiler *compiler, sljit_s32 type,
1953         sljit_s32 reg,
1954         sljit_s32 mem, sljit_sw memw)
1955 {
1956 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1957         sljit_s32 allowed_flags;
1958
1959         CHECK_ARGUMENT((type & 0xff) >= SLJIT_MOV && (type & 0xff) <= SLJIT_MOV_P);
1960         CHECK_ARGUMENT(!(type & SLJIT_32) || ((type & 0xff) >= SLJIT_MOV_U8 && (type & 0xff) <= SLJIT_MOV_S16));
1961
1962         if (type & SLJIT_MEM_UNALIGNED) {
1963                 allowed_flags = SLJIT_MEM_ALIGNED_16 | SLJIT_MEM_ALIGNED_32;
1964
1965                 switch (type & 0xff) {
1966                 case SLJIT_MOV_U8:
1967                 case SLJIT_MOV_S8:
1968                 case SLJIT_MOV_U16:
1969                 case SLJIT_MOV_S16:
1970                         allowed_flags = 0;
1971                         break;
1972                 case SLJIT_MOV_U32:
1973                 case SLJIT_MOV_S32:
1974                 case SLJIT_MOV32:
1975                         allowed_flags = SLJIT_MEM_ALIGNED_16;
1976                         break;
1977                 }
1978                 CHECK_ARGUMENT((type & ~(0xff | SLJIT_32 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | allowed_flags)) == 0);
1979                 CHECK_ARGUMENT((type & (SLJIT_MEM_ALIGNED_16 | SLJIT_MEM_ALIGNED_32)) != (SLJIT_MEM_ALIGNED_16 | SLJIT_MEM_ALIGNED_32));
1980         } else {
1981                 CHECK_ARGUMENT((type & SLJIT_MEM_PRE) || (type & SLJIT_MEM_POST));
1982                 CHECK_ARGUMENT((type & (SLJIT_MEM_PRE | SLJIT_MEM_POST)) != (SLJIT_MEM_PRE | SLJIT_MEM_POST));
1983                 CHECK_ARGUMENT((type & ~(0xff | SLJIT_32 | SLJIT_MEM_STORE | SLJIT_MEM_SUPP | SLJIT_MEM_PRE | SLJIT_MEM_POST)) == 0);
1984                 CHECK_ARGUMENT((mem & REG_MASK) != 0 && (mem & REG_MASK) != reg);
1985         }
1986
1987         FUNCTION_CHECK_SRC_MEM(mem, memw);
1988         CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(reg));
1989 #endif
1990 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1991         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1992                 if (type & (SLJIT_MEM_PRE | SLJIT_MEM_POST)) {
1993                         if (type & SLJIT_MEM_SUPP)
1994                                 CHECK_RETURN_OK;
1995                         if (sljit_emit_mem(compiler, type | SLJIT_MEM_SUPP, reg, mem, memw) == SLJIT_ERR_UNSUPPORTED) {
1996                                 fprintf(compiler->verbose, "  // mem: unsupported form, no instructions are emitted");
1997                                 CHECK_RETURN_OK;
1998                         }
1999                 }
2000
2001                 if ((type & 0xff) == SLJIT_MOV32)
2002                         fprintf(compiler->verbose, "  mem32.%s",
2003                                 (type & SLJIT_MEM_STORE) ? "st" : "ld");
2004                 else
2005                         fprintf(compiler->verbose, "  mem%s.%s%s",
2006                                 !(type & SLJIT_32) ? "" : "32",
2007                                 (type & SLJIT_MEM_STORE) ? "st" : "ld",
2008                                 op1_names[(type & 0xff) - SLJIT_OP1_BASE]);
2009
2010                 if (type & SLJIT_MEM_UNALIGNED) {
2011                         printf(".un%s%s ", (type & SLJIT_MEM_ALIGNED_16) ? ".16" : "", (type & SLJIT_MEM_ALIGNED_32) ? ".32" : "");
2012                 } else
2013                         printf((type & SLJIT_MEM_PRE) ? ".pre " : ".post ");
2014                 sljit_verbose_reg(compiler, reg);
2015                 fprintf(compiler->verbose, ", ");
2016                 sljit_verbose_param(compiler, mem, memw);
2017                 fprintf(compiler->verbose, "\n");
2018         }
2019 #endif
2020         CHECK_RETURN_OK;
2021 }
2022
2023 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fmem(struct sljit_compiler *compiler, sljit_s32 type,
2024         sljit_s32 freg,
2025         sljit_s32 mem, sljit_sw memw)
2026 {
2027 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2028         CHECK_ARGUMENT((type & 0xff) == SLJIT_MOV_F64);
2029         if (type & SLJIT_MEM_UNALIGNED) {
2030                 CHECK_ARGUMENT((type & ~(0xff | SLJIT_32 | SLJIT_MEM_STORE | SLJIT_MEM_UNALIGNED | SLJIT_MEM_ALIGNED_16 | (type & SLJIT_32 ? 0 : SLJIT_MEM_ALIGNED_32))) == 0);
2031                 CHECK_ARGUMENT((type & (SLJIT_MEM_ALIGNED_16 | SLJIT_MEM_ALIGNED_32)) != (SLJIT_MEM_ALIGNED_16 | SLJIT_MEM_ALIGNED_32));
2032         } else {
2033                 CHECK_ARGUMENT((type & SLJIT_MEM_PRE) || (type & SLJIT_MEM_POST));
2034                 CHECK_ARGUMENT((type & (SLJIT_MEM_PRE | SLJIT_MEM_POST)) != (SLJIT_MEM_PRE | SLJIT_MEM_POST));
2035                 CHECK_ARGUMENT((type & ~(0xff | SLJIT_32 | SLJIT_MEM_STORE | SLJIT_MEM_SUPP | SLJIT_MEM_PRE | SLJIT_MEM_POST)) == 0);
2036         }
2037
2038         FUNCTION_CHECK_SRC_MEM(mem, memw);
2039         CHECK_ARGUMENT(FUNCTION_CHECK_IS_FREG(freg));
2040 #endif
2041 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2042         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
2043                 if (type & (SLJIT_MEM_PRE | SLJIT_MEM_POST)) {
2044                         if (type & SLJIT_MEM_SUPP)
2045                                 CHECK_RETURN_OK;
2046                         if (sljit_emit_fmem(compiler, type | SLJIT_MEM_SUPP, freg, mem, memw) == SLJIT_ERR_UNSUPPORTED) {
2047                                 fprintf(compiler->verbose, "  // fmem: unsupported form, no instructions are emitted");
2048                                 CHECK_RETURN_OK;
2049                         }
2050                 }
2051
2052                 fprintf(compiler->verbose, "  fmem.%s%s",
2053                         (type & SLJIT_MEM_STORE) ? "st" : "ld",
2054                         !(type & SLJIT_32) ? ".f64" : ".f32");
2055
2056                 if (type & SLJIT_MEM_UNALIGNED) {
2057                         printf(".un%s%s ", (type & SLJIT_MEM_ALIGNED_16) ? ".16" : "", (type & SLJIT_MEM_ALIGNED_32) ? ".32" : "");
2058                 } else
2059                         printf((type & SLJIT_MEM_PRE) ? ".pre " : ".post ");
2060                 sljit_verbose_freg(compiler, freg);
2061                 fprintf(compiler->verbose, ", ");
2062                 sljit_verbose_param(compiler, mem, memw);
2063                 fprintf(compiler->verbose, "\n");
2064         }
2065 #endif
2066         CHECK_RETURN_OK;
2067 }
2068
2069 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_local_base(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw offset)
2070 {
2071         /* Any offset is allowed. */
2072         SLJIT_UNUSED_ARG(offset);
2073
2074 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2075         FUNCTION_CHECK_DST(dst, dstw);
2076 #endif
2077 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2078         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
2079                 fprintf(compiler->verbose, "  local_base ");
2080                 sljit_verbose_param(compiler, dst, dstw);
2081                 fprintf(compiler->verbose, ", #%" SLJIT_PRINT_D "d\n", offset);
2082         }
2083 #endif
2084         CHECK_RETURN_OK;
2085 }
2086
2087 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw init_value)
2088 {
2089         SLJIT_UNUSED_ARG(init_value);
2090
2091 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2092         FUNCTION_CHECK_DST(dst, dstw);
2093 #endif
2094 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2095         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
2096                 fprintf(compiler->verbose, "  const ");
2097                 sljit_verbose_param(compiler, dst, dstw);
2098                 fprintf(compiler->verbose, ", #%" SLJIT_PRINT_D "d\n", init_value);
2099         }
2100 #endif
2101         CHECK_RETURN_OK;
2102 }
2103
2104 static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_put_label(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
2105 {
2106 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2107         FUNCTION_CHECK_DST(dst, dstw);
2108 #endif
2109 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2110         if (SLJIT_UNLIKELY(!!compiler->verbose)) {
2111                 fprintf(compiler->verbose, "  put_label ");
2112                 sljit_verbose_param(compiler, dst, dstw);
2113                 fprintf(compiler->verbose, "\n");
2114         }
2115 #endif
2116         CHECK_RETURN_OK;
2117 }
2118
2119 #endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_VERBOSE */
2120
2121 #define SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw) \
2122         SLJIT_COMPILE_ASSERT(!(SLJIT_CONV_SW_FROM_F64 & 0x1) && !(SLJIT_CONV_F64_FROM_SW & 0x1), \
2123                 invalid_float_opcodes); \
2124         if (GET_OPCODE(op) >= SLJIT_CONV_SW_FROM_F64 && GET_OPCODE(op) <= SLJIT_CMP_F64) { \
2125                 if (GET_OPCODE(op) == SLJIT_CMP_F64) { \
2126                         CHECK(check_sljit_emit_fop1_cmp(compiler, op, dst, dstw, src, srcw)); \
2127                         ADJUST_LOCAL_OFFSET(dst, dstw); \
2128                         ADJUST_LOCAL_OFFSET(src, srcw); \
2129                         return sljit_emit_fop1_cmp(compiler, op, dst, dstw, src, srcw); \
2130                 } \
2131                 if ((GET_OPCODE(op) | 0x1) == SLJIT_CONV_S32_FROM_F64) { \
2132                         CHECK(check_sljit_emit_fop1_conv_sw_from_f64(compiler, op, dst, dstw, src, srcw)); \
2133                         ADJUST_LOCAL_OFFSET(dst, dstw); \
2134                         ADJUST_LOCAL_OFFSET(src, srcw); \
2135                         return sljit_emit_fop1_conv_sw_from_f64(compiler, op, dst, dstw, src, srcw); \
2136                 } \
2137                 CHECK(check_sljit_emit_fop1_conv_f64_from_sw(compiler, op, dst, dstw, src, srcw)); \
2138                 ADJUST_LOCAL_OFFSET(dst, dstw); \
2139                 ADJUST_LOCAL_OFFSET(src, srcw); \
2140                 return sljit_emit_fop1_conv_f64_from_sw(compiler, op, dst, dstw, src, srcw); \
2141         } \
2142         CHECK(check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw)); \
2143         ADJUST_LOCAL_OFFSET(dst, dstw); \
2144         ADJUST_LOCAL_OFFSET(src, srcw);
2145
2146 static SLJIT_INLINE sljit_s32 emit_mov_before_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw)
2147 {
2148 #if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2149         /* At the moment the pointer size is always equal to sljit_sw. May be changed in the future. */
2150         if (src == SLJIT_RETURN_REG && (op == SLJIT_MOV || op == SLJIT_MOV_P))
2151                 return SLJIT_SUCCESS;
2152 #else
2153         if (src == SLJIT_RETURN_REG && (op == SLJIT_MOV || op == SLJIT_MOV_U32 || op == SLJIT_MOV_S32 || op == SLJIT_MOV_P))
2154                 return SLJIT_SUCCESS;
2155 #endif
2156
2157 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
2158                 || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2159         compiler->skip_checks = 1;
2160 #endif
2161         return sljit_emit_op1(compiler, op, SLJIT_RETURN_REG, 0, src, srcw);
2162 }
2163
2164 #if !(defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC)
2165
2166 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw)
2167 {
2168         CHECK_ERROR();
2169         CHECK(check_sljit_emit_return(compiler, op, src, srcw));
2170
2171         FAIL_IF(emit_mov_before_return(compiler, op, src, srcw));
2172
2173 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
2174                 || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2175         compiler->skip_checks = 1;
2176 #endif
2177         return sljit_emit_return_void(compiler);
2178 }
2179
2180 #endif
2181
2182 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) \
2183                 || (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC) \
2184                 || (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) \
2185                 || ((defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) && !(defined SLJIT_MIPS_REV && SLJIT_MIPS_REV >= 1 && SLJIT_MIPS_REV < 6)) \
2186                 || (defined SLJIT_CONFIG_RISCV && SLJIT_CONFIG_RISCV)
2187
2188 static SLJIT_INLINE sljit_s32 sljit_emit_cmov_generic(struct sljit_compiler *compiler, sljit_s32 type,
2189         sljit_s32 dst_reg,
2190         sljit_s32 src, sljit_sw srcw)
2191 {
2192         struct sljit_label *label;
2193         struct sljit_jump *jump;
2194         sljit_s32 op = (dst_reg & SLJIT_32) ? SLJIT_MOV32 : SLJIT_MOV;
2195
2196 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2197                 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2198         compiler->skip_checks = 1;
2199 #endif
2200         jump = sljit_emit_jump(compiler, type ^ 0x1);
2201         FAIL_IF(!jump);
2202
2203 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2204                 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2205         compiler->skip_checks = 1;
2206 #endif
2207         FAIL_IF(sljit_emit_op1(compiler, op, dst_reg & ~SLJIT_32, 0, src, srcw));
2208
2209 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2210                 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2211         compiler->skip_checks = 1;
2212 #endif
2213         label = sljit_emit_label(compiler);
2214         FAIL_IF(!label);
2215         sljit_set_label(jump, label);
2216         return SLJIT_SUCCESS;
2217 }
2218
2219 #endif
2220
2221 #if (!(defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) || (defined SLJIT_MIPS_REV && SLJIT_MIPS_REV >= 6))
2222
2223 static sljit_s32 sljit_emit_mem_unaligned(struct sljit_compiler *compiler, sljit_s32 type,
2224         sljit_s32 reg,
2225         sljit_s32 mem, sljit_sw memw)
2226 {
2227 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
2228                 || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2229         compiler->skip_checks = 1;
2230 #endif
2231
2232         if (type & SLJIT_MEM_STORE)
2233                 return sljit_emit_op1(compiler, type & (0xff | SLJIT_32), mem, memw, reg, 0);
2234         return sljit_emit_op1(compiler, type & (0xff | SLJIT_32), reg, 0, mem, memw);
2235 }
2236
2237 static sljit_s32 sljit_emit_fmem_unaligned(struct sljit_compiler *compiler, sljit_s32 type,
2238         sljit_s32 freg,
2239         sljit_s32 mem, sljit_sw memw)
2240 {
2241 #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
2242                 || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2243         compiler->skip_checks = 1;
2244 #endif
2245
2246         if (type & SLJIT_MEM_STORE)
2247                 return sljit_emit_fop1(compiler, type & (0xff | SLJIT_32), mem, memw, freg, 0);
2248         return sljit_emit_fop1(compiler, type & (0xff | SLJIT_32), freg, 0, mem, memw);
2249 }
2250
2251 #endif
2252
2253 /* CPU description section */
2254
2255 #if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE)
2256 #define SLJIT_CPUINFO_PART1 " 32bit ("
2257 #elif (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE)
2258 #define SLJIT_CPUINFO_PART1 " 64bit ("
2259 #else
2260 #error "Internal error: CPU type info missing"
2261 #endif
2262
2263 #if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
2264 #define SLJIT_CPUINFO_PART2 "little endian + "
2265 #elif (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN)
2266 #define SLJIT_CPUINFO_PART2 "big endian + "
2267 #else
2268 #error "Internal error: CPU type info missing"
2269 #endif
2270
2271 #if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED)
2272 #define SLJIT_CPUINFO_PART3 "unaligned)"
2273 #else
2274 #define SLJIT_CPUINFO_PART3 "aligned)"
2275 #endif
2276
2277 #define SLJIT_CPUINFO SLJIT_CPUINFO_PART1 SLJIT_CPUINFO_PART2 SLJIT_CPUINFO_PART3
2278
2279 #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
2280 #       include "sljitNativeX86_common.c"
2281 #elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5)
2282 #       include "sljitNativeARM_32.c"
2283 #elif (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7)
2284 #       include "sljitNativeARM_32.c"
2285 #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
2286 #       include "sljitNativeARM_T2_32.c"
2287 #elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
2288 #       include "sljitNativeARM_64.c"
2289 #elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
2290 #       include "sljitNativePPC_common.c"
2291 #elif (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)
2292 #       include "sljitNativeMIPS_common.c"
2293 #elif (defined SLJIT_CONFIG_RISCV && SLJIT_CONFIG_RISCV)
2294 #       include "sljitNativeRISCV_common.c"
2295 #elif (defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC)
2296 #       include "sljitNativeSPARC_common.c"
2297 #elif (defined SLJIT_CONFIG_S390X && SLJIT_CONFIG_S390X)
2298 #       include "sljitNativeS390X.c"
2299 #endif
2300
2301 #if !(defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) \
2302         && !(defined SLJIT_CONFIG_RISCV && SLJIT_CONFIG_RISCV)
2303
2304 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_s32 type,
2305         sljit_s32 src1, sljit_sw src1w,
2306         sljit_s32 src2, sljit_sw src2w)
2307 {
2308         /* Default compare for most architectures. */
2309         sljit_s32 flags, tmp_src, condition;
2310         sljit_sw tmp_srcw;
2311
2312         CHECK_ERROR_PTR();
2313         CHECK_PTR(check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w));
2314
2315         condition = type & 0xff;
2316 #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
2317         if ((condition == SLJIT_EQUAL || condition == SLJIT_NOT_EQUAL)) {
2318                 if ((src1 & SLJIT_IMM) && !src1w) {
2319                         src1 = src2;
2320                         src1w = src2w;
2321                         src2 = SLJIT_IMM;
2322                         src2w = 0;
2323                 }
2324                 if ((src2 & SLJIT_IMM) && !src2w)
2325                         return emit_cmp_to0(compiler, type, src1, src1w);
2326         }
2327 #endif
2328
2329         if (SLJIT_UNLIKELY((src1 & SLJIT_IMM) && !(src2 & SLJIT_IMM))) {
2330                 /* Immediate is preferred as second argument by most architectures. */
2331                 switch (condition) {
2332                 case SLJIT_LESS:
2333                         condition = SLJIT_GREATER;
2334                         break;
2335                 case SLJIT_GREATER_EQUAL:
2336                         condition = SLJIT_LESS_EQUAL;
2337                         break;
2338                 case SLJIT_GREATER:
2339                         condition = SLJIT_LESS;
2340                         break;
2341                 case SLJIT_LESS_EQUAL:
2342                         condition = SLJIT_GREATER_EQUAL;
2343                         break;
2344                 case SLJIT_SIG_LESS:
2345                         condition = SLJIT_SIG_GREATER;
2346                         break;
2347                 case SLJIT_SIG_GREATER_EQUAL:
2348                         condition = SLJIT_SIG_LESS_EQUAL;
2349                         break;
2350                 case SLJIT_SIG_GREATER:
2351                         condition = SLJIT_SIG_LESS;
2352                         break;
2353                 case SLJIT_SIG_LESS_EQUAL:
2354                         condition = SLJIT_SIG_GREATER_EQUAL;
2355                         break;
2356                 }
2357
2358                 type = condition | (type & (SLJIT_32 | SLJIT_REWRITABLE_JUMP));
2359                 tmp_src = src1;
2360                 src1 = src2;
2361                 src2 = tmp_src;
2362                 tmp_srcw = src1w;
2363                 src1w = src2w;
2364                 src2w = tmp_srcw;
2365         }
2366
2367         if (condition <= SLJIT_NOT_ZERO)
2368                 flags = SLJIT_SET_Z;
2369         else
2370                 flags = condition << VARIABLE_FLAG_SHIFT;
2371
2372 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2373                 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2374         compiler->skip_checks = 1;
2375 #endif
2376         PTR_FAIL_IF(sljit_emit_op2u(compiler,
2377                 SLJIT_SUB | flags | (type & SLJIT_32), src1, src1w, src2, src2w));
2378 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2379                 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2380         compiler->skip_checks = 1;
2381 #endif
2382         return sljit_emit_jump(compiler, condition | (type & (SLJIT_REWRITABLE_JUMP | SLJIT_32)));
2383 }
2384
2385 #endif /* !SLJIT_CONFIG_MIPS */
2386
2387 #if (defined SLJIT_CONFIG_ARM && SLJIT_CONFIG_ARM)
2388
2389 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_cmp_info(sljit_s32 type)
2390 {
2391         if (type < SLJIT_UNORDERED || type > SLJIT_ORDERED_LESS_EQUAL)
2392                 return 0;
2393
2394         switch (type) {
2395         case SLJIT_UNORDERED_OR_EQUAL:
2396         case SLJIT_ORDERED_NOT_EQUAL:
2397                 return 0;
2398         }
2399
2400         return 1;
2401 }
2402
2403 #endif /* SLJIT_CONFIG_ARM */
2404
2405 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_s32 type,
2406         sljit_s32 src1, sljit_sw src1w,
2407         sljit_s32 src2, sljit_sw src2w)
2408 {
2409         CHECK_ERROR_PTR();
2410         CHECK_PTR(check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w));
2411
2412 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2413                 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2414         compiler->skip_checks = 1;
2415 #endif
2416         sljit_emit_fop1(compiler, SLJIT_CMP_F64 | ((type & 0xff) << VARIABLE_FLAG_SHIFT) | (type & SLJIT_32), src1, src1w, src2, src2w);
2417
2418 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2419                 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2420         compiler->skip_checks = 1;
2421 #endif
2422         return sljit_emit_jump(compiler, type);
2423 }
2424
2425 #if !(defined SLJIT_CONFIG_ARM && SLJIT_CONFIG_ARM) \
2426         && !(defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) \
2427         && !(defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
2428
2429 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_mem(struct sljit_compiler *compiler, sljit_s32 type,
2430         sljit_s32 reg,
2431         sljit_s32 mem, sljit_sw memw)
2432 {
2433         CHECK_ERROR();
2434         CHECK(check_sljit_emit_mem(compiler, type, reg, mem, memw));
2435
2436         if (type & (SLJIT_MEM_PRE | SLJIT_MEM_POST))
2437                 return SLJIT_ERR_UNSUPPORTED;
2438
2439         return sljit_emit_mem_unaligned(compiler, type, reg, mem, memw);
2440 }
2441
2442 #endif
2443
2444 #if !(defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) \
2445         && !(defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) \
2446         && !(defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC)
2447
2448 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fmem(struct sljit_compiler *compiler, sljit_s32 type,
2449         sljit_s32 freg,
2450         sljit_s32 mem, sljit_sw memw)
2451 {
2452         CHECK_ERROR();
2453         CHECK(check_sljit_emit_fmem(compiler, type, freg, mem, memw));
2454
2455         if (type & (SLJIT_MEM_PRE | SLJIT_MEM_POST))
2456                 return SLJIT_ERR_UNSUPPORTED;
2457
2458         return sljit_emit_fmem_unaligned(compiler, type, freg, mem, memw);
2459 }
2460
2461 #endif
2462
2463 #if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) \
2464         && !(defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
2465
2466 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_local_base(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw offset)
2467 {
2468         CHECK_ERROR();
2469         CHECK(check_sljit_get_local_base(compiler, dst, dstw, offset));
2470
2471         ADJUST_LOCAL_OFFSET(SLJIT_MEM1(SLJIT_SP), offset);
2472 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
2473                 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
2474         compiler->skip_checks = 1;
2475 #endif
2476         if (offset != 0)
2477                 return sljit_emit_op2(compiler, SLJIT_ADD, dst, dstw, SLJIT_SP, 0, SLJIT_IMM, offset);
2478         return sljit_emit_op1(compiler, SLJIT_MOV, dst, dstw, SLJIT_SP, 0);
2479 }
2480
2481 #endif
2482
2483 #else /* SLJIT_CONFIG_UNSUPPORTED */
2484
2485 /* Empty function bodies for those machines, which are not (yet) supported. */
2486
2487 SLJIT_API_FUNC_ATTRIBUTE const char* sljit_get_platform_name(void)
2488 {
2489         return "unsupported";
2490 }
2491
2492 SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void *allocator_data, void *exec_allocator_data)
2493 {
2494         SLJIT_UNUSED_ARG(allocator_data);
2495         SLJIT_UNUSED_ARG(exec_allocator_data);
2496         SLJIT_UNREACHABLE();
2497         return NULL;
2498 }
2499
2500 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler)
2501 {
2502         SLJIT_UNUSED_ARG(compiler);
2503         SLJIT_UNREACHABLE();
2504 }
2505
2506 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_compiler_memory_error(struct sljit_compiler *compiler)
2507 {
2508         SLJIT_UNUSED_ARG(compiler);
2509         SLJIT_UNREACHABLE();
2510 }
2511
2512 SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_s32 size)
2513 {
2514         SLJIT_UNUSED_ARG(compiler);
2515         SLJIT_UNUSED_ARG(size);
2516         SLJIT_UNREACHABLE();
2517         return NULL;
2518 }
2519
2520 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
2521 SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose)
2522 {
2523         SLJIT_UNUSED_ARG(compiler);
2524         SLJIT_UNUSED_ARG(verbose);
2525         SLJIT_UNREACHABLE();
2526 }
2527 #endif
2528
2529 SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
2530 {
2531         SLJIT_UNUSED_ARG(compiler);
2532         SLJIT_UNREACHABLE();
2533         return NULL;
2534 }
2535
2536 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_has_cpu_feature(sljit_s32 feature_type)
2537 {
2538         SLJIT_UNUSED_ARG(feature_type);
2539         SLJIT_UNREACHABLE();
2540         return 0;
2541 }
2542
2543 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_cmp_info(sljit_s32 type)
2544 {
2545         SLJIT_UNUSED_ARG(type);
2546         SLJIT_UNREACHABLE();
2547         return 0;
2548 }
2549
2550 SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code, void *exec_allocator_data)
2551 {
2552         SLJIT_UNUSED_ARG(code);
2553         SLJIT_UNUSED_ARG(exec_allocator_data);
2554         SLJIT_UNREACHABLE();
2555 }
2556
2557 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_enter(struct sljit_compiler *compiler,
2558         sljit_s32 options, sljit_s32 arg_types, sljit_s32 scratches, sljit_s32 saveds,
2559         sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
2560 {
2561         SLJIT_UNUSED_ARG(compiler);
2562         SLJIT_UNUSED_ARG(options);
2563         SLJIT_UNUSED_ARG(arg_types);
2564         SLJIT_UNUSED_ARG(scratches);
2565         SLJIT_UNUSED_ARG(saveds);
2566         SLJIT_UNUSED_ARG(fscratches);
2567         SLJIT_UNUSED_ARG(fsaveds);
2568         SLJIT_UNUSED_ARG(local_size);
2569         SLJIT_UNREACHABLE();
2570         return SLJIT_ERR_UNSUPPORTED;
2571 }
2572
2573 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_set_context(struct sljit_compiler *compiler,
2574         sljit_s32 options, sljit_s32 arg_types, sljit_s32 scratches, sljit_s32 saveds,
2575         sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
2576 {
2577         SLJIT_UNUSED_ARG(compiler);
2578         SLJIT_UNUSED_ARG(options);
2579         SLJIT_UNUSED_ARG(arg_types);
2580         SLJIT_UNUSED_ARG(scratches);
2581         SLJIT_UNUSED_ARG(saveds);
2582         SLJIT_UNUSED_ARG(fscratches);
2583         SLJIT_UNUSED_ARG(fsaveds);
2584         SLJIT_UNUSED_ARG(local_size);
2585         SLJIT_UNREACHABLE();
2586         return SLJIT_ERR_UNSUPPORTED;
2587 }
2588
2589 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw)
2590 {
2591         SLJIT_UNUSED_ARG(compiler);
2592         SLJIT_UNUSED_ARG(op);
2593         SLJIT_UNUSED_ARG(src);
2594         SLJIT_UNUSED_ARG(srcw);
2595         SLJIT_UNREACHABLE();
2596         return SLJIT_ERR_UNSUPPORTED;
2597 }
2598
2599 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return_void(struct sljit_compiler *compiler)
2600 {
2601         SLJIT_UNUSED_ARG(compiler);
2602         SLJIT_UNREACHABLE();
2603         return SLJIT_ERR_UNSUPPORTED;
2604 }
2605
2606 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
2607 {
2608         SLJIT_UNUSED_ARG(compiler);
2609         SLJIT_UNUSED_ARG(dst);
2610         SLJIT_UNUSED_ARG(dstw);
2611         SLJIT_UNREACHABLE();
2612         return SLJIT_ERR_UNSUPPORTED;
2613 }
2614
2615 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op)
2616 {
2617         SLJIT_UNUSED_ARG(compiler);
2618         SLJIT_UNUSED_ARG(op);
2619         SLJIT_UNREACHABLE();
2620         return SLJIT_ERR_UNSUPPORTED;
2621 }
2622
2623 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op1(struct sljit_compiler *compiler, sljit_s32 op,
2624         sljit_s32 dst, sljit_sw dstw,
2625         sljit_s32 src, sljit_sw srcw)
2626 {
2627         SLJIT_UNUSED_ARG(compiler);
2628         SLJIT_UNUSED_ARG(op);
2629         SLJIT_UNUSED_ARG(dst);
2630         SLJIT_UNUSED_ARG(dstw);
2631         SLJIT_UNUSED_ARG(src);
2632         SLJIT_UNUSED_ARG(srcw);
2633         SLJIT_UNREACHABLE();
2634         return SLJIT_ERR_UNSUPPORTED;
2635 }
2636
2637 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2(struct sljit_compiler *compiler, sljit_s32 op,
2638         sljit_s32 dst, sljit_sw dstw,
2639         sljit_s32 src1, sljit_sw src1w,
2640         sljit_s32 src2, sljit_sw src2w)
2641 {
2642         SLJIT_UNUSED_ARG(compiler);
2643         SLJIT_UNUSED_ARG(op);
2644         SLJIT_UNUSED_ARG(dst);
2645         SLJIT_UNUSED_ARG(dstw);
2646         SLJIT_UNUSED_ARG(src1);
2647         SLJIT_UNUSED_ARG(src1w);
2648         SLJIT_UNUSED_ARG(src2);
2649         SLJIT_UNUSED_ARG(src2w);
2650         SLJIT_UNREACHABLE();
2651         return SLJIT_ERR_UNSUPPORTED;
2652 }
2653
2654 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2u(struct sljit_compiler *compiler, sljit_s32 op,
2655         sljit_s32 src1, sljit_sw src1w,
2656         sljit_s32 src2, sljit_sw src2w)
2657 {
2658         SLJIT_UNUSED_ARG(compiler);
2659         SLJIT_UNUSED_ARG(op);
2660         SLJIT_UNUSED_ARG(src1);
2661         SLJIT_UNUSED_ARG(src1w);
2662         SLJIT_UNUSED_ARG(src2);
2663         SLJIT_UNUSED_ARG(src2w);
2664         SLJIT_UNREACHABLE();
2665         return SLJIT_ERR_UNSUPPORTED;
2666 }
2667
2668 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_src(struct sljit_compiler *compiler, sljit_s32 op,
2669         sljit_s32 src, sljit_sw srcw)
2670 {
2671         SLJIT_UNUSED_ARG(compiler);
2672         SLJIT_UNUSED_ARG(op);
2673         SLJIT_UNUSED_ARG(src);
2674         SLJIT_UNUSED_ARG(srcw);
2675         SLJIT_UNREACHABLE();
2676         return SLJIT_ERR_UNSUPPORTED;
2677 }
2678
2679 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_register_index(sljit_s32 reg)
2680 {
2681         SLJIT_UNREACHABLE();
2682         return reg;
2683 }
2684
2685 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_custom(struct sljit_compiler *compiler,
2686         void *instruction, sljit_u32 size)
2687 {
2688         SLJIT_UNUSED_ARG(compiler);
2689         SLJIT_UNUSED_ARG(instruction);
2690         SLJIT_UNUSED_ARG(size);
2691         SLJIT_UNREACHABLE();
2692         return SLJIT_ERR_UNSUPPORTED;
2693 }
2694
2695 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_current_flags(struct sljit_compiler *compiler, sljit_s32 current_flags)
2696 {
2697         SLJIT_UNUSED_ARG(compiler);
2698         SLJIT_UNUSED_ARG(current_flags);
2699 }
2700
2701 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop1(struct sljit_compiler *compiler, sljit_s32 op,
2702         sljit_s32 dst, sljit_sw dstw,
2703         sljit_s32 src, sljit_sw srcw)
2704 {
2705         SLJIT_UNUSED_ARG(compiler);
2706         SLJIT_UNUSED_ARG(op);
2707         SLJIT_UNUSED_ARG(dst);
2708         SLJIT_UNUSED_ARG(dstw);
2709         SLJIT_UNUSED_ARG(src);
2710         SLJIT_UNUSED_ARG(srcw);
2711         SLJIT_UNREACHABLE();
2712         return SLJIT_ERR_UNSUPPORTED;
2713 }
2714
2715 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop2(struct sljit_compiler *compiler, sljit_s32 op,
2716         sljit_s32 dst, sljit_sw dstw,
2717         sljit_s32 src1, sljit_sw src1w,
2718         sljit_s32 src2, sljit_sw src2w)
2719 {
2720         SLJIT_UNUSED_ARG(compiler);
2721         SLJIT_UNUSED_ARG(op);
2722         SLJIT_UNUSED_ARG(dst);
2723         SLJIT_UNUSED_ARG(dstw);
2724         SLJIT_UNUSED_ARG(src1);
2725         SLJIT_UNUSED_ARG(src1w);
2726         SLJIT_UNUSED_ARG(src2);
2727         SLJIT_UNUSED_ARG(src2w);
2728         SLJIT_UNREACHABLE();
2729         return SLJIT_ERR_UNSUPPORTED;
2730 }
2731
2732 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
2733 {
2734         SLJIT_UNUSED_ARG(compiler);
2735         SLJIT_UNREACHABLE();
2736         return NULL;
2737 }
2738
2739 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type)
2740 {
2741         SLJIT_UNUSED_ARG(compiler);
2742         SLJIT_UNUSED_ARG(type);
2743         SLJIT_UNREACHABLE();
2744         return NULL;
2745 }
2746
2747 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_call(struct sljit_compiler *compiler, sljit_s32 type,
2748         sljit_s32 arg_types)
2749 {
2750         SLJIT_UNUSED_ARG(compiler);
2751         SLJIT_UNUSED_ARG(type);
2752         SLJIT_UNUSED_ARG(arg_types);
2753         SLJIT_UNREACHABLE();
2754         return NULL;
2755 }
2756
2757 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_s32 type,
2758         sljit_s32 src1, sljit_sw src1w,
2759         sljit_s32 src2, sljit_sw src2w)
2760 {
2761         SLJIT_UNUSED_ARG(compiler);
2762         SLJIT_UNUSED_ARG(type);
2763         SLJIT_UNUSED_ARG(src1);
2764         SLJIT_UNUSED_ARG(src1w);
2765         SLJIT_UNUSED_ARG(src2);
2766         SLJIT_UNUSED_ARG(src2w);
2767         SLJIT_UNREACHABLE();
2768         return NULL;
2769 }
2770
2771 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_s32 type,
2772         sljit_s32 src1, sljit_sw src1w,
2773         sljit_s32 src2, sljit_sw src2w)
2774 {
2775         SLJIT_UNUSED_ARG(compiler);
2776         SLJIT_UNUSED_ARG(type);
2777         SLJIT_UNUSED_ARG(src1);
2778         SLJIT_UNUSED_ARG(src1w);
2779         SLJIT_UNUSED_ARG(src2);
2780         SLJIT_UNUSED_ARG(src2w);
2781         SLJIT_UNREACHABLE();
2782         return NULL;
2783 }
2784
2785 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label)
2786 {
2787         SLJIT_UNUSED_ARG(jump);
2788         SLJIT_UNUSED_ARG(label);
2789         SLJIT_UNREACHABLE();
2790 }
2791
2792 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target)
2793 {
2794         SLJIT_UNUSED_ARG(jump);
2795         SLJIT_UNUSED_ARG(target);
2796         SLJIT_UNREACHABLE();
2797 }
2798
2799 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_put_label(struct sljit_put_label *put_label, struct sljit_label *label)
2800 {
2801         SLJIT_UNUSED_ARG(put_label);
2802         SLJIT_UNUSED_ARG(label);
2803         SLJIT_UNREACHABLE();
2804 }
2805
2806 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw)
2807 {
2808         SLJIT_UNUSED_ARG(compiler);
2809         SLJIT_UNUSED_ARG(type);
2810         SLJIT_UNUSED_ARG(src);
2811         SLJIT_UNUSED_ARG(srcw);
2812         SLJIT_UNREACHABLE();
2813         return SLJIT_ERR_UNSUPPORTED;
2814 }
2815
2816 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_icall(struct sljit_compiler *compiler, sljit_s32 type,
2817         sljit_s32 arg_types,
2818         sljit_s32 src, sljit_sw srcw)
2819 {
2820         SLJIT_UNUSED_ARG(compiler);
2821         SLJIT_UNUSED_ARG(type);
2822         SLJIT_UNUSED_ARG(arg_types);
2823         SLJIT_UNUSED_ARG(src);
2824         SLJIT_UNUSED_ARG(srcw);
2825         SLJIT_UNREACHABLE();
2826         return SLJIT_ERR_UNSUPPORTED;
2827 }
2828
2829 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_s32 op,
2830         sljit_s32 dst, sljit_sw dstw,
2831         sljit_s32 type)
2832 {
2833         SLJIT_UNUSED_ARG(compiler);
2834         SLJIT_UNUSED_ARG(op);
2835         SLJIT_UNUSED_ARG(dst);
2836         SLJIT_UNUSED_ARG(dstw);
2837         SLJIT_UNUSED_ARG(type);
2838         SLJIT_UNREACHABLE();
2839         return SLJIT_ERR_UNSUPPORTED;
2840 }
2841
2842 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_cmov(struct sljit_compiler *compiler, sljit_s32 type,
2843         sljit_s32 dst_reg,
2844         sljit_s32 src, sljit_sw srcw)
2845 {
2846         SLJIT_UNUSED_ARG(compiler);
2847         SLJIT_UNUSED_ARG(type);
2848         SLJIT_UNUSED_ARG(dst_reg);
2849         SLJIT_UNUSED_ARG(src);
2850         SLJIT_UNUSED_ARG(srcw);
2851         SLJIT_UNREACHABLE();
2852         return SLJIT_ERR_UNSUPPORTED;
2853 }
2854
2855 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_mem(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 reg, sljit_s32 mem, sljit_sw memw)
2856 {
2857         SLJIT_UNUSED_ARG(compiler);
2858         SLJIT_UNUSED_ARG(type);
2859         SLJIT_UNUSED_ARG(reg);
2860         SLJIT_UNUSED_ARG(mem);
2861         SLJIT_UNUSED_ARG(memw);
2862         SLJIT_UNREACHABLE();
2863         return SLJIT_ERR_UNSUPPORTED;
2864 }
2865
2866 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fmem(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 freg, sljit_s32 mem, sljit_sw memw)
2867 {
2868         SLJIT_UNUSED_ARG(compiler);
2869         SLJIT_UNUSED_ARG(type);
2870         SLJIT_UNUSED_ARG(freg);
2871         SLJIT_UNUSED_ARG(mem);
2872         SLJIT_UNUSED_ARG(memw);
2873         SLJIT_UNREACHABLE();
2874         return SLJIT_ERR_UNSUPPORTED;
2875 }
2876
2877 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_local_base(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw offset)
2878 {
2879         SLJIT_UNUSED_ARG(compiler);
2880         SLJIT_UNUSED_ARG(dst);
2881         SLJIT_UNUSED_ARG(dstw);
2882         SLJIT_UNUSED_ARG(offset);
2883         SLJIT_UNREACHABLE();
2884         return SLJIT_ERR_UNSUPPORTED;
2885 }
2886
2887 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw initval)
2888 {
2889         SLJIT_UNUSED_ARG(compiler);
2890         SLJIT_UNUSED_ARG(dst);
2891         SLJIT_UNUSED_ARG(dstw);
2892         SLJIT_UNUSED_ARG(initval);
2893         SLJIT_UNREACHABLE();
2894         return NULL;
2895 }
2896
2897 SLJIT_API_FUNC_ATTRIBUTE struct sljit_put_label* sljit_emit_put_label(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
2898 {
2899         SLJIT_UNUSED_ARG(compiler);
2900         SLJIT_UNUSED_ARG(dst);
2901         SLJIT_UNUSED_ARG(dstw);
2902         return NULL;
2903 }
2904
2905 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset)
2906 {
2907         SLJIT_UNUSED_ARG(addr);
2908         SLJIT_UNUSED_ARG(new_target);
2909         SLJIT_UNUSED_ARG(executable_offset);
2910         SLJIT_UNREACHABLE();
2911 }
2912
2913 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant, sljit_sw executable_offset)
2914 {
2915         SLJIT_UNUSED_ARG(addr);
2916         SLJIT_UNUSED_ARG(new_constant);
2917         SLJIT_UNUSED_ARG(executable_offset);
2918         SLJIT_UNREACHABLE();
2919 }
2920
2921 #endif /* !SLJIT_CONFIG_UNSUPPORTED */