/[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 1452 by zherczeg, Fri Mar 15 06:58:31 2013 UTC revision 1453 by zherczeg, Thu Jan 30 06:10:21 2014 UTC
# Line 64  SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST cha Line 64  SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST cha
64  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
65    
66  /* Last register + 1. */  /* Last register + 1. */
67  #define TMP_REGISTER    (SLJIT_NO_REGISTERS + 1)  #define TMP_REG1        (SLJIT_NO_REGISTERS + 1)
68    
69  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 2] = {  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 2] = {
70          0, 0, 2, 1, 0, 0, 3, 6, 7, 0, 0, 4, 5          0, 0, 2, 1, 0, 0, 3, 6, 7, 0, 0, 4, 5
# Line 85  static SLJIT_CONST sljit_ub reg_map[SLJI Line 85  static SLJIT_CONST sljit_ub reg_map[SLJI
85  #else /* SLJIT_CONFIG_X86_32 */  #else /* SLJIT_CONFIG_X86_32 */
86    
87  /* Last register + 1. */  /* Last register + 1. */
88  #define TMP_REGISTER    (SLJIT_NO_REGISTERS + 1)  #define TMP_REG1        (SLJIT_NO_REGISTERS + 1)
89  #define TMP_REG2        (SLJIT_NO_REGISTERS + 2)  #define TMP_REG2        (SLJIT_NO_REGISTERS + 2)
90  #define TMP_REG3        (SLJIT_NO_REGISTERS + 3)  #define TMP_REG3        (SLJIT_NO_REGISTERS + 3)
91    
# Line 633  static void SLJIT_CALL sljit_grow_stack( Line 633  static void SLJIT_CALL sljit_grow_stack(
633          CPU cycles if the stack is large enough. However, you don't know it in          CPU cycles if the stack is large enough. However, you don't know it in
634          advance, so it must always be called. I think this is a bad design in          advance, so it must always be called. I think this is a bad design in
635          general even if it has some reasons. */          general even if it has some reasons. */
636          *(sljit_si*)alloca(local_size) = 0;          *(volatile sljit_si*)alloca(local_size) = 0;
637  }  }
638    
639  #endif  #endif
# Line 653  static sljit_si emit_mov(struct sljit_co Line 653  static sljit_si emit_mov(struct sljit_co
653          if (dst == SLJIT_UNUSED) {          if (dst == SLJIT_UNUSED) {
654                  /* No destination, doesn't need to setup flags. */                  /* No destination, doesn't need to setup flags. */
655                  if (src & SLJIT_MEM) {                  if (src & SLJIT_MEM) {
656                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src, srcw);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, src, srcw);
657                          FAIL_IF(!inst);                          FAIL_IF(!inst);
658                          *inst = MOV_r_rm;                          *inst = MOV_r_rm;
659                  }                  }
660                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
661          }          }
662          if (src <= TMP_REGISTER) {          if (FAST_IS_REG(src)) {
663                  inst = emit_x86_instruction(compiler, 1, src, 0, dst, dstw);                  inst = emit_x86_instruction(compiler, 1, src, 0, dst, dstw);
664                  FAIL_IF(!inst);                  FAIL_IF(!inst);
665                  *inst = MOV_rm_r;                  *inst = MOV_rm_r;
666                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
667          }          }
668          if (src & SLJIT_IMM) {          if (src & SLJIT_IMM) {
669                  if (dst <= TMP_REGISTER) {                  if (FAST_IS_REG(dst)) {
670  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
671                          return emit_do_imm(compiler, MOV_r_i32 + reg_map[dst], srcw);                          return emit_do_imm(compiler, MOV_r_i32 + reg_map[dst], srcw);
672  #else  #else
# Line 692  static sljit_si emit_mov(struct sljit_co Line 692  static sljit_si emit_mov(struct sljit_co
692                  *inst = MOV_rm_i32;                  *inst = MOV_rm_i32;
693                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
694          }          }
695          if (dst <= TMP_REGISTER) {          if (FAST_IS_REG(dst)) {
696                  inst = emit_x86_instruction(compiler, 1, dst, 0, src, srcw);                  inst = emit_x86_instruction(compiler, 1, dst, 0, src, srcw);
697                  FAIL_IF(!inst);                  FAIL_IF(!inst);
698                  *inst = MOV_r_rm;                  *inst = MOV_r_rm;
# Line 700  static sljit_si emit_mov(struct sljit_co Line 700  static sljit_si emit_mov(struct sljit_co
700          }          }
701    
702          /* Memory to memory move. Requires two instruction. */          /* Memory to memory move. Requires two instruction. */
703          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src, srcw);          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, src, srcw);
704          FAIL_IF(!inst);          FAIL_IF(!inst);
705          *inst = MOV_r_rm;          *inst = MOV_r_rm;
706          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, dst, dstw);          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, dst, dstw);
707          FAIL_IF(!inst);          FAIL_IF(!inst);
708          *inst = MOV_rm_r;          *inst = MOV_rm_r;
709          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
# Line 745  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 745  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
745                  SLJIT_COMPILE_ASSERT(                  SLJIT_COMPILE_ASSERT(
746                          reg_map[SLJIT_SCRATCH_REG1] == 0                          reg_map[SLJIT_SCRATCH_REG1] == 0
747                          && reg_map[SLJIT_SCRATCH_REG2] == 2                          && reg_map[SLJIT_SCRATCH_REG2] == 2
748                          && reg_map[TMP_REGISTER] > 7,                          && reg_map[TMP_REG1] > 7,
749                          invalid_register_assignment_for_div_mul);                          invalid_register_assignment_for_div_mul);
750  #else  #else
751                  SLJIT_COMPILE_ASSERT(                  SLJIT_COMPILE_ASSERT(
752                          reg_map[SLJIT_SCRATCH_REG1] == 0                          reg_map[SLJIT_SCRATCH_REG1] == 0
753                          && reg_map[SLJIT_SCRATCH_REG2] < 7                          && reg_map[SLJIT_SCRATCH_REG2] < 7
754                          && reg_map[TMP_REGISTER] == 2,                          && reg_map[TMP_REG1] == 2,
755                          invalid_register_assignment_for_div_mul);                          invalid_register_assignment_for_div_mul);
756  #endif  #endif
757                  compiler->mode32 = op & SLJIT_INT_OP;                  compiler->mode32 = op & SLJIT_INT_OP;
# Line 760  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 760  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
760                  op = GET_OPCODE(op);                  op = GET_OPCODE(op);
761                  if (op == SLJIT_UDIV) {                  if (op == SLJIT_UDIV) {
762  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || defined(_WIN64)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || defined(_WIN64)
763                          EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_SCRATCH_REG2, 0);                          EMIT_MOV(compiler, TMP_REG1, 0, SLJIT_SCRATCH_REG2, 0);
764                          inst = emit_x86_instruction(compiler, 1, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0);                          inst = emit_x86_instruction(compiler, 1, SLJIT_SCRATCH_REG2, 0, SLJIT_SCRATCH_REG2, 0);
765  #else  #else
766                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, TMP_REGISTER, 0);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, TMP_REG1, 0);
767  #endif  #endif
768                          FAIL_IF(!inst);                          FAIL_IF(!inst);
769                          *inst = XOR_r_rm;                          *inst = XOR_r_rm;
# Line 771  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 771  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
771    
772                  if (op == SLJIT_SDIV) {                  if (op == SLJIT_SDIV) {
773  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || defined(_WIN64)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) || defined(_WIN64)
774                          EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_SCRATCH_REG2, 0);                          EMIT_MOV(compiler, TMP_REG1, 0, SLJIT_SCRATCH_REG2, 0);
775  #endif  #endif
776    
777  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
# Line 800  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 800  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
800                  FAIL_IF(!inst);                  FAIL_IF(!inst);
801                  INC_SIZE(2);                  INC_SIZE(2);
802                  *inst++ = GROUP_F7;                  *inst++ = GROUP_F7;
803                  *inst = MOD_REG | ((op >= SLJIT_UDIV) ? reg_map[TMP_REGISTER] : reg_map[SLJIT_SCRATCH_REG2]);                  *inst = MOD_REG | ((op >= SLJIT_UDIV) ? reg_map[TMP_REG1] : reg_map[SLJIT_SCRATCH_REG2]);
804  #else  #else
805  #ifdef _WIN64  #ifdef _WIN64
806                  size = (!compiler->mode32 || op >= SLJIT_UDIV) ? 3 : 2;                  size = (!compiler->mode32 || op >= SLJIT_UDIV) ? 3 : 2;
# Line 816  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 816  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
816                  else if (op >= SLJIT_UDIV)                  else if (op >= SLJIT_UDIV)
817                          *inst++ = REX_B;                          *inst++ = REX_B;
818                  *inst++ = GROUP_F7;                  *inst++ = GROUP_F7;
819                  *inst = MOD_REG | ((op >= SLJIT_UDIV) ? reg_lmap[TMP_REGISTER] : reg_lmap[SLJIT_SCRATCH_REG2]);                  *inst = MOD_REG | ((op >= SLJIT_UDIV) ? reg_lmap[TMP_REG1] : reg_lmap[SLJIT_SCRATCH_REG2]);
820  #else  #else
821                  if (!compiler->mode32)                  if (!compiler->mode32)
822                          *inst++ = REX_W;                          *inst++ = REX_W;
# Line 839  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 839  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
839                          break;                          break;
840                  }                  }
841  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && !defined(_WIN64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && !defined(_WIN64)
842                  EMIT_MOV(compiler, SLJIT_SCRATCH_REG2, 0, TMP_REGISTER, 0);                  EMIT_MOV(compiler, SLJIT_SCRATCH_REG2, 0, TMP_REG1, 0);
843  #endif  #endif
844                  break;                  break;
845          }          }
# Line 873  static sljit_si emit_mov_byte(struct slj Line 873  static sljit_si emit_mov_byte(struct slj
873                  return SLJIT_SUCCESS; /* Empty instruction. */                  return SLJIT_SUCCESS; /* Empty instruction. */
874    
875          if (src & SLJIT_IMM) {          if (src & SLJIT_IMM) {
876                  if (dst <= TMP_REGISTER) {                  if (FAST_IS_REG(dst)) {
877  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
878                          return emit_do_imm(compiler, MOV_r_i32 + reg_map[dst], srcw);                          return emit_do_imm(compiler, MOV_r_i32 + reg_map[dst], srcw);
879  #else  #else
# Line 889  static sljit_si emit_mov_byte(struct slj Line 889  static sljit_si emit_mov_byte(struct slj
889                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
890          }          }
891    
892          dst_r = (dst <= TMP_REGISTER) ? dst : TMP_REGISTER;          dst_r = FAST_IS_REG(dst) ? dst : TMP_REG1;
893    
894          if ((dst & SLJIT_MEM) && src <= TMP_REGISTER) {          if ((dst & SLJIT_MEM) && FAST_IS_REG(src)) {
895  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
896                  if (reg_map[src] >= 4) {                  if (reg_map[src] >= 4) {
897                          SLJIT_ASSERT(dst_r == TMP_REGISTER);                          SLJIT_ASSERT(dst_r == TMP_REG1);
898                          EMIT_MOV(compiler, TMP_REGISTER, 0, src, 0);                          EMIT_MOV(compiler, TMP_REG1, 0, src, 0);
899                  } else                  } else
900                          dst_r = src;                          dst_r = src;
901  #else  #else
# Line 903  static sljit_si emit_mov_byte(struct slj Line 903  static sljit_si emit_mov_byte(struct slj
903  #endif  #endif
904          }          }
905  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
906          else if (src <= TMP_REGISTER && reg_map[src] >= 4) {          else if (FAST_IS_REG(src) && reg_map[src] >= 4) {
907                  /* src, dst are registers. */                  /* src, dst are registers. */
908                  SLJIT_ASSERT(dst >= SLJIT_SCRATCH_REG1 && dst <= TMP_REGISTER);                  SLJIT_ASSERT(SLOW_IS_REG(dst));
909                  if (reg_map[dst] < 4) {                  if (reg_map[dst] < 4) {
910                          if (dst != src)                          if (dst != src)
911                                  EMIT_MOV(compiler, dst, 0, src, 0);                                  EMIT_MOV(compiler, dst, 0, src, 0);
# Line 946  static sljit_si emit_mov_byte(struct slj Line 946  static sljit_si emit_mov_byte(struct slj
946    
947          if (dst & SLJIT_MEM) {          if (dst & SLJIT_MEM) {
948  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
949                  if (dst_r == TMP_REGISTER) {                  if (dst_r == TMP_REG1) {
950                          /* Find a non-used register, whose reg_map[src] < 4. */                          /* Find a non-used register, whose reg_map[src] < 4. */
951                          if ((dst & 0xf) == SLJIT_SCRATCH_REG1) {                          if ((dst & REG_MASK) == SLJIT_SCRATCH_REG1) {
952                                  if ((dst & 0xf0) == (SLJIT_SCRATCH_REG2 << 4))                                  if ((dst & OFFS_REG_MASK) == TO_OFFS_REG(SLJIT_SCRATCH_REG2))
953                                          work_r = SLJIT_SCRATCH_REG3;                                          work_r = SLJIT_SCRATCH_REG3;
954                                  else                                  else
955                                          work_r = SLJIT_SCRATCH_REG2;                                          work_r = SLJIT_SCRATCH_REG2;
956                          }                          }
957                          else {                          else {
958                                  if ((dst & 0xf0) != (SLJIT_SCRATCH_REG1 << 4))                                  if ((dst & OFFS_REG_MASK) != TO_OFFS_REG(SLJIT_SCRATCH_REG1))
959                                          work_r = SLJIT_SCRATCH_REG1;                                          work_r = SLJIT_SCRATCH_REG1;
960                                  else if ((dst & 0xf) == SLJIT_SCRATCH_REG2)                                  else if ((dst & REG_MASK) == SLJIT_SCRATCH_REG2)
961                                          work_r = SLJIT_SCRATCH_REG3;                                          work_r = SLJIT_SCRATCH_REG3;
962                                  else                                  else
963                                          work_r = SLJIT_SCRATCH_REG2;                                          work_r = SLJIT_SCRATCH_REG2;
964                          }                          }
965    
966                          if (work_r == SLJIT_SCRATCH_REG1) {                          if (work_r == SLJIT_SCRATCH_REG1) {
967                                  ENCODE_PREFIX(XCHG_EAX_r + reg_map[TMP_REGISTER]);                                  ENCODE_PREFIX(XCHG_EAX_r + reg_map[TMP_REG1]);
968                          }                          }
969                          else {                          else {
970                                  inst = emit_x86_instruction(compiler, 1, work_r, 0, dst_r, 0);                                  inst = emit_x86_instruction(compiler, 1, work_r, 0, dst_r, 0);
# Line 977  static sljit_si emit_mov_byte(struct slj Line 977  static sljit_si emit_mov_byte(struct slj
977                          *inst = MOV_rm8_r8;                          *inst = MOV_rm8_r8;
978    
979                          if (work_r == SLJIT_SCRATCH_REG1) {                          if (work_r == SLJIT_SCRATCH_REG1) {
980                                  ENCODE_PREFIX(XCHG_EAX_r + reg_map[TMP_REGISTER]);                                  ENCODE_PREFIX(XCHG_EAX_r + reg_map[TMP_REG1]);
981                          }                          }
982                          else {                          else {
983                                  inst = emit_x86_instruction(compiler, 1, work_r, 0, dst_r, 0);                                  inst = emit_x86_instruction(compiler, 1, work_r, 0, dst_r, 0);
# Line 1015  static sljit_si emit_mov_half(struct slj Line 1015  static sljit_si emit_mov_half(struct slj
1015                  return SLJIT_SUCCESS; /* Empty instruction. */                  return SLJIT_SUCCESS; /* Empty instruction. */
1016    
1017          if (src & SLJIT_IMM) {          if (src & SLJIT_IMM) {
1018                  if (dst <= TMP_REGISTER) {                  if (FAST_IS_REG(dst)) {
1019  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1020                          return emit_do_imm(compiler, MOV_r_i32 + reg_map[dst], srcw);                          return emit_do_imm(compiler, MOV_r_i32 + reg_map[dst], srcw);
1021  #else  #else
# Line 1031  static sljit_si emit_mov_half(struct slj Line 1031  static sljit_si emit_mov_half(struct slj
1031                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1032          }          }
1033    
1034          dst_r = (dst <= TMP_REGISTER) ? dst : TMP_REGISTER;          dst_r = FAST_IS_REG(dst) ? dst : TMP_REG1;
1035    
1036          if ((dst & SLJIT_MEM) && src <= TMP_REGISTER)          if ((dst & SLJIT_MEM) && FAST_IS_REG(src))
1037                  dst_r = src;                  dst_r = src;
1038          else {          else {
1039                  inst = emit_x86_instruction(compiler, 2, dst_r, 0, src, srcw);                  inst = emit_x86_instruction(compiler, 2, dst_r, 0, src, srcw);
# Line 1058  static sljit_si emit_unary(struct sljit_ Line 1058  static sljit_si emit_unary(struct sljit_
1058          sljit_ub* inst;          sljit_ub* inst;
1059    
1060          if (dst == SLJIT_UNUSED) {          if (dst == SLJIT_UNUSED) {
1061                  EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);                  EMIT_MOV(compiler, TMP_REG1, 0, src, srcw);
1062                  inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REG1, 0);
1063                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1064                  *inst++ = GROUP_F7;                  *inst++ = GROUP_F7;
1065                  *inst |= opcode;                  *inst |= opcode;
# Line 1073  static sljit_si emit_unary(struct sljit_ Line 1073  static sljit_si emit_unary(struct sljit_
1073                  *inst |= opcode;                  *inst |= opcode;
1074                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1075          }          }
1076          if (dst <= TMP_REGISTER) {          if (FAST_IS_REG(dst)) {
1077                  EMIT_MOV(compiler, dst, 0, src, srcw);                  EMIT_MOV(compiler, dst, 0, src, srcw);
1078                  inst = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);                  inst = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
1079                  FAIL_IF(!inst);                  FAIL_IF(!inst);
# Line 1081  static sljit_si emit_unary(struct sljit_ Line 1081  static sljit_si emit_unary(struct sljit_
1081                  *inst |= opcode;                  *inst |= opcode;
1082                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1083          }          }
1084          EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);          EMIT_MOV(compiler, TMP_REG1, 0, src, srcw);
1085          inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);          inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REG1, 0);
1086          FAIL_IF(!inst);          FAIL_IF(!inst);
1087          *inst++ = GROUP_F7;          *inst++ = GROUP_F7;
1088          *inst |= opcode;          *inst |= opcode;
1089          EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);          EMIT_MOV(compiler, dst, dstw, TMP_REG1, 0);
1090          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1091  }  }
1092    
# Line 1097  static sljit_si emit_not_with_flags(stru Line 1097  static sljit_si emit_not_with_flags(stru
1097          sljit_ub* inst;          sljit_ub* inst;
1098    
1099          if (dst == SLJIT_UNUSED) {          if (dst == SLJIT_UNUSED) {
1100                  EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);                  EMIT_MOV(compiler, TMP_REG1, 0, src, srcw);
1101                  inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REG1, 0);
1102                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1103                  *inst++ = GROUP_F7;                  *inst++ = GROUP_F7;
1104                  *inst |= NOT_rm;                  *inst |= NOT_rm;
1105                  inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, TMP_REG1, 0);
1106                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1107                  *inst = OR_r_rm;                  *inst = OR_r_rm;
1108                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1109          }          }
1110          if (dst <= TMP_REGISTER) {          if (FAST_IS_REG(dst)) {
1111                  EMIT_MOV(compiler, dst, 0, src, srcw);                  EMIT_MOV(compiler, dst, 0, src, srcw);
1112                  inst = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);                  inst = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
1113                  FAIL_IF(!inst);                  FAIL_IF(!inst);
# Line 1118  static sljit_si emit_not_with_flags(stru Line 1118  static sljit_si emit_not_with_flags(stru
1118                  *inst = OR_r_rm;                  *inst = OR_r_rm;
1119                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1120          }          }
1121          EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);          EMIT_MOV(compiler, TMP_REG1, 0, src, srcw);
1122          inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);          inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REG1, 0);
1123          FAIL_IF(!inst);          FAIL_IF(!inst);
1124          *inst++ = GROUP_F7;          *inst++ = GROUP_F7;
1125          *inst |= NOT_rm;          *inst |= NOT_rm;
1126          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, TMP_REGISTER, 0);          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, TMP_REG1, 0);
1127          FAIL_IF(!inst);          FAIL_IF(!inst);
1128          *inst = OR_r_rm;          *inst = OR_r_rm;
1129          EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);          EMIT_MOV(compiler, dst, dstw, TMP_REG1, 0);
1130          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1131  }  }
1132    
# Line 1140  static sljit_si emit_clz(struct sljit_co Line 1140  static sljit_si emit_clz(struct sljit_co
1140          SLJIT_UNUSED_ARG(op_flags);          SLJIT_UNUSED_ARG(op_flags);
1141          if (SLJIT_UNLIKELY(dst == SLJIT_UNUSED)) {          if (SLJIT_UNLIKELY(dst == SLJIT_UNUSED)) {
1142                  /* Just set the zero flag. */                  /* Just set the zero flag. */
1143                  EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);                  EMIT_MOV(compiler, TMP_REG1, 0, src, srcw);
1144                  inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1, 0, 0, TMP_REG1, 0);
1145                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1146                  *inst++ = GROUP_F7;                  *inst++ = GROUP_F7;
1147                  *inst |= NOT_rm;                  *inst |= NOT_rm;
1148  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1149                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, 31, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, 31, TMP_REG1, 0);
1150  #else  #else
1151                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, !(op_flags & SLJIT_INT_OP) ? 63 : 31, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, !(op_flags & SLJIT_INT_OP) ? 63 : 31, TMP_REG1, 0);
1152  #endif  #endif
1153                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1154                  *inst |= SHR;                  *inst |= SHR;
# Line 1156  static sljit_si emit_clz(struct sljit_co Line 1156  static sljit_si emit_clz(struct sljit_co
1156          }          }
1157    
1158          if (SLJIT_UNLIKELY(src & SLJIT_IMM)) {          if (SLJIT_UNLIKELY(src & SLJIT_IMM)) {
1159                  EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_IMM, srcw);                  EMIT_MOV(compiler, TMP_REG1, 0, SLJIT_IMM, srcw);
1160                  src = TMP_REGISTER;                  src = TMP_REG1;
1161                  srcw = 0;                  srcw = 0;
1162          }          }
1163    
1164          inst = emit_x86_instruction(compiler, 2, TMP_REGISTER, 0, src, srcw);          inst = emit_x86_instruction(compiler, 2, TMP_REG1, 0, src, srcw);
1165          FAIL_IF(!inst);          FAIL_IF(!inst);
1166          *inst++ = GROUP_0F;          *inst++ = GROUP_0F;
1167          *inst = BSR_r_rm;          *inst = BSR_r_rm;
1168    
1169  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1170          if (dst <= TMP_REGISTER)          if (FAST_IS_REG(dst))
1171                  dst_r = dst;                  dst_r = dst;
1172          else {          else {
1173                  /* Find an unused temporary register. */                  /* Find an unused temporary register. */
1174                  if ((dst & 0xf) != SLJIT_SCRATCH_REG1 && (dst & 0xf0) != (SLJIT_SCRATCH_REG1 << 4))                  if ((dst & REG_MASK) != SLJIT_SCRATCH_REG1 && (dst & OFFS_REG_MASK) != TO_OFFS_REG(SLJIT_SCRATCH_REG1))
1175                          dst_r = SLJIT_SCRATCH_REG1;                          dst_r = SLJIT_SCRATCH_REG1;
1176                  else if ((dst & 0xf) != SLJIT_SCRATCH_REG2 && (dst & 0xf0) != (SLJIT_SCRATCH_REG2 << 4))                  else if ((dst & REG_MASK) != SLJIT_SCRATCH_REG2 && (dst & OFFS_REG_MASK) != TO_OFFS_REG(SLJIT_SCRATCH_REG2))
1177                          dst_r = SLJIT_SCRATCH_REG2;                          dst_r = SLJIT_SCRATCH_REG2;
1178                  else                  else
1179                          dst_r = SLJIT_SCRATCH_REG3;                          dst_r = SLJIT_SCRATCH_REG3;
# Line 1181  static sljit_si emit_clz(struct sljit_co Line 1181  static sljit_si emit_clz(struct sljit_co
1181          }          }
1182          EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, 32 + 31);          EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, 32 + 31);
1183  #else  #else
1184          dst_r = (dst <= TMP_REGISTER) ? dst : TMP_REG2;          dst_r = FAST_IS_REG(dst) ? dst : TMP_REG2;
1185          compiler->mode32 = 0;          compiler->mode32 = 0;
1186          EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, !(op_flags & SLJIT_INT_OP) ? 64 + 63 : 32 + 31);          EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, !(op_flags & SLJIT_INT_OP) ? 64 + 63 : 32 + 31);
1187          compiler->mode32 = op_flags & SLJIT_INT_OP;          compiler->mode32 = op_flags & SLJIT_INT_OP;
# Line 1191  static sljit_si emit_clz(struct sljit_co Line 1191  static sljit_si emit_clz(struct sljit_co
1191                  get_cpu_features();                  get_cpu_features();
1192    
1193          if (cpu_has_cmov) {          if (cpu_has_cmov) {
1194                  inst = emit_x86_instruction(compiler, 2, dst_r, 0, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 2, dst_r, 0, TMP_REG1, 0);
1195                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1196                  *inst++ = GROUP_0F;                  *inst++ = GROUP_0F;
1197                  *inst = CMOVNE_r_rm;                  *inst = CMOVNE_r_rm;
# Line 1204  static sljit_si emit_clz(struct sljit_co Line 1204  static sljit_si emit_clz(struct sljit_co
1204                  *inst++ = JE_i8;                  *inst++ = JE_i8;
1205                  *inst++ = 2;                  *inst++ = 2;
1206                  *inst++ = MOV_r_rm;                  *inst++ = MOV_r_rm;
1207                  *inst++ = MOD_REG | (reg_map[dst_r] << 3) | reg_map[TMP_REGISTER];                  *inst++ = MOD_REG | (reg_map[dst_r] << 3) | reg_map[TMP_REG1];
1208  #else  #else
1209                  inst = (sljit_ub*)ensure_buf(compiler, 1 + 5);                  inst = (sljit_ub*)ensure_buf(compiler, 1 + 5);
1210                  FAIL_IF(!inst);                  FAIL_IF(!inst);
# Line 1212  static sljit_si emit_clz(struct sljit_co Line 1212  static sljit_si emit_clz(struct sljit_co
1212    
1213                  *inst++ = JE_i8;                  *inst++ = JE_i8;
1214                  *inst++ = 3;                  *inst++ = 3;
1215                  *inst++ = REX_W | (reg_map[dst_r] >= 8 ? REX_R : 0) | (reg_map[TMP_REGISTER] >= 8 ? REX_B : 0);                  *inst++ = REX_W | (reg_map[dst_r] >= 8 ? REX_R : 0) | (reg_map[TMP_REG1] >= 8 ? REX_B : 0);
1216                  *inst++ = MOV_r_rm;                  *inst++ = MOV_r_rm;
1217                  *inst++ = MOD_REG | (reg_lmap[dst_r] << 3) | reg_lmap[TMP_REGISTER];                  *inst++ = MOD_REG | (reg_lmap[dst_r] << 3) | reg_lmap[TMP_REG1];
1218  #endif  #endif
1219          }          }
1220    
# Line 1271  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 1271  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
1271  #endif  #endif
1272    
1273                  if (op_flags & SLJIT_INT_OP) {                  if (op_flags & SLJIT_INT_OP) {
1274                          if (src <= TMP_REGISTER && src == dst) {                          if (FAST_IS_REG(src) && src == dst) {
1275                                  if (!TYPE_CAST_NEEDED(op))                                  if (!TYPE_CAST_NEEDED(op))
1276                                          return SLJIT_SUCCESS;                                          return SLJIT_SUCCESS;
1277                          }                          }
# Line 1322  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 1322  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
1322  #endif  #endif
1323                  }                  }
1324    
1325                  if (SLJIT_UNLIKELY(update) && (src & SLJIT_MEM) && !src_is_ereg && (src & 0xf) && (srcw != 0 || (src & 0xf0) != 0)) {                  if (SLJIT_UNLIKELY(update) && (src & SLJIT_MEM) && !src_is_ereg && (src & REG_MASK) && (srcw != 0 || (src & OFFS_REG_MASK) != 0)) {
1326                          inst = emit_x86_instruction(compiler, 1, src & 0xf, 0, src, srcw);                          inst = emit_x86_instruction(compiler, 1, src & REG_MASK, 0, src, srcw);
1327                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1328                          *inst = LEA_r_m;                          *inst = LEA_r_m;
1329                          src &= SLJIT_MEM | 0xf;                          src &= SLJIT_MEM | 0xf;
# Line 1333  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 1333  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
1333  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1334                  if (SLJIT_UNLIKELY(dst_is_ereg) && (!(op == SLJIT_MOV || op == SLJIT_MOV_UI || op == SLJIT_MOV_SI || op == SLJIT_MOV_P) || (src & SLJIT_MEM))) {                  if (SLJIT_UNLIKELY(dst_is_ereg) && (!(op == SLJIT_MOV || op == SLJIT_MOV_UI || op == SLJIT_MOV_SI || op == SLJIT_MOV_P) || (src & SLJIT_MEM))) {
1335                          SLJIT_ASSERT(dst == SLJIT_MEM1(SLJIT_LOCALS_REG));                          SLJIT_ASSERT(dst == SLJIT_MEM1(SLJIT_LOCALS_REG));
1336                          dst = TMP_REGISTER;                          dst = TMP_REG1;
1337                  }                  }
1338  #endif  #endif
1339    
# Line 1369  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 1369  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
1369                  }                  }
1370    
1371  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
1372                  if (SLJIT_UNLIKELY(dst_is_ereg) && dst == TMP_REGISTER)                  if (SLJIT_UNLIKELY(dst_is_ereg) && dst == TMP_REG1)
1373                          return emit_mov(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), dstw, TMP_REGISTER, 0);                          return emit_mov(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), dstw, TMP_REG1, 0);
1374  #endif  #endif
1375    
1376                  if (SLJIT_UNLIKELY(update) && (dst & SLJIT_MEM) && (dst & 0xf) && (dstw != 0 || (dst & 0xf0) != 0)) {                  if (SLJIT_UNLIKELY(update) && (dst & SLJIT_MEM) && (dst & REG_MASK) && (dstw != 0 || (dst & OFFS_REG_MASK) != 0)) {
1377                          inst = emit_x86_instruction(compiler, 1, dst & 0xf, 0, dst, dstw);                          inst = emit_x86_instruction(compiler, 1, dst & REG_MASK, 0, dst, dstw);
1378                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1379                          *inst = LEA_r_m;                          *inst = LEA_r_m;
1380                  }                  }
# Line 1447  static sljit_si emit_cum_binary(struct s Line 1447  static sljit_si emit_cum_binary(struct s
1447          sljit_ub* inst;          sljit_ub* inst;
1448    
1449          if (dst == SLJIT_UNUSED) {          if (dst == SLJIT_UNUSED) {
1450                  EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                  EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
1451                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1452                          BINARY_IMM(op_imm, op_mr, src2w, TMP_REGISTER, 0);                          BINARY_IMM(op_imm, op_mr, src2w, TMP_REG1, 0);
1453                  }                  }
1454                  else {                  else {
1455                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, src2, src2w);
1456                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1457                          *inst = op_rm;                          *inst = op_rm;
1458                  }                  }
# Line 1472  static sljit_si emit_cum_binary(struct s Line 1472  static sljit_si emit_cum_binary(struct s
1472                                  BINARY_IMM(op_imm, op_mr, src2w, dst, dstw);                                  BINARY_IMM(op_imm, op_mr, src2w, dst, dstw);
1473                          }                          }
1474                  }                  }
1475                  else if (dst <= TMP_REGISTER) {                  else if (FAST_IS_REG(dst)) {
1476                          inst = emit_x86_instruction(compiler, 1, dst, dstw, src2, src2w);                          inst = emit_x86_instruction(compiler, 1, dst, dstw, src2, src2w);
1477                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1478                          *inst = op_rm;                          *inst = op_rm;
1479                  }                  }
1480                  else if (src2 <= TMP_REGISTER) {                  else if (FAST_IS_REG(src2)) {
1481                          /* Special exception for sljit_emit_op_flags. */                          /* Special exception for sljit_emit_op_flags. */
1482                          inst = emit_x86_instruction(compiler, 1, src2, src2w, dst, dstw);                          inst = emit_x86_instruction(compiler, 1, src2, src2w, dst, dstw);
1483                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1484                          *inst = op_mr;                          *inst = op_mr;
1485                  }                  }
1486                  else {                  else {
1487                          EMIT_MOV(compiler, TMP_REGISTER, 0, src2, src2w);                          EMIT_MOV(compiler, TMP_REG1, 0, src2, src2w);
1488                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, dst, dstw);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, dst, dstw);
1489                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1490                          *inst = op_mr;                          *inst = op_mr;
1491                  }                  }
# Line 1506  static sljit_si emit_cum_binary(struct s Line 1506  static sljit_si emit_cum_binary(struct s
1506                                  BINARY_IMM(op_imm, op_mr, src1w, dst, dstw);                                  BINARY_IMM(op_imm, op_mr, src1w, dst, dstw);
1507                          }                          }
1508                  }                  }
1509                  else if (dst <= TMP_REGISTER) {                  else if (FAST_IS_REG(dst)) {
1510                          inst = emit_x86_instruction(compiler, 1, dst, dstw, src1, src1w);                          inst = emit_x86_instruction(compiler, 1, dst, dstw, src1, src1w);
1511                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1512                          *inst = op_rm;                          *inst = op_rm;
1513                  }                  }
1514                  else if (src1 <= TMP_REGISTER) {                  else if (FAST_IS_REG(src1)) {
1515                          inst = emit_x86_instruction(compiler, 1, src1, src1w, dst, dstw);                          inst = emit_x86_instruction(compiler, 1, src1, src1w, dst, dstw);
1516                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1517                          *inst = op_mr;                          *inst = op_mr;
1518                  }                  }
1519                  else {                  else {
1520                          EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                          EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
1521                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, dst, dstw);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, dst, dstw);
1522                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1523                          *inst = op_mr;                          *inst = op_mr;
1524                  }                  }
# Line 1526  static sljit_si emit_cum_binary(struct s Line 1526  static sljit_si emit_cum_binary(struct s
1526          }          }
1527    
1528          /* General version. */          /* General version. */
1529          if (dst <= TMP_REGISTER) {          if (FAST_IS_REG(dst)) {
1530                  EMIT_MOV(compiler, dst, 0, src1, src1w);                  EMIT_MOV(compiler, dst, 0, src1, src1w);
1531                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1532                          BINARY_IMM(op_imm, op_mr, src2w, dst, 0);                          BINARY_IMM(op_imm, op_mr, src2w, dst, 0);
# Line 1539  static sljit_si emit_cum_binary(struct s Line 1539  static sljit_si emit_cum_binary(struct s
1539          }          }
1540          else {          else {
1541                  /* This version requires less memory writing. */                  /* This version requires less memory writing. */
1542                  EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                  EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
1543                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1544                          BINARY_IMM(op_imm, op_mr, src2w, TMP_REGISTER, 0);                          BINARY_IMM(op_imm, op_mr, src2w, TMP_REG1, 0);
1545                  }                  }
1546                  else {                  else {
1547                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, src2, src2w);
1548                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1549                          *inst = op_rm;                          *inst = op_rm;
1550                  }                  }
1551                  EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);                  EMIT_MOV(compiler, dst, dstw, TMP_REG1, 0);
1552          }          }
1553    
1554          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
# Line 1563  static sljit_si emit_non_cum_binary(stru Line 1563  static sljit_si emit_non_cum_binary(stru
1563          sljit_ub* inst;          sljit_ub* inst;
1564    
1565          if (dst == SLJIT_UNUSED) {          if (dst == SLJIT_UNUSED) {
1566                  EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                  EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
1567                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1568                          BINARY_IMM(op_imm, op_mr, src2w, TMP_REGISTER, 0);                          BINARY_IMM(op_imm, op_mr, src2w, TMP_REG1, 0);
1569                  }                  }
1570                  else {                  else {
1571                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, src2, src2w);
1572                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1573                          *inst = op_rm;                          *inst = op_rm;
1574                  }                  }
# Line 1588  static sljit_si emit_non_cum_binary(stru Line 1588  static sljit_si emit_non_cum_binary(stru
1588                                  BINARY_IMM(op_imm, op_mr, src2w, dst, dstw);                                  BINARY_IMM(op_imm, op_mr, src2w, dst, dstw);
1589                          }                          }
1590                  }                  }
1591                  else if (dst <= TMP_REGISTER) {                  else if (FAST_IS_REG(dst)) {
1592                          inst = emit_x86_instruction(compiler, 1, dst, dstw, src2, src2w);                          inst = emit_x86_instruction(compiler, 1, dst, dstw, src2, src2w);
1593                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1594                          *inst = op_rm;                          *inst = op_rm;
1595                  }                  }
1596                  else if (src2 <= TMP_REGISTER) {                  else if (FAST_IS_REG(src2)) {
1597                          inst = emit_x86_instruction(compiler, 1, src2, src2w, dst, dstw);                          inst = emit_x86_instruction(compiler, 1, src2, src2w, dst, dstw);
1598                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1599                          *inst = op_mr;                          *inst = op_mr;
1600                  }                  }
1601                  else {                  else {
1602                          EMIT_MOV(compiler, TMP_REGISTER, 0, src2, src2w);                          EMIT_MOV(compiler, TMP_REG1, 0, src2, src2w);
1603                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, dst, dstw);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, dst, dstw);
1604                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1605                          *inst = op_mr;                          *inst = op_mr;
1606                  }                  }
# Line 1608  static sljit_si emit_non_cum_binary(stru Line 1608  static sljit_si emit_non_cum_binary(stru
1608          }          }
1609    
1610          /* General version. */          /* General version. */
1611          if (dst <= TMP_REGISTER && dst != src2) {          if (FAST_IS_REG(dst) && dst != src2) {
1612                  EMIT_MOV(compiler, dst, 0, src1, src1w);                  EMIT_MOV(compiler, dst, 0, src1, src1w);
1613                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1614                          BINARY_IMM(op_imm, op_mr, src2w, dst, 0);                          BINARY_IMM(op_imm, op_mr, src2w, dst, 0);
# Line 1621  static sljit_si emit_non_cum_binary(stru Line 1621  static sljit_si emit_non_cum_binary(stru
1621          }          }
1622          else {          else {
1623                  /* This version requires less memory writing. */                  /* This version requires less memory writing. */
1624                  EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                  EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
1625                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1626                          BINARY_IMM(op_imm, op_mr, src2w, TMP_REGISTER, 0);                          BINARY_IMM(op_imm, op_mr, src2w, TMP_REG1, 0);
1627                  }                  }
1628                  else {                  else {
1629                          inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);                          inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, src2, src2w);
1630                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1631                          *inst = op_rm;                          *inst = op_rm;
1632                  }                  }
1633                  EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);                  EMIT_MOV(compiler, dst, dstw, TMP_REG1, 0);
1634          }          }
1635    
1636          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
# Line 1644  static sljit_si emit_mul(struct sljit_co Line 1644  static sljit_si emit_mul(struct sljit_co
1644          sljit_ub* inst;          sljit_ub* inst;
1645          sljit_si dst_r;          sljit_si dst_r;
1646    
1647          dst_r = (dst <= TMP_REGISTER) ? dst : TMP_REGISTER;          dst_r = FAST_IS_REG(dst) ? dst : TMP_REG1;
1648    
1649          /* Register destination. */          /* Register destination. */
1650          if (dst_r == src1 && !(src2 & SLJIT_IMM)) {          if (dst_r == src1 && !(src2 & SLJIT_IMM)) {
# Line 1752  static sljit_si emit_mul(struct sljit_co Line 1752  static sljit_si emit_mul(struct sljit_co
1752          else {          else {
1753                  /* Neither argument is immediate. */                  /* Neither argument is immediate. */
1754                  if (ADDRESSING_DEPENDS_ON(src2, dst_r))                  if (ADDRESSING_DEPENDS_ON(src2, dst_r))
1755                          dst_r = TMP_REGISTER;                          dst_r = TMP_REG1;
1756                  EMIT_MOV(compiler, dst_r, 0, src1, src1w);                  EMIT_MOV(compiler, dst_r, 0, src1, src1w);
1757                  inst = emit_x86_instruction(compiler, 2, dst_r, 0, src2, src2w);                  inst = emit_x86_instruction(compiler, 2, dst_r, 0, src2, src2w);
1758                  FAIL_IF(!inst);                  FAIL_IF(!inst);
# Line 1760  static sljit_si emit_mul(struct sljit_co Line 1760  static sljit_si emit_mul(struct sljit_co
1760                  *inst = IMUL_r_rm;                  *inst = IMUL_r_rm;
1761          }          }
1762    
1763          if (dst_r == TMP_REGISTER)          if (dst_r == TMP_REG1)
1764                  EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);                  EMIT_MOV(compiler, dst, dstw, TMP_REG1, 0);
1765    
1766          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1767  }  }
# Line 1782  static sljit_si emit_lea_binary(struct s Line 1782  static sljit_si emit_lea_binary(struct s
1782                          return SLJIT_ERR_UNSUPPORTED;                          return SLJIT_ERR_UNSUPPORTED;
1783          }          }
1784    
1785          dst_r = (dst <= TMP_REGISTER) ? dst : TMP_REGISTER;          dst_r = FAST_IS_REG(dst) ? dst : TMP_REG1;
1786    
1787          if (src1 <= TMP_REGISTER) {          if (FAST_IS_REG(src1)) {
1788                  if (src2 <= TMP_REGISTER || src2 == TMP_REGISTER) {                  if (FAST_IS_REG(src2)) {
1789                          inst = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM2(src1, src2), 0);                          inst = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM2(src1, src2), 0);
1790                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1791                          *inst = LEA_r_m;                          *inst = LEA_r_m;
# Line 1803  static sljit_si emit_lea_binary(struct s Line 1803  static sljit_si emit_lea_binary(struct s
1803                          done = 1;                          done = 1;
1804                  }                  }
1805          }          }
1806          else if (src2 <= TMP_REGISTER) {          else if (FAST_IS_REG(src2)) {
1807  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1808                  if ((src1 & SLJIT_IMM) && (compiler->mode32 || IS_HALFWORD(src1w))) {                  if ((src1 & SLJIT_IMM) && (compiler->mode32 || IS_HALFWORD(src1w))) {
1809                          inst = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src2), (sljit_si)src1w);                          inst = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src2), (sljit_si)src1w);
# Line 1818  static sljit_si emit_lea_binary(struct s Line 1818  static sljit_si emit_lea_binary(struct s
1818          }          }
1819    
1820          if (done) {          if (done) {
1821                  if (dst_r == TMP_REGISTER)                  if (dst_r == TMP_REG1)
1822                          return emit_mov(compiler, dst, dstw, TMP_REGISTER, 0);                          return emit_mov(compiler, dst, dstw, TMP_REG1, 0);
1823                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1824          }          }
1825          return SLJIT_ERR_UNSUPPORTED;          return SLJIT_ERR_UNSUPPORTED;
# Line 1840  static sljit_si emit_cmp_binary(struct s Line 1840  static sljit_si emit_cmp_binary(struct s
1840                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1841          }          }
1842    
1843          if (src1 <= TMP_REGISTER) {          if (FAST_IS_REG(src1)) {
1844                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1845                          BINARY_IMM(CMP, CMP_rm_r, src2w, src1, 0);                          BINARY_IMM(CMP, CMP_rm_r, src2w, src1, 0);
1846                  }                  }
# Line 1852  static sljit_si emit_cmp_binary(struct s Line 1852  static sljit_si emit_cmp_binary(struct s
1852                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1853          }          }
1854    
1855          if (src2 <= TMP_REGISTER && !(src1 & SLJIT_IMM)) {          if (FAST_IS_REG(src2) && !(src1 & SLJIT_IMM)) {
1856                  inst = emit_x86_instruction(compiler, 1, src2, 0, src1, src1w);                  inst = emit_x86_instruction(compiler, 1, src2, 0, src1, src1w);
1857                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1858                  *inst = CMP_rm_r;                  *inst = CMP_rm_r;
# Line 1861  static sljit_si emit_cmp_binary(struct s Line 1861  static sljit_si emit_cmp_binary(struct s
1861    
1862          if (src2 & SLJIT_IMM) {          if (src2 & SLJIT_IMM) {
1863                  if (src1 & SLJIT_IMM) {                  if (src1 & SLJIT_IMM) {
1864                          EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                          EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
1865                          src1 = TMP_REGISTER;                          src1 = TMP_REG1;
1866                          src1w = 0;                          src1w = 0;
1867                  }                  }
1868                  BINARY_IMM(CMP, CMP_rm_r, src2w, src1, src1w);                  BINARY_IMM(CMP, CMP_rm_r, src2w, src1, src1w);
1869          }          }
1870          else {          else {
1871                  EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                  EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
1872                  inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);                  inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, src2, src2w);
1873                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1874                  *inst = CMP_r_rm;                  *inst = CMP_r_rm;
1875          }          }
# Line 1900  static sljit_si emit_test_binary(struct Line 1900  static sljit_si emit_test_binary(struct
1900                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1901          }          }
1902    
1903          if (src1 <= TMP_REGISTER) {          if (FAST_IS_REG(src1)) {
1904                  if (src2 & SLJIT_IMM) {                  if (src2 & SLJIT_IMM) {
1905  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1906                          if (IS_HALFWORD(src2w) || compiler->mode32) {                          if (IS_HALFWORD(src2w) || compiler->mode32) {
# Line 1928  static sljit_si emit_test_binary(struct Line 1928  static sljit_si emit_test_binary(struct
1928                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1929          }          }
1930    
1931          if (src2 <= TMP_REGISTER) {          if (FAST_IS_REG(src2)) {
1932                  if (src1 & SLJIT_IMM) {                  if (src1 & SLJIT_IMM) {
1933  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1934                          if (IS_HALFWORD(src1w) || compiler->mode32) {                          if (IS_HALFWORD(src1w) || compiler->mode32) {
# Line 1956  static sljit_si emit_test_binary(struct Line 1956  static sljit_si emit_test_binary(struct
1956                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
1957          }          }
1958    
1959          EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);          EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
1960          if (src2 & SLJIT_IMM) {          if (src2 & SLJIT_IMM) {
1961  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
1962                  if (IS_HALFWORD(src2w) || compiler->mode32) {                  if (IS_HALFWORD(src2w) || compiler->mode32) {
1963                          inst = emit_x86_instruction(compiler, 1, SLJIT_IMM, src2w, TMP_REGISTER, 0);                          inst = emit_x86_instruction(compiler, 1, SLJIT_IMM, src2w, TMP_REG1, 0);
1964                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1965                          *inst = GROUP_F7;                          *inst = GROUP_F7;
1966                  }                  }
1967                  else {                  else {
1968                          FAIL_IF(emit_load_imm64(compiler, TMP_REG2, src2w));                          FAIL_IF(emit_load_imm64(compiler, TMP_REG2, src2w));
1969                          inst = emit_x86_instruction(compiler, 1, TMP_REG2, 0, TMP_REGISTER, 0);                          inst = emit_x86_instruction(compiler, 1, TMP_REG2, 0, TMP_REG1, 0);
1970                          FAIL_IF(!inst);                          FAIL_IF(!inst);
1971                          *inst = TEST_rm_r;                          *inst = TEST_rm_r;
1972                  }                  }
1973  #else  #else
1974                  inst = emit_x86_instruction(compiler, 1, SLJIT_IMM, src2w, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1, SLJIT_IMM, src2w, TMP_REG1, 0);
1975                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1976                  *inst = GROUP_F7;                  *inst = GROUP_F7;
1977  #endif  #endif
1978          }          }
1979          else {          else {
1980                  inst = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);                  inst = emit_x86_instruction(compiler, 1, TMP_REG1, 0, src2, src2w);
1981                  FAIL_IF(!inst);                  FAIL_IF(!inst);
1982                  *inst = TEST_rm_r;                  *inst = TEST_rm_r;
1983          }          }
# Line 2000  static sljit_si emit_shift(struct sljit_ Line 2000  static sljit_si emit_shift(struct sljit_
2000                          return SLJIT_SUCCESS;                          return SLJIT_SUCCESS;
2001                  }                  }
2002                  if (dst == SLJIT_UNUSED) {                  if (dst == SLJIT_UNUSED) {
2003                          EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                          EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
2004                          inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, TMP_REGISTER, 0);                          inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, TMP_REG1, 0);
2005                          FAIL_IF(!inst);                          FAIL_IF(!inst);
2006                          *inst |= mode;                          *inst |= mode;
2007                          return SLJIT_SUCCESS;                          return SLJIT_SUCCESS;
2008                  }                  }
2009                  if (dst == SLJIT_PREF_SHIFT_REG && src2 == SLJIT_PREF_SHIFT_REG) {                  if (dst == SLJIT_PREF_SHIFT_REG && src2 == SLJIT_PREF_SHIFT_REG) {
2010                          EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                          EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
2011                          inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);                          inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REG1, 0);
2012                          FAIL_IF(!inst);                          FAIL_IF(!inst);
2013                          *inst |= mode;                          *inst |= mode;
2014                          EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);                          EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REG1, 0);
2015                          return SLJIT_SUCCESS;                          return SLJIT_SUCCESS;
2016                  }                  }
2017                  if (dst <= TMP_REGISTER) {                  if (FAST_IS_REG(dst)) {
2018                          EMIT_MOV(compiler, dst, 0, src1, src1w);                          EMIT_MOV(compiler, dst, 0, src1, src1w);
2019                          inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, dst, 0);                          inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, dst, 0);
2020                          FAIL_IF(!inst);                          FAIL_IF(!inst);
# Line 2022  static sljit_si emit_shift(struct sljit_ Line 2022  static sljit_si emit_shift(struct sljit_
2022                          return SLJIT_SUCCESS;                          return SLJIT_SUCCESS;
2023                  }                  }
2024    
2025                  EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                  EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
2026                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, TMP_REG1, 0);
2027                  FAIL_IF(!inst);                  FAIL_IF(!inst);
2028                  *inst |= mode;                  *inst |= mode;
2029                  EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);                  EMIT_MOV(compiler, dst, dstw, TMP_REG1, 0);
2030                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
2031          }          }
2032    
2033          if (dst == SLJIT_PREF_SHIFT_REG) {          if (dst == SLJIT_PREF_SHIFT_REG) {
2034                  EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                  EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
2035                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);
2036                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REG1, 0);
2037                  FAIL_IF(!inst);                  FAIL_IF(!inst);
2038                  *inst |= mode;                  *inst |= mode;
2039                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REG1, 0);
2040          }          }
2041          else if (dst <= TMP_REGISTER && dst != src2 && !ADDRESSING_DEPENDS_ON(src2, dst)) {          else if (FAST_IS_REG(dst) && dst != src2 && !ADDRESSING_DEPENDS_ON(src2, dst)) {
2042                  if (src1 != dst)                  if (src1 != dst)
2043                          EMIT_MOV(compiler, dst, 0, src1, src1w);                          EMIT_MOV(compiler, dst, 0, src1, src1w);
2044                  EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_PREF_SHIFT_REG, 0);                  EMIT_MOV(compiler, TMP_REG1, 0, SLJIT_PREF_SHIFT_REG, 0);
2045                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);
2046                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, dst, 0);                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, dst, 0);
2047                  FAIL_IF(!inst);                  FAIL_IF(!inst);
2048                  *inst |= mode;                  *inst |= mode;
2049                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REG1, 0);
2050          }          }
2051          else {          else {
2052                  /* This case is really difficult, since ecx itself may used for                  /* This case is really difficult, since ecx itself may used for
2053                     addressing, and we must ensure to work even in that case. */                     addressing, and we must ensure to work even in that case. */
2054                  EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);                  EMIT_MOV(compiler, TMP_REG1, 0, src1, src1w);
2055  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
2056                  EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_PREF_SHIFT_REG, 0);                  EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_PREF_SHIFT_REG, 0);
2057  #else  #else
# Line 2059  static sljit_si emit_shift(struct sljit_ Line 2059  static sljit_si emit_shift(struct sljit_
2059                  EMIT_MOV(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), sizeof(sljit_sw), SLJIT_PREF_SHIFT_REG, 0);                  EMIT_MOV(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), sizeof(sljit_sw), SLJIT_PREF_SHIFT_REG, 0);
2060  #endif  #endif
2061                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);
2062                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);                  inst = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REG1, 0);
2063                  FAIL_IF(!inst);                  FAIL_IF(!inst);
2064                  *inst |= mode;                  *inst |= mode;
2065  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
# Line 2067  static sljit_si emit_shift(struct sljit_ Line 2067  static sljit_si emit_shift(struct sljit_
2067  #else  #else
2068                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), sizeof(sljit_sw));                  EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), sizeof(sljit_sw));
2069  #endif  #endif
2070                  EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);                  EMIT_MOV(compiler, dst, dstw, TMP_REG1, 0);
2071          }          }
2072    
2073          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
# Line 2098  static sljit_si emit_shift_with_flags(st Line 2098  static sljit_si emit_shift_with_flags(st
2098          if (!set_flags)          if (!set_flags)
2099                  return emit_shift(compiler, mode, dst, dstw, src1, src1w, src2, src2w);                  return emit_shift(compiler, mode, dst, dstw, src1, src1w, src2, src2w);
2100    
2101          if (!(dst <= TMP_REGISTER))          if (!FAST_IS_REG(dst))
2102                  FAIL_IF(emit_cmp_binary(compiler, src1, src1w, SLJIT_IMM, 0));                  FAIL_IF(emit_cmp_binary(compiler, src1, src1w, SLJIT_IMM, 0));
2103    
2104          FAIL_IF(emit_shift(compiler,mode, dst, dstw, src1, src1w, src2, src2w));          FAIL_IF(emit_shift(compiler,mode, dst, dstw, src1, src1w, src2, src2w));
2105    
2106          if (dst <= TMP_REGISTER)          if (FAST_IS_REG(dst))
2107                  return emit_cmp_binary(compiler, dst, dstw, SLJIT_IMM, 0);                  return emit_cmp_binary(compiler, dst, dstw, SLJIT_IMM, 0);
2108          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
2109  }  }
# Line 2329  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2329  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2329    
2330          if (GET_OPCODE(op) == SLJIT_CMPD) {          if (GET_OPCODE(op) == SLJIT_CMPD) {
2331                  compiler->flags_saved = 0;                  compiler->flags_saved = 0;
2332                  if (dst <= SLJIT_FLOAT_REG6)                  if (FAST_IS_REG(dst))
2333                          dst_r = dst;                          dst_r = dst;
2334                  else {                  else {
2335                          dst_r = TMP_FREG;                          dst_r = TMP_FREG;
# Line 2339  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2339  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2339          }          }
2340    
2341          if (op == SLJIT_MOVD) {          if (op == SLJIT_MOVD) {
2342                  if (dst <= SLJIT_FLOAT_REG6)                  if (FAST_IS_REG(dst))
2343                          return emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst, src, srcw);                          return emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst, src, srcw);
2344                  if (src <= SLJIT_FLOAT_REG6)                  if (FAST_IS_REG(src))
2345                          return emit_sse2_store(compiler, op & SLJIT_SINGLE_OP, dst, dstw, src);                          return emit_sse2_store(compiler, op & SLJIT_SINGLE_OP, dst, dstw, src);
2346                  FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, TMP_FREG, src, srcw));                  FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, TMP_FREG, src, srcw));
2347                  return emit_sse2_store(compiler, op & SLJIT_SINGLE_OP, dst, dstw, TMP_FREG);                  return emit_sse2_store(compiler, op & SLJIT_SINGLE_OP, dst, dstw, TMP_FREG);
2348          }          }
2349    
2350          if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG6) {          if (SLOW_IS_REG(dst)) {
2351                  dst_r = dst;                  dst_r = dst;
2352                  if (dst != src)                  if (dst != src)
2353                          FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst_r, src, srcw));                          FAIL_IF(emit_sse2_load(compiler, op & SLJIT_SINGLE_OP, dst_r, src, srcw));
# Line 2386  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2386  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2386          compiler->mode32 = 1;          compiler->mode32 = 1;
2387  #endif  #endif
2388    
2389          if (dst <= SLJIT_FLOAT_REG6) {          if (FAST_IS_REG(dst)) {
2390                  dst_r = dst;                  dst_r = dst;
2391                  if (dst == src1)                  if (dst == src1)
2392                          ; /* Do nothing here. */                          ; /* Do nothing here. */
# Line 2548  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2548  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2548  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)  #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
2549  #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)  #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
2550                  if (src == SLJIT_SCRATCH_REG3) {                  if (src == SLJIT_SCRATCH_REG3) {
2551                          EMIT_MOV(compiler, TMP_REGISTER, 0, src, 0);                          EMIT_MOV(compiler, TMP_REG1, 0, src, 0);
2552                          src = TMP_REGISTER;                          src = TMP_REG1;
2553                  }                  }
2554                  if (src == SLJIT_MEM1(SLJIT_LOCALS_REG) && type >= SLJIT_CALL3)                  if (src == SLJIT_MEM1(SLJIT_LOCALS_REG) && type >= SLJIT_CALL3)
2555                          srcw += sizeof(sljit_sw);                          srcw += sizeof(sljit_sw);
# Line 2557  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2557  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2557  #endif  #endif
2558  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && defined(_WIN64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && defined(_WIN64)
2559                  if (src == SLJIT_SCRATCH_REG3) {                  if (src == SLJIT_SCRATCH_REG3) {
2560                          EMIT_MOV(compiler, TMP_REGISTER, 0, src, 0);                          EMIT_MOV(compiler, TMP_REG1, 0, src, 0);
2561                          src = TMP_REGISTER;                          src = TMP_REG1;
2562                  }                  }
2563  #endif  #endif
2564                  FAIL_IF(call_with_args(compiler, type));                  FAIL_IF(call_with_args(compiler, type));
# Line 2626  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2626  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2626          cond_set = get_jump_code(type) + 0x10;          cond_set = get_jump_code(type) + 0x10;
2627    
2628  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
2629          if (GET_OPCODE(op) == SLJIT_OR && !GET_ALL_FLAGS(op) && dst <= TMP_REGISTER && dst == src) {          if (GET_OPCODE(op) == SLJIT_OR && !GET_ALL_FLAGS(op) && FAST_IS_REG(dst) && dst == src) {
2630                  inst = (sljit_ub*)ensure_buf(compiler, 1 + 4 + 3);                  inst = (sljit_ub*)ensure_buf(compiler, 1 + 4 + 3);
2631                  FAIL_IF(!inst);                  FAIL_IF(!inst);
2632                  INC_SIZE(4 + 3);                  INC_SIZE(4 + 3);
2633                  /* Set low register to conditional flag. */                  /* Set low register to conditional flag. */
2634                  *inst++ = (reg_map[TMP_REGISTER] <= 7) ? REX : REX_B;                  *inst++ = (reg_map[TMP_REG1] <= 7) ? REX : REX_B;
2635                  *inst++ = GROUP_0F;                  *inst++ = GROUP_0F;
2636                  *inst++ = cond_set;                  *inst++ = cond_set;
2637                  *inst++ = MOD_REG | reg_lmap[TMP_REGISTER];                  *inst++ = MOD_REG | reg_lmap[TMP_REG1];
2638                  *inst++ = REX | (reg_map[TMP_REGISTER] <= 7 ? 0 : REX_R) | (reg_map[dst] <= 7 ? 0 : REX_B);                  *inst++ = REX | (reg_map[TMP_REG1] <= 7 ? 0 : REX_R) | (reg_map[dst] <= 7 ? 0 : REX_B);
2639                  *inst++ = OR_rm8_r8;                  *inst++ = OR_rm8_r8;
2640                  *inst++ = MOD_REG | (reg_lmap[TMP_REGISTER] << 3) | reg_lmap[dst];                  *inst++ = MOD_REG | (reg_lmap[TMP_REG1] << 3) | reg_lmap[dst];
2641                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
2642          }          }
2643    
2644          reg = (op == SLJIT_MOV && dst <= TMP_REGISTER) ? dst : TMP_REGISTER;          reg = (op == SLJIT_MOV && FAST_IS_REG(dst)) ? dst : TMP_REG1;
2645    
2646          inst = (sljit_ub*)ensure_buf(compiler, 1 + 4 + 4);          inst = (sljit_ub*)ensure_buf(compiler, 1 + 4 + 4);
2647          FAIL_IF(!inst);          FAIL_IF(!inst);
# Line 2656  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2656  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2656          *inst++ = MOVZX_r_rm8;          *inst++ = MOVZX_r_rm8;
2657          *inst = MOD_REG | (reg_lmap[reg] << 3) | reg_lmap[reg];          *inst = MOD_REG | (reg_lmap[reg] << 3) | reg_lmap[reg];
2658    
2659          if (reg != TMP_REGISTER)          if (reg != TMP_REG1)
2660                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
2661    
2662          if (GET_OPCODE(op) < SLJIT_ADD) {          if (GET_OPCODE(op) < SLJIT_ADD) {
2663                  compiler->mode32 = GET_OPCODE(op) != SLJIT_MOV;                  compiler->mode32 = GET_OPCODE(op) != SLJIT_MOV;
2664                  return emit_mov(compiler, dst, dstw, TMP_REGISTER, 0);                  return emit_mov(compiler, dst, dstw, TMP_REG1, 0);
2665          }          }
2666  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
2667          compiler->skip_checks = 1;          compiler->skip_checks = 1;
2668  #endif  #endif
2669          return sljit_emit_op2(compiler, op, dst, dstw, dst, dstw, TMP_REGISTER, 0);          return sljit_emit_op2(compiler, op, dst, dstw, dst, dstw, TMP_REG1, 0);
2670  #else /* SLJIT_CONFIG_X86_64 */  #else /* SLJIT_CONFIG_X86_64 */
2671          if (GET_OPCODE(op) < SLJIT_ADD && dst <= TMP_REGISTER) {          if (GET_OPCODE(op) < SLJIT_ADD && FAST_IS_REG(dst)) {
2672                  if (reg_map[dst] <= 4) {                  if (reg_map[dst] <= 4) {
2673                          /* Low byte is accessible. */                          /* Low byte is accessible. */
2674                          inst = (sljit_ub*)ensure_buf(compiler, 1 + 3 + 3);                          inst = (sljit_ub*)ensure_buf(compiler, 1 + 3 + 3);
# Line 2690  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2690  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2690                          get_cpu_features();                          get_cpu_features();
2691    
2692                  if (cpu_has_cmov) {                  if (cpu_has_cmov) {
2693                          EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_IMM, 1);                          EMIT_MOV(compiler, TMP_REG1, 0, SLJIT_IMM, 1);
2694                          /* a xor reg, reg operation would overwrite the flags. */                          /* a xor reg, reg operation would overwrite the flags. */
2695                          EMIT_MOV(compiler, dst, 0, SLJIT_IMM, 0);                          EMIT_MOV(compiler, dst, 0, SLJIT_IMM, 0);
2696    
# Line 2701  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2701  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2701                          *inst++ = GROUP_0F;                          *inst++ = GROUP_0F;
2702                          /* cmovcc = setcc - 0x50. */                          /* cmovcc = setcc - 0x50. */
2703                          *inst++ = cond_set - 0x50;                          *inst++ = cond_set - 0x50;
2704                          *inst++ = MOD_REG | (reg_map[dst] << 3) | reg_map[TMP_REGISTER];                          *inst++ = MOD_REG | (reg_map[dst] << 3) | reg_map[TMP_REG1];
2705                          return SLJIT_SUCCESS;                          return SLJIT_SUCCESS;
2706                  }                  }
2707    
2708                  inst = (sljit_ub*)ensure_buf(compiler, 1 + 1 + 3 + 3 + 1);                  inst = (sljit_ub*)ensure_buf(compiler, 1 + 1 + 3 + 3 + 1);
2709                  FAIL_IF(!inst);                  FAIL_IF(!inst);
2710                  INC_SIZE(1 + 3 + 3 + 1);                  INC_SIZE(1 + 3 + 3 + 1);
2711                  *inst++ = XCHG_EAX_r + reg_map[TMP_REGISTER];                  *inst++ = XCHG_EAX_r + reg_map[TMP_REG1];
2712                  /* Set al to conditional flag. */                  /* Set al to conditional flag. */
2713                  *inst++ = GROUP_0F;                  *inst++ = GROUP_0F;
2714                  *inst++ = cond_set;                  *inst++ = cond_set;
# Line 2717  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2717  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2717                  *inst++ = GROUP_0F;                  *inst++ = GROUP_0F;
2718                  *inst++ = MOVZX_r_rm8;                  *inst++ = MOVZX_r_rm8;
2719                  *inst++ = MOD_REG | (reg_map[dst] << 3) | 0 /* eax */;                  *inst++ = MOD_REG | (reg_map[dst] << 3) | 0 /* eax */;
2720                  *inst++ = XCHG_EAX_r + reg_map[TMP_REGISTER];                  *inst++ = XCHG_EAX_r + reg_map[TMP_REG1];
2721                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
2722          }          }
2723    
2724          if (GET_OPCODE(op) == SLJIT_OR && !GET_ALL_FLAGS(op) && dst <= TMP_REGISTER && dst == src && reg_map[dst] <= 4) {          if (GET_OPCODE(op) == SLJIT_OR && !GET_ALL_FLAGS(op) && FAST_IS_REG(dst) && dst == src && reg_map[dst] <= 4) {
2725                  SLJIT_COMPILE_ASSERT(reg_map[SLJIT_SCRATCH_REG1] == 0, scratch_reg1_must_be_eax);                  SLJIT_COMPILE_ASSERT(reg_map[SLJIT_SCRATCH_REG1] == 0, scratch_reg1_must_be_eax);
2726                  if (dst != SLJIT_SCRATCH_REG1) {                  if (dst != SLJIT_SCRATCH_REG1) {
2727                          inst = (sljit_ub*)ensure_buf(compiler, 1 + 1 + 3 + 2 + 1);                          inst = (sljit_ub*)ensure_buf(compiler, 1 + 1 + 3 + 2 + 1);
2728                          FAIL_IF(!inst);                          FAIL_IF(!inst);
2729                          INC_SIZE(1 + 3 + 2 + 1);                          INC_SIZE(1 + 3 + 2 + 1);
2730                          /* Set low register to conditional flag. */                          /* Set low register to conditional flag. */
2731                          *inst++ = XCHG_EAX_r + reg_map[TMP_REGISTER];                          *inst++ = XCHG_EAX_r + reg_map[TMP_REG1];
2732                          *inst++ = GROUP_0F;                          *inst++ = GROUP_0F;
2733                          *inst++ = cond_set;                          *inst++ = cond_set;
2734                          *inst++ = MOD_REG | 0 /* eax */;                          *inst++ = MOD_REG | 0 /* eax */;
2735                          *inst++ = OR_rm8_r8;                          *inst++ = OR_rm8_r8;
2736                          *inst++ = MOD_REG | (0 /* eax */ << 3) | reg_map[dst];                          *inst++ = MOD_REG | (0 /* eax */ << 3) | reg_map[dst];
2737                          *inst++ = XCHG_EAX_r + reg_map[TMP_REGISTER];                          *inst++ = XCHG_EAX_r + reg_map[TMP_REG1];
2738                  }                  }
2739                  else {                  else {
2740                          inst = (sljit_ub*)ensure_buf(compiler, 1 + 2 + 3 + 2 + 2);                          inst = (sljit_ub*)ensure_buf(compiler, 1 + 2 + 3 + 2 + 2);
# Line 2742  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2742  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2742                          INC_SIZE(2 + 3 + 2 + 2);                          INC_SIZE(2 + 3 + 2 + 2);
2743                          /* Set low register to conditional flag. */                          /* Set low register to conditional flag. */
2744                          *inst++ = XCHG_r_rm;                          *inst++ = XCHG_r_rm;
2745                          *inst++ = MOD_REG | (1 /* ecx */ << 3) | reg_map[TMP_REGISTER];                          *inst++ = MOD_REG | (1 /* ecx */ << 3) | reg_map[TMP_REG1];
2746                          *inst++ = GROUP_0F;                          *inst++ = GROUP_0F;
2747                          *inst++ = cond_set;                          *inst++ = cond_set;
2748                          *inst++ = MOD_REG | 1 /* ecx */;                          *inst++ = MOD_REG | 1 /* ecx */;
2749                          *inst++ = OR_rm8_r8;                          *inst++ = OR_rm8_r8;
2750                          *inst++ = MOD_REG | (1 /* ecx */ << 3) | 0 /* eax */;                          *inst++ = MOD_REG | (1 /* ecx */ << 3) | 0 /* eax */;
2751                          *inst++ = XCHG_r_rm;                          *inst++ = XCHG_r_rm;
2752                          *inst++ = MOD_REG | (1 /* ecx */ << 3) | reg_map[TMP_REGISTER];                          *inst++ = MOD_REG | (1 /* ecx */ << 3) | reg_map[TMP_REG1];
2753                  }                  }
2754                  return SLJIT_SUCCESS;                  return SLJIT_SUCCESS;
2755          }          }
2756    
2757          /* Set TMP_REGISTER to the bit. */          /* Set TMP_REG1 to the bit. */
2758          inst = (sljit_ub*)ensure_buf(compiler, 1 + 1 + 3 + 3 + 1);          inst = (sljit_ub*)ensure_buf(compiler, 1 + 1 + 3 + 3 + 1);
2759          FAIL_IF(!inst);          FAIL_IF(!inst);
2760          INC_SIZE(1 + 3 + 3 + 1);          INC_SIZE(1 + 3 + 3 + 1);
2761          *inst++ = XCHG_EAX_r + reg_map[TMP_REGISTER];          *inst++ = XCHG_EAX_r + reg_map[TMP_REG1];
2762          /* Set al to conditional flag. */          /* Set al to conditional flag. */
2763          *inst++ = GROUP_0F;          *inst++ = GROUP_0F;
2764          *inst++ = cond_set;          *inst++ = cond_set;
# Line 2768  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2768  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2768          *inst++ = MOVZX_r_rm8;          *inst++ = MOVZX_r_rm8;
2769          *inst++ = MOD_REG | (0 << 3) /* eax */ | 0 /* eax */;          *inst++ = MOD_REG | (0 << 3) /* eax */ | 0 /* eax */;
2770    
2771          *inst++ = XCHG_EAX_r + reg_map[TMP_REGISTER];          *inst++ = XCHG_EAX_r + reg_map[TMP_REG1];
2772    
2773          if (GET_OPCODE(op) < SLJIT_ADD)          if (GET_OPCODE(op) < SLJIT_ADD)
2774                  return emit_mov(compiler, dst, dstw, TMP_REGISTER, 0);                  return emit_mov(compiler, dst, dstw, TMP_REG1, 0);
2775    
2776  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
2777          compiler->skip_checks = 1;          compiler->skip_checks = 1;
2778  #endif  #endif
2779          return sljit_emit_op2(compiler, op, dst_save, dstw_save, dst_save, dstw_save, TMP_REGISTER, 0);          return sljit_emit_op2(compiler, op, dst_save, dstw_save, dst_save, dstw_save, TMP_REG1, 0);
2780  #endif /* SLJIT_CONFIG_X86_64 */  #endif /* SLJIT_CONFIG_X86_64 */
2781  }  }
2782    
# Line 2796  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_ Line 2796  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_
2796    
2797  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
2798          if (NOT_HALFWORD(offset)) {          if (NOT_HALFWORD(offset)) {
2799                  FAIL_IF(emit_load_imm64(compiler, TMP_REGISTER, offset));                  FAIL_IF(emit_load_imm64(compiler, TMP_REG1, offset));
2800  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)  #if (defined SLJIT_DEBUG && SLJIT_DEBUG)
2801                  SLJIT_ASSERT(emit_lea_binary(compiler, SLJIT_KEEP_FLAGS, dst, dstw, SLJIT_LOCALS_REG, 0, TMP_REGISTER, 0) != SLJIT_ERR_UNSUPPORTED);                  SLJIT_ASSERT(emit_lea_binary(compiler, SLJIT_KEEP_FLAGS, dst, dstw, SLJIT_LOCALS_REG, 0, TMP_REG1, 0) != SLJIT_ERR_UNSUPPORTED);
2802                  return compiler->error;                  return compiler->error;
2803  #else  #else
2804                  return emit_lea_binary(compiler, SLJIT_KEEP_FLAGS, dst, dstw, SLJIT_LOCALS_REG, 0, TMP_REGISTER, 0);                  return emit_lea_binary(compiler, SLJIT_KEEP_FLAGS, dst, dstw, SLJIT_LOCALS_REG, 0, TMP_REG1, 0);
2805  #endif  #endif
2806          }          }
2807  #endif  #endif
# Line 2831  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co Line 2831  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co
2831    
2832  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
2833          compiler->mode32 = 0;          compiler->mode32 = 0;
2834          reg = (dst <= TMP_REGISTER) ? dst : TMP_REGISTER;          reg = SLOW_IS_REG(dst) ? dst : TMP_REG1;
2835    
2836          if (emit_load_imm64(compiler, reg, init_value))          if (emit_load_imm64(compiler, reg, init_value))
2837                  return NULL;                  return NULL;
2838  #else  #else
2839          if (dst == SLJIT_UNUSED)          if (dst == SLJIT_UNUSED)
2840                  dst = TMP_REGISTER;                  dst = TMP_REG1;
2841    
2842          if (emit_mov(compiler, dst, dstw, SLJIT_IMM, init_value))          if (emit_mov(compiler, dst, dstw, SLJIT_IMM, init_value))
2843                  return NULL;                  return NULL;
# Line 2850  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co Line 2850  SLJIT_API_FUNC_ATTRIBUTE struct sljit_co
2850          *inst++ = 1;          *inst++ = 1;
2851    
2852  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)  #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
2853          if (reg == TMP_REGISTER && dst != SLJIT_UNUSED)          if (dst & SLJIT_MEM)
2854                  if (emit_mov(compiler, dst, dstw, TMP_REGISTER, 0))                  if (emit_mov(compiler, dst, dstw, TMP_REG1, 0))
2855                          return NULL;                          return NULL;
2856  #endif  #endif
2857    

Legend:
Removed from v.1452  
changed lines
  Added in v.1453

  ViewVC Help
Powered by ViewVC 1.1.5