1/* 2 * Stack-less Just-In-Time compiler 3 * 4 * Copyright 2009-2012 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without modification, are 7 * permitted provided that the following conditions are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright notice, this list of 10 * conditions and the following disclaimer. 11 * 12 * 2. Redistributions in binary form must reproduce the above copyright notice, this list 13 * of conditions and the following disclaimer in the documentation and/or other materials 14 * provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY 17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 19 * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 21 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 22 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 24 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27#include "sljitLir.h" 28 29#define CHECK_ERROR() \ 30 do { \ 31 if (SLJIT_UNLIKELY(compiler->error)) \ 32 return compiler->error; \ 33 } while (0) 34 35#define CHECK_ERROR_PTR() \ 36 do { \ 37 if (SLJIT_UNLIKELY(compiler->error)) \ 38 return NULL; \ 39 } while (0) 40 41#define FAIL_IF(expr) \ 42 do { \ 43 if (SLJIT_UNLIKELY(expr)) \ 44 return compiler->error; \ 45 } while (0) 46 47#define PTR_FAIL_IF(expr) \ 48 do { \ 49 if (SLJIT_UNLIKELY(expr)) \ 50 return NULL; \ 51 } while (0) 52 53#define FAIL_IF_NULL(ptr) \ 54 do { \ 55 if (SLJIT_UNLIKELY(!(ptr))) { \ 56 compiler->error = SLJIT_ERR_ALLOC_FAILED; \ 57 return SLJIT_ERR_ALLOC_FAILED; \ 58 } \ 59 } while (0) 60 61#define PTR_FAIL_IF_NULL(ptr) \ 62 do { \ 63 if (SLJIT_UNLIKELY(!(ptr))) { \ 64 compiler->error = SLJIT_ERR_ALLOC_FAILED; \ 65 return NULL; \ 66 } \ 67 } while (0) 68 69#define PTR_FAIL_WITH_EXEC_IF(ptr) \ 70 do { \ 71 if (SLJIT_UNLIKELY(!(ptr))) { \ 72 compiler->error = SLJIT_ERR_EX_ALLOC_FAILED; \ 73 return NULL; \ 74 } \ 75 } while (0) 76 77#if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) 78 79#define GET_OPCODE(op) \ 80 ((op) & ~(SLJIT_I32_OP | SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS)) 81 82#define GET_FLAGS(op) \ 83 ((op) & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C)) 84 85#define GET_ALL_FLAGS(op) \ 86 ((op) & (SLJIT_I32_OP | SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS)) 87 88#define TYPE_CAST_NEEDED(op) \ 89 (((op) >= SLJIT_MOV_U8 && (op) <= SLJIT_MOV_S16) || ((op) >= SLJIT_MOVU_U8 && (op) <= SLJIT_MOVU_S16)) 90 91#define BUF_SIZE 4096 92 93#if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE) 94#define ABUF_SIZE 2048 95#else 96#define ABUF_SIZE 4096 97#endif 98 99/* Parameter parsing. */ 100#define REG_MASK 0x3f 101#define OFFS_REG(reg) (((reg) >> 8) & REG_MASK) 102#define OFFS_REG_MASK (REG_MASK << 8) 103#define TO_OFFS_REG(reg) ((reg) << 8) 104/* When reg cannot be unused. */ 105#define FAST_IS_REG(reg) ((reg) <= REG_MASK) 106/* When reg can be unused. */ 107#define SLOW_IS_REG(reg) ((reg) > 0 && (reg) <= REG_MASK) 108 109/* Jump flags. */ 110#define JUMP_LABEL 0x1 111#define JUMP_ADDR 0x2 112/* SLJIT_REWRITABLE_JUMP is 0x1000. */ 113 114#if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 115# define PATCH_MB 0x4 116# define PATCH_MW 0x8 117#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) 118# define PATCH_MD 0x10 119#endif 120#endif 121 122#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7) 123# define IS_BL 0x4 124# define PATCH_B 0x8 125#endif 126 127#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) 128# define CPOOL_SIZE 512 129#endif 130 131#if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) 132# define IS_COND 0x04 133# define IS_BL 0x08 134 /* conditional + imm8 */ 135# define PATCH_TYPE1 0x10 136 /* conditional + imm20 */ 137# define PATCH_TYPE2 0x20 138 /* IT + imm24 */ 139# define PATCH_TYPE3 0x30 140 /* imm11 */ 141# define PATCH_TYPE4 0x40 142 /* imm24 */ 143# define PATCH_TYPE5 0x50 144 /* BL + imm24 */ 145# define PATCH_BL 0x60 146 /* 0xf00 cc code for branches */ 147#endif 148 149#if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) 150# define IS_COND 0x004 151# define IS_CBZ 0x008 152# define IS_BL 0x010 153# define PATCH_B 0x020 154# define PATCH_COND 0x040 155# define PATCH_ABS48 0x080 156# define PATCH_ABS64 0x100 157#endif 158 159#if (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC) 160# define IS_COND 0x004 161# define IS_CALL 0x008 162# define PATCH_B 0x010 163# define PATCH_ABS_B 0x020 164#if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64) 165# define PATCH_ABS32 0x040 166# define PATCH_ABS48 0x080 167#endif 168# define REMOVE_COND 0x100 169#endif 170 171#if (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) 172# define IS_MOVABLE 0x004 173# define IS_JAL 0x008 174# define IS_CALL 0x010 175# define IS_BIT26_COND 0x020 176# define IS_BIT16_COND 0x040 177 178# define IS_COND (IS_BIT26_COND | IS_BIT16_COND) 179 180# define PATCH_B 0x080 181# define PATCH_J 0x100 182 183#if (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64) 184# define PATCH_ABS32 0x200 185# define PATCH_ABS48 0x400 186#endif 187 188 /* instruction types */ 189# define MOVABLE_INS 0 190 /* 1 - 31 last destination register */ 191 /* no destination (i.e: store) */ 192# define UNMOVABLE_INS 32 193 /* FPU status register */ 194# define FCSR_FCC 33 195#endif 196 197#if (defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX) 198# define IS_JAL 0x04 199# define IS_COND 0x08 200 201# define PATCH_B 0x10 202# define PATCH_J 0x20 203#endif 204 205#if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) 206# define IS_MOVABLE 0x04 207# define IS_COND 0x08 208# define IS_CALL 0x10 209 210# define PATCH_B 0x20 211# define PATCH_CALL 0x40 212 213 /* instruction types */ 214# define MOVABLE_INS 0 215 /* 1 - 31 last destination register */ 216 /* no destination (i.e: store) */ 217# define UNMOVABLE_INS 32 218 219# define DST_INS_MASK 0xff 220 221 /* ICC_SET is the same as SET_FLAGS. */ 222# define ICC_IS_SET (1 << 23) 223# define FCC_IS_SET (1 << 24) 224#endif 225 226/* Stack management. */ 227 228#define GET_SAVED_REGISTERS_SIZE(scratches, saveds, extra) \ 229 (((scratches < SLJIT_NUMBER_OF_SCRATCH_REGISTERS ? 0 : (scratches - SLJIT_NUMBER_OF_SCRATCH_REGISTERS)) + \ 230 (saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? saveds : SLJIT_NUMBER_OF_SAVED_REGISTERS) + \ 231 extra) * sizeof(sljit_sw)) 232 233#define ADJUST_LOCAL_OFFSET(p, i) \ 234 if ((p) == (SLJIT_MEM1(SLJIT_SP))) \ 235 (i) += SLJIT_LOCALS_OFFSET; 236 237#endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */ 238 239/* Utils can still be used even if SLJIT_CONFIG_UNSUPPORTED is set. */ 240#include "sljitUtils.c" 241 242#if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) 243 244#if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR) 245#include "sljitExecAllocator.c" 246#endif 247 248/* Argument checking features. */ 249 250#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 251 252/* Returns with error when an invalid argument is passed. */ 253 254#define CHECK_ARGUMENT(x) \ 255 do { \ 256 if (SLJIT_UNLIKELY(!(x))) \ 257 return 1; \ 258 } while (0) 259 260#define CHECK_RETURN_TYPE sljit_s32 261#define CHECK_RETURN_OK return 0 262 263#define CHECK(x) \ 264 do { \ 265 if (SLJIT_UNLIKELY(x)) { \ 266 compiler->error = SLJIT_ERR_BAD_ARGUMENT; \ 267 return SLJIT_ERR_BAD_ARGUMENT; \ 268 } \ 269 } while (0) 270 271#define CHECK_PTR(x) \ 272 do { \ 273 if (SLJIT_UNLIKELY(x)) { \ 274 compiler->error = SLJIT_ERR_BAD_ARGUMENT; \ 275 return NULL; \ 276 } \ 277 } while (0) 278 279#define CHECK_REG_INDEX(x) \ 280 do { \ 281 if (SLJIT_UNLIKELY(x)) { \ 282 return -2; \ 283 } \ 284 } while (0) 285 286#elif (defined SLJIT_DEBUG && SLJIT_DEBUG) 287 288/* Assertion failure occures if an invalid argument is passed. */ 289#undef SLJIT_ARGUMENT_CHECKS 290#define SLJIT_ARGUMENT_CHECKS 1 291 292#define CHECK_ARGUMENT(x) SLJIT_ASSERT(x) 293#define CHECK_RETURN_TYPE void 294#define CHECK_RETURN_OK return 295#define CHECK(x) x 296#define CHECK_PTR(x) x 297#define CHECK_REG_INDEX(x) x 298 299#elif (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 300 301/* Arguments are not checked. */ 302#define CHECK_RETURN_TYPE void 303#define CHECK_RETURN_OK return 304#define CHECK(x) x 305#define CHECK_PTR(x) x 306#define CHECK_REG_INDEX(x) x 307 308#else 309 310/* Arguments are not checked. */ 311#define CHECK(x) 312#define CHECK_PTR(x) 313#define CHECK_REG_INDEX(x) 314 315#endif /* SLJIT_ARGUMENT_CHECKS */ 316 317/* --------------------------------------------------------------------- */ 318/* Public functions */ 319/* --------------------------------------------------------------------- */ 320 321#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) || (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 322#define SLJIT_NEEDS_COMPILER_INIT 1 323static sljit_s32 compiler_initialized = 0; 324/* A thread safe initialization. */ 325static void init_compiler(void); 326#endif 327 328SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void *allocator_data) 329{ 330 struct sljit_compiler *compiler = (struct sljit_compiler*)SLJIT_MALLOC(sizeof(struct sljit_compiler), allocator_data); 331 if (!compiler) 332 return NULL; 333 SLJIT_ZEROMEM(compiler, sizeof(struct sljit_compiler)); 334 335 SLJIT_COMPILE_ASSERT( 336 sizeof(sljit_s8) == 1 && sizeof(sljit_u8) == 1 337 && sizeof(sljit_s16) == 2 && sizeof(sljit_u16) == 2 338 && sizeof(sljit_s32) == 4 && sizeof(sljit_u32) == 4 339 && (sizeof(sljit_p) == 4 || sizeof(sljit_p) == 8) 340 && sizeof(sljit_p) <= sizeof(sljit_sw) 341 && (sizeof(sljit_sw) == 4 || sizeof(sljit_sw) == 8) 342 && (sizeof(sljit_uw) == 4 || sizeof(sljit_uw) == 8), 343 invalid_integer_types); 344 SLJIT_COMPILE_ASSERT(SLJIT_I32_OP == SLJIT_F32_OP, 345 int_op_and_single_op_must_be_the_same); 346 SLJIT_COMPILE_ASSERT(SLJIT_REWRITABLE_JUMP != SLJIT_F32_OP, 347 rewritable_jump_and_single_op_must_not_be_the_same); 348 349 /* Only the non-zero members must be set. */ 350 compiler->error = SLJIT_SUCCESS; 351 352 compiler->allocator_data = allocator_data; 353 compiler->buf = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE, allocator_data); 354 compiler->abuf = (struct sljit_memory_fragment*)SLJIT_MALLOC(ABUF_SIZE, allocator_data); 355 356 if (!compiler->buf || !compiler->abuf) { 357 if (compiler->buf) 358 SLJIT_FREE(compiler->buf, allocator_data); 359 if (compiler->abuf) 360 SLJIT_FREE(compiler->abuf, allocator_data); 361 SLJIT_FREE(compiler, allocator_data); 362 return NULL; 363 } 364 365 compiler->buf->next = NULL; 366 compiler->buf->used_size = 0; 367 compiler->abuf->next = NULL; 368 compiler->abuf->used_size = 0; 369 370 compiler->scratches = -1; 371 compiler->saveds = -1; 372 compiler->fscratches = -1; 373 compiler->fsaveds = -1; 374 compiler->local_size = -1; 375 376#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) 377 compiler->args = -1; 378#endif 379 380#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) 381 compiler->cpool = (sljit_uw*)SLJIT_MALLOC(CPOOL_SIZE * sizeof(sljit_uw) 382 + CPOOL_SIZE * sizeof(sljit_u8), allocator_data); 383 if (!compiler->cpool) { 384 SLJIT_FREE(compiler->buf, allocator_data); 385 SLJIT_FREE(compiler->abuf, allocator_data); 386 SLJIT_FREE(compiler, allocator_data); 387 return NULL; 388 } 389 compiler->cpool_unique = (sljit_u8*)(compiler->cpool + CPOOL_SIZE); 390 compiler->cpool_diff = 0xffffffff; 391#endif 392 393#if (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) 394 compiler->delay_slot = UNMOVABLE_INS; 395#endif 396 397#if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32) 398 compiler->delay_slot = UNMOVABLE_INS; 399#endif 400 401#if (defined SLJIT_NEEDS_COMPILER_INIT && SLJIT_NEEDS_COMPILER_INIT) 402 if (!compiler_initialized) { 403 init_compiler(); 404 compiler_initialized = 1; 405 } 406#endif 407 408 return compiler; 409} 410 411SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler) 412{ 413 struct sljit_memory_fragment *buf; 414 struct sljit_memory_fragment *curr; 415 void *allocator_data = compiler->allocator_data; 416 SLJIT_UNUSED_ARG(allocator_data); 417 418 buf = compiler->buf; 419 while (buf) { 420 curr = buf; 421 buf = buf->next; 422 SLJIT_FREE(curr, allocator_data); 423 } 424 425 buf = compiler->abuf; 426 while (buf) { 427 curr = buf; 428 buf = buf->next; 429 SLJIT_FREE(curr, allocator_data); 430 } 431 432#if (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) 433 SLJIT_FREE(compiler->cpool, allocator_data); 434#endif 435 SLJIT_FREE(compiler, allocator_data); 436} 437 438SLJIT_API_FUNC_ATTRIBUTE void sljit_set_compiler_memory_error(struct sljit_compiler *compiler) 439{ 440 if (compiler->error == SLJIT_SUCCESS) 441 compiler->error = SLJIT_ERR_ALLOC_FAILED; 442} 443 444#if (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) 445SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code) 446{ 447 /* Remove thumb mode flag. */ 448 SLJIT_FREE_EXEC((void*)((sljit_uw)code & ~0x1)); 449} 450#elif (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL) 451SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code) 452{ 453 /* Resolve indirection. */ 454 code = (void*)(*(sljit_uw*)code); 455 SLJIT_FREE_EXEC(code); 456} 457#else 458SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code) 459{ 460 SLJIT_FREE_EXEC(code); 461} 462#endif 463 464SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label) 465{ 466 if (SLJIT_LIKELY(!!jump) && SLJIT_LIKELY(!!label)) { 467 jump->flags &= ~JUMP_ADDR; 468 jump->flags |= JUMP_LABEL; 469 jump->u.label = label; 470 } 471} 472 473SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target) 474{ 475 if (SLJIT_LIKELY(!!jump)) { 476 jump->flags &= ~JUMP_LABEL; 477 jump->flags |= JUMP_ADDR; 478 jump->u.target = target; 479 } 480} 481 482/* --------------------------------------------------------------------- */ 483/* Private functions */ 484/* --------------------------------------------------------------------- */ 485 486static void* ensure_buf(struct sljit_compiler *compiler, sljit_uw size) 487{ 488 sljit_u8 *ret; 489 struct sljit_memory_fragment *new_frag; 490 491 SLJIT_ASSERT(size <= 256); 492 if (compiler->buf->used_size + size <= (BUF_SIZE - (sljit_uw)SLJIT_OFFSETOF(struct sljit_memory_fragment, memory))) { 493 ret = compiler->buf->memory + compiler->buf->used_size; 494 compiler->buf->used_size += size; 495 return ret; 496 } 497 new_frag = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE, compiler->allocator_data); 498 PTR_FAIL_IF_NULL(new_frag); 499 new_frag->next = compiler->buf; 500 compiler->buf = new_frag; 501 new_frag->used_size = size; 502 return new_frag->memory; 503} 504 505static void* ensure_abuf(struct sljit_compiler *compiler, sljit_uw size) 506{ 507 sljit_u8 *ret; 508 struct sljit_memory_fragment *new_frag; 509 510 SLJIT_ASSERT(size <= 256); 511 if (compiler->abuf->used_size + size <= (ABUF_SIZE - (sljit_uw)SLJIT_OFFSETOF(struct sljit_memory_fragment, memory))) { 512 ret = compiler->abuf->memory + compiler->abuf->used_size; 513 compiler->abuf->used_size += size; 514 return ret; 515 } 516 new_frag = (struct sljit_memory_fragment*)SLJIT_MALLOC(ABUF_SIZE, compiler->allocator_data); 517 PTR_FAIL_IF_NULL(new_frag); 518 new_frag->next = compiler->abuf; 519 compiler->abuf = new_frag; 520 new_frag->used_size = size; 521 return new_frag->memory; 522} 523 524SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_s32 size) 525{ 526 CHECK_ERROR_PTR(); 527 528#if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 529 if (size <= 0 || size > 128) 530 return NULL; 531 size = (size + 7) & ~7; 532#else 533 if (size <= 0 || size > 64) 534 return NULL; 535 size = (size + 3) & ~3; 536#endif 537 return ensure_abuf(compiler, size); 538} 539 540static SLJIT_INLINE void reverse_buf(struct sljit_compiler *compiler) 541{ 542 struct sljit_memory_fragment *buf = compiler->buf; 543 struct sljit_memory_fragment *prev = NULL; 544 struct sljit_memory_fragment *tmp; 545 546 do { 547 tmp = buf->next; 548 buf->next = prev; 549 prev = buf; 550 buf = tmp; 551 } while (buf != NULL); 552 553 compiler->buf = prev; 554} 555 556static SLJIT_INLINE void set_emit_enter(struct sljit_compiler *compiler, 557 sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds, 558 sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size) 559{ 560 SLJIT_UNUSED_ARG(args); 561 SLJIT_UNUSED_ARG(local_size); 562 563 compiler->options = options; 564 compiler->scratches = scratches; 565 compiler->saveds = saveds; 566 compiler->fscratches = fscratches; 567 compiler->fsaveds = fsaveds; 568#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 569 compiler->logical_local_size = local_size; 570#endif 571} 572 573static SLJIT_INLINE void set_set_context(struct sljit_compiler *compiler, 574 sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds, 575 sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size) 576{ 577 SLJIT_UNUSED_ARG(args); 578 SLJIT_UNUSED_ARG(local_size); 579 580 compiler->options = options; 581 compiler->scratches = scratches; 582 compiler->saveds = saveds; 583 compiler->fscratches = fscratches; 584 compiler->fsaveds = fsaveds; 585#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 586 compiler->logical_local_size = local_size; 587#endif 588} 589 590static SLJIT_INLINE void set_label(struct sljit_label *label, struct sljit_compiler *compiler) 591{ 592 label->next = NULL; 593 label->size = compiler->size; 594 if (compiler->last_label) 595 compiler->last_label->next = label; 596 else 597 compiler->labels = label; 598 compiler->last_label = label; 599} 600 601static SLJIT_INLINE void set_jump(struct sljit_jump *jump, struct sljit_compiler *compiler, sljit_s32 flags) 602{ 603 jump->next = NULL; 604 jump->flags = flags; 605 if (compiler->last_jump) 606 compiler->last_jump->next = jump; 607 else 608 compiler->jumps = jump; 609 compiler->last_jump = jump; 610} 611 612static SLJIT_INLINE void set_const(struct sljit_const *const_, struct sljit_compiler *compiler) 613{ 614 const_->next = NULL; 615 const_->addr = compiler->size; 616 if (compiler->last_const) 617 compiler->last_const->next = const_; 618 else 619 compiler->consts = const_; 620 compiler->last_const = const_; 621} 622 623#define ADDRESSING_DEPENDS_ON(exp, reg) \ 624 (((exp) & SLJIT_MEM) && (((exp) & REG_MASK) == reg || OFFS_REG(exp) == reg)) 625 626#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 627#define FUNCTION_CHECK_OP() \ 628 CHECK_ARGUMENT(!GET_FLAGS(op) || !(op & SLJIT_KEEP_FLAGS)); \ 629 switch (GET_OPCODE(op)) { \ 630 case SLJIT_NOT: \ 631 case SLJIT_CLZ: \ 632 case SLJIT_AND: \ 633 case SLJIT_OR: \ 634 case SLJIT_XOR: \ 635 case SLJIT_SHL: \ 636 case SLJIT_LSHR: \ 637 case SLJIT_ASHR: \ 638 CHECK_ARGUMENT(!(op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C))); \ 639 break; \ 640 case SLJIT_NEG: \ 641 CHECK_ARGUMENT(!(op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_C))); \ 642 break; \ 643 case SLJIT_MUL: \ 644 CHECK_ARGUMENT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_C))); \ 645 break; \ 646 case SLJIT_ADD: \ 647 CHECK_ARGUMENT(!(op & (SLJIT_SET_U | SLJIT_SET_S))); \ 648 break; \ 649 case SLJIT_SUB: \ 650 break; \ 651 case SLJIT_ADDC: \ 652 case SLJIT_SUBC: \ 653 CHECK_ARGUMENT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O))); \ 654 break; \ 655 case SLJIT_BREAKPOINT: \ 656 case SLJIT_NOP: \ 657 case SLJIT_LMUL_UW: \ 658 case SLJIT_LMUL_SW: \ 659 case SLJIT_MOV: \ 660 case SLJIT_MOV_U32: \ 661 case SLJIT_MOV_P: \ 662 case SLJIT_MOVU: \ 663 case SLJIT_MOVU_U32: \ 664 case SLJIT_MOVU_P: \ 665 /* Nothing allowed */ \ 666 CHECK_ARGUMENT(!(op & (SLJIT_I32_OP | SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \ 667 break; \ 668 default: \ 669 /* Only SLJIT_I32_OP or SLJIT_F32_OP is allowed. */ \ 670 CHECK_ARGUMENT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \ 671 break; \ 672 } 673 674#define FUNCTION_CHECK_FOP() \ 675 CHECK_ARGUMENT(!GET_FLAGS(op) || !(op & SLJIT_KEEP_FLAGS)); \ 676 switch (GET_OPCODE(op)) { \ 677 case SLJIT_CMP_F64: \ 678 CHECK_ARGUMENT(!(op & (SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \ 679 CHECK_ARGUMENT((op & (SLJIT_SET_E | SLJIT_SET_S))); \ 680 break; \ 681 default: \ 682 /* Only SLJIT_I32_OP or SLJIT_F32_OP is allowed. */ \ 683 CHECK_ARGUMENT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \ 684 break; \ 685 } 686 687#define FUNCTION_CHECK_IS_REG(r) \ 688 (((r) >= SLJIT_R0 && (r) < (SLJIT_R0 + compiler->scratches)) || \ 689 ((r) > (SLJIT_S0 - compiler->saveds) && (r) <= SLJIT_S0)) 690 691#define FUNCTION_CHECK_IS_REG_OR_UNUSED(r) \ 692 ((r) == SLJIT_UNUSED || \ 693 ((r) >= SLJIT_R0 && (r) < (SLJIT_R0 + compiler->scratches)) || \ 694 ((r) > (SLJIT_S0 - compiler->saveds) && (r) <= SLJIT_S0)) 695 696#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) 697#define CHECK_NOT_VIRTUAL_REGISTER(p) \ 698 CHECK_ARGUMENT((p) < SLJIT_R3 || (p) > SLJIT_R6); 699#else 700#define CHECK_NOT_VIRTUAL_REGISTER(p) 701#endif 702 703#define FUNCTION_CHECK_SRC(p, i) \ 704 CHECK_ARGUMENT(compiler->scratches != -1 && compiler->saveds != -1); \ 705 if (FUNCTION_CHECK_IS_REG(p)) \ 706 CHECK_ARGUMENT((i) == 0); \ 707 else if ((p) == SLJIT_IMM) \ 708 ; \ 709 else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \ 710 CHECK_ARGUMENT((i) >= 0 && (i) < compiler->logical_local_size); \ 711 else { \ 712 CHECK_ARGUMENT((p) & SLJIT_MEM); \ 713 CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG_OR_UNUSED((p) & REG_MASK)); \ 714 CHECK_NOT_VIRTUAL_REGISTER((p) & REG_MASK); \ 715 if ((p) & OFFS_REG_MASK) { \ 716 CHECK_ARGUMENT(((p) & REG_MASK) != SLJIT_UNUSED); \ 717 CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \ 718 CHECK_NOT_VIRTUAL_REGISTER(OFFS_REG(p)); \ 719 CHECK_ARGUMENT(!((i) & ~0x3)); \ 720 } \ 721 CHECK_ARGUMENT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \ 722 } 723 724#define FUNCTION_CHECK_DST(p, i) \ 725 CHECK_ARGUMENT(compiler->scratches != -1 && compiler->saveds != -1); \ 726 if (FUNCTION_CHECK_IS_REG_OR_UNUSED(p)) \ 727 CHECK_ARGUMENT((i) == 0); \ 728 else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \ 729 CHECK_ARGUMENT((i) >= 0 && (i) < compiler->logical_local_size); \ 730 else { \ 731 CHECK_ARGUMENT((p) & SLJIT_MEM); \ 732 CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG_OR_UNUSED((p) & REG_MASK)); \ 733 CHECK_NOT_VIRTUAL_REGISTER((p) & REG_MASK); \ 734 if ((p) & OFFS_REG_MASK) { \ 735 CHECK_ARGUMENT(((p) & REG_MASK) != SLJIT_UNUSED); \ 736 CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \ 737 CHECK_NOT_VIRTUAL_REGISTER(OFFS_REG(p)); \ 738 CHECK_ARGUMENT(!((i) & ~0x3)); \ 739 } \ 740 CHECK_ARGUMENT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \ 741 } 742 743#define FUNCTION_FCHECK(p, i) \ 744 CHECK_ARGUMENT(compiler->fscratches != -1 && compiler->fsaveds != -1); \ 745 if (((p) >= SLJIT_FR0 && (p) < (SLJIT_FR0 + compiler->fscratches)) || \ 746 ((p) > (SLJIT_FS0 - compiler->fsaveds) && (p) <= SLJIT_FS0)) \ 747 CHECK_ARGUMENT(i == 0); \ 748 else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \ 749 CHECK_ARGUMENT((i) >= 0 && (i) < compiler->logical_local_size); \ 750 else { \ 751 CHECK_ARGUMENT((p) & SLJIT_MEM); \ 752 CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG_OR_UNUSED((p) & REG_MASK)); \ 753 CHECK_NOT_VIRTUAL_REGISTER((p) & REG_MASK); \ 754 if ((p) & OFFS_REG_MASK) { \ 755 CHECK_ARGUMENT(((p) & REG_MASK) != SLJIT_UNUSED); \ 756 CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \ 757 CHECK_NOT_VIRTUAL_REGISTER(OFFS_REG(p)); \ 758 CHECK_ARGUMENT(((p) & OFFS_REG_MASK) != TO_OFFS_REG(SLJIT_SP) && !(i & ~0x3)); \ 759 } \ 760 CHECK_ARGUMENT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \ 761 } 762 763#define FUNCTION_CHECK_OP1() \ 764 if (GET_OPCODE(op) >= SLJIT_MOVU && GET_OPCODE(op) <= SLJIT_MOVU_P) { \ 765 CHECK_ARGUMENT(!(src & SLJIT_MEM) || (src & REG_MASK) != SLJIT_SP); \ 766 CHECK_ARGUMENT(!(dst & SLJIT_MEM) || (dst & REG_MASK) != SLJIT_SP); \ 767 if ((src & SLJIT_MEM) && (src & REG_MASK)) \ 768 CHECK_ARGUMENT((dst & REG_MASK) != (src & REG_MASK) && OFFS_REG(dst) != (src & REG_MASK)); \ 769 } 770 771#endif /* SLJIT_ARGUMENT_CHECKS */ 772 773#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 774 775SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose) 776{ 777 compiler->verbose = verbose; 778} 779 780#if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 781#ifdef _WIN64 782# define SLJIT_PRINT_D "I64" 783#else 784# define SLJIT_PRINT_D "l" 785#endif 786#else 787# define SLJIT_PRINT_D "" 788#endif 789 790#define sljit_verbose_reg(compiler, r) \ 791 do { \ 792 if ((r) < (SLJIT_R0 + compiler->scratches)) \ 793 fprintf(compiler->verbose, "r%d", (r) - SLJIT_R0); \ 794 else \ 795 fprintf(compiler->verbose, "s%d", SLJIT_NUMBER_OF_REGISTERS - (r)); \ 796 } while (0) 797 798#define sljit_verbose_param(compiler, p, i) \ 799 if ((p) & SLJIT_IMM) \ 800 fprintf(compiler->verbose, "#%" SLJIT_PRINT_D "d", (i)); \ 801 else if ((p) & SLJIT_MEM) { \ 802 if ((p) & REG_MASK) { \ 803 fputc('[', compiler->verbose); \ 804 sljit_verbose_reg(compiler, (p) & REG_MASK); \ 805 if ((p) & OFFS_REG_MASK) { \ 806 fprintf(compiler->verbose, " + "); \ 807 sljit_verbose_reg(compiler, OFFS_REG(p)); \ 808 if (i) \ 809 fprintf(compiler->verbose, " * %d", 1 << (i)); \ 810 } \ 811 else if (i) \ 812 fprintf(compiler->verbose, " + %" SLJIT_PRINT_D "d", (i)); \ 813 fputc(']', compiler->verbose); \ 814 } \ 815 else \ 816 fprintf(compiler->verbose, "[#%" SLJIT_PRINT_D "d]", (i)); \ 817 } else if (p) \ 818 sljit_verbose_reg(compiler, p); \ 819 else \ 820 fprintf(compiler->verbose, "unused"); 821 822#define sljit_verbose_fparam(compiler, p, i) \ 823 if ((p) & SLJIT_MEM) { \ 824 if ((p) & REG_MASK) { \ 825 fputc('[', compiler->verbose); \ 826 sljit_verbose_reg(compiler, (p) & REG_MASK); \ 827 if ((p) & OFFS_REG_MASK) { \ 828 fprintf(compiler->verbose, " + "); \ 829 sljit_verbose_reg(compiler, OFFS_REG(p)); \ 830 if (i) \ 831 fprintf(compiler->verbose, "%d", 1 << (i)); \ 832 } \ 833 else if (i) \ 834 fprintf(compiler->verbose, "%" SLJIT_PRINT_D "d", (i)); \ 835 fputc(']', compiler->verbose); \ 836 } \ 837 else \ 838 fprintf(compiler->verbose, "[#%" SLJIT_PRINT_D "d]", (i)); \ 839 } \ 840 else { \ 841 if ((p) < (SLJIT_FR0 + compiler->fscratches)) \ 842 fprintf(compiler->verbose, "fr%d", (p) - SLJIT_FR0); \ 843 else \ 844 fprintf(compiler->verbose, "fs%d", SLJIT_NUMBER_OF_FLOAT_REGISTERS - (p)); \ 845 } 846 847static const char* op0_names[] = { 848 (char*)"breakpoint", (char*)"nop", (char*)"lmul.uw", (char*)"lmul.sw", 849 (char*)"divmod.u", (char*)"divmod.s", (char*)"div.u", (char*)"div.s" 850}; 851 852static const char* op1_names[] = { 853 (char*)"", (char*)".u8", (char*)".s8", (char*)".u16", 854 (char*)".s16", (char*)".u32", (char*)".s32", (char*)".p", 855 (char*)"", (char*)".u8", (char*)".s8", (char*)".u16", 856 (char*)".s16", (char*)".u32", (char*)".s32", (char*)".p", 857 (char*)"not", (char*)"neg", (char*)"clz", 858}; 859 860static const char* op2_names[] = { 861 (char*)"add", (char*)"addc", (char*)"sub", (char*)"subc", 862 (char*)"mul", (char*)"and", (char*)"or", (char*)"xor", 863 (char*)"shl", (char*)"lshr", (char*)"ashr", 864}; 865 866static const char* fop1_names[] = { 867 (char*)"mov", (char*)"conv", (char*)"conv", (char*)"conv", 868 (char*)"conv", (char*)"conv", (char*)"cmp", (char*)"neg", 869 (char*)"abs", 870}; 871 872static const char* fop2_names[] = { 873 (char*)"add", (char*)"sub", (char*)"mul", (char*)"div" 874}; 875 876#define JUMP_POSTFIX(type) \ 877 ((type & 0xff) <= SLJIT_MUL_NOT_OVERFLOW ? ((type & SLJIT_I32_OP) ? "32" : "") \ 878 : ((type & 0xff) <= SLJIT_ORDERED_F64 ? ((type & SLJIT_F32_OP) ? ".f32" : ".f64") : "")) 879 880static char* jump_names[] = { 881 (char*)"equal", (char*)"not_equal", 882 (char*)"less", (char*)"greater_equal", 883 (char*)"greater", (char*)"less_equal", 884 (char*)"sig_less", (char*)"sig_greater_equal", 885 (char*)"sig_greater", (char*)"sig_less_equal", 886 (char*)"overflow", (char*)"not_overflow", 887 (char*)"mul_overflow", (char*)"mul_not_overflow", 888 (char*)"equal", (char*)"not_equal", 889 (char*)"less", (char*)"greater_equal", 890 (char*)"greater", (char*)"less_equal", 891 (char*)"unordered", (char*)"ordered", 892 (char*)"jump", (char*)"fast_call", 893 (char*)"call0", (char*)"call1", (char*)"call2", (char*)"call3" 894}; 895 896#endif /* SLJIT_VERBOSE */ 897 898/* --------------------------------------------------------------------- */ 899/* Arch dependent */ 900/* --------------------------------------------------------------------- */ 901 902#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \ 903 || (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 904 905static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_generate_code(struct sljit_compiler *compiler) 906{ 907#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 908 struct sljit_jump *jump; 909#endif 910 911 SLJIT_UNUSED_ARG(compiler); 912 913#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 914 CHECK_ARGUMENT(compiler->size > 0); 915 jump = compiler->jumps; 916 while (jump) { 917 /* All jumps have target. */ 918 CHECK_ARGUMENT(jump->flags & (JUMP_LABEL | JUMP_ADDR)); 919 jump = jump->next; 920 } 921#endif 922 CHECK_RETURN_OK; 923} 924 925static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_enter(struct sljit_compiler *compiler, 926 sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds, 927 sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size) 928{ 929 SLJIT_UNUSED_ARG(compiler); 930 931#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 932 CHECK_ARGUMENT(!(options & ~SLJIT_DOUBLE_ALIGNMENT)); 933 CHECK_ARGUMENT(args >= 0 && args <= 3); 934 CHECK_ARGUMENT(scratches >= 0 && scratches <= SLJIT_NUMBER_OF_REGISTERS); 935 CHECK_ARGUMENT(saveds >= 0 && saveds <= SLJIT_NUMBER_OF_REGISTERS); 936 CHECK_ARGUMENT(scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS); 937 CHECK_ARGUMENT(args <= saveds); 938 CHECK_ARGUMENT(fscratches >= 0 && fscratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS); 939 CHECK_ARGUMENT(fsaveds >= 0 && fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS); 940 CHECK_ARGUMENT(fscratches + fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS); 941 CHECK_ARGUMENT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE); 942#endif 943#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 944 if (SLJIT_UNLIKELY(!!compiler->verbose)) 945 fprintf(compiler->verbose, " enter options:none args:%d scratches:%d saveds:%d fscratches:%d fsaveds:%d local_size:%d\n", 946 args, scratches, saveds, fscratches, fsaveds, local_size); 947#endif 948 CHECK_RETURN_OK; 949} 950 951static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_set_context(struct sljit_compiler *compiler, 952 sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds, 953 sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size) 954{ 955 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 956 compiler->skip_checks = 0; 957 CHECK_RETURN_OK; 958 } 959 960#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 961 CHECK_ARGUMENT(!(options & ~SLJIT_DOUBLE_ALIGNMENT)); 962 CHECK_ARGUMENT(args >= 0 && args <= 3); 963 CHECK_ARGUMENT(scratches >= 0 && scratches <= SLJIT_NUMBER_OF_REGISTERS); 964 CHECK_ARGUMENT(saveds >= 0 && saveds <= SLJIT_NUMBER_OF_REGISTERS); 965 CHECK_ARGUMENT(scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS); 966 CHECK_ARGUMENT(args <= saveds); 967 CHECK_ARGUMENT(fscratches >= 0 && fscratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS); 968 CHECK_ARGUMENT(fsaveds >= 0 && fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS); 969 CHECK_ARGUMENT(fscratches + fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS); 970 CHECK_ARGUMENT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE); 971#endif 972#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 973 if (SLJIT_UNLIKELY(!!compiler->verbose)) 974 fprintf(compiler->verbose, " set_context options:none args:%d scratches:%d saveds:%d fscratches:%d fsaveds:%d local_size:%d\n", 975 args, scratches, saveds, fscratches, fsaveds, local_size); 976#endif 977 CHECK_RETURN_OK; 978} 979 980static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw) 981{ 982#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 983 CHECK_ARGUMENT(compiler->scratches >= 0); 984 if (op != SLJIT_UNUSED) { 985 CHECK_ARGUMENT(op >= SLJIT_MOV && op <= SLJIT_MOV_P); 986 FUNCTION_CHECK_SRC(src, srcw); 987 } 988 else 989 CHECK_ARGUMENT(src == 0 && srcw == 0); 990#endif 991#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 992 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 993 if (op == SLJIT_UNUSED) 994 fprintf(compiler->verbose, " return\n"); 995 else { 996 fprintf(compiler->verbose, " return%s ", op1_names[op - SLJIT_OP1_BASE]); 997 sljit_verbose_param(compiler, src, srcw); 998 fprintf(compiler->verbose, "\n"); 999 } 1000 } 1001#endif 1002 CHECK_RETURN_OK; 1003} 1004 1005static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw) 1006{ 1007#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1008 FUNCTION_CHECK_DST(dst, dstw); 1009#endif 1010#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1011 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1012 fprintf(compiler->verbose, " fast_enter "); 1013 sljit_verbose_param(compiler, dst, dstw); 1014 fprintf(compiler->verbose, "\n"); 1015 } 1016#endif 1017 CHECK_RETURN_OK; 1018} 1019 1020static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_s32 src, sljit_sw srcw) 1021{ 1022#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1023 FUNCTION_CHECK_SRC(src, srcw); 1024#endif 1025#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1026 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1027 fprintf(compiler->verbose, " fast_return "); 1028 sljit_verbose_param(compiler, src, srcw); 1029 fprintf(compiler->verbose, "\n"); 1030 } 1031#endif 1032 CHECK_RETURN_OK; 1033} 1034 1035static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op) 1036{ 1037#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1038 CHECK_ARGUMENT((op >= SLJIT_BREAKPOINT && op <= SLJIT_LMUL_SW) 1039 || ((op & ~SLJIT_I32_OP) >= SLJIT_DIVMOD_UW && (op & ~SLJIT_I32_OP) <= SLJIT_DIV_SW)); 1040 CHECK_ARGUMENT(op < SLJIT_LMUL_UW || compiler->scratches >= 2); 1041#endif 1042#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1043 if (SLJIT_UNLIKELY(!!compiler->verbose)) 1044 { 1045 fprintf(compiler->verbose, " %s", op0_names[GET_OPCODE(op) - SLJIT_OP0_BASE]); 1046 if (GET_OPCODE(op) >= SLJIT_DIVMOD_UW) { 1047 fprintf(compiler->verbose, (op & SLJIT_I32_OP) ? "32" : "w"); 1048 } 1049 fprintf(compiler->verbose, "\n"); 1050 } 1051#endif 1052 CHECK_RETURN_OK; 1053} 1054 1055static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op1(struct sljit_compiler *compiler, sljit_s32 op, 1056 sljit_s32 dst, sljit_sw dstw, 1057 sljit_s32 src, sljit_sw srcw) 1058{ 1059 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 1060 compiler->skip_checks = 0; 1061 CHECK_RETURN_OK; 1062 } 1063 1064#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1065 CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_CLZ); 1066 FUNCTION_CHECK_OP(); 1067 FUNCTION_CHECK_SRC(src, srcw); 1068 FUNCTION_CHECK_DST(dst, dstw); 1069 FUNCTION_CHECK_OP1(); 1070#endif 1071#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1072 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1073 if (GET_OPCODE(op) <= SLJIT_MOVU_P) 1074 { 1075 fprintf(compiler->verbose, " mov%s%s%s ", (GET_OPCODE(op) >= SLJIT_MOVU) ? "u" : "", 1076 !(op & SLJIT_I32_OP) ? "" : "32", (op != SLJIT_MOV32 && op != SLJIT_MOVU32) ? op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE] : ""); 1077 } 1078 else 1079 { 1080 fprintf(compiler->verbose, " %s%s%s%s%s%s%s%s ", op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE], !(op & SLJIT_I32_OP) ? "" : "32", 1081 !(op & SLJIT_SET_E) ? "" : ".e", !(op & SLJIT_SET_U) ? "" : ".u", !(op & SLJIT_SET_S) ? "" : ".s", 1082 !(op & SLJIT_SET_O) ? "" : ".o", !(op & SLJIT_SET_C) ? "" : ".c", !(op & SLJIT_KEEP_FLAGS) ? "" : ".k"); 1083 } 1084 1085 sljit_verbose_param(compiler, dst, dstw); 1086 fprintf(compiler->verbose, ", "); 1087 sljit_verbose_param(compiler, src, srcw); 1088 fprintf(compiler->verbose, "\n"); 1089 } 1090#endif 1091 CHECK_RETURN_OK; 1092} 1093 1094static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op2(struct sljit_compiler *compiler, sljit_s32 op, 1095 sljit_s32 dst, sljit_sw dstw, 1096 sljit_s32 src1, sljit_sw src1w, 1097 sljit_s32 src2, sljit_sw src2w) 1098{ 1099 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 1100 compiler->skip_checks = 0; 1101 CHECK_RETURN_OK; 1102 } 1103 1104#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1105 CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_ADD && GET_OPCODE(op) <= SLJIT_ASHR); 1106 FUNCTION_CHECK_OP(); 1107 FUNCTION_CHECK_SRC(src1, src1w); 1108 FUNCTION_CHECK_SRC(src2, src2w); 1109 FUNCTION_CHECK_DST(dst, dstw); 1110#endif 1111#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1112 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1113 fprintf(compiler->verbose, " %s%s%s%s%s%s%s%s ", op2_names[GET_OPCODE(op) - SLJIT_OP2_BASE], !(op & SLJIT_I32_OP) ? "" : "32", 1114 !(op & SLJIT_SET_E) ? "" : ".e", !(op & SLJIT_SET_U) ? "" : ".u", !(op & SLJIT_SET_S) ? "" : ".s", 1115 !(op & SLJIT_SET_O) ? "" : ".o", !(op & SLJIT_SET_C) ? "" : ".c", !(op & SLJIT_KEEP_FLAGS) ? "" : ".k"); 1116 sljit_verbose_param(compiler, dst, dstw); 1117 fprintf(compiler->verbose, ", "); 1118 sljit_verbose_param(compiler, src1, src1w); 1119 fprintf(compiler->verbose, ", "); 1120 sljit_verbose_param(compiler, src2, src2w); 1121 fprintf(compiler->verbose, "\n"); 1122 } 1123#endif 1124 CHECK_RETURN_OK; 1125} 1126 1127static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_register_index(sljit_s32 reg) 1128{ 1129 SLJIT_UNUSED_ARG(reg); 1130#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1131 CHECK_ARGUMENT(reg > 0 && reg <= SLJIT_NUMBER_OF_REGISTERS); 1132#endif 1133 CHECK_RETURN_OK; 1134} 1135 1136static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_float_register_index(sljit_s32 reg) 1137{ 1138 SLJIT_UNUSED_ARG(reg); 1139#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1140 CHECK_ARGUMENT(reg > 0 && reg <= SLJIT_NUMBER_OF_FLOAT_REGISTERS); 1141#endif 1142 CHECK_RETURN_OK; 1143} 1144 1145static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op_custom(struct sljit_compiler *compiler, 1146 void *instruction, sljit_s32 size) 1147{ 1148#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1149 int i; 1150#endif 1151 1152 SLJIT_UNUSED_ARG(compiler); 1153 1154#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1155 CHECK_ARGUMENT(instruction); 1156#if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 1157 CHECK_ARGUMENT(size > 0 && size < 16); 1158#elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) 1159 CHECK_ARGUMENT((size == 2 && (((sljit_sw)instruction) & 0x1) == 0) 1160 || (size == 4 && (((sljit_sw)instruction) & 0x3) == 0)); 1161#else 1162 CHECK_ARGUMENT(size == 4 && (((sljit_sw)instruction) & 0x3) == 0); 1163#endif 1164 1165#endif 1166#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1167 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1168 fprintf(compiler->verbose, " op_custom"); 1169 for (i = 0; i < size; i++) 1170 fprintf(compiler->verbose, " 0x%x", ((sljit_u8*)instruction)[i]); 1171 fprintf(compiler->verbose, "\n"); 1172 } 1173#endif 1174 CHECK_RETURN_OK; 1175} 1176 1177static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1(struct sljit_compiler *compiler, sljit_s32 op, 1178 sljit_s32 dst, sljit_sw dstw, 1179 sljit_s32 src, sljit_sw srcw) 1180{ 1181 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 1182 compiler->skip_checks = 0; 1183 CHECK_RETURN_OK; 1184 } 1185 1186#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1187 CHECK_ARGUMENT(sljit_is_fpu_available()); 1188 CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_MOV_F64 && GET_OPCODE(op) <= SLJIT_ABS_F64); 1189 FUNCTION_CHECK_FOP(); 1190 FUNCTION_FCHECK(src, srcw); 1191 FUNCTION_FCHECK(dst, dstw); 1192#endif 1193#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1194 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1195 if (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_F32) 1196 fprintf(compiler->verbose, " %s%s ", fop1_names[SLJIT_CONV_F64_FROM_F32 - SLJIT_FOP1_BASE], 1197 (op & SLJIT_F32_OP) ? ".f32.from.f64" : ".f64.from.f32"); 1198 else 1199 fprintf(compiler->verbose, " %s%s ", fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE], 1200 (op & SLJIT_F32_OP) ? ".f32" : ".f64"); 1201 1202 sljit_verbose_fparam(compiler, dst, dstw); 1203 fprintf(compiler->verbose, ", "); 1204 sljit_verbose_fparam(compiler, src, srcw); 1205 fprintf(compiler->verbose, "\n"); 1206 } 1207#endif 1208 CHECK_RETURN_OK; 1209} 1210 1211static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_cmp(struct sljit_compiler *compiler, sljit_s32 op, 1212 sljit_s32 src1, sljit_sw src1w, 1213 sljit_s32 src2, sljit_sw src2w) 1214{ 1215 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 1216 compiler->skip_checks = 0; 1217 CHECK_RETURN_OK; 1218 } 1219 1220#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1221 CHECK_ARGUMENT(sljit_is_fpu_available()); 1222 CHECK_ARGUMENT(GET_OPCODE(op) == SLJIT_CMP_F64); 1223 FUNCTION_CHECK_FOP(); 1224 FUNCTION_FCHECK(src1, src1w); 1225 FUNCTION_FCHECK(src2, src2w); 1226#endif 1227#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1228 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1229 fprintf(compiler->verbose, " %s%s%s%s ", fop1_names[SLJIT_CMP_F64 - SLJIT_FOP1_BASE], (op & SLJIT_F32_OP) ? ".f32" : ".f64", 1230 (op & SLJIT_SET_E) ? ".e" : "", (op & SLJIT_SET_S) ? ".s" : ""); 1231 sljit_verbose_fparam(compiler, src1, src1w); 1232 fprintf(compiler->verbose, ", "); 1233 sljit_verbose_fparam(compiler, src2, src2w); 1234 fprintf(compiler->verbose, "\n"); 1235 } 1236#endif 1237 CHECK_RETURN_OK; 1238} 1239 1240static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_conv_sw_from_f64(struct sljit_compiler *compiler, sljit_s32 op, 1241 sljit_s32 dst, sljit_sw dstw, 1242 sljit_s32 src, sljit_sw srcw) 1243{ 1244 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 1245 compiler->skip_checks = 0; 1246 CHECK_RETURN_OK; 1247 } 1248 1249#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1250 CHECK_ARGUMENT(sljit_is_fpu_available()); 1251 CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_CONV_SW_FROM_F64 && GET_OPCODE(op) <= SLJIT_CONV_S32_FROM_F64); 1252 FUNCTION_CHECK_FOP(); 1253 FUNCTION_FCHECK(src, srcw); 1254 FUNCTION_CHECK_DST(dst, dstw); 1255#endif 1256#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1257 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1258 fprintf(compiler->verbose, " %s%s.from%s ", fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE], 1259 (GET_OPCODE(op) == SLJIT_CONV_S32_FROM_F64) ? ".s32" : ".sw", 1260 (op & SLJIT_F32_OP) ? ".f32" : ".f64"); 1261 sljit_verbose_param(compiler, dst, dstw); 1262 fprintf(compiler->verbose, ", "); 1263 sljit_verbose_fparam(compiler, src, srcw); 1264 fprintf(compiler->verbose, "\n"); 1265 } 1266#endif 1267 CHECK_RETURN_OK; 1268} 1269 1270static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_conv_f64_from_sw(struct sljit_compiler *compiler, sljit_s32 op, 1271 sljit_s32 dst, sljit_sw dstw, 1272 sljit_s32 src, sljit_sw srcw) 1273{ 1274 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 1275 compiler->skip_checks = 0; 1276 CHECK_RETURN_OK; 1277 } 1278 1279#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1280 CHECK_ARGUMENT(sljit_is_fpu_available()); 1281 CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_CONV_F64_FROM_SW && GET_OPCODE(op) <= SLJIT_CONV_F64_FROM_S32); 1282 FUNCTION_CHECK_FOP(); 1283 FUNCTION_CHECK_SRC(src, srcw); 1284 FUNCTION_FCHECK(dst, dstw); 1285#endif 1286#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1287 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1288 fprintf(compiler->verbose, " %s%s.from%s ", fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE], 1289 (op & SLJIT_F32_OP) ? ".f32" : ".f64", 1290 (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_S32) ? ".s32" : ".sw"); 1291 sljit_verbose_fparam(compiler, dst, dstw); 1292 fprintf(compiler->verbose, ", "); 1293 sljit_verbose_param(compiler, src, srcw); 1294 fprintf(compiler->verbose, "\n"); 1295 } 1296#endif 1297 CHECK_RETURN_OK; 1298} 1299 1300static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop2(struct sljit_compiler *compiler, sljit_s32 op, 1301 sljit_s32 dst, sljit_sw dstw, 1302 sljit_s32 src1, sljit_sw src1w, 1303 sljit_s32 src2, sljit_sw src2w) 1304{ 1305#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1306 CHECK_ARGUMENT(sljit_is_fpu_available()); 1307 CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_ADD_F64 && GET_OPCODE(op) <= SLJIT_DIV_F64); 1308 FUNCTION_CHECK_FOP(); 1309 FUNCTION_FCHECK(src1, src1w); 1310 FUNCTION_FCHECK(src2, src2w); 1311 FUNCTION_FCHECK(dst, dstw); 1312#endif 1313#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1314 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1315 fprintf(compiler->verbose, " %s%s ", fop2_names[GET_OPCODE(op) - SLJIT_FOP2_BASE], (op & SLJIT_F32_OP) ? ".f32" : ".f64"); 1316 sljit_verbose_fparam(compiler, dst, dstw); 1317 fprintf(compiler->verbose, ", "); 1318 sljit_verbose_fparam(compiler, src1, src1w); 1319 fprintf(compiler->verbose, ", "); 1320 sljit_verbose_fparam(compiler, src2, src2w); 1321 fprintf(compiler->verbose, "\n"); 1322 } 1323#endif 1324 CHECK_RETURN_OK; 1325} 1326 1327static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_label(struct sljit_compiler *compiler) 1328{ 1329 SLJIT_UNUSED_ARG(compiler); 1330 1331#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1332 if (SLJIT_UNLIKELY(!!compiler->verbose)) 1333 fprintf(compiler->verbose, "label:\n"); 1334#endif 1335 CHECK_RETURN_OK; 1336} 1337 1338static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type) 1339{ 1340 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 1341 compiler->skip_checks = 0; 1342 CHECK_RETURN_OK; 1343 } 1344 1345#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1346 CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_I32_OP))); 1347 CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_CALL3); 1348 CHECK_ARGUMENT((type & 0xff) < SLJIT_JUMP || !(type & SLJIT_I32_OP)); 1349 CHECK_ARGUMENT((type & 0xff) <= SLJIT_CALL0 || ((type & 0xff) - SLJIT_CALL0) <= compiler->scratches); 1350#endif 1351#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1352 if (SLJIT_UNLIKELY(!!compiler->verbose)) 1353 fprintf(compiler->verbose, " jump%s %s%s\n", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r", 1354 jump_names[type & 0xff], JUMP_POSTFIX(type)); 1355#endif 1356 CHECK_RETURN_OK; 1357} 1358 1359static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_cmp(struct sljit_compiler *compiler, sljit_s32 type, 1360 sljit_s32 src1, sljit_sw src1w, 1361 sljit_s32 src2, sljit_sw src2w) 1362{ 1363#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1364 CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_I32_OP))); 1365 CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_SIG_LESS_EQUAL); 1366 FUNCTION_CHECK_SRC(src1, src1w); 1367 FUNCTION_CHECK_SRC(src2, src2w); 1368#endif 1369#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1370 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1371 fprintf(compiler->verbose, " cmp%s %s%s, ", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r", 1372 jump_names[type & 0xff], (type & SLJIT_I32_OP) ? "32" : ""); 1373 sljit_verbose_param(compiler, src1, src1w); 1374 fprintf(compiler->verbose, ", "); 1375 sljit_verbose_param(compiler, src2, src2w); 1376 fprintf(compiler->verbose, "\n"); 1377 } 1378#endif 1379 CHECK_RETURN_OK; 1380} 1381 1382static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_s32 type, 1383 sljit_s32 src1, sljit_sw src1w, 1384 sljit_s32 src2, sljit_sw src2w) 1385{ 1386#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1387 CHECK_ARGUMENT(sljit_is_fpu_available()); 1388 CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_F32_OP))); 1389 CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL_F64 && (type & 0xff) <= SLJIT_ORDERED_F64); 1390 FUNCTION_FCHECK(src1, src1w); 1391 FUNCTION_FCHECK(src2, src2w); 1392#endif 1393#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1394 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1395 fprintf(compiler->verbose, " fcmp%s %s%s, ", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r", 1396 jump_names[type & 0xff], (type & SLJIT_F32_OP) ? ".f32" : ".f64"); 1397 sljit_verbose_fparam(compiler, src1, src1w); 1398 fprintf(compiler->verbose, ", "); 1399 sljit_verbose_fparam(compiler, src2, src2w); 1400 fprintf(compiler->verbose, "\n"); 1401 } 1402#endif 1403 CHECK_RETURN_OK; 1404} 1405 1406static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw) 1407{ 1408 if (SLJIT_UNLIKELY(compiler->skip_checks)) { 1409 compiler->skip_checks = 0; 1410 CHECK_RETURN_OK; 1411 } 1412 1413#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1414 CHECK_ARGUMENT(type >= SLJIT_JUMP && type <= SLJIT_CALL3); 1415 CHECK_ARGUMENT(type <= SLJIT_CALL0 || (type - SLJIT_CALL0) <= compiler->scratches); 1416 FUNCTION_CHECK_SRC(src, srcw); 1417#endif 1418#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1419 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1420 fprintf(compiler->verbose, " ijump.%s ", jump_names[type]); 1421 sljit_verbose_param(compiler, src, srcw); 1422 fprintf(compiler->verbose, "\n"); 1423 } 1424#endif 1425 CHECK_RETURN_OK; 1426} 1427 1428static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_s32 op, 1429 sljit_s32 dst, sljit_sw dstw, 1430 sljit_s32 src, sljit_sw srcw, 1431 sljit_s32 type) 1432{ 1433#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1434 CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_I32_OP))); 1435 CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_ORDERED_F64); 1436 CHECK_ARGUMENT(op == SLJIT_MOV || GET_OPCODE(op) == SLJIT_MOV_U32 || GET_OPCODE(op) == SLJIT_MOV_S32 1437 || (GET_OPCODE(op) >= SLJIT_AND && GET_OPCODE(op) <= SLJIT_XOR)); 1438 CHECK_ARGUMENT((op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C)) == 0); 1439 CHECK_ARGUMENT((op & (SLJIT_SET_E | SLJIT_KEEP_FLAGS)) != (SLJIT_SET_E | SLJIT_KEEP_FLAGS)); 1440 if (GET_OPCODE(op) < SLJIT_ADD) { 1441 CHECK_ARGUMENT(src == SLJIT_UNUSED && srcw == 0); 1442 } else { 1443 CHECK_ARGUMENT(src == dst && srcw == dstw); 1444 } 1445 FUNCTION_CHECK_DST(dst, dstw); 1446#endif 1447#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1448 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1449 fprintf(compiler->verbose, " flags %s%s%s%s, ", 1450 !(op & SLJIT_SET_E) ? "" : ".e", !(op & SLJIT_KEEP_FLAGS) ? "" : ".k", 1451 GET_OPCODE(op) < SLJIT_OP2_BASE ? "mov" : op2_names[GET_OPCODE(op) - SLJIT_OP2_BASE], 1452 GET_OPCODE(op) < SLJIT_OP2_BASE ? op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE] : ((op & SLJIT_I32_OP) ? "32" : "")); 1453 sljit_verbose_param(compiler, dst, dstw); 1454 if (src != SLJIT_UNUSED) { 1455 fprintf(compiler->verbose, ", "); 1456 sljit_verbose_param(compiler, src, srcw); 1457 } 1458 fprintf(compiler->verbose, ", %s%s\n", jump_names[type & 0xff], JUMP_POSTFIX(type)); 1459 } 1460#endif 1461 CHECK_RETURN_OK; 1462} 1463 1464static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_local_base(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw offset) 1465{ 1466 SLJIT_UNUSED_ARG(offset); 1467 1468#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1469 FUNCTION_CHECK_DST(dst, dstw); 1470#endif 1471#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1472 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1473 fprintf(compiler->verbose, " local_base "); 1474 sljit_verbose_param(compiler, dst, dstw); 1475 fprintf(compiler->verbose, ", #%" SLJIT_PRINT_D "d\n", offset); 1476 } 1477#endif 1478 CHECK_RETURN_OK; 1479} 1480 1481static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw init_value) 1482{ 1483 SLJIT_UNUSED_ARG(init_value); 1484 1485#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1486 FUNCTION_CHECK_DST(dst, dstw); 1487#endif 1488#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1489 if (SLJIT_UNLIKELY(!!compiler->verbose)) { 1490 fprintf(compiler->verbose, " const "); 1491 sljit_verbose_param(compiler, dst, dstw); 1492 fprintf(compiler->verbose, ", #%" SLJIT_PRINT_D "d\n", init_value); 1493 } 1494#endif 1495 CHECK_RETURN_OK; 1496} 1497 1498#endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_VERBOSE */ 1499 1500#define SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw) \ 1501 SLJIT_COMPILE_ASSERT(!(SLJIT_CONV_SW_FROM_F64 & 0x1) && !(SLJIT_CONV_F64_FROM_SW & 0x1), \ 1502 invalid_float_opcodes); \ 1503 if (GET_OPCODE(op) >= SLJIT_CONV_SW_FROM_F64 && GET_OPCODE(op) <= SLJIT_CMP_F64) { \ 1504 if (GET_OPCODE(op) == SLJIT_CMP_F64) { \ 1505 CHECK(check_sljit_emit_fop1_cmp(compiler, op, dst, dstw, src, srcw)); \ 1506 ADJUST_LOCAL_OFFSET(dst, dstw); \ 1507 ADJUST_LOCAL_OFFSET(src, srcw); \ 1508 return sljit_emit_fop1_cmp(compiler, op, dst, dstw, src, srcw); \ 1509 } \ 1510 if ((GET_OPCODE(op) | 0x1) == SLJIT_CONV_S32_FROM_F64) { \ 1511 CHECK(check_sljit_emit_fop1_conv_sw_from_f64(compiler, op, dst, dstw, src, srcw)); \ 1512 ADJUST_LOCAL_OFFSET(dst, dstw); \ 1513 ADJUST_LOCAL_OFFSET(src, srcw); \ 1514 return sljit_emit_fop1_conv_sw_from_f64(compiler, op, dst, dstw, src, srcw); \ 1515 } \ 1516 CHECK(check_sljit_emit_fop1_conv_f64_from_sw(compiler, op, dst, dstw, src, srcw)); \ 1517 ADJUST_LOCAL_OFFSET(dst, dstw); \ 1518 ADJUST_LOCAL_OFFSET(src, srcw); \ 1519 return sljit_emit_fop1_conv_f64_from_sw(compiler, op, dst, dstw, src, srcw); \ 1520 } \ 1521 CHECK(check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw)); \ 1522 ADJUST_LOCAL_OFFSET(dst, dstw); \ 1523 ADJUST_LOCAL_OFFSET(src, srcw); 1524 1525static SLJIT_INLINE sljit_s32 emit_mov_before_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw) 1526{ 1527 /* Return if don't need to do anything. */ 1528 if (op == SLJIT_UNUSED) 1529 return SLJIT_SUCCESS; 1530 1531#if (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1532 /* At the moment the pointer size is always equal to sljit_sw. May be changed in the future. */ 1533 if (src == SLJIT_RETURN_REG && (op == SLJIT_MOV || op == SLJIT_MOV_P)) 1534 return SLJIT_SUCCESS; 1535#else 1536 if (src == SLJIT_RETURN_REG && (op == SLJIT_MOV || op == SLJIT_MOV_U32 || op == SLJIT_MOV_S32 || op == SLJIT_MOV_P)) 1537 return SLJIT_SUCCESS; 1538#endif 1539 1540#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \ 1541 || (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1542 compiler->skip_checks = 1; 1543#endif 1544 return sljit_emit_op1(compiler, op, SLJIT_RETURN_REG, 0, src, srcw); 1545} 1546 1547/* CPU description section */ 1548 1549#if (defined SLJIT_32BIT_ARCHITECTURE && SLJIT_32BIT_ARCHITECTURE) 1550#define SLJIT_CPUINFO_PART1 " 32bit (" 1551#elif (defined SLJIT_64BIT_ARCHITECTURE && SLJIT_64BIT_ARCHITECTURE) 1552#define SLJIT_CPUINFO_PART1 " 64bit (" 1553#else 1554#error "Internal error: CPU type info missing" 1555#endif 1556 1557#if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN) 1558#define SLJIT_CPUINFO_PART2 "little endian + " 1559#elif (defined SLJIT_BIG_ENDIAN && SLJIT_BIG_ENDIAN) 1560#define SLJIT_CPUINFO_PART2 "big endian + " 1561#else 1562#error "Internal error: CPU type info missing" 1563#endif 1564 1565#if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED) 1566#define SLJIT_CPUINFO_PART3 "unaligned)" 1567#else 1568#define SLJIT_CPUINFO_PART3 "aligned)" 1569#endif 1570 1571#define SLJIT_CPUINFO SLJIT_CPUINFO_PART1 SLJIT_CPUINFO_PART2 SLJIT_CPUINFO_PART3 1572 1573#if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 1574# include "sljitNativeX86_common.c" 1575#elif (defined SLJIT_CONFIG_ARM_V5 && SLJIT_CONFIG_ARM_V5) 1576# include "sljitNativeARM_32.c" 1577#elif (defined SLJIT_CONFIG_ARM_V7 && SLJIT_CONFIG_ARM_V7) 1578# include "sljitNativeARM_32.c" 1579#elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2) 1580# include "sljitNativeARM_T2_32.c" 1581#elif (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) 1582# include "sljitNativeARM_64.c" 1583#elif (defined SLJIT_CONFIG_PPC && SLJIT_CONFIG_PPC) 1584# include "sljitNativePPC_common.c" 1585#elif (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) 1586# include "sljitNativeMIPS_common.c" 1587#elif (defined SLJIT_CONFIG_SPARC && SLJIT_CONFIG_SPARC) 1588# include "sljitNativeSPARC_common.c" 1589#elif (defined SLJIT_CONFIG_TILEGX && SLJIT_CONFIG_TILEGX) 1590# include "sljitNativeTILEGX_64.c" 1591#endif 1592 1593#if !(defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS) 1594 1595SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_s32 type, 1596 sljit_s32 src1, sljit_sw src1w, 1597 sljit_s32 src2, sljit_sw src2w) 1598{ 1599 /* Default compare for most architectures. */ 1600 sljit_s32 flags, tmp_src, condition; 1601 sljit_sw tmp_srcw; 1602 1603 CHECK_ERROR_PTR(); 1604 CHECK_PTR(check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w)); 1605 1606 condition = type & 0xff; 1607#if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64) 1608 if ((condition == SLJIT_EQUAL || condition == SLJIT_NOT_EQUAL)) { 1609 if ((src1 & SLJIT_IMM) && !src1w) { 1610 src1 = src2; 1611 src1w = src2w; 1612 src2 = SLJIT_IMM; 1613 src2w = 0; 1614 } 1615 if ((src2 & SLJIT_IMM) && !src2w) 1616 return emit_cmp_to0(compiler, type, src1, src1w); 1617 } 1618#endif 1619 1620 if (SLJIT_UNLIKELY((src1 & SLJIT_IMM) && !(src2 & SLJIT_IMM))) { 1621 /* Immediate is prefered as second argument by most architectures. */ 1622 switch (condition) { 1623 case SLJIT_LESS: 1624 condition = SLJIT_GREATER; 1625 break; 1626 case SLJIT_GREATER_EQUAL: 1627 condition = SLJIT_LESS_EQUAL; 1628 break; 1629 case SLJIT_GREATER: 1630 condition = SLJIT_LESS; 1631 break; 1632 case SLJIT_LESS_EQUAL: 1633 condition = SLJIT_GREATER_EQUAL; 1634 break; 1635 case SLJIT_SIG_LESS: 1636 condition = SLJIT_SIG_GREATER; 1637 break; 1638 case SLJIT_SIG_GREATER_EQUAL: 1639 condition = SLJIT_SIG_LESS_EQUAL; 1640 break; 1641 case SLJIT_SIG_GREATER: 1642 condition = SLJIT_SIG_LESS; 1643 break; 1644 case SLJIT_SIG_LESS_EQUAL: 1645 condition = SLJIT_SIG_GREATER_EQUAL; 1646 break; 1647 } 1648 type = condition | (type & (SLJIT_I32_OP | SLJIT_REWRITABLE_JUMP)); 1649 tmp_src = src1; 1650 src1 = src2; 1651 src2 = tmp_src; 1652 tmp_srcw = src1w; 1653 src1w = src2w; 1654 src2w = tmp_srcw; 1655 } 1656 1657 if (condition <= SLJIT_NOT_ZERO) 1658 flags = SLJIT_SET_E; 1659 else if (condition <= SLJIT_LESS_EQUAL) 1660 flags = SLJIT_SET_U; 1661 else 1662 flags = SLJIT_SET_S; 1663 1664#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \ 1665 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1666 compiler->skip_checks = 1; 1667#endif 1668 PTR_FAIL_IF(sljit_emit_op2(compiler, SLJIT_SUB | flags | (type & SLJIT_I32_OP), 1669 SLJIT_UNUSED, 0, src1, src1w, src2, src2w)); 1670#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \ 1671 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1672 compiler->skip_checks = 1; 1673#endif 1674 return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP)); 1675} 1676 1677SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_s32 type, 1678 sljit_s32 src1, sljit_sw src1w, 1679 sljit_s32 src2, sljit_sw src2w) 1680{ 1681 sljit_s32 flags, condition; 1682 1683 CHECK_ERROR_PTR(); 1684 CHECK_PTR(check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w)); 1685 1686 condition = type & 0xff; 1687 flags = (condition <= SLJIT_NOT_EQUAL_F64) ? SLJIT_SET_E : SLJIT_SET_S; 1688 if (type & SLJIT_F32_OP) 1689 flags |= SLJIT_F32_OP; 1690 1691#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \ 1692 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1693 compiler->skip_checks = 1; 1694#endif 1695 sljit_emit_fop1(compiler, SLJIT_CMP_F64 | flags, src1, src1w, src2, src2w); 1696 1697#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \ 1698 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1699 compiler->skip_checks = 1; 1700#endif 1701 return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP)); 1702} 1703 1704#endif 1705 1706#if !(defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) 1707 1708SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_local_base(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw offset) 1709{ 1710 CHECK_ERROR(); 1711 CHECK(check_sljit_get_local_base(compiler, dst, dstw, offset)); 1712 1713 ADJUST_LOCAL_OFFSET(SLJIT_MEM1(SLJIT_SP), offset); 1714#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \ 1715 || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) 1716 compiler->skip_checks = 1; 1717#endif 1718 if (offset != 0) 1719 return sljit_emit_op2(compiler, SLJIT_ADD | SLJIT_KEEP_FLAGS, dst, dstw, SLJIT_SP, 0, SLJIT_IMM, offset); 1720 return sljit_emit_op1(compiler, SLJIT_MOV, dst, dstw, SLJIT_SP, 0); 1721} 1722 1723#endif 1724 1725#else /* SLJIT_CONFIG_UNSUPPORTED */ 1726 1727/* Empty function bodies for those machines, which are not (yet) supported. */ 1728 1729SLJIT_API_FUNC_ATTRIBUTE const char* sljit_get_platform_name(void) 1730{ 1731 return "unsupported"; 1732} 1733 1734SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler* sljit_create_compiler(void) 1735{ 1736 SLJIT_ASSERT_STOP(); 1737 return NULL; 1738} 1739 1740SLJIT_API_FUNC_ATTRIBUTE void sljit_free_compiler(struct sljit_compiler *compiler) 1741{ 1742 SLJIT_UNUSED_ARG(compiler); 1743 SLJIT_ASSERT_STOP(); 1744} 1745 1746SLJIT_API_FUNC_ATTRIBUTE void* sljit_alloc_memory(struct sljit_compiler *compiler, sljit_s32 size) 1747{ 1748 SLJIT_UNUSED_ARG(compiler); 1749 SLJIT_UNUSED_ARG(size); 1750 SLJIT_ASSERT_STOP(); 1751 return NULL; 1752} 1753 1754#if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) 1755SLJIT_API_FUNC_ATTRIBUTE void sljit_compiler_verbose(struct sljit_compiler *compiler, FILE* verbose) 1756{ 1757 SLJIT_UNUSED_ARG(compiler); 1758 SLJIT_UNUSED_ARG(verbose); 1759 SLJIT_ASSERT_STOP(); 1760} 1761#endif 1762 1763SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler) 1764{ 1765 SLJIT_UNUSED_ARG(compiler); 1766 SLJIT_ASSERT_STOP(); 1767 return NULL; 1768} 1769 1770SLJIT_API_FUNC_ATTRIBUTE void sljit_free_code(void* code) 1771{ 1772 SLJIT_UNUSED_ARG(code); 1773 SLJIT_ASSERT_STOP(); 1774} 1775 1776SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_enter(struct sljit_compiler *compiler, 1777 sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds, 1778 sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size) 1779{ 1780 SLJIT_UNUSED_ARG(compiler); 1781 SLJIT_UNUSED_ARG(options); 1782 SLJIT_UNUSED_ARG(args); 1783 SLJIT_UNUSED_ARG(scratches); 1784 SLJIT_UNUSED_ARG(saveds); 1785 SLJIT_UNUSED_ARG(fscratches); 1786 SLJIT_UNUSED_ARG(fsaveds); 1787 SLJIT_UNUSED_ARG(local_size); 1788 SLJIT_ASSERT_STOP(); 1789 return SLJIT_ERR_UNSUPPORTED; 1790} 1791 1792SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_set_context(struct sljit_compiler *compiler, 1793 sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds, 1794 sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size) 1795{ 1796 SLJIT_UNUSED_ARG(compiler); 1797 SLJIT_UNUSED_ARG(options); 1798 SLJIT_UNUSED_ARG(args); 1799 SLJIT_UNUSED_ARG(scratches); 1800 SLJIT_UNUSED_ARG(saveds); 1801 SLJIT_UNUSED_ARG(fscratches); 1802 SLJIT_UNUSED_ARG(fsaveds); 1803 SLJIT_UNUSED_ARG(local_size); 1804 SLJIT_ASSERT_STOP(); 1805 return SLJIT_ERR_UNSUPPORTED; 1806} 1807 1808SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw) 1809{ 1810 SLJIT_UNUSED_ARG(compiler); 1811 SLJIT_UNUSED_ARG(op); 1812 SLJIT_UNUSED_ARG(src); 1813 SLJIT_UNUSED_ARG(srcw); 1814 SLJIT_ASSERT_STOP(); 1815 return SLJIT_ERR_UNSUPPORTED; 1816} 1817 1818SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw) 1819{ 1820 SLJIT_UNUSED_ARG(compiler); 1821 SLJIT_UNUSED_ARG(dst); 1822 SLJIT_UNUSED_ARG(dstw); 1823 SLJIT_ASSERT_STOP(); 1824 return SLJIT_ERR_UNSUPPORTED; 1825} 1826 1827SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_s32 src, sljit_sw srcw) 1828{ 1829 SLJIT_UNUSED_ARG(compiler); 1830 SLJIT_UNUSED_ARG(src); 1831 SLJIT_UNUSED_ARG(srcw); 1832 SLJIT_ASSERT_STOP(); 1833 return SLJIT_ERR_UNSUPPORTED; 1834} 1835 1836SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op) 1837{ 1838 SLJIT_UNUSED_ARG(compiler); 1839 SLJIT_UNUSED_ARG(op); 1840 SLJIT_ASSERT_STOP(); 1841 return SLJIT_ERR_UNSUPPORTED; 1842} 1843 1844SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op1(struct sljit_compiler *compiler, sljit_s32 op, 1845 sljit_s32 dst, sljit_sw dstw, 1846 sljit_s32 src, sljit_sw srcw) 1847{ 1848 SLJIT_UNUSED_ARG(compiler); 1849 SLJIT_UNUSED_ARG(op); 1850 SLJIT_UNUSED_ARG(dst); 1851 SLJIT_UNUSED_ARG(dstw); 1852 SLJIT_UNUSED_ARG(src); 1853 SLJIT_UNUSED_ARG(srcw); 1854 SLJIT_ASSERT_STOP(); 1855 return SLJIT_ERR_UNSUPPORTED; 1856} 1857 1858SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2(struct sljit_compiler *compiler, sljit_s32 op, 1859 sljit_s32 dst, sljit_sw dstw, 1860 sljit_s32 src1, sljit_sw src1w, 1861 sljit_s32 src2, sljit_sw src2w) 1862{ 1863 SLJIT_UNUSED_ARG(compiler); 1864 SLJIT_UNUSED_ARG(op); 1865 SLJIT_UNUSED_ARG(dst); 1866 SLJIT_UNUSED_ARG(dstw); 1867 SLJIT_UNUSED_ARG(src1); 1868 SLJIT_UNUSED_ARG(src1w); 1869 SLJIT_UNUSED_ARG(src2); 1870 SLJIT_UNUSED_ARG(src2w); 1871 SLJIT_ASSERT_STOP(); 1872 return SLJIT_ERR_UNSUPPORTED; 1873} 1874 1875SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_register_index(sljit_s32 reg) 1876{ 1877 SLJIT_ASSERT_STOP(); 1878 return reg; 1879} 1880 1881SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_custom(struct sljit_compiler *compiler, 1882 void *instruction, sljit_s32 size) 1883{ 1884 SLJIT_UNUSED_ARG(compiler); 1885 SLJIT_UNUSED_ARG(instruction); 1886 SLJIT_UNUSED_ARG(size); 1887 SLJIT_ASSERT_STOP(); 1888 return SLJIT_ERR_UNSUPPORTED; 1889} 1890 1891SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_is_fpu_available(void) 1892{ 1893 SLJIT_ASSERT_STOP(); 1894 return 0; 1895} 1896 1897SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop1(struct sljit_compiler *compiler, sljit_s32 op, 1898 sljit_s32 dst, sljit_sw dstw, 1899 sljit_s32 src, sljit_sw srcw) 1900{ 1901 SLJIT_UNUSED_ARG(compiler); 1902 SLJIT_UNUSED_ARG(op); 1903 SLJIT_UNUSED_ARG(dst); 1904 SLJIT_UNUSED_ARG(dstw); 1905 SLJIT_UNUSED_ARG(src); 1906 SLJIT_UNUSED_ARG(srcw); 1907 SLJIT_ASSERT_STOP(); 1908 return SLJIT_ERR_UNSUPPORTED; 1909} 1910 1911SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop2(struct sljit_compiler *compiler, sljit_s32 op, 1912 sljit_s32 dst, sljit_sw dstw, 1913 sljit_s32 src1, sljit_sw src1w, 1914 sljit_s32 src2, sljit_sw src2w) 1915{ 1916 SLJIT_UNUSED_ARG(compiler); 1917 SLJIT_UNUSED_ARG(op); 1918 SLJIT_UNUSED_ARG(dst); 1919 SLJIT_UNUSED_ARG(dstw); 1920 SLJIT_UNUSED_ARG(src1); 1921 SLJIT_UNUSED_ARG(src1w); 1922 SLJIT_UNUSED_ARG(src2); 1923 SLJIT_UNUSED_ARG(src2w); 1924 SLJIT_ASSERT_STOP(); 1925 return SLJIT_ERR_UNSUPPORTED; 1926} 1927 1928SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler) 1929{ 1930 SLJIT_UNUSED_ARG(compiler); 1931 SLJIT_ASSERT_STOP(); 1932 return NULL; 1933} 1934 1935SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type) 1936{ 1937 SLJIT_UNUSED_ARG(compiler); 1938 SLJIT_UNUSED_ARG(type); 1939 SLJIT_ASSERT_STOP(); 1940 return NULL; 1941} 1942 1943SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_s32 type, 1944 sljit_s32 src1, sljit_sw src1w, 1945 sljit_s32 src2, sljit_sw src2w) 1946{ 1947 SLJIT_UNUSED_ARG(compiler); 1948 SLJIT_UNUSED_ARG(type); 1949 SLJIT_UNUSED_ARG(src1); 1950 SLJIT_UNUSED_ARG(src1w); 1951 SLJIT_UNUSED_ARG(src2); 1952 SLJIT_UNUSED_ARG(src2w); 1953 SLJIT_ASSERT_STOP(); 1954 return NULL; 1955} 1956 1957SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_s32 type, 1958 sljit_s32 src1, sljit_sw src1w, 1959 sljit_s32 src2, sljit_sw src2w) 1960{ 1961 SLJIT_UNUSED_ARG(compiler); 1962 SLJIT_UNUSED_ARG(type); 1963 SLJIT_UNUSED_ARG(src1); 1964 SLJIT_UNUSED_ARG(src1w); 1965 SLJIT_UNUSED_ARG(src2); 1966 SLJIT_UNUSED_ARG(src2w); 1967 SLJIT_ASSERT_STOP(); 1968 return NULL; 1969} 1970 1971SLJIT_API_FUNC_ATTRIBUTE void sljit_set_label(struct sljit_jump *jump, struct sljit_label* label) 1972{ 1973 SLJIT_UNUSED_ARG(jump); 1974 SLJIT_UNUSED_ARG(label); 1975 SLJIT_ASSERT_STOP(); 1976} 1977 1978SLJIT_API_FUNC_ATTRIBUTE void sljit_set_target(struct sljit_jump *jump, sljit_uw target) 1979{ 1980 SLJIT_UNUSED_ARG(jump); 1981 SLJIT_UNUSED_ARG(target); 1982 SLJIT_ASSERT_STOP(); 1983} 1984 1985SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw) 1986{ 1987 SLJIT_UNUSED_ARG(compiler); 1988 SLJIT_UNUSED_ARG(type); 1989 SLJIT_UNUSED_ARG(src); 1990 SLJIT_UNUSED_ARG(srcw); 1991 SLJIT_ASSERT_STOP(); 1992 return SLJIT_ERR_UNSUPPORTED; 1993} 1994 1995SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_s32 op, 1996 sljit_s32 dst, sljit_sw dstw, 1997 sljit_s32 src, sljit_sw srcw, 1998 sljit_s32 type) 1999{ 2000 SLJIT_UNUSED_ARG(compiler); 2001 SLJIT_UNUSED_ARG(op); 2002 SLJIT_UNUSED_ARG(dst); 2003 SLJIT_UNUSED_ARG(dstw); 2004 SLJIT_UNUSED_ARG(src); 2005 SLJIT_UNUSED_ARG(srcw); 2006 SLJIT_UNUSED_ARG(type); 2007 SLJIT_ASSERT_STOP(); 2008 return SLJIT_ERR_UNSUPPORTED; 2009} 2010 2011SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_local_base(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw offset) 2012{ 2013 SLJIT_UNUSED_ARG(compiler); 2014 SLJIT_UNUSED_ARG(dst); 2015 SLJIT_UNUSED_ARG(dstw); 2016 SLJIT_UNUSED_ARG(offset); 2017 SLJIT_ASSERT_STOP(); 2018 return SLJIT_ERR_UNSUPPORTED; 2019} 2020 2021SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw initval) 2022{ 2023 SLJIT_UNUSED_ARG(compiler); 2024 SLJIT_UNUSED_ARG(dst); 2025 SLJIT_UNUSED_ARG(dstw); 2026 SLJIT_UNUSED_ARG(initval); 2027 SLJIT_ASSERT_STOP(); 2028 return NULL; 2029} 2030 2031SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr) 2032{ 2033 SLJIT_UNUSED_ARG(addr); 2034 SLJIT_UNUSED_ARG(new_addr); 2035 SLJIT_ASSERT_STOP(); 2036} 2037 2038SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant) 2039{ 2040 SLJIT_UNUSED_ARG(addr); 2041 SLJIT_UNUSED_ARG(new_constant); 2042 SLJIT_ASSERT_STOP(); 2043} 2044 2045#endif 2046