/[pcre]/code/trunk/sljit/sljitLir.c
ViewVC logotype

Diff of /code/trunk/sljit/sljitLir.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1505 by zherczeg, Mon Aug 11 06:42:28 2014 UTC revision 1506 by zherczeg, Sat Sep 27 06:25:26 2014 UTC
# Line 38  Line 38 
38                          return NULL; \                          return NULL; \
39          } while (0)          } while (0)
40    
 #define CHECK_ERROR_VOID() \  
         do { \  
                 if (SLJIT_UNLIKELY(compiler->error)) \  
                         return; \  
         } while (0)  
   
41  #define FAIL_IF(expr) \  #define FAIL_IF(expr) \
42          do { \          do { \
43                  if (SLJIT_UNLIKELY(expr)) \                  if (SLJIT_UNLIKELY(expr)) \
# Line 236  Line 230 
230                  (saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? saveds : SLJIT_NUMBER_OF_SAVED_REGISTERS) + \                  (saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? saveds : SLJIT_NUMBER_OF_SAVED_REGISTERS) + \
231                  extra) * sizeof(sljit_sw))                  extra) * sizeof(sljit_sw))
232    
233  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #define ADJUST_LOCAL_OFFSET(p, i) \
234  #define SLJIT_HAS_FIXED_LOCALS_OFFSET 1          if ((p) == (SLJIT_MEM1(SLJIT_SP))) \
235                    (i) += SLJIT_LOCALS_OFFSET;
 #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)  
 #define FIXED_LOCALS_OFFSET ((2 + 4) * sizeof(sljit_sw))  
 #else  
 /* Maximum 3 arguments are passed on the stack. */  
 #define FIXED_LOCALS_OFFSET ((3 + 4) * sizeof(sljit_sw))  
 #endif  
   
 #endif /* SLJIT_CONFIG_X86_32 */  
   
 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  
 #define SLJIT_HAS_FIXED_LOCALS_OFFSET 1  
 #ifdef _WIN64  
 #define FIXED_LOCALS_OFFSET ((4 + 2) * sizeof(sljit_sw))  
 #else  
 #define FIXED_LOCALS_OFFSET (sizeof(sljit_sw))  
 #endif  
 #endif  
236    
237  #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)  #endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */
 #define SLJIT_HAS_VARIABLE_LOCALS_OFFSET 1  
 #endif  
238    
239  #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)  /* Utils can still be used even if SLJIT_CONFIG_UNSUPPORTED is set. */
240  #define SLJIT_HAS_FIXED_LOCALS_OFFSET 1  #include "sljitUtils.c"
 #ifdef _AIX  
 #define FIXED_LOCALS_OFFSET ((6 + 8) * sizeof(sljit_sw))  
 #else  
 #define FIXED_LOCALS_OFFSET (3 * sizeof(sljit_sw))  
 #endif  
 #endif  
241    
242  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)
 #define SLJIT_HAS_FIXED_LOCALS_OFFSET 1  
 #define FIXED_LOCALS_OFFSET ((6 + 8) * sizeof(sljit_sw))  
 #endif  
243    
244  #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)  #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)
245  #define SLJIT_HAS_FIXED_LOCALS_OFFSET 1  #include "sljitExecAllocator.c"
 #define FIXED_LOCALS_OFFSET (4 * sizeof(sljit_sw))  
246  #endif  #endif
247    
248  #if (defined SLJIT_CONFIG_MIPS_64 && SLJIT_CONFIG_MIPS_64)  /* Argument checking features. */
 #define SLJIT_HAS_FIXED_LOCALS_OFFSET 1  
 #define FIXED_LOCALS_OFFSET 0  
 #endif  
249    
250  #if (defined SLJIT_CONFIG_SPARC_32 && SLJIT_CONFIG_SPARC_32)  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
 #define SLJIT_HAS_FIXED_LOCALS_OFFSET 1  
 #define FIXED_LOCALS_OFFSET (23 * sizeof(sljit_sw))  
 #endif  
251    
252  #if (defined SLJIT_HAS_VARIABLE_LOCALS_OFFSET && SLJIT_HAS_VARIABLE_LOCALS_OFFSET)  /* Returns with error when an invalid argument is passed. */
253    
254  #define ADJUST_LOCAL_OFFSET(p, i) \  #define CHECK_ARGUMENT(x) \
255          if ((p) == (SLJIT_MEM1(SLJIT_SP))) \          do { \
256                  (i) += compiler->locals_offset;                  if (SLJIT_UNLIKELY(!(x))) \
257                            return 1; \
258            } while (0)
259    
260  #elif (defined SLJIT_HAS_FIXED_LOCALS_OFFSET && SLJIT_HAS_FIXED_LOCALS_OFFSET)  #define CHECK_RETURN_TYPE sljit_si
261    #define CHECK_RETURN_OK return 0
262    
263  #define ADJUST_LOCAL_OFFSET(p, i) \  #define CHECK(x) \
264          if ((p) == (SLJIT_MEM1(SLJIT_SP))) \          do { \
265                  (i) += FIXED_LOCALS_OFFSET;                  if (SLJIT_UNLIKELY(x)) { \
266                            compiler->error = SLJIT_ERR_BAD_ARGUMENT; \
267                            return SLJIT_ERR_BAD_ARGUMENT; \
268                    } \
269            } while (0)
270    
271  #else  #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 ADJUST_LOCAL_OFFSET(p, i)  #define CHECK_REG_INDEX(x) \
280            do { \
281                    if (SLJIT_UNLIKELY(x)) { \
282                            return -2; \
283                    } \
284            } while (0)
285    
286  #endif  #elif (defined SLJIT_DEBUG && SLJIT_DEBUG)
287    
288  #endif /* !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED) */  /* 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  /* Utils can still be used even if SLJIT_CONFIG_UNSUPPORTED is set. */  #else
 #include "sljitUtils.c"  
309    
310  #if !(defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED)  /* Arguments are not checked. */
311    #define CHECK(x)
312    #define CHECK_PTR(x)
313    #define CHECK_REG_INDEX(x)
314    
315  #if (defined SLJIT_EXECUTABLE_ALLOCATOR && SLJIT_EXECUTABLE_ALLOCATOR)  #endif /* SLJIT_ARGUMENT_CHECKS */
 #include "sljitExecAllocator.c"  
 #endif  
316    
317  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
318  /*  Public functions                                                     */  /*  Public functions                                                     */
# Line 375  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co Line 370  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co
370          compiler->saveds = -1;          compiler->saveds = -1;
371          compiler->fscratches = -1;          compiler->fscratches = -1;
372          compiler->fsaveds = -1;          compiler->fsaveds = -1;
373            compiler->local_size = -1;
374    
375  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
376          compiler->args = -1;          compiler->args = -1;
# Line 547  static SLJIT_INLINE void reverse_buf(str Line 543  static SLJIT_INLINE void reverse_buf(str
543          compiler->buf = prev;          compiler->buf = prev;
544  }  }
545    
546    static SLJIT_INLINE void set_emit_enter(struct sljit_compiler *compiler,
547            sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,
548            sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)
549    {
550            SLJIT_UNUSED_ARG(local_size);
551    
552            compiler->options = options;
553            compiler->scratches = scratches;
554            compiler->saveds = saveds;
555            compiler->fscratches = fscratches;
556            compiler->fsaveds = fsaveds;
557    #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
558            compiler->logical_local_size = local_size;
559    #endif
560    }
561    
562    static SLJIT_INLINE void set_set_context(struct sljit_compiler *compiler,
563            sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,
564            sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)
565    {
566            SLJIT_UNUSED_ARG(local_size);
567    
568            compiler->options = options;
569            compiler->scratches = scratches;
570            compiler->saveds = saveds;
571            compiler->fscratches = fscratches;
572            compiler->fsaveds = fsaveds;
573    #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
574            compiler->logical_local_size = local_size;
575    #endif
576    }
577    
578  static SLJIT_INLINE void set_label(struct sljit_label *label, struct sljit_compiler *compiler)  static SLJIT_INLINE void set_label(struct sljit_label *label, struct sljit_compiler *compiler)
579  {  {
580          label->next = NULL;          label->next = NULL;
# Line 583  static SLJIT_INLINE void set_const(struc Line 611  static SLJIT_INLINE void set_const(struc
611  #define ADDRESSING_DEPENDS_ON(exp, reg) \  #define ADDRESSING_DEPENDS_ON(exp, reg) \
612          (((exp) & SLJIT_MEM) && (((exp) & REG_MASK) == reg || OFFS_REG(exp) == reg))          (((exp) & SLJIT_MEM) && (((exp) & REG_MASK) == reg || OFFS_REG(exp) == reg))
613    
614  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
615  #define FUNCTION_CHECK_OP() \  #define FUNCTION_CHECK_OP() \
616          SLJIT_ASSERT(!GET_FLAGS(op) || !(op & SLJIT_KEEP_FLAGS)); \          CHECK_ARGUMENT(!GET_FLAGS(op) || !(op & SLJIT_KEEP_FLAGS)); \
617          switch (GET_OPCODE(op)) { \          switch (GET_OPCODE(op)) { \
618          case SLJIT_NOT: \          case SLJIT_NOT: \
619          case SLJIT_CLZ: \          case SLJIT_CLZ: \
# Line 595  static SLJIT_INLINE void set_const(struc Line 623  static SLJIT_INLINE void set_const(struc
623          case SLJIT_SHL: \          case SLJIT_SHL: \
624          case SLJIT_LSHR: \          case SLJIT_LSHR: \
625          case SLJIT_ASHR: \          case SLJIT_ASHR: \
626                  SLJIT_ASSERT(!(op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C))); \                  CHECK_ARGUMENT(!(op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C))); \
627                  break; \                  break; \
628          case SLJIT_NEG: \          case SLJIT_NEG: \
629                  SLJIT_ASSERT(!(op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_C))); \                  CHECK_ARGUMENT(!(op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_C))); \
630                  break; \                  break; \
631          case SLJIT_MUL: \          case SLJIT_MUL: \
632                  SLJIT_ASSERT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_C))); \                  CHECK_ARGUMENT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_C))); \
633                  break; \                  break; \
634          case SLJIT_ADD: \          case SLJIT_ADD: \
635                  SLJIT_ASSERT(!(op & (SLJIT_SET_U | SLJIT_SET_S))); \                  CHECK_ARGUMENT(!(op & (SLJIT_SET_U | SLJIT_SET_S))); \
636                  break; \                  break; \
637          case SLJIT_SUB: \          case SLJIT_SUB: \
638                  break; \                  break; \
639          case SLJIT_ADDC: \          case SLJIT_ADDC: \
640          case SLJIT_SUBC: \          case SLJIT_SUBC: \
641                  SLJIT_ASSERT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O))); \                  CHECK_ARGUMENT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O))); \
642                  break; \                  break; \
643          case SLJIT_BREAKPOINT: \          case SLJIT_BREAKPOINT: \
644          case SLJIT_NOP: \          case SLJIT_NOP: \
645          case SLJIT_UMUL: \          case SLJIT_LUMUL: \
646          case SLJIT_SMUL: \          case SLJIT_LSMUL: \
647          case SLJIT_MOV: \          case SLJIT_MOV: \
648          case SLJIT_MOV_UI: \          case SLJIT_MOV_UI: \
649          case SLJIT_MOV_P: \          case SLJIT_MOV_P: \
# Line 623  static SLJIT_INLINE void set_const(struc Line 651  static SLJIT_INLINE void set_const(struc
651          case SLJIT_MOVU_UI: \          case SLJIT_MOVU_UI: \
652          case SLJIT_MOVU_P: \          case SLJIT_MOVU_P: \
653                  /* Nothing allowed */ \                  /* Nothing allowed */ \
654                  SLJIT_ASSERT(!(op & (SLJIT_INT_OP | SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \                  CHECK_ARGUMENT(!(op & (SLJIT_INT_OP | SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \
655                  break; \                  break; \
656          default: \          default: \
657                  /* Only SLJIT_INT_OP or SLJIT_SINGLE_OP is allowed. */ \                  /* Only SLJIT_INT_OP or SLJIT_SINGLE_OP is allowed. */ \
658                  SLJIT_ASSERT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \                  CHECK_ARGUMENT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \
659                  break; \                  break; \
660          }          }
661    
662  #define FUNCTION_CHECK_FOP() \  #define FUNCTION_CHECK_FOP() \
663          SLJIT_ASSERT(!GET_FLAGS(op) || !(op & SLJIT_KEEP_FLAGS)); \          CHECK_ARGUMENT(!GET_FLAGS(op) || !(op & SLJIT_KEEP_FLAGS)); \
664          switch (GET_OPCODE(op)) { \          switch (GET_OPCODE(op)) { \
665          case SLJIT_CMPD: \          case SLJIT_DCMP: \
666                  SLJIT_ASSERT(!(op & (SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \                  CHECK_ARGUMENT(!(op & (SLJIT_SET_U | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \
667                  SLJIT_ASSERT((op & (SLJIT_SET_E | SLJIT_SET_S))); \                  CHECK_ARGUMENT((op & (SLJIT_SET_E | SLJIT_SET_S))); \
668                  break; \                  break; \
669          default: \          default: \
670                  /* Only SLJIT_INT_OP or SLJIT_SINGLE_OP is allowed. */ \                  /* Only SLJIT_INT_OP or SLJIT_SINGLE_OP is allowed. */ \
671                  SLJIT_ASSERT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \                  CHECK_ARGUMENT(!(op & (SLJIT_SET_E | SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C | SLJIT_KEEP_FLAGS))); \
672                  break; \                  break; \
673          }          }
674    
675  #define FUNCTION_CHECK_IS_REG(r) \  #define FUNCTION_CHECK_IS_REG(r) \
676            (((r) >= SLJIT_R0 && (r) < (SLJIT_R0 + compiler->scratches)) || \
677            ((r) > (SLJIT_S0 - compiler->saveds) && (r) <= SLJIT_S0))
678    
679    #define FUNCTION_CHECK_IS_REG_OR_UNUSED(r) \
680          ((r) == SLJIT_UNUSED || \          ((r) == SLJIT_UNUSED || \
681          ((r) >= SLJIT_R0 && (r) < (SLJIT_R0 + compiler->scratches)) || \          ((r) >= SLJIT_R0 && (r) < (SLJIT_R0 + compiler->scratches)) || \
682          ((r) > (SLJIT_S0 - compiler->saveds) && (r) <= SLJIT_S0))          ((r) > (SLJIT_S0 - compiler->saveds) && (r) <= SLJIT_S0))
683    
684  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
685  #define FUNCTION_ASSERT_IF_VIRTUAL(p) \  #define CHECK_NOT_VIRTUAL_REGISTER(p) \
686          SLJIT_ASSERT((p) < SLJIT_R3 || (p) > SLJIT_R6);          CHECK_ARGUMENT((p) < SLJIT_R3 || (p) > SLJIT_R6);
687  #else  #else
688  #define FUNCTION_ASSERT_IF_VIRTUAL(p)  #define CHECK_NOT_VIRTUAL_REGISTER(p)
689  #endif  #endif
690    
691  #define FUNCTION_CHECK_SRC(p, i) \  #define FUNCTION_CHECK_SRC(p, i) \
692          SLJIT_ASSERT(compiler->scratches != -1 && compiler->saveds != -1); \          CHECK_ARGUMENT(compiler->scratches != -1 && compiler->saveds != -1); \
693          if (FUNCTION_CHECK_IS_REG(p)) \          if (FUNCTION_CHECK_IS_REG(p)) \
694                  SLJIT_ASSERT((i) == 0 && (p) != SLJIT_UNUSED); \                  CHECK_ARGUMENT((i) == 0); \
695          else if ((p) == SLJIT_IMM) \          else if ((p) == SLJIT_IMM) \
696                  ; \                  ; \
697          else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \          else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \
698                  SLJIT_ASSERT((i) >= 0 && (i) < compiler->logical_local_size); \                  CHECK_ARGUMENT((i) >= 0 && (i) < compiler->logical_local_size); \
699          else if ((p) & SLJIT_MEM) { \          else { \
700                  SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & REG_MASK)); \                  CHECK_ARGUMENT((p) & SLJIT_MEM); \
701                  FUNCTION_ASSERT_IF_VIRTUAL((p) & REG_MASK); \                  CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG_OR_UNUSED((p) & REG_MASK)); \
702                    CHECK_NOT_VIRTUAL_REGISTER((p) & REG_MASK); \
703                  if ((p) & OFFS_REG_MASK) { \                  if ((p) & OFFS_REG_MASK) { \
704                          SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \                          CHECK_ARGUMENT(((p) & REG_MASK) != SLJIT_UNUSED); \
705                          FUNCTION_ASSERT_IF_VIRTUAL(OFFS_REG(p)); \                          CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \
706                          SLJIT_ASSERT(!((i) & ~0x3)); \                          CHECK_NOT_VIRTUAL_REGISTER(OFFS_REG(p)); \
707                            CHECK_ARGUMENT(!((i) & ~0x3)); \
708                  } \                  } \
709                  SLJIT_ASSERT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \                  CHECK_ARGUMENT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \
710          } \          }
         else \  
                 SLJIT_ASSERT_STOP();  
711    
712  #define FUNCTION_CHECK_DST(p, i) \  #define FUNCTION_CHECK_DST(p, i) \
713          SLJIT_ASSERT(compiler->scratches != -1 && compiler->saveds != -1); \          CHECK_ARGUMENT(compiler->scratches != -1 && compiler->saveds != -1); \
714          if (FUNCTION_CHECK_IS_REG(p)) \          if (FUNCTION_CHECK_IS_REG_OR_UNUSED(p)) \
715                  SLJIT_ASSERT((i) == 0); \                  CHECK_ARGUMENT((i) == 0); \
716          else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \          else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \
717                  SLJIT_ASSERT((i) >= 0 && (i) < compiler->logical_local_size); \                  CHECK_ARGUMENT((i) >= 0 && (i) < compiler->logical_local_size); \
718          else if ((p) & SLJIT_MEM) { \          else { \
719                  SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & REG_MASK)); \                  CHECK_ARGUMENT((p) & SLJIT_MEM); \
720                  FUNCTION_ASSERT_IF_VIRTUAL((p) & REG_MASK); \                  CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG_OR_UNUSED((p) & REG_MASK)); \
721                    CHECK_NOT_VIRTUAL_REGISTER((p) & REG_MASK); \
722                  if ((p) & OFFS_REG_MASK) { \                  if ((p) & OFFS_REG_MASK) { \
723                          SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \                          CHECK_ARGUMENT(((p) & REG_MASK) != SLJIT_UNUSED); \
724                          FUNCTION_ASSERT_IF_VIRTUAL(OFFS_REG(p)); \                          CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \
725                          SLJIT_ASSERT(!((i) & ~0x3)); \                          CHECK_NOT_VIRTUAL_REGISTER(OFFS_REG(p)); \
726                            CHECK_ARGUMENT(!((i) & ~0x3)); \
727                  } \                  } \
728                  SLJIT_ASSERT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \                  CHECK_ARGUMENT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \
729          } \          }
         else \  
                 SLJIT_ASSERT_STOP();  
730    
731  #define FUNCTION_FCHECK(p, i) \  #define FUNCTION_FCHECK(p, i) \
732          SLJIT_ASSERT(compiler->fscratches != -1 && compiler->fsaveds != -1); \          CHECK_ARGUMENT(compiler->fscratches != -1 && compiler->fsaveds != -1); \
733          if (((p) >= SLJIT_FR0 && (p) < (SLJIT_FR0 + compiler->fscratches)) || \          if (((p) >= SLJIT_FR0 && (p) < (SLJIT_FR0 + compiler->fscratches)) || \
734                          ((p) > (SLJIT_FS0 - compiler->fsaveds) && (p) <= SLJIT_FS0)) \                          ((p) > (SLJIT_FS0 - compiler->fsaveds) && (p) <= SLJIT_FS0)) \
735                  SLJIT_ASSERT(i == 0); \                  CHECK_ARGUMENT(i == 0); \
736          else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \          else if ((p) == (SLJIT_MEM1(SLJIT_SP))) \
737                  SLJIT_ASSERT((i) >= 0 && (i) < compiler->logical_local_size); \                  CHECK_ARGUMENT((i) >= 0 && (i) < compiler->logical_local_size); \
738          else if ((p) & SLJIT_MEM) { \          else { \
739                  SLJIT_ASSERT(FUNCTION_CHECK_IS_REG((p) & REG_MASK)); \                  CHECK_ARGUMENT((p) & SLJIT_MEM); \
740                  FUNCTION_ASSERT_IF_VIRTUAL((p) & REG_MASK); \                  CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG_OR_UNUSED((p) & REG_MASK)); \
741                    CHECK_NOT_VIRTUAL_REGISTER((p) & REG_MASK); \
742                  if ((p) & OFFS_REG_MASK) { \                  if ((p) & OFFS_REG_MASK) { \
743                          SLJIT_ASSERT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \                          CHECK_ARGUMENT(((p) & REG_MASK) != SLJIT_UNUSED); \
744                          FUNCTION_ASSERT_IF_VIRTUAL(OFFS_REG(p)); \                          CHECK_ARGUMENT(FUNCTION_CHECK_IS_REG(OFFS_REG(p))); \
745                          SLJIT_ASSERT(((p) & OFFS_REG_MASK) != TO_OFFS_REG(SLJIT_SP) && !(i & ~0x3)); \                          CHECK_NOT_VIRTUAL_REGISTER(OFFS_REG(p)); \
746                  } else \                          CHECK_ARGUMENT(((p) & OFFS_REG_MASK) != TO_OFFS_REG(SLJIT_SP) && !(i & ~0x3)); \
747                          SLJIT_ASSERT(OFFS_REG(p) == 0); \                  } \
748                  SLJIT_ASSERT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \                  CHECK_ARGUMENT(!((p) & ~(SLJIT_MEM | SLJIT_IMM | REG_MASK | OFFS_REG_MASK))); \
749          } \          }
         else \  
                 SLJIT_ASSERT_STOP();  
750    
751  #define FUNCTION_CHECK_OP1() \  #define FUNCTION_CHECK_OP1() \
752          if (GET_OPCODE(op) >= SLJIT_MOVU && GET_OPCODE(op) <= SLJIT_MOVU_P) { \          if (GET_OPCODE(op) >= SLJIT_MOVU && GET_OPCODE(op) <= SLJIT_MOVU_P) { \
753                  SLJIT_ASSERT(!(src & SLJIT_MEM) || (src & REG_MASK) != SLJIT_SP); \                  CHECK_ARGUMENT(!(src & SLJIT_MEM) || (src & REG_MASK) != SLJIT_SP); \
754                  SLJIT_ASSERT(!(dst & SLJIT_MEM) || (dst & REG_MASK) != SLJIT_SP); \                  CHECK_ARGUMENT(!(dst & SLJIT_MEM) || (dst & REG_MASK) != SLJIT_SP); \
755                  if ((src & SLJIT_MEM) && (src & REG_MASK)) \                  if ((src & SLJIT_MEM) && (src & REG_MASK)) \
756                          SLJIT_ASSERT((dst & REG_MASK) != (src & REG_MASK) && OFFS_REG(dst) != (src & REG_MASK)); \                          CHECK_ARGUMENT((dst & REG_MASK) != (src & REG_MASK) && OFFS_REG(dst) != (src & REG_MASK)); \
757          }          }
758    
759  #endif  #endif /* SLJIT_ARGUMENT_CHECKS */
760    
761  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
762    
# Line 803  SLJIT_API_FUNC_ATTRIBUTE void sljit_comp Line 834  SLJIT_API_FUNC_ATTRIBUTE void sljit_comp
834    
835  static SLJIT_CONST char* op0_names[] = {  static SLJIT_CONST char* op0_names[] = {
836          (char*)"breakpoint", (char*)"nop",          (char*)"breakpoint", (char*)"nop",
837          (char*)"umul", (char*)"smul", (char*)"udiv", (char*)"sdiv",          (char*)"lumul", (char*)"lsmul", (char*)"ludiv", (char*)"lsdiv",
838  };  };
839    
840  static SLJIT_CONST char* op1_names[] = {  static SLJIT_CONST char* op1_names[] = {
841          (char*)"mov", (char*)"mov.ub", (char*)"mov.sb", (char*)"mov.uh",          (char*)"mov", (char*)"mov_ub", (char*)"mov_sb", (char*)"mov_uh",
842          (char*)"mov.sh", (char*)"mov.ui", (char*)"mov.si", (char*)"mov.p",          (char*)"mov_sh", (char*)"mov_ui", (char*)"mov_si", (char*)"mov_p",
843          (char*)"movu", (char*)"movu.ub", (char*)"movu.sb", (char*)"movu.uh",          (char*)"movu", (char*)"movu_ub", (char*)"movu_sb", (char*)"movu_uh",
844          (char*)"movu.sh", (char*)"movu.ui", (char*)"movu.si", (char*)"movu.p",          (char*)"movu_sh", (char*)"movu_ui", (char*)"movu_si", (char*)"movu_p",
845          (char*)"not", (char*)"neg", (char*)"clz",          (char*)"not", (char*)"neg", (char*)"clz",
846  };  };
847    
# Line 830  static SLJIT_CONST char* fop2_names[] = Line 861  static SLJIT_CONST char* fop2_names[] =
861          (char*)"add", (char*)"sub", (char*)"mul", (char*)"div"          (char*)"add", (char*)"sub", (char*)"mul", (char*)"div"
862  };  };
863    
864    #define JUMP_PREFIX(type) \
865            ((type & 0xff) <= SLJIT_MUL_NOT_OVERFLOW ? ((type & SLJIT_INT_OP) ? "i_" : "") \
866            : ((type & 0xff) <= SLJIT_D_ORDERED ? ((type & SLJIT_SINGLE_OP) ? "s_" : "d_") : ""))
867    
868  static char* jump_names[] = {  static char* jump_names[] = {
869          (char*)"equal", (char*)"not_equal",          (char*)"equal", (char*)"not_equal",
870          (char*)"less", (char*)"greater_equal",          (char*)"less", (char*)"greater_equal",
# Line 838  static char* jump_names[] = { Line 873  static char* jump_names[] = {
873          (char*)"sig_greater", (char*)"sig_less_equal",          (char*)"sig_greater", (char*)"sig_less_equal",
874          (char*)"overflow", (char*)"not_overflow",          (char*)"overflow", (char*)"not_overflow",
875          (char*)"mul_overflow", (char*)"mul_not_overflow",          (char*)"mul_overflow", (char*)"mul_not_overflow",
876          (char*)"float_equal", (char*)"float_not_equal",          (char*)"equal", (char*)"not_equal",
877          (char*)"float_less", (char*)"float_greater_equal",          (char*)"less", (char*)"greater_equal",
878          (char*)"float_greater", (char*)"float_less_equal",          (char*)"greater", (char*)"less_equal",
879          (char*)"float_unordered", (char*)"float_ordered",          (char*)"unordered", (char*)"ordered",
880          (char*)"jump", (char*)"fast_call",          (char*)"jump", (char*)"fast_call",
881          (char*)"call0", (char*)"call1", (char*)"call2", (char*)"call3"          (char*)"call0", (char*)"call1", (char*)"call2", (char*)"call3"
882  };  };
883    
884  #endif  #endif /* SLJIT_VERBOSE */
885    
886  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
887  /*  Arch dependent                                                       */  /*  Arch dependent                                                       */
888  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
889    
890  static SLJIT_INLINE void check_sljit_generate_code(struct sljit_compiler *compiler)  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
891            || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
892    
893    static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_generate_code(struct sljit_compiler *compiler)
894  {  {
895  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
896          struct sljit_jump *jump;          struct sljit_jump *jump;
897  #endif  #endif
898          /* If debug and verbose are disabled, all arguments are unused. */  
899          SLJIT_UNUSED_ARG(compiler);          SLJIT_UNUSED_ARG(compiler);
900    
901          SLJIT_ASSERT(compiler->size > 0);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
902  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)          CHECK_ARGUMENT(compiler->size > 0);
903          jump = compiler->jumps;          jump = compiler->jumps;
904          while (jump) {          while (jump) {
905                  /* All jumps have target. */                  /* All jumps have target. */
906                  SLJIT_ASSERT(jump->flags & (JUMP_LABEL | JUMP_ADDR));                  CHECK_ARGUMENT(jump->flags & (JUMP_LABEL | JUMP_ADDR));
907                  jump = jump->next;                  jump = jump->next;
908          }          }
909  #endif  #endif
910            CHECK_RETURN_OK;
911  }  }
912    
913  static SLJIT_INLINE void check_sljit_emit_enter(struct sljit_compiler *compiler,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_enter(struct sljit_compiler *compiler,
914          sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,          sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,
915          sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)          sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)
916  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
917          SLJIT_UNUSED_ARG(compiler);          SLJIT_UNUSED_ARG(compiler);
         SLJIT_UNUSED_ARG(options);  
         SLJIT_UNUSED_ARG(args);  
         SLJIT_UNUSED_ARG(scratches);  
         SLJIT_UNUSED_ARG(saveds);  
         SLJIT_UNUSED_ARG(fscratches);  
         SLJIT_UNUSED_ARG(fsaveds);  
         SLJIT_UNUSED_ARG(local_size);  
918    
919          SLJIT_ASSERT(options == 0);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
920          SLJIT_ASSERT(args >= 0 && args <= 3);          CHECK_ARGUMENT(!(options & ~SLJIT_DOUBLE_ALIGNMENT));
921          SLJIT_ASSERT(scratches >= 0 && scratches <= SLJIT_NUMBER_OF_REGISTERS);          CHECK_ARGUMENT(args >= 0 && args <= 3);
922          SLJIT_ASSERT(saveds >= 0 && saveds <= SLJIT_NUMBER_OF_REGISTERS);          CHECK_ARGUMENT(scratches >= 0 && scratches <= SLJIT_NUMBER_OF_REGISTERS);
923          SLJIT_ASSERT(scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS);          CHECK_ARGUMENT(saveds >= 0 && saveds <= SLJIT_NUMBER_OF_REGISTERS);
924          SLJIT_ASSERT(args <= saveds);          CHECK_ARGUMENT(scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS);
925          SLJIT_ASSERT(fscratches >= 0 && fscratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);          CHECK_ARGUMENT(args <= saveds);
926          SLJIT_ASSERT(fsaveds >= 0 && fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);          CHECK_ARGUMENT(fscratches >= 0 && fscratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
927          SLJIT_ASSERT(fscratches + fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);          CHECK_ARGUMENT(fsaveds >= 0 && fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
928          SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);          CHECK_ARGUMENT(fscratches + fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
929            CHECK_ARGUMENT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
930    #endif
931  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
932          if (SLJIT_UNLIKELY(!!compiler->verbose))          if (SLJIT_UNLIKELY(!!compiler->verbose))
933                  fprintf(compiler->verbose, "  enter options:none args:%d scratches:%d saveds:%d fscratches:%d fsaveds:%d local_size:%d\n",                  fprintf(compiler->verbose, "  enter options:none args:%d scratches:%d saveds:%d fscratches:%d fsaveds:%d local_size:%d\n",
934                          args, scratches, saveds, fscratches, fsaveds, local_size);                          args, scratches, saveds, fscratches, fsaveds, local_size);
935  #endif  #endif
936            CHECK_RETURN_OK;
937  }  }
938    
939  static SLJIT_INLINE void check_sljit_set_context(struct sljit_compiler *compiler,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_set_context(struct sljit_compiler *compiler,
940          sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,          sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,
941          sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)          sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)
942  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(options);  
         SLJIT_UNUSED_ARG(args);  
         SLJIT_UNUSED_ARG(scratches);  
         SLJIT_UNUSED_ARG(saveds);  
         SLJIT_UNUSED_ARG(fscratches);  
         SLJIT_UNUSED_ARG(fsaveds);  
         SLJIT_UNUSED_ARG(local_size);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
943          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
944                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
945                  return;                  CHECK_RETURN_OK;
946          }          }
 #endif  
947    
948          SLJIT_ASSERT(options == 0);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
949          SLJIT_ASSERT(args >= 0 && args <= 3);          CHECK_ARGUMENT(!(options & ~SLJIT_DOUBLE_ALIGNMENT));
950          SLJIT_ASSERT(scratches >= 0 && scratches <= SLJIT_NUMBER_OF_REGISTERS);          CHECK_ARGUMENT(args >= 0 && args <= 3);
951          SLJIT_ASSERT(saveds >= 0 && saveds <= SLJIT_NUMBER_OF_REGISTERS);          CHECK_ARGUMENT(scratches >= 0 && scratches <= SLJIT_NUMBER_OF_REGISTERS);
952          SLJIT_ASSERT(scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS);          CHECK_ARGUMENT(saveds >= 0 && saveds <= SLJIT_NUMBER_OF_REGISTERS);
953          SLJIT_ASSERT(args <= saveds);          CHECK_ARGUMENT(scratches + saveds <= SLJIT_NUMBER_OF_REGISTERS);
954          SLJIT_ASSERT(fscratches >= 0 && fscratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);          CHECK_ARGUMENT(args <= saveds);
955          SLJIT_ASSERT(fsaveds >= 0 && fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);          CHECK_ARGUMENT(fscratches >= 0 && fscratches <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
956          SLJIT_ASSERT(fscratches + fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);          CHECK_ARGUMENT(fsaveds >= 0 && fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
957          SLJIT_ASSERT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);          CHECK_ARGUMENT(fscratches + fsaveds <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
958            CHECK_ARGUMENT(local_size >= 0 && local_size <= SLJIT_MAX_LOCAL_SIZE);
959    #endif
960  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
961          if (SLJIT_UNLIKELY(!!compiler->verbose))          if (SLJIT_UNLIKELY(!!compiler->verbose))
962                  fprintf(compiler->verbose, "  set_context options:none args:%d scratches:%d saveds:%d fscratches:%d fsaveds:%d local_size:%d\n",                  fprintf(compiler->verbose, "  set_context options:none args:%d scratches:%d saveds:%d fscratches:%d fsaveds:%d local_size:%d\n",
963                          args, scratches, saveds, fscratches, fsaveds, local_size);                          args, scratches, saveds, fscratches, fsaveds, local_size);
964  #endif  #endif
965            CHECK_RETURN_OK;
966  }  }
967    
968  static SLJIT_INLINE void check_sljit_emit_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)
969  {  {
970          /* If debug and verbose are disabled, all arguments are unused. */  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
971          SLJIT_UNUSED_ARG(compiler);          CHECK_ARGUMENT(compiler->scratches >= 0);
         SLJIT_UNUSED_ARG(op);  
         SLJIT_UNUSED_ARG(src);  
         SLJIT_UNUSED_ARG(srcw);  
   
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
972          if (op != SLJIT_UNUSED) {          if (op != SLJIT_UNUSED) {
973                  SLJIT_ASSERT(op >= SLJIT_MOV && op <= SLJIT_MOV_P);                  CHECK_ARGUMENT(op >= SLJIT_MOV && op <= SLJIT_MOV_P);
974                  FUNCTION_CHECK_SRC(src, srcw);                  FUNCTION_CHECK_SRC(src, srcw);
975          }          }
976          else          else
977                  SLJIT_ASSERT(src == 0 && srcw == 0);                  CHECK_ARGUMENT(src == 0 && srcw == 0);
978  #endif  #endif
979  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
980          if (SLJIT_UNLIKELY(!!compiler->verbose)) {          if (SLJIT_UNLIKELY(!!compiler->verbose)) {
# Line 967  static SLJIT_INLINE void check_sljit_emi Line 987  static SLJIT_INLINE void check_sljit_emi
987                  }                  }
988          }          }
989  #endif  #endif
990            CHECK_RETURN_OK;
991  }  }
992    
993  static SLJIT_INLINE void check_sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw)
994  {  {
995          /* If debug and verbose are disabled, all arguments are unused. */  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
   
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
996          FUNCTION_CHECK_DST(dst, dstw);          FUNCTION_CHECK_DST(dst, dstw);
997  #endif  #endif
998  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
# Line 986  static SLJIT_INLINE void check_sljit_emi Line 1002  static SLJIT_INLINE void check_sljit_emi
1002                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1003          }          }
1004  #endif  #endif
1005            CHECK_RETURN_OK;
1006  }  }
1007    
1008  static SLJIT_INLINE void check_sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw)
1009  {  {
1010          /* If debug and verbose are disabled, all arguments are unused. */  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(src);  
         SLJIT_UNUSED_ARG(srcw);  
   
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1011          FUNCTION_CHECK_SRC(src, srcw);          FUNCTION_CHECK_SRC(src, srcw);
1012  #endif  #endif
1013  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
# Line 1005  static SLJIT_INLINE void check_sljit_emi Line 1017  static SLJIT_INLINE void check_sljit_emi
1017                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1018          }          }
1019  #endif  #endif
1020            CHECK_RETURN_OK;
1021  }  }
1022    
1023  static SLJIT_INLINE void check_sljit_emit_op0(struct sljit_compiler *compiler, sljit_si op)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op0(struct sljit_compiler *compiler, sljit_si op)
1024  {  {
1025          /* If debug and verbose are disabled, all arguments are unused. */  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1026          SLJIT_UNUSED_ARG(compiler);          CHECK_ARGUMENT((op >= SLJIT_BREAKPOINT && op <= SLJIT_LSMUL)
1027          SLJIT_UNUSED_ARG(op);                  || ((op & ~SLJIT_INT_OP) >= SLJIT_LUDIV && (op & ~SLJIT_INT_OP) <= SLJIT_LSDIV));
1028            CHECK_ARGUMENT(op < SLJIT_LUMUL || compiler->scratches >= 2);
1029          SLJIT_ASSERT((op >= SLJIT_BREAKPOINT && op <= SLJIT_SMUL)  #endif
                 || ((op & ~SLJIT_INT_OP) >= SLJIT_UDIV && (op & ~SLJIT_INT_OP) <= SLJIT_SDIV));  
         SLJIT_ASSERT(op < SLJIT_UMUL || compiler->scratches >= 2);  
1030  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1031          if (SLJIT_UNLIKELY(!!compiler->verbose))          if (SLJIT_UNLIKELY(!!compiler->verbose))
1032                  fprintf(compiler->verbose, "  %s%s\n", !(op & SLJIT_INT_OP) ? "" : "i", op0_names[GET_OPCODE(op) - SLJIT_OP0_BASE]);                  fprintf(compiler->verbose, "  %s%s\n", !(op & SLJIT_INT_OP) ? "" : "i", op0_names[GET_OPCODE(op) - SLJIT_OP0_BASE]);
1033  #endif  #endif
1034            CHECK_RETURN_OK;
1035  }  }
1036    
1037  static SLJIT_INLINE void check_sljit_emit_op1(struct sljit_compiler *compiler, sljit_si op,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op1(struct sljit_compiler *compiler, sljit_si op,
1038          sljit_si dst, sljit_sw dstw,          sljit_si dst, sljit_sw dstw,
1039          sljit_si src, sljit_sw srcw)          sljit_si src, sljit_sw srcw)
1040  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(op);  
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(src);  
         SLJIT_UNUSED_ARG(srcw);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1041          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1042                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
1043                  return;                  CHECK_RETURN_OK;
1044          }          }
 #endif  
1045    
1046          SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_CLZ);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1047  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)          CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_CLZ);
1048          FUNCTION_CHECK_OP();          FUNCTION_CHECK_OP();
1049          FUNCTION_CHECK_SRC(src, srcw);          FUNCTION_CHECK_SRC(src, srcw);
1050          FUNCTION_CHECK_DST(dst, dstw);          FUNCTION_CHECK_DST(dst, dstw);
# Line 1059  static SLJIT_INLINE void check_sljit_emi Line 1061  static SLJIT_INLINE void check_sljit_emi
1061                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1062          }          }
1063  #endif  #endif
1064            CHECK_RETURN_OK;
1065  }  }
1066    
1067  static SLJIT_INLINE void check_sljit_emit_op2(struct sljit_compiler *compiler, sljit_si op,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op2(struct sljit_compiler *compiler, sljit_si op,
1068          sljit_si dst, sljit_sw dstw,          sljit_si dst, sljit_sw dstw,
1069          sljit_si src1, sljit_sw src1w,          sljit_si src1, sljit_sw src1w,
1070          sljit_si src2, sljit_sw src2w)          sljit_si src2, sljit_sw src2w)
1071  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(op);  
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(src1);  
         SLJIT_UNUSED_ARG(src1w);  
         SLJIT_UNUSED_ARG(src2);  
         SLJIT_UNUSED_ARG(src2w);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1072          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1073                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
1074                  return;                  CHECK_RETURN_OK;
1075          }          }
 #endif  
1076    
1077          SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_ADD && GET_OPCODE(op) <= SLJIT_ASHR);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1078  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)          CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_ADD && GET_OPCODE(op) <= SLJIT_ASHR);
1079          FUNCTION_CHECK_OP();          FUNCTION_CHECK_OP();
1080          FUNCTION_CHECK_SRC(src1, src1w);          FUNCTION_CHECK_SRC(src1, src1w);
1081          FUNCTION_CHECK_SRC(src2, src2w);          FUNCTION_CHECK_SRC(src2, src2w);
# Line 1103  static SLJIT_INLINE void check_sljit_emi Line 1094  static SLJIT_INLINE void check_sljit_emi
1094                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1095          }          }
1096  #endif  #endif
1097            CHECK_RETURN_OK;
1098  }  }
1099    
1100  static SLJIT_INLINE void check_sljit_get_register_index(sljit_si reg)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_register_index(sljit_si reg)
1101  {  {
1102          SLJIT_UNUSED_ARG(reg);          SLJIT_UNUSED_ARG(reg);
1103          SLJIT_ASSERT(reg > 0 && reg <= SLJIT_NUMBER_OF_REGISTERS);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1104            CHECK_ARGUMENT(reg > 0 && reg <= SLJIT_NUMBER_OF_REGISTERS);
1105    #endif
1106            CHECK_RETURN_OK;
1107  }  }
1108    
1109  static SLJIT_INLINE void check_sljit_get_float_register_index(sljit_si reg)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_float_register_index(sljit_si reg)
1110  {  {
1111          SLJIT_UNUSED_ARG(reg);          SLJIT_UNUSED_ARG(reg);
1112          SLJIT_ASSERT(reg > 0 && reg <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1113            CHECK_ARGUMENT(reg > 0 && reg <= SLJIT_NUMBER_OF_FLOAT_REGISTERS);
1114    #endif
1115            CHECK_RETURN_OK;
1116  }  }
1117    
1118  static SLJIT_INLINE void check_sljit_emit_op_custom(struct sljit_compiler *compiler,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op_custom(struct sljit_compiler *compiler,
1119          void *instruction, sljit_si size)          void *instruction, sljit_si size)
1120  {  {
1121    #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1122            int i;
1123    #endif
1124    
1125          SLJIT_UNUSED_ARG(compiler);          SLJIT_UNUSED_ARG(compiler);
         SLJIT_UNUSED_ARG(instruction);  
         SLJIT_UNUSED_ARG(size);  
         SLJIT_ASSERT(instruction);  
 }  
1126    
1127  #define SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw) \  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1128          SLJIT_ASSERT(sljit_is_fpu_available()); \          CHECK_ARGUMENT(instruction);
1129          SLJIT_COMPILE_ASSERT(!(SLJIT_CONVW_FROMD & 0x1) && !(SLJIT_CONVD_FROMW & 0x1), \  #if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86)
1130                  invalid_float_opcodes); \          CHECK_ARGUMENT(size > 0 && size < 16);
1131          if (GET_OPCODE(op) >= SLJIT_CONVW_FROMD && GET_OPCODE(op) <= SLJIT_CMPD) { \  #elif (defined SLJIT_CONFIG_ARM_THUMB2 && SLJIT_CONFIG_ARM_THUMB2)
1132                  if (GET_OPCODE(op) == SLJIT_CMPD) { \          CHECK_ARGUMENT((size == 2 && (((sljit_sw)instruction) & 0x1) == 0)
1133                          check_sljit_emit_fop1_cmp(compiler, op, dst, dstw, src, srcw); \                  || (size == 4 && (((sljit_sw)instruction) & 0x3) == 0));
1134                          ADJUST_LOCAL_OFFSET(dst, dstw); \  #else
1135                          ADJUST_LOCAL_OFFSET(src, srcw); \          CHECK_ARGUMENT(size == 4 && (((sljit_sw)instruction) & 0x3) == 0);
1136                          return sljit_emit_fop1_cmp(compiler, op, dst, dstw, src, srcw); \  #endif
1137                  } \  
1138                  if ((GET_OPCODE(op) | 0x1) == SLJIT_CONVI_FROMD) { \  #endif
1139                          check_sljit_emit_fop1_convw_fromd(compiler, op, dst, dstw, src, srcw); \  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1140                          ADJUST_LOCAL_OFFSET(dst, dstw); \          if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1141                          ADJUST_LOCAL_OFFSET(src, srcw); \                  fprintf(compiler->verbose, "  op_custom");
1142                          return sljit_emit_fop1_convw_fromd(compiler, op, dst, dstw, src, srcw); \                  for (i = 0; i < size; i++)
1143                  } \                          fprintf(compiler->verbose, " 0x%x", ((sljit_ub*)instruction)[i]);
1144                  check_sljit_emit_fop1_convd_fromw(compiler, op, dst, dstw, src, srcw); \                  fprintf(compiler->verbose, "\n");
1145                  ADJUST_LOCAL_OFFSET(dst, dstw); \          }
1146                  ADJUST_LOCAL_OFFSET(src, srcw); \  #endif
1147                  return sljit_emit_fop1_convd_fromw(compiler, op, dst, dstw, src, srcw); \          CHECK_RETURN_OK;
1148          } \  }
         check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw); \  
         ADJUST_LOCAL_OFFSET(dst, dstw); \  
         ADJUST_LOCAL_OFFSET(src, srcw);  
1149    
1150  static SLJIT_INLINE void check_sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op,
1151          sljit_si dst, sljit_sw dstw,          sljit_si dst, sljit_sw dstw,
1152          sljit_si src, sljit_sw srcw)          sljit_si src, sljit_sw srcw)
1153  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(op);  
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(src);  
         SLJIT_UNUSED_ARG(srcw);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1154          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1155                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
1156                  return;                  CHECK_RETURN_OK;
1157          }          }
 #endif  
1158    
1159          SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_MOVD && GET_OPCODE(op) <= SLJIT_ABSD);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1160  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)          CHECK_ARGUMENT(sljit_is_fpu_available());
1161            CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_DMOV && GET_OPCODE(op) <= SLJIT_DABS);
1162          FUNCTION_CHECK_FOP();          FUNCTION_CHECK_FOP();
1163          FUNCTION_FCHECK(src, srcw);          FUNCTION_FCHECK(src, srcw);
1164          FUNCTION_FCHECK(dst, dstw);          FUNCTION_FCHECK(dst, dstw);
1165  #endif  #endif
1166  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1167          if (SLJIT_UNLIKELY(!!compiler->verbose)) {          if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1168                  fprintf(compiler->verbose, "  %s%s ", fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE],                  if (GET_OPCODE(op) == SLJIT_CONVD_FROMS)
1169                          (GET_OPCODE(op) == SLJIT_CONVD_FROMS)                          fprintf(compiler->verbose, "  %s%s ", fop1_names[SLJIT_CONVD_FROMS - SLJIT_FOP1_BASE],
1170                          ? ((op & SLJIT_SINGLE_OP) ? "s.fromd" : "d.froms")                                  (op & SLJIT_SINGLE_OP) ? "s.fromd" : "d.froms");
1171                          : ((op & SLJIT_SINGLE_OP) ? "s" : "d"));                  else
1172                            fprintf(compiler->verbose, "  %s%s ", (op & SLJIT_SINGLE_OP) ? "s" : "d",
1173                                    fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE]);
1174    
1175                  sljit_verbose_fparam(compiler, dst, dstw);                  sljit_verbose_fparam(compiler, dst, dstw);
1176                  fprintf(compiler->verbose, ", ");                  fprintf(compiler->verbose, ", ");
1177                  sljit_verbose_fparam(compiler, src, srcw);                  sljit_verbose_fparam(compiler, src, srcw);
1178                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1179          }          }
1180  #endif  #endif
1181            CHECK_RETURN_OK;
1182  }  }
1183    
1184  static SLJIT_INLINE void check_sljit_emit_fop1_cmp(struct sljit_compiler *compiler, sljit_si op,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_cmp(struct sljit_compiler *compiler, sljit_si op,
1185          sljit_si src1, sljit_sw src1w,          sljit_si src1, sljit_sw src1w,
1186          sljit_si src2, sljit_sw src2w)          sljit_si src2, sljit_sw src2w)
1187  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(op);  
         SLJIT_UNUSED_ARG(src1);  
         SLJIT_UNUSED_ARG(src1w);  
         SLJIT_UNUSED_ARG(src2);  
         SLJIT_UNUSED_ARG(src2w);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1188          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1189                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
1190                  return;                  CHECK_RETURN_OK;
1191          }          }
 #endif  
1192    
1193          SLJIT_ASSERT(GET_OPCODE(op) == SLJIT_CMPD);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1194  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)          CHECK_ARGUMENT(sljit_is_fpu_available());
1195            CHECK_ARGUMENT(GET_OPCODE(op) == SLJIT_DCMP);
1196          FUNCTION_CHECK_FOP();          FUNCTION_CHECK_FOP();
1197          FUNCTION_FCHECK(src1, src1w);          FUNCTION_FCHECK(src1, src1w);
1198          FUNCTION_FCHECK(src2, src2w);          FUNCTION_FCHECK(src2, src2w);
1199  #endif  #endif
1200  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1201          if (SLJIT_UNLIKELY(!!compiler->verbose)) {          if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1202                  fprintf(compiler->verbose, "  %s%s%s%s ", fop1_names[GET_OPCODE(op) - SLJIT_FOP1_BASE], (op & SLJIT_SINGLE_OP) ? "s" : "d",                  fprintf(compiler->verbose, "  %s%s%s%s ", (op & SLJIT_SINGLE_OP) ? "s" : "d", fop1_names[SLJIT_DCMP - SLJIT_FOP1_BASE],
1203                          !(op & SLJIT_SET_E) ? "" : ".e", !(op & SLJIT_SET_S) ? "" : ".s");                          (op & SLJIT_SET_E) ? ".e" : "", (op & SLJIT_SET_S) ? ".s" : "");
1204                  sljit_verbose_fparam(compiler, src1, src1w);                  sljit_verbose_fparam(compiler, src1, src1w);
1205                  fprintf(compiler->verbose, ", ");                  fprintf(compiler->verbose, ", ");
1206                  sljit_verbose_fparam(compiler, src2, src2w);                  sljit_verbose_fparam(compiler, src2, src2w);
1207                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1208          }          }
1209  #endif  #endif
1210            CHECK_RETURN_OK;
1211  }  }
1212    
1213  static SLJIT_INLINE void check_sljit_emit_fop1_convw_fromd(struct sljit_compiler *compiler, sljit_si op,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_convw_fromd(struct sljit_compiler *compiler, sljit_si op,
1214          sljit_si dst, sljit_sw dstw,          sljit_si dst, sljit_sw dstw,
1215          sljit_si src, sljit_sw srcw)          sljit_si src, sljit_sw srcw)
1216  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(op);  
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(src);  
         SLJIT_UNUSED_ARG(srcw);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1217          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1218                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
1219                  return;                  CHECK_RETURN_OK;
1220          }          }
 #endif  
1221    
1222          SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_CONVW_FROMD && GET_OPCODE(op) <= SLJIT_CONVI_FROMD);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1223  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)          CHECK_ARGUMENT(sljit_is_fpu_available());
1224            CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_CONVW_FROMD && GET_OPCODE(op) <= SLJIT_CONVI_FROMD);
1225          FUNCTION_CHECK_FOP();          FUNCTION_CHECK_FOP();
1226          FUNCTION_FCHECK(src, srcw);          FUNCTION_FCHECK(src, srcw);
1227          FUNCTION_CHECK_DST(dst, dstw);          FUNCTION_CHECK_DST(dst, dstw);
# Line 1264  static SLJIT_INLINE void check_sljit_emi Line 1237  static SLJIT_INLINE void check_sljit_emi
1237                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1238          }          }
1239  #endif  #endif
1240            CHECK_RETURN_OK;
1241  }  }
1242    
1243  static SLJIT_INLINE void check_sljit_emit_fop1_convd_fromw(struct sljit_compiler *compiler, sljit_si op,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop1_convd_fromw(struct sljit_compiler *compiler, sljit_si op,
1244          sljit_si dst, sljit_sw dstw,          sljit_si dst, sljit_sw dstw,
1245          sljit_si src, sljit_sw srcw)          sljit_si src, sljit_sw srcw)
1246  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(op);  
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(src);  
         SLJIT_UNUSED_ARG(srcw);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1247          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1248                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
1249                  return;                  CHECK_RETURN_OK;
1250          }          }
 #endif  
1251    
1252          SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_CONVD_FROMW && GET_OPCODE(op) <= SLJIT_CONVD_FROMI);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1253  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)          CHECK_ARGUMENT(sljit_is_fpu_available());
1254            CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_CONVD_FROMW && GET_OPCODE(op) <= SLJIT_CONVD_FROMI);
1255          FUNCTION_CHECK_FOP();          FUNCTION_CHECK_FOP();
1256          FUNCTION_CHECK_SRC(src, srcw);          FUNCTION_CHECK_SRC(src, srcw);
1257          FUNCTION_FCHECK(dst, dstw);          FUNCTION_FCHECK(dst, dstw);
# Line 1302  static SLJIT_INLINE void check_sljit_emi Line 1267  static SLJIT_INLINE void check_sljit_emi
1267                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1268          }          }
1269  #endif  #endif
1270            CHECK_RETURN_OK;
1271  }  }
1272    
1273  static SLJIT_INLINE void check_sljit_emit_fop2(struct sljit_compiler *compiler, sljit_si op,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fop2(struct sljit_compiler *compiler, sljit_si op,
1274          sljit_si dst, sljit_sw dstw,          sljit_si dst, sljit_sw dstw,
1275          sljit_si src1, sljit_sw src1w,          sljit_si src1, sljit_sw src1w,
1276          sljit_si src2, sljit_sw src2w)          sljit_si src2, sljit_sw src2w)
1277  {  {
1278          /* If debug and verbose are disabled, all arguments are unused. */  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1279          SLJIT_UNUSED_ARG(compiler);          CHECK_ARGUMENT(sljit_is_fpu_available());
1280          SLJIT_UNUSED_ARG(op);          CHECK_ARGUMENT(GET_OPCODE(op) >= SLJIT_DADD && GET_OPCODE(op) <= SLJIT_DDIV);
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(src1);  
         SLJIT_UNUSED_ARG(src1w);  
         SLJIT_UNUSED_ARG(src2);  
         SLJIT_UNUSED_ARG(src2w);  
   
         SLJIT_ASSERT(sljit_is_fpu_available());  
         SLJIT_ASSERT(GET_OPCODE(op) >= SLJIT_ADDD && GET_OPCODE(op) <= SLJIT_DIVD);  
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1281          FUNCTION_CHECK_FOP();          FUNCTION_CHECK_FOP();
1282          FUNCTION_FCHECK(src1, src1w);          FUNCTION_FCHECK(src1, src1w);
1283          FUNCTION_FCHECK(src2, src2w);          FUNCTION_FCHECK(src2, src2w);
# Line 1329  static SLJIT_INLINE void check_sljit_emi Line 1285  static SLJIT_INLINE void check_sljit_emi
1285  #endif  #endif
1286  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1287          if (SLJIT_UNLIKELY(!!compiler->verbose)) {          if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1288                  fprintf(compiler->verbose, "  %s%s ", fop2_names[GET_OPCODE(op) - SLJIT_FOP2_BASE], (op & SLJIT_SINGLE_OP) ? "s" : "d");                  fprintf(compiler->verbose, "  %s%s ", (op & SLJIT_SINGLE_OP) ? "s" : "d", fop2_names[GET_OPCODE(op) - SLJIT_FOP2_BASE]);
1289                  sljit_verbose_fparam(compiler, dst, dstw);                  sljit_verbose_fparam(compiler, dst, dstw);
1290                  fprintf(compiler->verbose, ", ");                  fprintf(compiler->verbose, ", ");
1291                  sljit_verbose_fparam(compiler, src1, src1w);                  sljit_verbose_fparam(compiler, src1, src1w);
# Line 1338  static SLJIT_INLINE void check_sljit_emi Line 1294  static SLJIT_INLINE void check_sljit_emi
1294                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1295          }          }
1296  #endif  #endif
1297            CHECK_RETURN_OK;
1298  }  }
1299    
1300  static SLJIT_INLINE void check_sljit_emit_label(struct sljit_compiler *compiler)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_label(struct sljit_compiler *compiler)
1301  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
1302          SLJIT_UNUSED_ARG(compiler);          SLJIT_UNUSED_ARG(compiler);
1303    
1304  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1305          if (SLJIT_UNLIKELY(!!compiler->verbose))          if (SLJIT_UNLIKELY(!!compiler->verbose))
1306                  fprintf(compiler->verbose, "label:\n");                  fprintf(compiler->verbose, "label:\n");
1307  #endif  #endif
1308            CHECK_RETURN_OK;
1309  }  }
1310    
1311  static SLJIT_INLINE void check_sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
1312  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(type);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1313          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1314                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
1315                  return;                  CHECK_RETURN_OK;
1316          }          }
 #endif  
1317    
1318          SLJIT_ASSERT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP)));  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1319          SLJIT_ASSERT((type & 0xff) >= SLJIT_C_EQUAL && (type & 0xff) <= SLJIT_CALL3);          CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_INT_OP)));
1320            CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_CALL3);
1321            CHECK_ARGUMENT((type & 0xff) < SLJIT_JUMP || !(type & SLJIT_INT_OP));
1322    #endif
1323  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1324          if (SLJIT_UNLIKELY(!!compiler->verbose))          if (SLJIT_UNLIKELY(!!compiler->verbose))
1325                  fprintf(compiler->verbose, "  jump%s.%s\n", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r", jump_names[type & 0xff]);                  fprintf(compiler->verbose, "  jump%s.%s%s\n", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r",
1326                            JUMP_PREFIX(type), jump_names[type & 0xff]);
1327  #endif  #endif
1328            CHECK_RETURN_OK;
1329  }  }
1330    
1331  static SLJIT_INLINE void check_sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,
1332          sljit_si src1, sljit_sw src1w,          sljit_si src1, sljit_sw src1w,
1333          sljit_si src2, sljit_sw src2w)          sljit_si src2, sljit_sw src2w)
1334  {  {
1335          SLJIT_UNUSED_ARG(compiler);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1336          SLJIT_UNUSED_ARG(type);          CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_INT_OP)));
1337          SLJIT_UNUSED_ARG(src1);          CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_SIG_LESS_EQUAL);
         SLJIT_UNUSED_ARG(src1w);  
         SLJIT_UNUSED_ARG(src2);  
         SLJIT_UNUSED_ARG(src2w);  
   
         SLJIT_ASSERT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_INT_OP)));  
         SLJIT_ASSERT((type & 0xff) >= SLJIT_C_EQUAL && (type & 0xff) <= SLJIT_C_SIG_LESS_EQUAL);  
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1338          FUNCTION_CHECK_SRC(src1, src1w);          FUNCTION_CHECK_SRC(src1, src1w);
1339          FUNCTION_CHECK_SRC(src2, src2w);          FUNCTION_CHECK_SRC(src2, src2w);
1340  #endif  #endif
1341  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1342          if (SLJIT_UNLIKELY(!!compiler->verbose)) {          if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1343                  fprintf(compiler->verbose, "  %scmp%s.%s ", !(type & SLJIT_INT_OP) ? "" : "i", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r", jump_names[type & 0xff]);                  fprintf(compiler->verbose, "  cmp%s.%s%s ", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r",
1344                            (type & SLJIT_INT_OP) ? "i_" : "", jump_names[type & 0xff]);
1345                  sljit_verbose_param(compiler, src1, src1w);                  sljit_verbose_param(compiler, src1, src1w);
1346                  fprintf(compiler->verbose, ", ");                  fprintf(compiler->verbose, ", ");
1347                  sljit_verbose_param(compiler, src2, src2w);                  sljit_verbose_param(compiler, src2, src2w);
1348                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1349          }          }
1350  #endif  #endif
1351            CHECK_RETURN_OK;
1352  }  }
1353    
1354  static SLJIT_INLINE void check_sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,
1355          sljit_si src1, sljit_sw src1w,          sljit_si src1, sljit_sw src1w,
1356          sljit_si src2, sljit_sw src2w)          sljit_si src2, sljit_sw src2w)
1357  {  {
1358          SLJIT_UNUSED_ARG(compiler);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1359          SLJIT_UNUSED_ARG(type);          CHECK_ARGUMENT(sljit_is_fpu_available());
1360          SLJIT_UNUSED_ARG(src1);          CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_SINGLE_OP)));
1361          SLJIT_UNUSED_ARG(src1w);          CHECK_ARGUMENT((type & 0xff) >= SLJIT_D_EQUAL && (type & 0xff) <= SLJIT_D_ORDERED);
         SLJIT_UNUSED_ARG(src2);  
         SLJIT_UNUSED_ARG(src2w);  
   
         SLJIT_ASSERT(sljit_is_fpu_available());  
         SLJIT_ASSERT(!(type & ~(0xff | SLJIT_REWRITABLE_JUMP | SLJIT_SINGLE_OP)));  
         SLJIT_ASSERT((type & 0xff) >= SLJIT_C_FLOAT_EQUAL && (type & 0xff) <= SLJIT_C_FLOAT_ORDERED);  
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1362          FUNCTION_FCHECK(src1, src1w);          FUNCTION_FCHECK(src1, src1w);
1363          FUNCTION_FCHECK(src2, src2w);          FUNCTION_FCHECK(src2, src2w);
1364  #endif  #endif
1365  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1366          if (SLJIT_UNLIKELY(!!compiler->verbose)) {          if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1367                  fprintf(compiler->verbose, "  %scmp%s.%s ", (type & SLJIT_SINGLE_OP) ? "s" : "d",                  fprintf(compiler->verbose, "  fcmp%s.%s%s ", !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r",
1368                          !(type & SLJIT_REWRITABLE_JUMP) ? "" : ".r", jump_names[type & 0xff]);                          (type & SLJIT_SINGLE_OP) ? "s_" : "d_", jump_names[type & 0xff]);
1369                  sljit_verbose_fparam(compiler, src1, src1w);                  sljit_verbose_fparam(compiler, src1, src1w);
1370                  fprintf(compiler->verbose, ", ");                  fprintf(compiler->verbose, ", ");
1371                  sljit_verbose_fparam(compiler, src2, src2w);                  sljit_verbose_fparam(compiler, src2, src2w);
1372                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1373          }          }
1374  #endif  #endif
1375            CHECK_RETURN_OK;
1376  }  }
1377    
1378  static SLJIT_INLINE void check_sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
1379  {  {
         /* If debug and verbose are disabled, all arguments are unused. */  
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(type);  
         SLJIT_UNUSED_ARG(src);  
         SLJIT_UNUSED_ARG(srcw);  
   
 #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1380          if (SLJIT_UNLIKELY(compiler->skip_checks)) {          if (SLJIT_UNLIKELY(compiler->skip_checks)) {
1381                  compiler->skip_checks = 0;                  compiler->skip_checks = 0;
1382                  return;                  CHECK_RETURN_OK;
1383          }          }
 #endif  
1384    
1385          SLJIT_ASSERT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1386  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)          CHECK_ARGUMENT(type >= SLJIT_JUMP && type <= SLJIT_CALL3);
1387          FUNCTION_CHECK_SRC(src, srcw);          FUNCTION_CHECK_SRC(src, srcw);
1388  #endif  #endif
1389  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
# Line 1456  static SLJIT_INLINE void check_sljit_emi Line 1393  static SLJIT_INLINE void check_sljit_emi
1393                  fprintf(compiler->verbose, "\n");                  fprintf(compiler->verbose, "\n");
1394          }          }
1395  #endif  #endif
1396            CHECK_RETURN_OK;
1397  }  }
1398    
1399  static SLJIT_INLINE void check_sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_si op,  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_si op,
1400          sljit_si dst, sljit_sw dstw,          sljit_si dst, sljit_sw dstw,
1401          sljit_si src, sljit_sw srcw,          sljit_si src, sljit_sw srcw,
1402          sljit_si type)          sljit_si type)
1403  {  {
1404          /* If debug and verbose are disabled, all arguments are unused. */  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1405          SLJIT_UNUSED_ARG(compiler);          CHECK_ARGUMENT(!(type & ~(0xff | SLJIT_INT_OP)));
1406          SLJIT_UNUSED_ARG(op);          CHECK_ARGUMENT((type & 0xff) >= SLJIT_EQUAL && (type & 0xff) <= SLJIT_D_ORDERED);
1407          SLJIT_UNUSED_ARG(dst);          CHECK_ARGUMENT(op == SLJIT_MOV || GET_OPCODE(op) == SLJIT_MOV_UI || GET_OPCODE(op) == SLJIT_MOV_SI
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(src);  
         SLJIT_UNUSED_ARG(srcw);  
         SLJIT_UNUSED_ARG(type);  
   
         SLJIT_ASSERT(type >= SLJIT_C_EQUAL && type < SLJIT_JUMP);  
         SLJIT_ASSERT(op == SLJIT_MOV || GET_OPCODE(op) == SLJIT_MOV_UI || GET_OPCODE(op) == SLJIT_MOV_SI  
1408                  || (GET_OPCODE(op) >= SLJIT_AND && GET_OPCODE(op) <= SLJIT_XOR));                  || (GET_OPCODE(op) >= SLJIT_AND && GET_OPCODE(op) <= SLJIT_XOR));
1409          SLJIT_ASSERT((op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C)) == 0);          CHECK_ARGUMENT((op & (SLJIT_SET_U | SLJIT_SET_S | SLJIT_SET_O | SLJIT_SET_C)) == 0);
1410          SLJIT_ASSERT((op & (SLJIT_SET_E | SLJIT_KEEP_FLAGS)) != (SLJIT_SET_E | SLJIT_KEEP_FLAGS));          CHECK_ARGUMENT((op & (SLJIT_SET_E | SLJIT_KEEP_FLAGS)) != (SLJIT_SET_E | SLJIT_KEEP_FLAGS));
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1411          if (GET_OPCODE(op) < SLJIT_ADD) {          if (GET_OPCODE(op) < SLJIT_ADD) {
1412                  SLJIT_ASSERT(src == SLJIT_UNUSED && srcw == 0);                  CHECK_ARGUMENT(src == SLJIT_UNUSED && srcw == 0);
1413          } else {          } else {
1414                  SLJIT_ASSERT(src == dst && srcw == dstw);                  CHECK_ARGUMENT(src == dst && srcw == dstw);
1415          }          }
1416          FUNCTION_CHECK_DST(dst, dstw);          FUNCTION_CHECK_DST(dst, dstw);
1417  #endif  #endif
1418  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1419          if (SLJIT_UNLIKELY(!!compiler->verbose)) {          if (SLJIT_UNLIKELY(!!compiler->verbose)) {
1420                  fprintf(compiler->verbose, "  %sflags.%s%s%s ", !(op & SLJIT_INT_OP) ? "" : "i",                  fprintf(compiler->verbose, "  flags.%s%s%s%s ", !(op & SLJIT_INT_OP) ? "" : "i",
1421                          GET_OPCODE(op) >= SLJIT_OP2_BASE ? op2_names[GET_OPCODE(op) - SLJIT_OP2_BASE] : op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE],                          GET_OPCODE(op) >= SLJIT_OP2_BASE ? op2_names[GET_OPCODE(op) - SLJIT_OP2_BASE] : op1_names[GET_OPCODE(op) - SLJIT_OP1_BASE],
1422                          !(op & SLJIT_SET_E) ? "" : ".e", !(op & SLJIT_KEEP_FLAGS) ? "" : ".k");                          !(op & SLJIT_SET_E) ? "" : ".e", !(op & SLJIT_KEEP_FLAGS) ? "" : ".k");
1423                  sljit_verbose_param(compiler, dst, dstw);                  sljit_verbose_param(compiler, dst, dstw);
# Line 1495  static SLJIT_INLINE void check_sljit_emi Line 1425  static SLJIT_INLINE void check_sljit_emi
1425                          fprintf(compiler->verbose, ", ");                          fprintf(compiler->verbose, ", ");
1426                          sljit_verbose_param(compiler, src, srcw);                          sljit_verbose_param(compiler, src, srcw);
1427                  }                  }
1428                  fprintf(compiler->verbose, ", %s\n", jump_names[type]);                  fprintf(compiler->verbose, ", %s%s\n", JUMP_PREFIX(type), jump_names[type & 0xff]);
1429          }          }
1430  #endif  #endif
1431            CHECK_RETURN_OK;
1432  }  }
1433    
1434  static SLJIT_INLINE void check_sljit_get_local_base(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw offset)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_get_local_base(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw offset)
1435  {  {
1436          SLJIT_UNUSED_ARG(compiler);  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(offset);  
   
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1437          FUNCTION_CHECK_DST(dst, dstw);          FUNCTION_CHECK_DST(dst, dstw);
1438  #endif  #endif
1439  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
# Line 1517  static SLJIT_INLINE void check_sljit_get Line 1443  static SLJIT_INLINE void check_sljit_get
1443                  fprintf(compiler->verbose, ", #%" SLJIT_PRINT_D "d\n", offset);                  fprintf(compiler->verbose, ", #%" SLJIT_PRINT_D "d\n", offset);
1444          }          }
1445  #endif  #endif
1446            CHECK_RETURN_OK;
1447  }  }
1448    
1449  static SLJIT_INLINE void check_sljit_emit_const(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw init_value)  static SLJIT_INLINE CHECK_RETURN_TYPE check_sljit_emit_const(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw init_value)
1450  {  {
1451          /* If debug and verbose are disabled, all arguments are unused. */  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
         SLJIT_UNUSED_ARG(compiler);  
         SLJIT_UNUSED_ARG(dst);  
         SLJIT_UNUSED_ARG(dstw);  
         SLJIT_UNUSED_ARG(init_value);  
   
 #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  
1452          FUNCTION_CHECK_DST(dst, dstw);          FUNCTION_CHECK_DST(dst, dstw);
1453  #endif  #endif
1454  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
# Line 1537  static SLJIT_INLINE void check_sljit_emi Line 1458  static SLJIT_INLINE void check_sljit_emi
1458                  fprintf(compiler->verbose, ", #%" SLJIT_PRINT_D "d\n", init_value);                  fprintf(compiler->verbose, ", #%" SLJIT_PRINT_D "d\n", init_value);
1459          }          }
1460  #endif  #endif
1461            CHECK_RETURN_OK;
1462  }  }
1463    
1464    #endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_VERBOSE */
1465    
1466    #define SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw) \
1467            SLJIT_COMPILE_ASSERT(!(SLJIT_CONVW_FROMD & 0x1) && !(SLJIT_CONVD_FROMW & 0x1), \
1468                    invalid_float_opcodes); \
1469            if (GET_OPCODE(op) >= SLJIT_CONVW_FROMD && GET_OPCODE(op) <= SLJIT_DCMP) { \
1470                    if (GET_OPCODE(op) == SLJIT_DCMP) { \
1471                            CHECK(check_sljit_emit_fop1_cmp(compiler, op, dst, dstw, src, srcw)); \
1472                            ADJUST_LOCAL_OFFSET(dst, dstw); \
1473                            ADJUST_LOCAL_OFFSET(src, srcw); \
1474                            return sljit_emit_fop1_cmp(compiler, op, dst, dstw, src, srcw); \
1475                    } \
1476                    if ((GET_OPCODE(op) | 0x1) == SLJIT_CONVI_FROMD) { \
1477                            CHECK(check_sljit_emit_fop1_convw_fromd(compiler, op, dst, dstw, src, srcw)); \
1478                            ADJUST_LOCAL_OFFSET(dst, dstw); \
1479                            ADJUST_LOCAL_OFFSET(src, srcw); \
1480                            return sljit_emit_fop1_convw_fromd(compiler, op, dst, dstw, src, srcw); \
1481                    } \
1482                    CHECK(check_sljit_emit_fop1_convd_fromw(compiler, op, dst, dstw, src, srcw)); \
1483                    ADJUST_LOCAL_OFFSET(dst, dstw); \
1484                    ADJUST_LOCAL_OFFSET(src, srcw); \
1485                    return sljit_emit_fop1_convd_fromw(compiler, op, dst, dstw, src, srcw); \
1486            } \
1487            CHECK(check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw)); \
1488            ADJUST_LOCAL_OFFSET(dst, dstw); \
1489            ADJUST_LOCAL_OFFSET(src, srcw);
1490    
1491  static SLJIT_INLINE sljit_si emit_mov_before_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)  static SLJIT_INLINE sljit_si emit_mov_before_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)
1492  {  {
1493          /* Return if don't need to do anything. */          /* Return if don't need to do anything. */
# Line 1554  static SLJIT_INLINE sljit_si emit_mov_be Line 1503  static SLJIT_INLINE sljit_si emit_mov_be
1503                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1504  #endif  #endif
1505    
1506  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \
1507                    || (defined SLJIT_VERBOSE && SLJIT_VERBOSE)
1508          compiler->skip_checks = 1;          compiler->skip_checks = 1;
1509  #endif  #endif
1510          return sljit_emit_op1(compiler, op, SLJIT_RETURN_REG, 0, src, srcw);          return sljit_emit_op1(compiler, op, SLJIT_RETURN_REG, 0, src, srcw);
# Line 1617  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1567  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1567          sljit_sw tmp_srcw;          sljit_sw tmp_srcw;
1568    
1569          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
1570          check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w);          CHECK_PTR(check_sljit_emit_cmp(compiler, type, src1, src1w, src2, src2w));
1571    
1572          condition = type & 0xff;          condition = type & 0xff;
1573  #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)  #if (defined SLJIT_CONFIG_ARM_64 && SLJIT_CONFIG_ARM_64)
1574          if ((condition == SLJIT_C_EQUAL || condition == SLJIT_C_NOT_EQUAL)) {          if ((condition == SLJIT_EQUAL || condition == SLJIT_NOT_EQUAL)) {
1575                  if ((src1 & SLJIT_IMM) && !src1w) {                  if ((src1 & SLJIT_IMM) && !src1w) {
1576                          src1 = src2;                          src1 = src2;
1577                          src1w = src2w;                          src1w = src2w;
# Line 1636  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1586  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1586          if (SLJIT_UNLIKELY((src1 & SLJIT_IMM) && !(src2 & SLJIT_IMM))) {          if (SLJIT_UNLIKELY((src1 & SLJIT_IMM) && !(src2 & SLJIT_IMM))) {
1587                  /* Immediate is prefered as second argument by most architectures. */                  /* Immediate is prefered as second argument by most architectures. */
1588                  switch (condition) {                  switch (condition) {
1589                  case SLJIT_C_LESS:                  case SLJIT_LESS:
1590                          condition = SLJIT_C_GREATER;                          condition = SLJIT_GREATER;
1591                          break;                          break;
1592                  case SLJIT_C_GREATER_EQUAL:                  case SLJIT_GREATER_EQUAL:
1593                          condition = SLJIT_C_LESS_EQUAL;                          condition = SLJIT_LESS_EQUAL;
1594                          break;                          break;
1595                  case SLJIT_C_GREATER:                  case SLJIT_GREATER:
1596                          condition = SLJIT_C_LESS;                          condition = SLJIT_LESS;
1597                          break;                          break;
1598                  case SLJIT_C_LESS_EQUAL:                  case SLJIT_LESS_EQUAL:
1599                          condition = SLJIT_C_GREATER_EQUAL;                          condition = SLJIT_GREATER_EQUAL;
1600                          break;                          break;
1601                  case SLJIT_C_SIG_LESS:                  case SLJIT_SIG_LESS:
1602                          condition = SLJIT_C_SIG_GREATER;                          condition = SLJIT_SIG_GREATER;
1603                          break;                          break;
1604                  case SLJIT_C_SIG_GREATER_EQUAL:                  case SLJIT_SIG_GREATER_EQUAL:
1605                          condition = SLJIT_C_SIG_LESS_EQUAL;                          condition = SLJIT_SIG_LESS_EQUAL;
1606                          break;                          break;
1607                  case SLJIT_C_SIG_GREATER:                  case SLJIT_SIG_GREATER:
1608                          condition = SLJIT_C_SIG_LESS;                          condition = SLJIT_SIG_LESS;
1609                          break;                          break;
1610                  case SLJIT_C_SIG_LESS_EQUAL:                  case SLJIT_SIG_LESS_EQUAL:
1611                          condition = SLJIT_C_SIG_GREATER_EQUAL;                          condition = SLJIT_SIG_GREATER_EQUAL;
1612                          break;                          break;
1613                  }                  }
1614                  type = condition | (type & (SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP));                  type = condition | (type & (SLJIT_INT_OP | SLJIT_REWRITABLE_JUMP));
# Line 1670  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1620  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1620                  src2w = tmp_srcw;                  src2w = tmp_srcw;
1621          }          }
1622    
1623          if (condition <= SLJIT_C_NOT_ZERO)          if (condition <= SLJIT_NOT_ZERO)
1624                  flags = SLJIT_SET_E;                  flags = SLJIT_SET_E;
1625          else if (condition <= SLJIT_C_LESS_EQUAL)          else if (condition <= SLJIT_LESS_EQUAL)
1626                  flags = SLJIT_SET_U;                  flags = SLJIT_SET_U;
1627          else          else
1628                  flags = SLJIT_SET_S;                  flags = SLJIT_SET_S;
1629    
1630  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
1631                    || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1632          compiler->skip_checks = 1;          compiler->skip_checks = 1;
1633  #endif  #endif
1634          PTR_FAIL_IF(sljit_emit_op2(compiler, SLJIT_SUB | flags | (type & SLJIT_INT_OP),          PTR_FAIL_IF(sljit_emit_op2(compiler, SLJIT_SUB | flags | (type & SLJIT_INT_OP),
1635                  SLJIT_UNUSED, 0, src1, src1w, src2, src2w));                  SLJIT_UNUSED, 0, src1, src1w, src2, src2w));
1636  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
1637                    || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1638          compiler->skip_checks = 1;          compiler->skip_checks = 1;
1639  #endif  #endif
1640          return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));          return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
# Line 1694  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1646  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1646  {  {
1647          sljit_si flags, condition;          sljit_si flags, condition;
1648    
1649          check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w);          CHECK_ERROR_PTR();
1650            CHECK_PTR(check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w));
1651    
1652          condition = type & 0xff;          condition = type & 0xff;
1653          flags = (condition <= SLJIT_C_FLOAT_NOT_EQUAL) ? SLJIT_SET_E : SLJIT_SET_S;          flags = (condition <= SLJIT_D_NOT_EQUAL) ? SLJIT_SET_E : SLJIT_SET_S;
1654          if (type & SLJIT_SINGLE_OP)          if (type & SLJIT_SINGLE_OP)
1655                  flags |= SLJIT_SINGLE_OP;                  flags |= SLJIT_SINGLE_OP;
1656    
1657  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
1658                    || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1659          compiler->skip_checks = 1;          compiler->skip_checks = 1;
1660  #endif  #endif
1661          sljit_emit_fop1(compiler, SLJIT_CMPD | flags, src1, src1w, src2, src2w);          sljit_emit_fop1(compiler, SLJIT_DCMP | flags, src1, src1w, src2, src2w);
1662    
1663  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
1664                    || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1665          compiler->skip_checks = 1;          compiler->skip_checks = 1;
1666  #endif  #endif
1667          return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));          return sljit_emit_jump(compiler, condition | (type & SLJIT_REWRITABLE_JUMP));
# Line 1719  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1674  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1674  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_local_base(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw offset)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_local_base(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw offset)
1675  {  {
1676          CHECK_ERROR();          CHECK_ERROR();
1677          check_sljit_get_local_base(compiler, dst, dstw, offset);          CHECK(check_sljit_get_local_base(compiler, dst, dstw, offset));
1678    
1679          ADJUST_LOCAL_OFFSET(SLJIT_MEM1(SLJIT_SP), offset);          ADJUST_LOCAL_OFFSET(SLJIT_MEM1(SLJIT_SP), offset);
1680  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) \
1681                    || (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS)
1682          compiler->skip_checks = 1;          compiler->skip_checks = 1;
1683  #endif  #endif
1684          if (offset != 0)          if (offset != 0)
# Line 1799  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 1755  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
1755          return SLJIT_ERR_UNSUPPORTED;          return SLJIT_ERR_UNSUPPORTED;
1756  }  }
1757    
1758  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler,  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_set_context(struct sljit_compiler *compiler,
1759          sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,          sljit_si options, sljit_si args, sljit_si scratches, sljit_si saveds,
1760          sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)          sljit_si fscratches, sljit_si fsaveds, sljit_si local_size)
1761  {  {
# Line 1812  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_ Line 1768  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_
1768          SLJIT_UNUSED_ARG(fsaveds);          SLJIT_UNUSED_ARG(fsaveds);
1769          SLJIT_UNUSED_ARG(local_size);          SLJIT_UNUSED_ARG(local_size);
1770          SLJIT_ASSERT_STOP();          SLJIT_ASSERT_STOP();
1771            return SLJIT_ERR_UNSUPPORTED;
1772  }  }
1773    
1774  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)

Legend:
Removed from v.1505  
changed lines
  Added in v.1506

  ViewVC Help
Powered by ViewVC 1.1.5