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

Diff of /code/trunk/sljit/sljitNativeX86_common.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 72  static SLJIT_CONST sljit_ub reg_map[SLJI Line 72  static SLJIT_CONST sljit_ub reg_map[SLJI
72    
73  #define CHECK_EXTRA_REGS(p, w, do) \  #define CHECK_EXTRA_REGS(p, w, do) \
74          if (p >= SLJIT_TEMPORARY_EREG1 && p <= SLJIT_TEMPORARY_EREG2) { \          if (p >= SLJIT_TEMPORARY_EREG1 && p <= SLJIT_TEMPORARY_EREG2) { \
75                  w = compiler->temporaries_start + (p - SLJIT_TEMPORARY_EREG1) * sizeof(sljit_w); \                  w = compiler->temporaries_start + (p - SLJIT_TEMPORARY_EREG1) * sizeof(sljit_sw); \
76                  p = SLJIT_MEM1(SLJIT_LOCALS_REG); \                  p = SLJIT_MEM1(SLJIT_LOCALS_REG); \
77                  do; \                  do; \
78          } \          } \
79          else if (p >= SLJIT_SAVED_EREG1 && p <= SLJIT_SAVED_EREG2) { \          else if (p >= SLJIT_SAVED_EREG1 && p <= SLJIT_SAVED_EREG2) { \
80                  w = compiler->saveds_start + (p - SLJIT_SAVED_EREG1) * sizeof(sljit_w); \                  w = compiler->saveds_start + (p - SLJIT_SAVED_EREG1) * sizeof(sljit_sw); \
81                  p = SLJIT_MEM1(SLJIT_LOCALS_REG); \                  p = SLJIT_MEM1(SLJIT_LOCALS_REG); \
82                  do; \                  do; \
83          }          }
# Line 118  static SLJIT_CONST sljit_ub reg_lmap[SLJ Line 118  static SLJIT_CONST sljit_ub reg_lmap[SLJ
118  #define REX_B           0x41  #define REX_B           0x41
119  #define REX             0x40  #define REX             0x40
120    
 typedef unsigned int sljit_uhw;  
 typedef int sljit_hw;  
   
121  #define IS_HALFWORD(x)          ((x) <= 0x7fffffffll && (x) >= -0x80000000ll)  #define IS_HALFWORD(x)          ((x) <= 0x7fffffffll && (x) >= -0x80000000ll)
122  #define NOT_HALFWORD(x)         ((x) > 0x7fffffffll || (x) < -0x80000000ll)  #define NOT_HALFWORD(x)         ((x) > 0x7fffffffll || (x) < -0x80000000ll)
123    
# Line 129  typedef int sljit_hw; Line 126  typedef int sljit_hw;
126  #endif /* SLJIT_CONFIG_X86_32 */  #endif /* SLJIT_CONFIG_X86_32 */
127    
128  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
129  #define TMP_FREG        (SLJIT_FLOAT_REG4 + 1)  #define TMP_FREG        (0)
130  #endif  #endif
131    
132  /* Size flags for emit_x86_instruction: */  /* Size flags for emit_x86_instruction: */
# Line 142  typedef int sljit_hw; Line 139  typedef int sljit_hw;
139  #define EX86_PREF_66            0x0400  #define EX86_PREF_66            0x0400
140    
141  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
142  #define EX86_PREF_F2            0x0800  #define EX86_SSE2               0x0800
143  #define EX86_SSE2               0x1000  #define EX86_PREF_F2            0x1000
144    #define EX86_PREF_F3            0x2000
145  #endif  #endif
146    
147  #define INC_SIZE(s)                     (*buf++ = (s), compiler->size += (s))  #define INC_SIZE(s)                     (*buf++ = (s), compiler->size += (s))
# Line 156  typedef int sljit_hw; Line 154  typedef int sljit_hw;
154  /* r32, r/m32 */  /* r32, r/m32 */
155  #define MOV_RM(mod, reg, rm)            (*buf++ = (0x8b), *buf++ = (mod) << 6 | (reg) << 3 | (rm))  #define MOV_RM(mod, reg, rm)            (*buf++ = (0x8b), *buf++ = (mod) << 6 | (reg) << 3 | (rm))
156    
157  static sljit_ub get_jump_code(int type)  static sljit_ub get_jump_code(sljit_si type)
158  {  {
159          switch (type) {          switch (type) {
160          case SLJIT_C_EQUAL:          case SLJIT_C_EQUAL:
# Line 212  static sljit_ub get_jump_code(int type) Line 210  static sljit_ub get_jump_code(int type)
210          return 0;          return 0;
211  }  }
212    
213  static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, int type);  static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_si type);
214    
215  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
216  static sljit_ub* generate_fixed_jump(sljit_ub *code_ptr, sljit_w addr, int type);  static sljit_ub* generate_fixed_jump(sljit_ub *code_ptr, sljit_sw addr, sljit_si type);
217  #endif  #endif
218    
219  static sljit_ub* generate_near_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_ub *code, int type)  static sljit_ub* generate_near_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_ub *code, sljit_si type)
220  {  {
221          int short_jump;          sljit_si short_jump;
222          sljit_uw label_addr;          sljit_uw label_addr;
223    
224          if (jump->flags & JUMP_LABEL)          if (jump->flags & JUMP_LABEL)
225                  label_addr = (sljit_uw)(code + jump->u.label->size);                  label_addr = (sljit_uw)(code + jump->u.label->size);
226          else          else
227                  label_addr = jump->u.target;                  label_addr = jump->u.target;
228          short_jump = (sljit_w)(label_addr - (jump->addr + 2)) >= -128 && (sljit_w)(label_addr - (jump->addr + 2)) <= 127;          short_jump = (sljit_sw)(label_addr - (jump->addr + 2)) >= -128 && (sljit_sw)(label_addr - (jump->addr + 2)) <= 127;
229    
230  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
231          if ((sljit_w)(label_addr - (jump->addr + 1)) > 0x7fffffffll || (sljit_w)(label_addr - (jump->addr + 1)) < -0x80000000ll)          if ((sljit_sw)(label_addr - (jump->addr + 1)) > 0x7fffffffll || (sljit_sw)(label_addr - (jump->addr + 1)) < -0x80000000ll)
232                  return generate_far_jump_code(jump, code_ptr, type);                  return generate_far_jump_code(jump, code_ptr, type);
233  #endif  #endif
234    
# Line 258  static sljit_ub* generate_near_jump_code Line 256  static sljit_ub* generate_near_jump_code
256    
257          if (short_jump) {          if (short_jump) {
258                  jump->flags |= PATCH_MB;                  jump->flags |= PATCH_MB;
259                  code_ptr += sizeof(sljit_b);                  code_ptr += sizeof(sljit_sb);
260          } else {          } else {
261                  jump->flags |= PATCH_MW;                  jump->flags |= PATCH_MW;
262  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
263                  code_ptr += sizeof(sljit_w);                  code_ptr += sizeof(sljit_sw);
264  #else  #else
265                  code_ptr += sizeof(sljit_hw);                  code_ptr += sizeof(sljit_si);
266  #endif  #endif
267          }          }
268    
# Line 323  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 321  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
321                                          label = label->next;                                          label = label->next;
322                                  }                                  }
323                                  else if (*buf_ptr == 1) {                                  else if (*buf_ptr == 1) {
324                                          const_->addr = ((sljit_uw)code_ptr) - sizeof(sljit_w);                                          const_->addr = ((sljit_uw)code_ptr) - sizeof(sljit_sw);
325                                          const_ = const_->next;                                          const_ = const_->next;
326                                  }                                  }
327                                  else {                                  else {
328  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
329                                          *code_ptr++ = (*buf_ptr == 2) ? 0xe8 /* call */ : 0xe9 /* jmp */;                                          *code_ptr++ = (*buf_ptr == 2) ? 0xe8 /* call */ : 0xe9 /* jmp */;
330                                          buf_ptr++;                                          buf_ptr++;
331                                          *(sljit_w*)code_ptr = *(sljit_w*)buf_ptr - ((sljit_w)code_ptr + sizeof(sljit_w));                                          *(sljit_sw*)code_ptr = *(sljit_sw*)buf_ptr - ((sljit_sw)code_ptr + sizeof(sljit_sw));
332                                          code_ptr += sizeof(sljit_w);                                          code_ptr += sizeof(sljit_sw);
333                                          buf_ptr += sizeof(sljit_w) - 1;                                          buf_ptr += sizeof(sljit_sw) - 1;
334  #else  #else
335                                          code_ptr = generate_fixed_jump(code_ptr, *(sljit_w*)(buf_ptr + 1), *buf_ptr);                                          code_ptr = generate_fixed_jump(code_ptr, *(sljit_sw*)(buf_ptr + 1), *buf_ptr);
336                                          buf_ptr += sizeof(sljit_w);                                          buf_ptr += sizeof(sljit_sw);
337  #endif  #endif
338                                  }                                  }
339                                  buf_ptr++;                                  buf_ptr++;
# Line 352  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 350  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
350          jump = compiler->jumps;          jump = compiler->jumps;
351          while (jump) {          while (jump) {
352                  if (jump->flags & PATCH_MB) {                  if (jump->flags & PATCH_MB) {
353                          SLJIT_ASSERT((sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_b))) >= -128 && (sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_b))) <= 127);                          SLJIT_ASSERT((sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_sb))) >= -128 && (sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_sb))) <= 127);
354                          *(sljit_ub*)jump->addr = (sljit_ub)(jump->u.label->addr - (jump->addr + sizeof(sljit_b)));                          *(sljit_ub*)jump->addr = (sljit_ub)(jump->u.label->addr - (jump->addr + sizeof(sljit_sb)));
355                  } else if (jump->flags & PATCH_MW) {                  } else if (jump->flags & PATCH_MW) {
356                          if (jump->flags & JUMP_LABEL) {                          if (jump->flags & JUMP_LABEL) {
357  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
358                                  *(sljit_w*)jump->addr = (sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_w)));                                  *(sljit_sw*)jump->addr = (sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_sw)));
359  #else  #else
360                                  SLJIT_ASSERT((sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_hw))) >= -0x80000000ll && (sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_hw))) <= 0x7fffffffll);                                  SLJIT_ASSERT((sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_si))) >= -0x80000000ll && (sljit_sw)(jump->u.label->addr - (jump->addr + sizeof(sljit_si))) <= 0x7fffffffll);
361                                  *(sljit_hw*)jump->addr = (sljit_hw)(jump->u.label->addr - (jump->addr + sizeof(sljit_hw)));                                  *(sljit_si*)jump->addr = (sljit_si)(jump->u.label->addr - (jump->addr + sizeof(sljit_si)));
362  #endif  #endif
363                          }                          }
364                          else {                          else {
365  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
366                                  *(sljit_w*)jump->addr = (sljit_w)(jump->u.target - (jump->addr + sizeof(sljit_w)));                                  *(sljit_sw*)jump->addr = (sljit_sw)(jump->u.target - (jump->addr + sizeof(sljit_sw)));
367  #else  #else
368                                  SLJIT_ASSERT((sljit_w)(jump->u.target - (jump->addr + sizeof(sljit_hw))) >= -0x80000000ll && (sljit_w)(jump->u.target - (jump->addr + sizeof(sljit_hw))) <= 0x7fffffffll);                                  SLJIT_ASSERT((sljit_sw)(jump->u.target - (jump->addr + sizeof(sljit_si))) >= -0x80000000ll && (sljit_sw)(jump->u.target - (jump->addr + sizeof(sljit_si))) <= 0x7fffffffll);
369                                  *(sljit_hw*)jump->addr = (sljit_hw)(jump->u.target - (jump->addr + sizeof(sljit_hw)));                                  *(sljit_si*)jump->addr = (sljit_si)(jump->u.target - (jump->addr + sizeof(sljit_si)));
370  #endif  #endif
371                          }                          }
372                  }                  }
373  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
374                  else if (jump->flags & PATCH_MD)                  else if (jump->flags & PATCH_MD)
375                          *(sljit_w*)jump->addr = jump->u.label->addr;                          *(sljit_sw*)jump->addr = jump->u.label->addr;
376  #endif  #endif
377    
378                  jump = jump->next;                  jump = jump->next;
# Line 391  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 389  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
389  /*  Operators                                                            */  /*  Operators                                                            */
390  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
391    
392  static int emit_cum_binary(struct sljit_compiler *compiler,  static sljit_si emit_cum_binary(struct sljit_compiler *compiler,
393          sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,          sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,
394          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
395          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
396          int src2, sljit_w src2w);          sljit_si src2, sljit_sw src2w);
397    
398  static int emit_non_cum_binary(struct sljit_compiler *compiler,  static sljit_si emit_non_cum_binary(struct sljit_compiler *compiler,
399          sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,          sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,
400          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
401          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
402          int src2, sljit_w src2w);          sljit_si src2, sljit_sw src2w);
403    
404  static int emit_mov(struct sljit_compiler *compiler,  static sljit_si emit_mov(struct sljit_compiler *compiler,
405          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
406          int src, sljit_w srcw);          sljit_si src, sljit_sw srcw);
407    
408  static SLJIT_INLINE int emit_save_flags(struct sljit_compiler *compiler)  static SLJIT_INLINE sljit_si emit_save_flags(struct sljit_compiler *compiler)
409  {  {
410          sljit_ub *buf;          sljit_ub *buf;
411    
# Line 421  static SLJIT_INLINE int emit_save_flags( Line 419  static SLJIT_INLINE int emit_save_flags(
419          INC_SIZE(6);          INC_SIZE(6);
420          *buf++ = REX_W;          *buf++ = REX_W;
421  #endif  #endif
422          *buf++ = 0x8d; /* lea esp/rsp, [esp/rsp + sizeof(sljit_w)] */          *buf++ = 0x8d; /* lea esp/rsp, [esp/rsp + sizeof(sljit_sw)] */
423          *buf++ = 0x64;          *buf++ = 0x64;
424          *buf++ = 0x24;          *buf++ = 0x24;
425          *buf++ = (sljit_ub)sizeof(sljit_w);          *buf++ = (sljit_ub)sizeof(sljit_sw);
426          *buf++ = 0x9c; /* pushfd / pushfq */          *buf++ = 0x9c; /* pushfd / pushfq */
427          compiler->flags_saved = 1;          compiler->flags_saved = 1;
428          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
429  }  }
430    
431  static SLJIT_INLINE int emit_restore_flags(struct sljit_compiler *compiler, int keep_flags)  static SLJIT_INLINE sljit_si emit_restore_flags(struct sljit_compiler *compiler, sljit_si keep_flags)
432  {  {
433          sljit_ub *buf;          sljit_ub *buf;
434    
# Line 446  static SLJIT_INLINE int emit_restore_fla Line 444  static SLJIT_INLINE int emit_restore_fla
444          *buf++ = 0x9d; /* popfq */          *buf++ = 0x9d; /* popfq */
445          *buf++ = REX_W;          *buf++ = REX_W;
446  #endif  #endif
447          *buf++ = 0x8d; /* lea esp/rsp, [esp/rsp - sizeof(sljit_w)] */          *buf++ = 0x8d; /* lea esp/rsp, [esp/rsp - sizeof(sljit_sw)] */
448          *buf++ = 0x64;          *buf++ = 0x64;
449          *buf++ = 0x24;          *buf++ = 0x24;
450          *buf++ = (sljit_ub)-(int)sizeof(sljit_w);          *buf++ = (sljit_ub)-(sljit_sb)sizeof(sljit_sw);
451          compiler->flags_saved = keep_flags;          compiler->flags_saved = keep_flags;
452          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
453  }  }
# Line 457  static SLJIT_INLINE int emit_restore_fla Line 455  static SLJIT_INLINE int emit_restore_fla
455  #ifdef _WIN32  #ifdef _WIN32
456  #include <malloc.h>  #include <malloc.h>
457    
458  static void SLJIT_CALL sljit_grow_stack(sljit_w local_size)  static void SLJIT_CALL sljit_grow_stack(sljit_sw local_size)
459  {  {
460          /* Workaround for calling the internal _chkstk() function on Windows.          /* Workaround for calling the internal _chkstk() function on Windows.
461          This function touches all 4k pages belongs to the requested stack space,          This function touches all 4k pages belongs to the requested stack space,
# Line 476  static void SLJIT_CALL sljit_grow_stack( Line 474  static void SLJIT_CALL sljit_grow_stack(
474  #include "sljitNativeX86_64.c"  #include "sljitNativeX86_64.c"
475  #endif  #endif
476    
477  static int emit_mov(struct sljit_compiler *compiler,  static sljit_si emit_mov(struct sljit_compiler *compiler,
478          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
479          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
480  {  {
481          sljit_ub* code;          sljit_ub* code;
482    
# Line 544  static int emit_mov(struct sljit_compile Line 542  static int emit_mov(struct sljit_compile
542  #define EMIT_MOV(compiler, dst, dstw, src, srcw) \  #define EMIT_MOV(compiler, dst, dstw, src, srcw) \
543          FAIL_IF(emit_mov(compiler, dst, dstw, src, srcw));          FAIL_IF(emit_mov(compiler, dst, dstw, src, srcw));
544    
545  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)
546  {  {
547          sljit_ub *buf;          sljit_ub *buf;
548  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
549          int size;          sljit_si size;
550  #endif  #endif
551    
552          CHECK_ERROR();          CHECK_ERROR();
# Line 688  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 686  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
686                  *code = (prefix); \                  *code = (prefix); \
687          } while (0)          } while (0)
688    
689  static int emit_mov_byte(struct sljit_compiler *compiler, int sign,  static sljit_si emit_mov_byte(struct sljit_compiler *compiler, sljit_si sign,
690          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
691          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
692  {  {
693          sljit_ub* code;          sljit_ub* code;
694          int dst_r;          sljit_si dst_r;
695  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
696          int work_r;          sljit_si work_r;
697  #endif  #endif
698    
699  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
# Line 831  static int emit_mov_byte(struct sljit_co Line 829  static int emit_mov_byte(struct sljit_co
829          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
830  }  }
831    
832  static int emit_mov_half(struct sljit_compiler *compiler, int sign,  static sljit_si emit_mov_half(struct sljit_compiler *compiler, sljit_si sign,
833          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
834          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
835  {  {
836          sljit_ub* code;          sljit_ub* code;
837          int dst_r;          sljit_si dst_r;
838    
839  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
840          compiler->mode32 = 0;          compiler->mode32 = 0;
# Line 879  static int emit_mov_half(struct sljit_co Line 877  static int emit_mov_half(struct sljit_co
877          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
878  }  }
879    
880  static int emit_unary(struct sljit_compiler *compiler, int un_index,  static sljit_si emit_unary(struct sljit_compiler *compiler, sljit_si un_index,
881          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
882          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
883  {  {
884          sljit_ub* code;          sljit_ub* code;
885    
# Line 918  static int emit_unary(struct sljit_compi Line 916  static int emit_unary(struct sljit_compi
916          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
917  }  }
918    
919  static int emit_not_with_flags(struct sljit_compiler *compiler,  static sljit_si emit_not_with_flags(struct sljit_compiler *compiler,
920          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
921          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
922  {  {
923          sljit_ub* code;          sljit_ub* code;
924    
# Line 958  static int emit_not_with_flags(struct sl Line 956  static int emit_not_with_flags(struct sl
956          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
957  }  }
958    
959  static int emit_clz(struct sljit_compiler *compiler, int op,  static sljit_si emit_clz(struct sljit_compiler *compiler, sljit_si op_flags,
960          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
961          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
962  {  {
963          sljit_ub* code;          sljit_ub* code;
964          int dst_r;          sljit_si dst_r;
965    
966          SLJIT_UNUSED_ARG(op);          SLJIT_UNUSED_ARG(op_flags);
967          if (SLJIT_UNLIKELY(dst == SLJIT_UNUSED)) {          if (SLJIT_UNLIKELY(dst == SLJIT_UNUSED)) {
968                  /* Just set the zero flag. */                  /* Just set the zero flag. */
969                  EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);                  EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
# Line 976  static int emit_clz(struct sljit_compile Line 974  static int emit_clz(struct sljit_compile
974  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
975                  code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, 31, TMP_REGISTER, 0);                  code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, 31, TMP_REGISTER, 0);
976  #else  #else
977                  code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, !(op & SLJIT_INT_OP) ? 63 : 31, TMP_REGISTER, 0);                  code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, !(op_flags & SLJIT_INT_OP) ? 63 : 31, TMP_REGISTER, 0);
978  #endif  #endif
979                  FAIL_IF(!code);                  FAIL_IF(!code);
980                  *code |= 0x5 << 3;                  *code |= 0x5 << 3;
# Line 1011  static int emit_clz(struct sljit_compile Line 1009  static int emit_clz(struct sljit_compile
1009  #else  #else
1010          dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) ? dst : TMP_REG2;          dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) ? dst : TMP_REG2;
1011          compiler->mode32 = 0;          compiler->mode32 = 0;
1012          EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, !(op & SLJIT_INT_OP) ? 64 + 63 : 32 + 31);          EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, !(op_flags & SLJIT_INT_OP) ? 64 + 63 : 32 + 31);
1013          compiler->mode32 = op & SLJIT_INT_OP;          compiler->mode32 = op_flags & SLJIT_INT_OP;
1014  #endif  #endif
1015    
1016          code = emit_x86_instruction(compiler, 2, dst_r, 0, TMP_REGISTER, 0);          code = emit_x86_instruction(compiler, 2, dst_r, 0, TMP_REGISTER, 0);
# Line 1023  static int emit_clz(struct sljit_compile Line 1021  static int emit_clz(struct sljit_compile
1021  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1022          code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, 31, dst_r, 0);          code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, 31, dst_r, 0);
1023  #else  #else
1024          code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, !(op & SLJIT_INT_OP) ? 63 : 31, dst_r, 0);          code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, !(op_flags & SLJIT_INT_OP) ? 63 : 31, dst_r, 0);
1025  #endif  #endif
1026          FAIL_IF(!code);          FAIL_IF(!code);
1027          *(code + 1) |= 0x6 << 3;          *(code + 1) |= 0x6 << 3;
# Line 1041  static int emit_clz(struct sljit_compile Line 1039  static int emit_clz(struct sljit_compile
1039          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1040  }  }
1041    
1042  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,
1043          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1044          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
1045  {  {
1046          sljit_ub* code;          sljit_ub* code;
1047          int update = 0;          sljit_si update = 0;
1048            sljit_si op_flags = GET_ALL_FLAGS(op);
1049  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1050          int dst_is_ereg = 0;          sljit_si dst_is_ereg = 0;
1051          int src_is_ereg = 0;          sljit_si src_is_ereg = 0;
1052  #else  #else
1053          #define src_is_ereg 0          #define src_is_ereg 0
1054  #endif  #endif
# Line 1062  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1061  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1061          CHECK_EXTRA_REGS(dst, dstw, dst_is_ereg = 1);          CHECK_EXTRA_REGS(dst, dstw, dst_is_ereg = 1);
1062          CHECK_EXTRA_REGS(src, srcw, src_is_ereg = 1);          CHECK_EXTRA_REGS(src, srcw, src_is_ereg = 1);
1063  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1064          compiler->mode32 = op & SLJIT_INT_OP;          compiler->mode32 = op_flags & SLJIT_INT_OP;
1065  #endif  #endif
1066    
1067          if (GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_MOVU_P) {          op = GET_OPCODE(op);
1068                  op = GET_OPCODE(op);          if (op >= SLJIT_MOV && op <= SLJIT_MOVU_P) {
1069  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1070                  compiler->mode32 = 0;                  compiler->mode32 = 0;
1071  #endif  #endif
1072    
1073                    if (op_flags & SLJIT_INT_OP) {
1074                            if (src <= SLJIT_NO_REGISTERS && src == dst) {
1075                                    if (!TYPE_CAST_NEEDED(op))
1076                                            return SLJIT_SUCCESS;
1077                            }
1078    #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1079                            if (op == SLJIT_MOV_SI && (src & SLJIT_MEM))
1080                                    op = SLJIT_MOV_UI;
1081                            if (op == SLJIT_MOVU_SI && (src & SLJIT_MEM))
1082                                    op = SLJIT_MOVU_UI;
1083                            if (op == SLJIT_MOV_UI && (src & SLJIT_IMM))
1084                                    op = SLJIT_MOV_SI;
1085                            if (op == SLJIT_MOVU_UI && (src & SLJIT_IMM))
1086                                    op = SLJIT_MOVU_SI;
1087    #endif
1088                    }
1089    
1090                  SLJIT_COMPILE_ASSERT(SLJIT_MOV + 8 == SLJIT_MOVU, movu_offset);                  SLJIT_COMPILE_ASSERT(SLJIT_MOV + 8 == SLJIT_MOVU, movu_offset);
1091                  if (op >= SLJIT_MOVU) {                  if (op >= SLJIT_MOVU) {
1092                          update = 1;                          update = 1;
# Line 1083  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1099  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1099                                  srcw = (sljit_ub)srcw;                                  srcw = (sljit_ub)srcw;
1100                                  break;                                  break;
1101                          case SLJIT_MOV_SB:                          case SLJIT_MOV_SB:
1102                                  srcw = (sljit_b)srcw;                                  srcw = (sljit_sb)srcw;
1103                                  break;                                  break;
1104                          case SLJIT_MOV_UH:                          case SLJIT_MOV_UH:
1105                                  srcw = (sljit_uh)srcw;                                  srcw = (sljit_uh)srcw;
1106                                  break;                                  break;
1107                          case SLJIT_MOV_SH:                          case SLJIT_MOV_SH:
1108                                  srcw = (sljit_h)srcw;                                  srcw = (sljit_sh)srcw;
1109                                  break;                                  break;
1110  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1111                          case SLJIT_MOV_UI:                          case SLJIT_MOV_UI:
1112                                  srcw = (sljit_ui)srcw;                                  srcw = (sljit_ui)srcw;
1113                                  break;                                  break;
1114                          case SLJIT_MOV_SI:                          case SLJIT_MOV_SI:
1115                                  srcw = (sljit_i)srcw;                                  srcw = (sljit_si)srcw;
1116                                  break;                                  break;
1117  #endif  #endif
1118                          }                          }
# Line 1165  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1181  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1181                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1182          }          }
1183    
1184          if (SLJIT_UNLIKELY(GET_FLAGS(op)))          if (SLJIT_UNLIKELY(GET_FLAGS(op_flags)))
1185                  compiler->flags_saved = 0;                  compiler->flags_saved = 0;
1186    
1187          switch (GET_OPCODE(op)) {          switch (op) {
1188          case SLJIT_NOT:          case SLJIT_NOT:
1189                  if (SLJIT_UNLIKELY(op & SLJIT_SET_E))                  if (SLJIT_UNLIKELY(op_flags & SLJIT_SET_E))
1190                          return emit_not_with_flags(compiler, dst, dstw, src, srcw);                          return emit_not_with_flags(compiler, dst, dstw, src, srcw);
1191                  return emit_unary(compiler, 0x2, dst, dstw, src, srcw);                  return emit_unary(compiler, 0x2, dst, dstw, src, srcw);
1192    
1193          case SLJIT_NEG:          case SLJIT_NEG:
1194                  if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)                  if (SLJIT_UNLIKELY(op_flags & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)
1195                          FAIL_IF(emit_save_flags(compiler));                          FAIL_IF(emit_save_flags(compiler));
1196                  return emit_unary(compiler, 0x3, dst, dstw, src, srcw);                  return emit_unary(compiler, 0x3, dst, dstw, src, srcw);
1197    
1198          case SLJIT_CLZ:          case SLJIT_CLZ:
1199                  if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)                  if (SLJIT_UNLIKELY(op_flags & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)
1200                          FAIL_IF(emit_save_flags(compiler));                          FAIL_IF(emit_save_flags(compiler));
1201                  return emit_clz(compiler, op, dst, dstw, src, srcw);                  return emit_clz(compiler, op_flags, dst, dstw, src, srcw);
1202          }          }
1203    
1204          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
# Line 1222  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1238  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1238    
1239  #endif  #endif
1240    
1241  static int emit_cum_binary(struct sljit_compiler *compiler,  static sljit_si emit_cum_binary(struct sljit_compiler *compiler,
1242          sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,          sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,
1243          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1244          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1245          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1246  {  {
1247          sljit_ub* code;          sljit_ub* code;
1248    
# Line 1338  static int emit_cum_binary(struct sljit_ Line 1354  static int emit_cum_binary(struct sljit_
1354          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1355  }  }
1356    
1357  static int emit_non_cum_binary(struct sljit_compiler *compiler,  static sljit_si emit_non_cum_binary(struct sljit_compiler *compiler,
1358          sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,          sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,
1359          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1360          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1361          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1362  {  {
1363          sljit_ub* code;          sljit_ub* code;
1364    
# Line 1420  static int emit_non_cum_binary(struct sl Line 1436  static int emit_non_cum_binary(struct sl
1436          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1437  }  }
1438    
1439  static int emit_mul(struct sljit_compiler *compiler,  static sljit_si emit_mul(struct sljit_compiler *compiler,
1440          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1441          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1442          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1443  {  {
1444          sljit_ub* code;          sljit_ub* code;
1445          int dst_r;          sljit_si dst_r;
1446    
1447          dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REGISTER;          dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REGISTER;
1448    
# Line 1457  static int emit_mul(struct sljit_compile Line 1473  static int emit_mul(struct sljit_compile
1473                          code = (sljit_ub*)ensure_buf(compiler, 1 + 1);                          code = (sljit_ub*)ensure_buf(compiler, 1 + 1);
1474                          FAIL_IF(!code);                          FAIL_IF(!code);
1475                          INC_CSIZE(1);                          INC_CSIZE(1);
1476                          *code = (sljit_b)src1w;                          *code = (sljit_sb)src1w;
1477                  }                  }
1478  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1479                  else {                  else {
# Line 1467  static int emit_mul(struct sljit_compile Line 1483  static int emit_mul(struct sljit_compile
1483                          code = (sljit_ub*)ensure_buf(compiler, 1 + 4);                          code = (sljit_ub*)ensure_buf(compiler, 1 + 4);
1484                          FAIL_IF(!code);                          FAIL_IF(!code);
1485                          INC_CSIZE(4);                          INC_CSIZE(4);
1486                          *(sljit_w*)code = src1w;                          *(sljit_sw*)code = src1w;
1487                  }                  }
1488  #else  #else
1489                  else if (IS_HALFWORD(src1w)) {                  else if (IS_HALFWORD(src1w)) {
# Line 1477  static int emit_mul(struct sljit_compile Line 1493  static int emit_mul(struct sljit_compile
1493                          code = (sljit_ub*)ensure_buf(compiler, 1 + 4);                          code = (sljit_ub*)ensure_buf(compiler, 1 + 4);
1494                          FAIL_IF(!code);                          FAIL_IF(!code);
1495                          INC_CSIZE(4);                          INC_CSIZE(4);
1496                          *(sljit_hw*)code = (sljit_hw)src1w;                          *(sljit_si*)code = (sljit_si)src1w;
1497                  }                  }
1498                  else {                  else {
1499                          EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_IMM, src1w);                          EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_IMM, src1w);
# Line 1500  static int emit_mul(struct sljit_compile Line 1516  static int emit_mul(struct sljit_compile
1516                          code = (sljit_ub*)ensure_buf(compiler, 1 + 1);                          code = (sljit_ub*)ensure_buf(compiler, 1 + 1);
1517                          FAIL_IF(!code);                          FAIL_IF(!code);
1518                          INC_CSIZE(1);                          INC_CSIZE(1);
1519                          *code = (sljit_b)src2w;                          *code = (sljit_sb)src2w;
1520                  }                  }
1521  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1522                  else {                  else {
# Line 1510  static int emit_mul(struct sljit_compile Line 1526  static int emit_mul(struct sljit_compile
1526                          code = (sljit_ub*)ensure_buf(compiler, 1 + 4);                          code = (sljit_ub*)ensure_buf(compiler, 1 + 4);
1527                          FAIL_IF(!code);                          FAIL_IF(!code);
1528                          INC_CSIZE(4);                          INC_CSIZE(4);
1529                          *(sljit_w*)code = src2w;                          *(sljit_sw*)code = src2w;
1530                  }                  }
1531  #else  #else
1532                  else if (IS_HALFWORD(src2w)) {                  else if (IS_HALFWORD(src2w)) {
# Line 1520  static int emit_mul(struct sljit_compile Line 1536  static int emit_mul(struct sljit_compile
1536                          code = (sljit_ub*)ensure_buf(compiler, 1 + 4);                          code = (sljit_ub*)ensure_buf(compiler, 1 + 4);
1537                          FAIL_IF(!code);                          FAIL_IF(!code);
1538                          INC_CSIZE(4);                          INC_CSIZE(4);
1539                          *(sljit_hw*)code = (sljit_hw)src2w;                          *(sljit_si*)code = (sljit_si)src2w;
1540                  }                  }
1541                  else {                  else {
1542                          EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_IMM, src1w);                          EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_IMM, src1w);
# Line 1550  static int emit_mul(struct sljit_compile Line 1566  static int emit_mul(struct sljit_compile
1566          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1567  }  }
1568    
1569  static int emit_lea_binary(struct sljit_compiler *compiler,  static sljit_si emit_lea_binary(struct sljit_compiler *compiler,
1570          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1571          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1572          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1573  {  {
1574          sljit_ub* code;          sljit_ub* code;
1575          int dst_r, done = 0;          sljit_si dst_r, done = 0;
1576    
1577          /* These cases better be left to handled by normal way. */          /* These cases better be left to handled by normal way. */
1578          if (dst == src1 && dstw == src1w)          if (dst == src1 && dstw == src1w)
# Line 1575  static int emit_lea_binary(struct sljit_ Line 1591  static int emit_lea_binary(struct sljit_
1591                  }                  }
1592  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1593                  if ((src2 & SLJIT_IMM) && (compiler->mode32 || IS_HALFWORD(src2w))) {                  if ((src2 & SLJIT_IMM) && (compiler->mode32 || IS_HALFWORD(src2w))) {
1594                          code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src1), (int)src2w);                          code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src1), (sljit_si)src2w);
1595  #else  #else
1596                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1597                          code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src1), src2w);                          code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src1), src2w);
# Line 1588  static int emit_lea_binary(struct sljit_ Line 1604  static int emit_lea_binary(struct sljit_
1604          else if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= SLJIT_NO_REGISTERS) {          else if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= SLJIT_NO_REGISTERS) {
1605  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1606                  if ((src1 & SLJIT_IMM) && (compiler->mode32 || IS_HALFWORD(src1w))) {                  if ((src1 & SLJIT_IMM) && (compiler->mode32 || IS_HALFWORD(src1w))) {
1607                          code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src2), (int)src1w);                          code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src2), (sljit_si)src1w);
1608  #else  #else
1609                  if (src1 & SLJIT_IMM) {                  if (src1 & SLJIT_IMM) {
1610                          code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src2), src1w);                          code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src2), src1w);
# Line 1607  static int emit_lea_binary(struct sljit_ Line 1623  static int emit_lea_binary(struct sljit_
1623          return SLJIT_ERR_UNSUPPORTED;          return SLJIT_ERR_UNSUPPORTED;
1624  }  }
1625    
1626  static int emit_cmp_binary(struct sljit_compiler *compiler,  static sljit_si emit_cmp_binary(struct sljit_compiler *compiler,
1627          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1628          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1629  {  {
1630          sljit_ub* code;          sljit_ub* code;
1631    
# Line 1658  static int emit_cmp_binary(struct sljit_ Line 1674  static int emit_cmp_binary(struct sljit_
1674          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1675  }  }
1676    
1677  static int emit_test_binary(struct sljit_compiler *compiler,  static sljit_si emit_test_binary(struct sljit_compiler *compiler,
1678          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1679          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1680  {  {
1681          sljit_ub* code;          sljit_ub* code;
1682    
# Line 1766  static int emit_test_binary(struct sljit Line 1782  static int emit_test_binary(struct sljit
1782          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1783  }  }
1784    
1785  static int emit_shift(struct sljit_compiler *compiler,  static sljit_si emit_shift(struct sljit_compiler *compiler,
1786          sljit_ub mode,          sljit_ub mode,
1787          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1788          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1789          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1790  {  {
1791          sljit_ub* code;          sljit_ub* code;
1792    
# Line 1838  static int emit_shift(struct sljit_compi Line 1854  static int emit_shift(struct sljit_compi
1854                  EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_PREF_SHIFT_REG, 0);                  EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_PREF_SHIFT_REG, 0);
1855  #else  #else
1856                  /* [esp+0] contains the flags. */                  /* [esp+0] contains the flags. */
1857                  EMIT_MOV(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), sizeof(sljit_w), SLJIT_PREF_SHIFT_REG, 0);                  EMIT_MOV(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), sizeof(sljit_sw), SLJIT_PREF_SHIFT_REG, 0);
1858  #endif  #endif
1859                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);
1860                  code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);                  code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);
# Line 1847  static int emit_shift(struct sljit_compi Line 1863  static int emit_shift(struct sljit_compi
1863  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1864                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REG2, 0);                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REG2, 0);
1865  #else  #else
1866                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), sizeof(sljit_w));                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), sizeof(sljit_sw));
1867  #endif  #endif
1868                  EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);                  EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
1869          }          }
# Line 1855  static int emit_shift(struct sljit_compi Line 1871  static int emit_shift(struct sljit_compi
1871          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1872  }  }
1873    
1874  static int emit_shift_with_flags(struct sljit_compiler *compiler,  static sljit_si emit_shift_with_flags(struct sljit_compiler *compiler,
1875          sljit_ub mode, int set_flags,          sljit_ub mode, sljit_si set_flags,
1876          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1877          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1878          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1879  {  {
1880          /* The CPU does not set flags if the shift count is 0. */          /* The CPU does not set flags if the shift count is 0. */
1881          if (src2 & SLJIT_IMM) {          if (src2 & SLJIT_IMM) {
# Line 1890  static int emit_shift_with_flags(struct Line 1906  static int emit_shift_with_flags(struct
1906          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1907  }  }
1908    
1909  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,
1910          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1911          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1912          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1913  {  {
1914          CHECK_ERROR();          CHECK_ERROR();
1915          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 1985  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 2001  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
2001          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
2002  }  }
2003    
2004  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_register_index(sljit_si reg)
2005  {  {
2006          check_sljit_get_register_index(reg);          check_sljit_get_register_index(reg);
2007  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
# Line 1996  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_r Line 2012  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_r
2012          return reg_map[reg];          return reg_map[reg];
2013  }  }
2014    
2015  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,
2016          void *instruction, int size)          void *instruction, sljit_si size)
2017  {  {
2018          sljit_ub *buf;          sljit_ub *buf;
2019    
# Line 2019  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 2035  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
2035  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
2036    
2037  /* Alignment + 2 * 16 bytes. */  /* Alignment + 2 * 16 bytes. */
2038  static sljit_i sse2_data[3 + 4 + 4];  static sljit_si sse2_data[3 + (4 + 4) * 2];
2039  static sljit_i *sse2_buffer;  static sljit_si *sse2_buffer;
2040    
2041  static void init_compiler(void)  static void init_compiler(void)
2042  {  {
2043          sse2_buffer = (sljit_i*)(((sljit_uw)sse2_data + 15) & ~0xf);          sse2_buffer = (sljit_si*)(((sljit_uw)sse2_data + 15) & ~0xf);
2044          sse2_buffer[0] = 0;          /* Single precision constants. */
2045          sse2_buffer[1] = 0x80000000;          sse2_buffer[0] = 0x80000000;
2046          sse2_buffer[4] = 0xffffffff;          sse2_buffer[4] = 0x7fffffff;
2047          sse2_buffer[5] = 0x7fffffff;          /* Double precision constants. */
2048            sse2_buffer[8] = 0;
2049            sse2_buffer[9] = 0x80000000;
2050            sse2_buffer[12] = 0xffffffff;
2051            sse2_buffer[13] = 0x7fffffff;
2052  }  }
2053    
2054  #endif  #endif
2055    
2056  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_is_fpu_available(void)
2057  {  {
2058  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
2059  #if (defined SLJIT_DETECT_SSE2 && SLJIT_DETECT_SSE2)  #if (defined SLJIT_DETECT_SSE2 && SLJIT_DETECT_SSE2)
2060          static int sse2_available = -1;          static sljit_si sse2_available = -1;
2061          int features;          sljit_si features;
2062    
2063          if (sse2_available != -1)          if (sse2_available != -1)
2064                  return sse2_available;                  return sse2_available;
# Line 2079  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fp Line 2099  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fp
2099    
2100  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
2101    
2102  static int emit_sse2(struct sljit_compiler *compiler, sljit_ub opcode,  static sljit_si emit_sse2(struct sljit_compiler *compiler, sljit_ub opcode,
2103          int xmm1, int xmm2, sljit_w xmm2w)          sljit_si single, sljit_si xmm1, sljit_si xmm2, sljit_sw xmm2w)
2104  {  {
2105          sljit_ub *buf;          sljit_ub *buf;
2106    
2107          buf = emit_x86_instruction(compiler, 2 | EX86_PREF_F2 | EX86_SSE2, xmm1, 0, xmm2, xmm2w);          buf = emit_x86_instruction(compiler, 2 | (single ? EX86_PREF_F3 : EX86_PREF_F2) | EX86_SSE2, xmm1, 0, xmm2, xmm2w);
2108          FAIL_IF(!buf);          FAIL_IF(!buf);
2109          *buf++ = 0x0f;          *buf++ = 0x0f;
2110          *buf = opcode;          *buf = opcode;
2111          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
2112  }  }
2113    
2114  static int emit_sse2_logic(struct sljit_compiler *compiler, sljit_ub opcode,  static sljit_si emit_sse2_logic(struct sljit_compiler *compiler, sljit_ub opcode,
2115          int xmm1, int xmm2, sljit_w xmm2w)          sljit_si pref66, sljit_si xmm1, sljit_si xmm2, sljit_sw xmm2w)
2116  {  {
2117          sljit_ub *buf;          sljit_ub *buf;
2118    
2119          buf = emit_x86_instruction(compiler, 2 | EX86_PREF_66 | EX86_SSE2, xmm1, 0, xmm2, xmm2w);          buf = emit_x86_instruction(compiler, 2 | (pref66 ? EX86_PREF_66 : 0) | EX86_SSE2, xmm1, 0, xmm2, xmm2w);
2120          FAIL_IF(!buf);          FAIL_IF(!buf);
2121          *buf++ = 0x0f;          *buf++ = 0x0f;
2122          *buf = opcode;          *buf = opcode;
2123          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
2124  }  }
2125    
2126  static SLJIT_INLINE int emit_sse2_load(struct sljit_compiler *compiler,  static SLJIT_INLINE sljit_si emit_sse2_load(struct sljit_compiler *compiler,
2127          int dst, int src, sljit_w srcw)          sljit_si single, sljit_si dst, sljit_si src, sljit_sw srcw)
2128  {  {
2129          return emit_sse2(compiler, 0x10, dst, src, srcw);          return emit_sse2(compiler, 0x10, single, dst, src, srcw);
2130  }  }
2131    
2132  static SLJIT_INLINE int emit_sse2_store(struct sljit_compiler *compiler,  static SLJIT_INLINE sljit_si emit_sse2_store(struct sljit_compiler *compiler,
2133          int dst, sljit_w dstw, int src)          sljit_si single, sljit_si dst, sljit_sw dstw, sljit_si src)
2134  {  {
2135          return emit_sse2(compiler, 0x11, src, dst, dstw);          return emit_sse2(compiler, 0x11, single, src, dst, dstw);
2136  }  }
2137    
2138  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,
2139          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
2140          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
2141  {  {
2142          int dst_r;          sljit_si dst_r;
2143    
2144          CHECK_ERROR();          CHECK_ERROR();
2145          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);
# Line 2128  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 2148  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
2148          compiler->mode32 = 1;          compiler->mode32 = 1;
2149  #endif  #endif
2150    
2151          if (GET_OPCODE(op) == SLJIT_FCMP) {          if (GET_OPCODE(op) == SLJIT_CMPD) {
2152                  compiler->flags_saved = 0;                  compiler->flags_saved = 0;
2153                  if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4)                  if (dst <= SLJIT_FLOAT_REG6)
2154                          dst_r = dst;                          dst_r = dst;
2155                  else {                  else {
2156                          dst_r = TMP_FREG;                          dst_r = TMP_FREG;
2157                          FAIL_IF(emit_sse2_load(compiler, dst_r, dst, dstw));                          FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst_r, dst, dstw));
2158                  }                  }
2159                  return emit_sse2_logic(compiler, 0x2e, dst_r, src, srcw);                  return emit_sse2_logic(compiler, 0x2e, !(op & SLJIT_SINGLE_OP), dst_r, src, srcw);
2160          }          }
2161    
2162          if (op == SLJIT_FMOV) {          if (op == SLJIT_MOVD) {
2163                  if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4)                  if (dst <= SLJIT_FLOAT_REG6)
2164                          return emit_sse2_load(compiler, dst, src, srcw);                          return emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst, src, srcw);
2165                  if (src >= SLJIT_FLOAT_REG1 && src <= SLJIT_FLOAT_REG4)                  if (src <= SLJIT_FLOAT_REG6)
2166                          return emit_sse2_store(compiler, dst, dstw, src);                          return emit_sse2_store(compiler, op & SLJIT_SINGLE_OP, dst, dstw, src);
2167                  FAIL_IF(emit_sse2_load(compiler, TMP_FREG, src, srcw));                  FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, TMP_FREG, src, srcw));
2168                  return emit_sse2_store(compiler, dst, dstw, TMP_FREG);                  return emit_sse2_store(compiler, op & SLJIT_SINGLE_OP, dst, dstw, TMP_FREG);
2169          }          }
2170    
2171          if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4) {          if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG6) {
2172                  dst_r = dst;                  dst_r = dst;
2173                  if (dst != src)                  if (dst != src)
2174                          FAIL_IF(emit_sse2_load(compiler, dst_r, src, srcw));                          FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst_r, src, srcw));
2175          }          }
2176          else {          else {
2177                  dst_r = TMP_FREG;                  dst_r = TMP_FREG;
2178                  FAIL_IF(emit_sse2_load(compiler, dst_r, src, srcw));                  FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst_r, src, srcw));
2179          }          }
2180    
2181          switch (op) {          switch (GET_OPCODE(op)) {
2182          case SLJIT_FNEG:          case SLJIT_NEGD:
2183                  FAIL_IF(emit_sse2_logic(compiler, 0x57, dst_r, SLJIT_MEM0(), (sljit_w)sse2_buffer));                  FAIL_IF(emit_sse2_logic(compiler, 0x57, 1, dst_r, SLJIT_MEM0(), (sljit_sw)(op & SLJIT_SINGLE_OP ? sse2_buffer : sse2_buffer + 8)));
2184                  break;                  break;
2185    
2186          case SLJIT_FABS:          case SLJIT_ABSD:
2187                  FAIL_IF(emit_sse2_logic(compiler, 0x54, dst_r, SLJIT_MEM0(), (sljit_w)(sse2_buffer + 4)));                  FAIL_IF(emit_sse2_logic(compiler, 0x54, 1, dst_r, SLJIT_MEM0(), (sljit_sw)(op & SLJIT_SINGLE_OP ? sse2_buffer + 4 : sse2_buffer + 12)));
2188                  break;                  break;
2189          }          }
2190    
2191          if (dst_r == TMP_FREG)          if (dst_r == TMP_FREG)
2192                  return emit_sse2_store(compiler, dst, dstw, TMP_FREG);                  return emit_sse2_store(compiler, op & SLJIT_SINGLE_OP, dst, dstw, TMP_FREG);
2193          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
2194  }  }
2195    
2196  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,
2197          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
2198          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
2199          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
2200  {  {
2201          int dst_r;          sljit_si dst_r;
2202    
2203          CHECK_ERROR();          CHECK_ERROR();
2204          check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);          check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
# Line 2187  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 2207  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
2207          compiler->mode32 = 1;          compiler->mode32 = 1;
2208  #endif  #endif
2209    
2210          if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4) {          if (dst <= SLJIT_FLOAT_REG6) {
2211                  dst_r = dst;                  dst_r = dst;
2212                  if (dst == src1)                  if (dst == src1)
2213                          ; /* Do nothing here. */                          ; /* Do nothing here. */
2214                  else if (dst == src2 && (op == SLJIT_FADD || op == SLJIT_FMUL)) {                  else if (dst == src2 && (op == SLJIT_ADDD || op == SLJIT_MULD)) {
2215                          /* Swap arguments. */                          /* Swap arguments. */
2216                          src2 = src1;                          src2 = src1;
2217                          src2w = src1w;                          src2w = src1w;
2218                  }                  }
2219                  else if (dst != src2)                  else if (dst != src2)
2220                          FAIL_IF(emit_sse2_load(compiler, dst_r, src1, src1w));                          FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst_r, src1, src1w));
2221                  else {                  else {
2222                          dst_r = TMP_FREG;                          dst_r = TMP_FREG;
2223                          FAIL_IF(emit_sse2_load(compiler, TMP_FREG, src1, src1w));                          FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, TMP_FREG, src1, src1w));
2224                  }                  }
2225          }          }
2226          else {          else {
2227                  dst_r = TMP_FREG;                  dst_r = TMP_FREG;
2228                  FAIL_IF(emit_sse2_load(compiler, TMP_FREG, src1, src1w));                  FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, TMP_FREG, src1, src1w));
2229          }          }
2230    
2231          switch (op) {          switch (GET_OPCODE(op)) {
2232          case SLJIT_FADD:          case SLJIT_ADDD:
2233                  FAIL_IF(emit_sse2(compiler, 0x58, dst_r, src2, src2w));                  FAIL_IF(emit_sse2(compiler, 0x58, op & SLJIT_SINGLE_OP, dst_r, src2, src2w));
2234                  break;                  break;
2235    
2236          case SLJIT_FSUB:          case SLJIT_SUBD:
2237                  FAIL_IF(emit_sse2(compiler, 0x5c, dst_r, src2, src2w));                  FAIL_IF(emit_sse2(compiler, 0x5c, op & SLJIT_SINGLE_OP, dst_r, src2, src2w));
2238                  break;                  break;
2239    
2240          case SLJIT_FMUL:          case SLJIT_MULD:
2241                  FAIL_IF(emit_sse2(compiler, 0x59, dst_r, src2, src2w));                  FAIL_IF(emit_sse2(compiler, 0x59, op & SLJIT_SINGLE_OP, dst_r, src2, src2w));
2242                  break;                  break;
2243    
2244          case SLJIT_FDIV:          case SLJIT_DIVD:
2245                  FAIL_IF(emit_sse2(compiler, 0x5e, dst_r, src2, src2w));                  FAIL_IF(emit_sse2(compiler, 0x5e, op & SLJIT_SINGLE_OP, dst_r, src2, src2w));
2246                  break;                  break;
2247          }          }
2248    
2249          if (dst_r == TMP_FREG)          if (dst_r == TMP_FREG)
2250                  return emit_sse2_store(compiler, dst, dstw, TMP_FREG);                  return emit_sse2_store(compiler, op & SLJIT_SINGLE_OP, dst, dstw, TMP_FREG);
2251          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
2252  }  }
2253    
2254  #else  #else
2255    
2256  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,
2257          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
2258          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
2259  {  {
2260          CHECK_ERROR();          CHECK_ERROR();
2261          /* Should cause an assertion fail. */          /* Should cause an assertion fail. */
# Line 2244  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 2264  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
2264          return SLJIT_ERR_UNSUPPORTED;          return SLJIT_ERR_UNSUPPORTED;
2265  }  }
2266    
2267  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,
2268          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
2269          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
2270          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
2271  {  {
2272          CHECK_ERROR();          CHECK_ERROR();
2273          /* Should cause an assertion fail. */          /* Should cause an assertion fail. */
# Line 2291  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la Line 2311  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la
2311          return label;          return label;
2312  }  }
2313    
2314  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)
2315  {  {
2316          sljit_ub *buf;          sljit_ub *buf;
2317          struct sljit_jump *jump;          struct sljit_jump *jump;
# Line 2328  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 2348  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
2348          return jump;          return jump;
2349  }  }
2350    
2351  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)
2352  {  {
2353          sljit_ub *code;          sljit_ub *code;
2354          struct sljit_jump *jump;          struct sljit_jump *jump;
# Line 2353  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 2373  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
2373                          src = TMP_REGISTER;                          src = TMP_REGISTER;
2374                  }                  }
2375                  if (src == SLJIT_MEM1(SLJIT_LOCALS_REG) && type >= SLJIT_CALL3)                  if (src == SLJIT_MEM1(SLJIT_LOCALS_REG) && type >= SLJIT_CALL3)
2376                          srcw += sizeof(sljit_w);                          srcw += sizeof(sljit_sw);
2377  #else  #else
2378                  if (src == SLJIT_MEM1(SLJIT_LOCALS_REG))                  if (src == SLJIT_MEM1(SLJIT_LOCALS_REG))
2379                          srcw += sizeof(sljit_w) * (type - SLJIT_CALL0);                          srcw += sizeof(sljit_sw) * (type - SLJIT_CALL0);
2380  #endif  #endif
2381  #endif  #endif
2382  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && defined(_WIN64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && defined(_WIN64)
# Line 2400  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 2420  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
2420          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
2421  }  }
2422    
2423  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)
2424  {  {
2425          sljit_ub *buf;          sljit_ub *buf;
2426          sljit_ub cond_set = 0;          sljit_ub cond_set = 0;
2427          int dst_save = dst;          sljit_si dst_save = dst;
2428          sljit_w dstw_save = dstw;          sljit_sw dstw_save = dstw;
2429  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
2430          int reg;          sljit_si reg;
2431  #endif  #endif
2432    
2433          CHECK_ERROR();          CHECK_ERROR();
# Line 2591  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 2611  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
2611          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
2612  }  }
2613    
2614  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_local_base(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w offset)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_local_base(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw, sljit_sw offset)
2615  {  {
2616          CHECK_ERROR();          CHECK_ERROR();
2617          check_sljit_get_local_base(compiler, dst, dstw, offset);          check_sljit_get_local_base(compiler, dst, dstw, offset);
# Line 2622  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_l Line 2642  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_l
2642          return emit_mov(compiler, dst, dstw, SLJIT_LOCALS_REG, 0);          return emit_mov(compiler, dst, dstw, SLJIT_LOCALS_REG, 0);
2643  }  }
2644    
2645  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)
2646  {  {
2647          sljit_ub *buf;          sljit_ub *buf;
2648          struct sljit_const *const_;          struct sljit_const *const_;
2649  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
2650          int reg;          sljit_si reg;
2651  #endif  #endif
2652    
2653          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
# Line 2672  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co Line 2692  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co
2692  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)
2693  {  {
2694  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
2695          *(sljit_w*)addr = new_addr - (addr + 4);          *(sljit_sw*)addr = new_addr - (addr + 4);
2696  #else  #else
2697          *(sljit_uw*)addr = new_addr;          *(sljit_uw*)addr = new_addr;
2698  #endif  #endif
2699  }  }
2700    
2701  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)
2702  {  {
2703          *(sljit_w*)addr = new_constant;          *(sljit_sw*)addr = new_constant;
2704  }  }

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

  ViewVC Help
Powered by ViewVC 1.1.5