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

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

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

revision 1194 by zherczeg, Sun Oct 28 05:22:32 2012 UTC revision 1195 by zherczeg, Thu Nov 1 15:21:27 2012 UTC
# Line 38  typedef sljit_ui sljit_ins; Line 38  typedef sljit_ui sljit_ins;
38  #define TMP_REG3        (SLJIT_NO_REGISTERS + 3)  #define TMP_REG3        (SLJIT_NO_REGISTERS + 3)
39  #define TMP_PC          (SLJIT_NO_REGISTERS + 4)  #define TMP_PC          (SLJIT_NO_REGISTERS + 4)
40    
41  #define TMP_FREG1       (SLJIT_FLOAT_REG4 + 1)  #define TMP_FREG1       (0)
42  #define TMP_FREG2       (SLJIT_FLOAT_REG4 + 2)  #define TMP_FREG2       (SLJIT_FLOAT_REG6 + 1)
43    
44  /* See sljit_emit_enter and sljit_emit_op0 if you want to change them. */  /* See sljit_emit_enter and sljit_emit_op0 if you want to change them. */
45  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 5] = {  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 5] = {
# Line 166  static SLJIT_CONST sljit_ub reg_map[SLJI Line 166  static SLJIT_CONST sljit_ub reg_map[SLJI
166  #define UXTB_W          0xfa5ff080  #define UXTB_W          0xfa5ff080
167  #define UXTH            0xb280  #define UXTH            0xb280
168  #define UXTH_W          0xfa1ff080  #define UXTH_W          0xfa1ff080
169  #define VABS_F64        0xeeb00bc0  #define VABS_F32        0xeeb00ac0
170  #define VADD_F64        0xee300b00  #define VADD_F32        0xee300a00
171  #define VCMP_F64        0xeeb40b40  #define VCMP_F32        0xeeb40a40
172  #define VDIV_F64        0xee800b00  #define VDIV_F32        0xee800a00
173  #define VMOV_F64        0xeeb00b40  #define VMOV_F32        0xeeb00a40
174  #define VMRS            0xeef1fa10  #define VMRS            0xeef1fa10
175  #define VMUL_F64        0xee200b00  #define VMUL_F32        0xee200a00
176  #define VNEG_F64        0xeeb10b40  #define VNEG_F32        0xeeb10a40
177  #define VSTR            0xed000b00  #define VSTR_F32        0xed000a00
178  #define VSUB_F64        0xee300b40  #define VSUB_F32        0xee300a40
179    
180  static int push_inst16(struct sljit_compiler *compiler, sljit_ins inst)  static sljit_si push_inst16(struct sljit_compiler *compiler, sljit_ins inst)
181  {  {
182          sljit_uh *ptr;          sljit_uh *ptr;
183          SLJIT_ASSERT(!(inst & 0xffff0000));          SLJIT_ASSERT(!(inst & 0xffff0000));
# Line 189  static int push_inst16(struct sljit_comp Line 189  static int push_inst16(struct sljit_comp
189          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
190  }  }
191    
192  static int push_inst32(struct sljit_compiler *compiler, sljit_ins inst)  static sljit_si push_inst32(struct sljit_compiler *compiler, sljit_ins inst)
193  {  {
194          sljit_uh *ptr = (sljit_uh*)ensure_buf(compiler, sizeof(sljit_ins));          sljit_uh *ptr = (sljit_uh*)ensure_buf(compiler, sizeof(sljit_ins));
195          FAIL_IF(!ptr);          FAIL_IF(!ptr);
# Line 199  static int push_inst32(struct sljit_comp Line 199  static int push_inst32(struct sljit_comp
199          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
200  }  }
201    
202  static SLJIT_INLINE int emit_imm32_const(struct sljit_compiler *compiler, int dst, sljit_uw imm)  static SLJIT_INLINE sljit_si emit_imm32_const(struct sljit_compiler *compiler, sljit_si dst, sljit_uw imm)
203  {  {
204          FAIL_IF(push_inst32(compiler, MOVW | RD4(dst) |          FAIL_IF(push_inst32(compiler, MOVW | RD4(dst) |
205                  COPY_BITS(imm, 12, 16, 4) | COPY_BITS(imm, 11, 26, 1) | COPY_BITS(imm, 8, 12, 3) | (imm & 0xff)));                  COPY_BITS(imm, 12, 16, 4) | COPY_BITS(imm, 11, 26, 1) | COPY_BITS(imm, 8, 12, 3) | (imm & 0xff)));
# Line 209  static SLJIT_INLINE int emit_imm32_const Line 209  static SLJIT_INLINE int emit_imm32_const
209    
210  static SLJIT_INLINE void modify_imm32_const(sljit_uh* inst, sljit_uw new_imm)  static SLJIT_INLINE void modify_imm32_const(sljit_uh* inst, sljit_uw new_imm)
211  {  {
212          int dst = inst[1] & 0x0f00;          sljit_si dst = inst[1] & 0x0f00;
213          SLJIT_ASSERT(((inst[0] & 0xfbf0) == (MOVW >> 16)) && ((inst[2] & 0xfbf0) == (MOVT >> 16)) && dst == (inst[3] & 0x0f00));          SLJIT_ASSERT(((inst[0] & 0xfbf0) == (MOVW >> 16)) && ((inst[2] & 0xfbf0) == (MOVT >> 16)) && dst == (inst[3] & 0x0f00));
214          inst[0] = (MOVW >> 16) | COPY_BITS(new_imm, 12, 0, 4) | COPY_BITS(new_imm, 11, 10, 1);          inst[0] = (MOVW >> 16) | COPY_BITS(new_imm, 12, 0, 4) | COPY_BITS(new_imm, 11, 10, 1);
215          inst[1] = dst | COPY_BITS(new_imm, 8, 12, 3) | (new_imm & 0xff);          inst[1] = dst | COPY_BITS(new_imm, 8, 12, 3) | (new_imm & 0xff);
# Line 217  static SLJIT_INLINE void modify_imm32_co Line 217  static SLJIT_INLINE void modify_imm32_co
217          inst[3] = dst | COPY_BITS(new_imm, 8 + 16, 12, 3) | ((new_imm & 0xff0000) >> 16);          inst[3] = dst | COPY_BITS(new_imm, 8 + 16, 12, 3) | ((new_imm & 0xff0000) >> 16);
218  }  }
219    
220  static SLJIT_INLINE int detect_jump_type(struct sljit_jump *jump, sljit_uh *code_ptr, sljit_uh *code)  static SLJIT_INLINE sljit_si detect_jump_type(struct sljit_jump *jump, sljit_uh *code_ptr, sljit_uh *code)
221  {  {
222          sljit_w diff;          sljit_sw diff;
223    
224          if (jump->flags & SLJIT_REWRITABLE_JUMP)          if (jump->flags & SLJIT_REWRITABLE_JUMP)
225                  return 0;                  return 0;
# Line 228  static SLJIT_INLINE int detect_jump_type Line 228  static SLJIT_INLINE int detect_jump_type
228                  /* Branch to ARM code is not optimized yet. */                  /* Branch to ARM code is not optimized yet. */
229                  if (!(jump->u.target & 0x1))                  if (!(jump->u.target & 0x1))
230                          return 0;                          return 0;
231                  diff = ((sljit_w)jump->u.target - (sljit_w)(code_ptr + 2)) >> 1;                  diff = ((sljit_sw)jump->u.target - (sljit_sw)(code_ptr + 2)) >> 1;
232          }          }
233          else {          else {
234                  SLJIT_ASSERT(jump->flags & JUMP_LABEL);                  SLJIT_ASSERT(jump->flags & JUMP_LABEL);
235                  diff = ((sljit_w)(code + jump->u.label->size) - (sljit_w)(code_ptr + 2)) >> 1;                  diff = ((sljit_sw)(code + jump->u.label->size) - (sljit_sw)(code_ptr + 2)) >> 1;
236          }          }
237    
238          if (jump->flags & IS_COND) {          if (jump->flags & IS_COND) {
# Line 272  static SLJIT_INLINE int detect_jump_type Line 272  static SLJIT_INLINE int detect_jump_type
272          return 0;          return 0;
273  }  }
274    
275  static SLJIT_INLINE void inline_set_jump_addr(sljit_uw addr, sljit_uw new_addr, int flush)  static SLJIT_INLINE void inline_set_jump_addr(sljit_uw addr, sljit_uw new_addr, sljit_si flush)
276  {  {
277          sljit_uh* inst = (sljit_uh*)addr;          sljit_uh* inst = (sljit_uh*)addr;
278          modify_imm32_const(inst, new_addr);          modify_imm32_const(inst, new_addr);
# Line 283  static SLJIT_INLINE void inline_set_jump Line 283  static SLJIT_INLINE void inline_set_jump
283    
284  static SLJIT_INLINE void set_jump_instruction(struct sljit_jump *jump)  static SLJIT_INLINE void set_jump_instruction(struct sljit_jump *jump)
285  {  {
286          int type = (jump->flags >> 4) & 0xf;          sljit_si type = (jump->flags >> 4) & 0xf;
287          sljit_w diff;          sljit_sw diff;
288          sljit_uh *jump_inst;          sljit_uh *jump_inst;
289          int s, j1, j2;          sljit_si s, j1, j2;
290    
291          if (SLJIT_UNLIKELY(type == 0)) {          if (SLJIT_UNLIKELY(type == 0)) {
292                  inline_set_jump_addr(jump->addr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target, 0);                  inline_set_jump_addr(jump->addr, (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target, 0);
# Line 295  static SLJIT_INLINE void set_jump_instru Line 295  static SLJIT_INLINE void set_jump_instru
295    
296          if (jump->flags & JUMP_ADDR) {          if (jump->flags & JUMP_ADDR) {
297                  SLJIT_ASSERT(jump->u.target & 0x1);                  SLJIT_ASSERT(jump->u.target & 0x1);
298                  diff = ((sljit_w)jump->u.target - (sljit_w)(jump->addr + 4)) >> 1;                  diff = ((sljit_sw)jump->u.target - (sljit_sw)(jump->addr + 4)) >> 1;
299          }          }
300          else          else
301                  diff = ((sljit_w)(jump->u.label->addr) - (sljit_w)(jump->addr + 4)) >> 1;                  diff = ((sljit_sw)(jump->u.label->addr) - (sljit_sw)(jump->addr + 4)) >> 1;
302          jump_inst = (sljit_uh*)jump->addr;          jump_inst = (sljit_uh*)jump->addr;
303    
304          switch (type) {          switch (type) {
# Line 410  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 410  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
410          SLJIT_ASSERT(!label);          SLJIT_ASSERT(!label);
411          SLJIT_ASSERT(!jump);          SLJIT_ASSERT(!jump);
412          SLJIT_ASSERT(!const_);          SLJIT_ASSERT(!const_);
413          SLJIT_ASSERT(code_ptr - code <= (int)compiler->size);          SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size);
414    
415          jump = compiler->jumps;          jump = compiler->jumps;
416          while (jump) {          while (jump) {
# Line 429  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 429  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
429  static sljit_uw get_imm(sljit_uw imm)  static sljit_uw get_imm(sljit_uw imm)
430  {  {
431          /* Thumb immediate form. */          /* Thumb immediate form. */
432          int counter;          sljit_si counter;
433    
434          if (imm <= 0xff)          if (imm <= 0xff)
435                  return imm;                  return imm;
# Line 475  static sljit_uw get_imm(sljit_uw imm) Line 475  static sljit_uw get_imm(sljit_uw imm)
475          return ((imm >> 24) & 0x7f) | COPY_BITS(counter, 4, 26, 1) | COPY_BITS(counter, 1, 12, 3) | COPY_BITS(counter, 0, 7, 1);          return ((imm >> 24) & 0x7f) | COPY_BITS(counter, 4, 26, 1) | COPY_BITS(counter, 1, 12, 3) | COPY_BITS(counter, 0, 7, 1);
476  }  }
477    
478  static int load_immediate(struct sljit_compiler *compiler, int dst, sljit_uw imm)  static sljit_si load_immediate(struct sljit_compiler *compiler, sljit_si dst, sljit_uw imm)
479  {  {
480          sljit_uw tmp;          sljit_uw tmp;
481    
# Line 510  static int load_immediate(struct sljit_c Line 510  static int load_immediate(struct sljit_c
510  #define SLOW_SRC1       0x0800000  #define SLOW_SRC1       0x0800000
511  #define SLOW_SRC2       0x1000000  #define SLOW_SRC2       0x1000000
512    
513  static int emit_op_imm(struct sljit_compiler *compiler, int flags, int dst, sljit_uw arg1, sljit_uw arg2)  static sljit_si emit_op_imm(struct sljit_compiler *compiler, sljit_si flags, sljit_si dst, sljit_uw arg1, sljit_uw arg2)
514  {  {
515          /* dst must be register, TMP_REG1          /* dst must be register, TMP_REG1
516             arg1 must be register, TMP_REG1, imm             arg1 must be register, TMP_REG1, imm
517             arg2 must be register, TMP_REG2, imm */             arg2 must be register, TMP_REG2, imm */
518          int reg;          sljit_si reg;
519          sljit_uw imm, negated_imm;          sljit_uw imm, negated_imm;
520    
521          if (SLJIT_UNLIKELY((flags & (ARG1_IMM | ARG2_IMM)) == (ARG1_IMM | ARG2_IMM))) {          if (SLJIT_UNLIKELY((flags & (ARG1_IMM | ARG2_IMM)) == (ARG1_IMM | ARG2_IMM))) {
# Line 543  static int emit_op_imm(struct sljit_comp Line 543  static int emit_op_imm(struct sljit_comp
543                          /* No form with immediate operand. */                          /* No form with immediate operand. */
544                          break;                          break;
545                  case SLJIT_ADD:                  case SLJIT_ADD:
546                          negated_imm = (sljit_uw)-(sljit_w)imm;                          negated_imm = (sljit_uw)-(sljit_sw)imm;
547                          if (!(flags & KEEP_FLAGS) && IS_2_LO_REGS(reg, dst)) {                          if (!(flags & KEEP_FLAGS) && IS_2_LO_REGS(reg, dst)) {
548                                  if (imm <= 0x7)                                  if (imm <= 0x7)
549                                          return push_inst16(compiler, ADDSI3 | IMM3(imm) | RD3(dst) | RN3(reg));                                          return push_inst16(compiler, ADDSI3 | IMM3(imm) | RD3(dst) | RN3(reg));
# Line 573  static int emit_op_imm(struct sljit_comp Line 573  static int emit_op_imm(struct sljit_comp
573                          break;                          break;
574                  case SLJIT_SUB:                  case SLJIT_SUB:
575                          if (flags & ARG2_IMM) {                          if (flags & ARG2_IMM) {
576                                  negated_imm = (sljit_uw)-(sljit_w)imm;                                  negated_imm = (sljit_uw)-(sljit_sw)imm;
577                                  if (!(flags & KEEP_FLAGS) && IS_2_LO_REGS(reg, dst)) {                                  if (!(flags & KEEP_FLAGS) && IS_2_LO_REGS(reg, dst)) {
578                                          if (imm <= 0x7)                                          if (imm <= 0x7)
579                                                  return push_inst16(compiler, SUBSI3 | IMM3(imm) | RD3(dst) | RN3(reg));                                                  return push_inst16(compiler, SUBSI3 | IMM3(imm) | RD3(dst) | RN3(reg));
# Line 888  static SLJIT_CONST sljit_uw sljit_mem32[ Line 888  static SLJIT_CONST sljit_uw sljit_mem32[
888  };  };
889    
890  /* Helper function. Dst should be reg + value, using at most 1 instruction, flags does not set. */  /* Helper function. Dst should be reg + value, using at most 1 instruction, flags does not set. */
891  static int emit_set_delta(struct sljit_compiler *compiler, int dst, int reg, sljit_w value)  static sljit_si emit_set_delta(struct sljit_compiler *compiler, sljit_si dst, sljit_si reg, sljit_sw value)
892  {  {
893          if (value >= 0) {          if (value >= 0) {
894                  if (value <= 0xfff)                  if (value <= 0xfff)
# Line 909  static int emit_set_delta(struct sljit_c Line 909  static int emit_set_delta(struct sljit_c
909  }  }
910    
911  /* Can perform an operation using at most 1 instruction. */  /* Can perform an operation using at most 1 instruction. */
912  static int getput_arg_fast(struct sljit_compiler *compiler, int flags, int reg, int arg, sljit_w argw)  static sljit_si getput_arg_fast(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
913  {  {
914          int tmp;          sljit_si tmp;
915    
916          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
917    
# Line 994  static int getput_arg_fast(struct sljit_ Line 994  static int getput_arg_fast(struct sljit_
994  /* see getput_arg below.  /* see getput_arg below.
995     Note: can_cache is called only for binary operators. Those     Note: can_cache is called only for binary operators. Those
996     operators always uses word arguments without write back. */     operators always uses word arguments without write back. */
997  static int can_cache(int arg, sljit_w argw, int next_arg, sljit_w next_argw)  static sljit_si can_cache(sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
998  {  {
999          /* Simple operation except for updates. */          /* Simple operation except for updates. */
1000          if ((arg & 0xf0) || !(next_arg & SLJIT_MEM))          if ((arg & 0xf0) || !(next_arg & SLJIT_MEM))
# Line 1016  static int can_cache(int arg, sljit_w ar Line 1016  static int can_cache(int arg, sljit_w ar
1016  }  }
1017    
1018  /* Emit the necessary instructions. See can_cache above. */  /* Emit the necessary instructions. See can_cache above. */
1019  static int getput_arg(struct sljit_compiler *compiler, int flags, int reg, int arg, sljit_w argw, int next_arg, sljit_w next_argw)  static sljit_si getput_arg(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
1020  {  {
1021          int tmp_r;          sljit_si tmp_r;
1022          sljit_w tmp;          sljit_sw tmp;
1023    
1024          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
1025          if (!(next_arg & SLJIT_MEM)) {          if (!(next_arg & SLJIT_MEM)) {
# Line 1115  static int getput_arg(struct sljit_compi Line 1115  static int getput_arg(struct sljit_compi
1115          return push_inst32(compiler, sljit_mem32[flags] | MEM_IMM12 | RT4(reg) | RN4(TMP_REG3) | 0);          return push_inst32(compiler, sljit_mem32[flags] | MEM_IMM12 | RT4(reg) | RN4(TMP_REG3) | 0);
1116  }  }
1117    
1118  static SLJIT_INLINE int emit_op_mem(struct sljit_compiler *compiler, int flags, int reg, int arg, sljit_w argw)  static SLJIT_INLINE sljit_si emit_op_mem(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
1119  {  {
1120          if (getput_arg_fast(compiler, flags, reg, arg, argw))          if (getput_arg_fast(compiler, flags, reg, arg, argw))
1121                  return compiler->error;                  return compiler->error;
# Line 1128  static SLJIT_INLINE int emit_op_mem(stru Line 1128  static SLJIT_INLINE int emit_op_mem(stru
1128  /*  Entry, exit                                                          */  /*  Entry, exit                                                          */
1129  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1130    
1131  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_enter(struct sljit_compiler *compiler, sljit_si args, sljit_si temporaries, sljit_si saveds, sljit_si local_size)
1132  {  {
1133          int size;          sljit_si size;
1134          sljit_ins push;          sljit_ins push;
1135    
1136          CHECK_ERROR();          CHECK_ERROR();
# Line 1182  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1182  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1182          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1183  }  }
1184    
1185  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, sljit_si args, sljit_si temporaries, sljit_si saveds, sljit_si local_size)
1186  {  {
1187          int size;          sljit_si size;
1188    
1189          CHECK_ERROR_VOID();          CHECK_ERROR_VOID();
1190          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);
# Line 1202  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_ Line 1202  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_
1202          compiler->local_size = local_size;          compiler->local_size = local_size;
1203  }  }
1204    
1205  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)
1206  {  {
1207          sljit_ins pop;          sljit_ins pop;
1208    
# Line 1245  extern "C" { Line 1245  extern "C" {
1245  #endif  #endif
1246    
1247  #if defined(__GNUC__)  #if defined(__GNUC__)
1248  extern unsigned int __aeabi_uidivmod(unsigned numerator, unsigned denominator);  extern unsigned int __aeabi_uidivmod(unsigned int numerator, int unsigned denominator);
1249  extern unsigned int __aeabi_idivmod(unsigned numerator, unsigned denominator);  extern int __aeabi_idivmod(int numerator, int denominator);
1250  #else  #else
1251  #error "Software divmod functions are needed"  #error "Software divmod functions are needed"
1252  #endif  #endif
# Line 1255  extern unsigned int __aeabi_idivmod(unsi Line 1255  extern unsigned int __aeabi_idivmod(unsi
1255  }  }
1256  #endif  #endif
1257    
1258  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op0(struct sljit_compiler *compiler, int op)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op0(struct sljit_compiler *compiler, sljit_si op)
1259  {  {
1260          CHECK_ERROR();          CHECK_ERROR();
1261          check_sljit_emit_op0(compiler, op);          check_sljit_emit_op0(compiler, op);
# Line 1299  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1299  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1299          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1300  }  }
1301    
1302  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct sljit_compiler *compiler, int op,  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op1(struct sljit_compiler *compiler, sljit_si op,
1303          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1304          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
1305  {  {
1306          int op_type, dst_r, flags;          sljit_si dst_r, flags;
1307            sljit_si op_flags = GET_ALL_FLAGS(op);
1308    
1309          CHECK_ERROR();          CHECK_ERROR();
1310          check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);
# Line 1313  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1314  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1314          compiler->cache_arg = 0;          compiler->cache_arg = 0;
1315          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1316    
         op_type = GET_OPCODE(op);  
1317          dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REG1;          dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REG1;
1318    
1319          if (op_type >= SLJIT_MOV && op_type <= SLJIT_MOVU_P) {          op = GET_OPCODE(op);
1320                  switch (op_type) {          if (op >= SLJIT_MOV && op <= SLJIT_MOVU_P) {
1321                    switch (op) {
1322                  case SLJIT_MOV:                  case SLJIT_MOV:
1323                  case SLJIT_MOV_UI:                  case SLJIT_MOV_UI:
1324                  case SLJIT_MOV_SI:                  case SLJIT_MOV_SI:
# Line 1332  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1333  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1333                  case SLJIT_MOV_SB:                  case SLJIT_MOV_SB:
1334                          flags = BYTE_SIZE | SIGNED;                          flags = BYTE_SIZE | SIGNED;
1335                          if (src & SLJIT_IMM)                          if (src & SLJIT_IMM)
1336                                  srcw = (sljit_b)srcw;                                  srcw = (sljit_sb)srcw;
1337                          break;                          break;
1338                  case SLJIT_MOV_UH:                  case SLJIT_MOV_UH:
1339                          flags = HALF_SIZE;                          flags = HALF_SIZE;
# Line 1342  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1343  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1343                  case SLJIT_MOV_SH:                  case SLJIT_MOV_SH:
1344                          flags = HALF_SIZE | SIGNED;                          flags = HALF_SIZE | SIGNED;
1345                          if (src & SLJIT_IMM)                          if (src & SLJIT_IMM)
1346                                  srcw = (sljit_h)srcw;                                  srcw = (sljit_sh)srcw;
1347                          break;                          break;
1348                  case SLJIT_MOVU:                  case SLJIT_MOVU:
1349                  case SLJIT_MOVU_UI:                  case SLJIT_MOVU_UI:
# Line 1358  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1359  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1359                  case SLJIT_MOVU_SB:                  case SLJIT_MOVU_SB:
1360                          flags = BYTE_SIZE | SIGNED | UPDATE;                          flags = BYTE_SIZE | SIGNED | UPDATE;
1361                          if (src & SLJIT_IMM)                          if (src & SLJIT_IMM)
1362                                  srcw = (sljit_b)srcw;                                  srcw = (sljit_sb)srcw;
1363                          break;                          break;
1364                  case SLJIT_MOVU_UH:                  case SLJIT_MOVU_UH:
1365                          flags = HALF_SIZE | UPDATE;                          flags = HALF_SIZE | UPDATE;
# Line 1368  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1369  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1369                  case SLJIT_MOVU_SH:                  case SLJIT_MOVU_SH:
1370                          flags = HALF_SIZE | SIGNED | UPDATE;                          flags = HALF_SIZE | SIGNED | UPDATE;
1371                          if (src & SLJIT_IMM)                          if (src & SLJIT_IMM)
1372                                  srcw = (sljit_h)srcw;                                  srcw = (sljit_sh)srcw;
1373                          break;                          break;
1374                  default:                  default:
1375                          SLJIT_ASSERT_STOP();                          SLJIT_ASSERT_STOP();
# Line 1385  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1386  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1386                                  FAIL_IF(getput_arg(compiler, flags, dst_r, src, srcw, dst, dstw));                                  FAIL_IF(getput_arg(compiler, flags, dst_r, src, srcw, dst, dstw));
1387                  } else {                  } else {
1388                          if (dst_r != TMP_REG1)                          if (dst_r != TMP_REG1)
1389                                  return emit_op_imm(compiler, op_type, dst_r, TMP_REG1, src);                                  return emit_op_imm(compiler, op, dst_r, TMP_REG1, src);
1390                          dst_r = src;                          dst_r = src;
1391                  }                  }
1392    
# Line 1398  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1399  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1399                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1400          }          }
1401    
1402          if (op_type == SLJIT_NEG) {          if (op == SLJIT_NEG) {
1403  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
1404                  compiler->skip_checks = 1;                  compiler->skip_checks = 1;
1405  #endif  #endif
1406                  return sljit_emit_op2(compiler, GET_FLAGS(op) | SLJIT_SUB, dst, dstw, SLJIT_IMM, 0, src, srcw);                  return sljit_emit_op2(compiler, SLJIT_SUB | op_flags, dst, dstw, SLJIT_IMM, 0, src, srcw);
1407          }          }
1408    
1409          flags = (GET_FLAGS(op) ? SET_FLAGS : 0) | ((op & SLJIT_KEEP_FLAGS) ? KEEP_FLAGS : 0);          flags = (GET_FLAGS(op_flags) ? SET_FLAGS : 0) | ((op_flags & SLJIT_KEEP_FLAGS) ? KEEP_FLAGS : 0);
1410          if (src & SLJIT_MEM) {          if (src & SLJIT_MEM) {
1411                  if (getput_arg_fast(compiler, WORD_SIZE, TMP_REG2, src, srcw))                  if (getput_arg_fast(compiler, WORD_SIZE, TMP_REG2, src, srcw))
1412                          FAIL_IF(compiler->error);                          FAIL_IF(compiler->error);
# Line 1419  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1420  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1420          else          else
1421                  srcw = src;                  srcw = src;
1422    
1423          emit_op_imm(compiler, flags | op_type, dst_r, TMP_REG1, srcw);          emit_op_imm(compiler, flags | op, dst_r, TMP_REG1, srcw);
1424    
1425          if (dst & SLJIT_MEM) {          if (dst & SLJIT_MEM) {
1426                  if (getput_arg_fast(compiler, flags | STORE, dst_r, dst, dstw))                  if (getput_arg_fast(compiler, flags | STORE, dst_r, dst, dstw))
# Line 1430  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1431  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1431          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1432  }  }
1433    
1434  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct sljit_compiler *compiler, int op,  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op2(struct sljit_compiler *compiler, sljit_si op,
1435          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1436          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1437          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1438  {  {
1439          int dst_r, flags;          sljit_si dst_r, flags;
1440    
1441          CHECK_ERROR();          CHECK_ERROR();
1442          check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);          check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
# Line 1512  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1513  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1513          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1514  }  }
1515    
1516  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_register_index(sljit_si reg)
1517  {  {
1518          check_sljit_get_register_index(reg);          check_sljit_get_register_index(reg);
1519          return reg_map[reg];          return reg_map[reg];
1520  }  }
1521    
1522  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op_custom(struct sljit_compiler *compiler,  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_op_custom(struct sljit_compiler *compiler,
1523          void *instruction, int size)          void *instruction, sljit_si size)
1524  {  {
1525          CHECK_ERROR();          CHECK_ERROR();
1526          check_sljit_emit_op_custom(compiler, instruction, size);          check_sljit_emit_op_custom(compiler, instruction, size);
# Line 1534  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1535  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1535  /*  Floating point operators                                             */  /*  Floating point operators                                             */
1536  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1537    
1538  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_is_fpu_available(void)
1539  {  {
1540          return 1;          return 1;
1541  }  }
1542    
1543  static int emit_fop_mem(struct sljit_compiler *compiler, int flags, int reg, int arg, sljit_w argw)  #define FPU_LOAD (1 << 20)
1544    
1545    static sljit_si emit_fop_mem(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
1546  {  {
1547          sljit_w tmp;          sljit_sw tmp;
1548          sljit_w inst = VSTR | ((flags & STORE) ? 0 : 0x00100000);          sljit_uw imm;
1549            sljit_sw inst = VSTR_F32 | (flags & (SLJIT_SINGLE_OP | FPU_LOAD));
1550    
1551          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
1552    
# Line 1553  static int emit_fop_mem(struct sljit_com Line 1557  static int emit_fop_mem(struct sljit_com
1557                  argw = 0;                  argw = 0;
1558          }          }
1559    
1560          if (arg & 0xf) {          if ((arg & 0xf) && (argw & 0x3) == 0) {
1561                  if (!(argw & ~0x3fc))                  if (!(argw & ~0x3fc))
1562                          return push_inst32(compiler, inst | 0x800000 | RN4(arg & 0xf) | DD4(reg) | (argw >> 2));                          return push_inst32(compiler, inst | 0x800000 | RN4(arg & 0xf) | DD4(reg) | (argw >> 2));
1563                  if (!(-argw & ~0x3fc))                  if (!(-argw & ~0x3fc))
# Line 1574  static int emit_fop_mem(struct sljit_com Line 1578  static int emit_fop_mem(struct sljit_com
1578                  }                  }
1579          }          }
1580    
1581            if (arg & 0xf) {
1582                    if (emit_set_delta(compiler, TMP_REG1, arg & 0xf, argw) != SLJIT_ERR_UNSUPPORTED) {
1583                            FAIL_IF(compiler->error);
1584                            return push_inst32(compiler, inst | 0x800000 | RN4(TMP_REG1) | DD4(reg));
1585                    }
1586                    imm = get_imm(argw & ~0x3fc);
1587                    if (imm != INVALID_IMM) {
1588                            FAIL_IF(push_inst32(compiler, ADD_WI | RD4(TMP_REG1) | RN4(arg & 0xf) | imm));
1589                            return push_inst32(compiler, inst | 0x800000 | RN4(TMP_REG1) | DD4(reg) | ((argw & 0x3fc) >> 2));
1590                    }
1591                    imm = get_imm(-argw & ~0x3fc);
1592                    if (imm != INVALID_IMM) {
1593                            argw = -argw;
1594                            FAIL_IF(push_inst32(compiler, SUB_WI | RD4(TMP_REG1) | RN4(arg & 0xf) | imm));
1595                            return push_inst32(compiler, inst | RN4(TMP_REG1) | DD4(reg) | ((argw & 0x3fc) >> 2));
1596                    }
1597            }
1598    
1599          compiler->cache_arg = arg;          compiler->cache_arg = arg;
1600          compiler->cache_argw = argw;          compiler->cache_argw = argw;
1601    
1602          if (SLJIT_UNLIKELY(!(arg & 0xf)))          if (SLJIT_UNLIKELY(!(arg & 0xf)))
1603                  FAIL_IF(load_immediate(compiler, TMP_REG3, argw));                  FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
         else if (emit_set_delta(compiler, TMP_REG3, arg & 0xf, argw) != SLJIT_ERR_UNSUPPORTED)  
                 FAIL_IF(compiler->error);  
1604          else {          else {
1605                  FAIL_IF(load_immediate(compiler, TMP_REG3, argw));                  FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
1606                  if (arg & 0xf)                  if (arg & 0xf)
# Line 1589  static int emit_fop_mem(struct sljit_com Line 1609  static int emit_fop_mem(struct sljit_com
1609          return push_inst32(compiler, inst | 0x800000 | RN4(TMP_REG3) | DD4(reg));          return push_inst32(compiler, inst | 0x800000 | RN4(TMP_REG3) | DD4(reg));
1610  }  }
1611    
1612  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op,
1613          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1614          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
1615  {  {
1616          int dst_r;          sljit_si dst_r;
1617    
1618          CHECK_ERROR();          CHECK_ERROR();
1619          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);
1620            SLJIT_COMPILE_ASSERT((SLJIT_SINGLE_OP == 0x100), float_transfer_bit_error);
1621    
1622          compiler->cache_arg = 0;          compiler->cache_arg = 0;
1623          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1624            op ^= SLJIT_SINGLE_OP;
1625    
1626          if (GET_OPCODE(op) == SLJIT_FCMP) {          if (GET_OPCODE(op) == SLJIT_CMPD) {
1627                  if (dst & SLJIT_MEM) {                  if (dst & SLJIT_MEM) {
1628                          emit_fop_mem(compiler, 0, TMP_FREG1, dst, dstw);                          emit_fop_mem(compiler, (op & SLJIT_SINGLE_OP) | FPU_LOAD, TMP_FREG1, dst, dstw);
1629                          dst = TMP_FREG1;                          dst = TMP_FREG1;
1630                  }                  }
1631                  if (src & SLJIT_MEM) {                  if (src & SLJIT_MEM) {
1632                          emit_fop_mem(compiler, 0, TMP_FREG2, src, srcw);                          emit_fop_mem(compiler, (op & SLJIT_SINGLE_OP) | FPU_LOAD, TMP_FREG2, src, srcw);
1633                          src = TMP_FREG2;                          src = TMP_FREG2;
1634                  }                  }
1635                  FAIL_IF(push_inst32(compiler, VCMP_F64 | DD4(dst) | DM4(src)));                  FAIL_IF(push_inst32(compiler, VCMP_F32 | (op & SLJIT_SINGLE_OP) | DD4(dst) | DM4(src)));
1636                  return push_inst32(compiler, VMRS);                  return push_inst32(compiler, VMRS);
1637          }          }
1638    
1639          dst_r = (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4) ? dst : TMP_FREG1;          dst_r = (dst > SLJIT_FLOAT_REG6) ? TMP_FREG1 : dst;
1640          if (src & SLJIT_MEM) {          if (src & SLJIT_MEM) {
1641                  emit_fop_mem(compiler, 0, dst_r, src, srcw);                  emit_fop_mem(compiler, (op & SLJIT_SINGLE_OP) | FPU_LOAD, dst_r, src, srcw);
1642                  src = dst_r;                  src = dst_r;
1643          }          }
1644    
1645          switch (GET_OPCODE(op)) {          switch (GET_OPCODE(op)) {
1646          case SLJIT_FMOV:          case SLJIT_MOVD:
1647                  if (src != dst_r)                  if (src != dst_r)
1648                          FAIL_IF(push_inst32(compiler, VMOV_F64 | DD4(dst_r) | DM4(src)));                          FAIL_IF(push_inst32(compiler, VMOV_F32 | (op & SLJIT_SINGLE_OP) | DD4(dst_r) | DM4(src)));
1649                  break;                  break;
1650          case SLJIT_FNEG:          case SLJIT_NEGD:
1651                  FAIL_IF(push_inst32(compiler, VNEG_F64 | DD4(dst_r) | DM4(src)));                  FAIL_IF(push_inst32(compiler, VNEG_F32 | (op & SLJIT_SINGLE_OP) | DD4(dst_r) | DM4(src)));
1652                  break;                  break;
1653          case SLJIT_FABS:          case SLJIT_ABSD:
1654                  FAIL_IF(push_inst32(compiler, VABS_F64 | DD4(dst_r) | DM4(src)));                  FAIL_IF(push_inst32(compiler, VABS_F32 | (op & SLJIT_SINGLE_OP) | DD4(dst_r) | DM4(src)));
1655                  break;                  break;
1656          }          }
1657    
1658          if (dst & SLJIT_MEM)          if (dst & SLJIT_MEM)
1659                  return emit_fop_mem(compiler, STORE, TMP_FREG1, dst, dstw);                  return emit_fop_mem(compiler, (op & SLJIT_SINGLE_OP), TMP_FREG1, dst, dstw);
1660          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1661  }  }
1662    
1663  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop2(struct sljit_compiler *compiler, sljit_si op,
1664          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1665          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1666          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1667  {  {
1668          int dst_r;          sljit_si dst_r;
1669    
1670          CHECK_ERROR();          CHECK_ERROR();
1671          check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);          check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
1672    
1673          compiler->cache_arg = 0;          compiler->cache_arg = 0;
1674          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1675            op ^= SLJIT_SINGLE_OP;
1676    
1677          dst_r = (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4) ? dst : TMP_FREG1;          dst_r = (dst > SLJIT_FLOAT_REG6) ? TMP_FREG1 : dst;
1678          if (src1 & SLJIT_MEM) {          if (src1 & SLJIT_MEM) {
1679                  emit_fop_mem(compiler, 0, TMP_FREG1, src1, src1w);                  emit_fop_mem(compiler, (op & SLJIT_SINGLE_OP) | FPU_LOAD, TMP_FREG1, src1, src1w);
1680                  src1 = TMP_FREG1;                  src1 = TMP_FREG1;
1681          }          }
1682          if (src2 & SLJIT_MEM) {          if (src2 & SLJIT_MEM) {
1683                  emit_fop_mem(compiler, 0, TMP_FREG2, src2, src2w);                  emit_fop_mem(compiler, (op & SLJIT_SINGLE_OP) | FPU_LOAD, TMP_FREG2, src2, src2w);
1684                  src2 = TMP_FREG2;                  src2 = TMP_FREG2;
1685          }          }
1686    
1687          switch (GET_OPCODE(op)) {          switch (GET_OPCODE(op)) {
1688          case SLJIT_FADD:          case SLJIT_ADDD:
1689                  FAIL_IF(push_inst32(compiler, VADD_F64 | DD4(dst_r) | DN4(src1) | DM4(src2)));                  FAIL_IF(push_inst32(compiler, VADD_F32 | (op & SLJIT_SINGLE_OP) | DD4(dst_r) | DN4(src1) | DM4(src2)));
1690                  break;                  break;
1691          case SLJIT_FSUB:          case SLJIT_SUBD:
1692                  FAIL_IF(push_inst32(compiler, VSUB_F64 | DD4(dst_r) | DN4(src1) | DM4(src2)));                  FAIL_IF(push_inst32(compiler, VSUB_F32 | (op & SLJIT_SINGLE_OP) | DD4(dst_r) | DN4(src1) | DM4(src2)));
1693                  break;                  break;
1694          case SLJIT_FMUL:          case SLJIT_MULD:
1695                  FAIL_IF(push_inst32(compiler, VMUL_F64 | DD4(dst_r) | DN4(src1) | DM4(src2)));                  FAIL_IF(push_inst32(compiler, VMUL_F32 | (op & SLJIT_SINGLE_OP) | DD4(dst_r) | DN4(src1) | DM4(src2)));
1696                  break;                  break;
1697          case SLJIT_FDIV:          case SLJIT_DIVD:
1698                  FAIL_IF(push_inst32(compiler, VDIV_F64 | DD4(dst_r) | DN4(src1) | DM4(src2)));                  FAIL_IF(push_inst32(compiler, VDIV_F32 | (op & SLJIT_SINGLE_OP) | DD4(dst_r) | DN4(src1) | DM4(src2)));
1699                  break;                  break;
1700          }          }
1701    
1702          if (dst & SLJIT_MEM)          if (dst & SLJIT_MEM)
1703                  return emit_fop_mem(compiler, STORE, TMP_FREG1, dst, dstw);                  return emit_fop_mem(compiler, (op & SLJIT_SINGLE_OP), TMP_FREG1, dst, dstw);
1704          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1705  }  }
1706    
1707    #undef FPU_LOAD
1708    
1709  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1710  /*  Other instructions                                                   */  /*  Other instructions                                                   */
1711  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1712    
1713  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw)
1714  {  {
1715          CHECK_ERROR();          CHECK_ERROR();
1716          check_sljit_emit_fast_enter(compiler, dst, dstw);          check_sljit_emit_fast_enter(compiler, dst, dstw);
# Line 1705  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1730  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1730          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1731  }  }
1732    
1733  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw)
1734  {  {
1735          CHECK_ERROR();          CHECK_ERROR();
1736          check_sljit_emit_fast_return(compiler, src, srcw);          check_sljit_emit_fast_return(compiler, src, srcw);
# Line 1732  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1757  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1757  /*  Conditional instructions                                             */  /*  Conditional instructions                                             */
1758  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1759    
1760  static sljit_uw get_cc(int type)  static sljit_uw get_cc(sljit_si type)
1761  {  {
1762          switch (type) {          switch (type) {
1763          case SLJIT_C_EQUAL:          case SLJIT_C_EQUAL:
# Line 1802  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la Line 1827  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la
1827          return label;          return label;
1828  }  }
1829    
1830  SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type)  SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_si type)
1831  {  {
1832          struct sljit_jump *jump;          struct sljit_jump *jump;
1833          int cc;          sljit_si cc;
1834    
1835          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
1836          check_sljit_emit_jump(compiler, type);          check_sljit_emit_jump(compiler, type);
# Line 1835  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1860  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1860          return jump;          return jump;
1861  }  }
1862    
1863  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
1864  {  {
1865          struct sljit_jump *jump;          struct sljit_jump *jump;
1866    
# Line 1865  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1890  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1890          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1891  }  }
1892    
1893  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_cond_value(struct sljit_compiler *compiler, sljit_si op, sljit_si dst, sljit_sw dstw, sljit_si type)
1894  {  {
1895          int dst_r;          sljit_si dst_r;
1896          sljit_uw cc;          sljit_uw cc;
1897    
1898          CHECK_ERROR();          CHECK_ERROR();
# Line 1913  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1938  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1938          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1939  }  }
1940    
1941  SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w init_value)  SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw init_value)
1942  {  {
1943          struct sljit_const *const_;          struct sljit_const *const_;
1944          int dst_r;          sljit_si dst_r;
1945    
1946          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
1947          check_sljit_emit_const(compiler, dst, dstw, init_value);          check_sljit_emit_const(compiler, dst, dstw, init_value);
# Line 1939  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_ Line 1964  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_
1964          inline_set_jump_addr(addr, new_addr, 1);          inline_set_jump_addr(addr, new_addr, 1);
1965  }  }
1966    
1967  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_w new_constant)  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant)
1968  {  {
1969          sljit_uh* inst = (sljit_uh*)addr;          sljit_uh* inst = (sljit_uh*)addr;
1970          modify_imm32_const(inst, new_constant);          modify_imm32_const(inst, new_constant);

Legend:
Removed from v.1194  
changed lines
  Added in v.1195

  ViewVC Help
Powered by ViewVC 1.1.5