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

Diff of /code/trunk/sljit/sljitNativeMIPS_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 60  typedef sljit_ui sljit_ins; Line 60  typedef sljit_ui sljit_ins;
60  #define GREATER_FLAG    13  #define GREATER_FLAG    13
61  #define OVERFLOW_FLAG   14  #define OVERFLOW_FLAG   14
62    
63  #define TMP_FREG1       ((SLJIT_FLOAT_REG4 + 1) << 1)  #define TMP_FREG1       (0)
64  #define TMP_FREG2       ((SLJIT_FLOAT_REG4 + 2) << 1)  #define TMP_FREG2       ((SLJIT_FLOAT_REG6 + 1) << 1)
65    
66  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 4] = {  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 4] = {
67          0, 2, 5, 6, 3, 8, 16, 17, 18, 19, 20, 29, 4, 25, 9          0, 2, 5, 6, 3, 8, 16, 17, 18, 19, 20, 29, 4, 25, 9
# Line 87  static SLJIT_CONST sljit_ub reg_map[SLJI Line 87  static SLJIT_CONST sljit_ub reg_map[SLJI
87  #define DR(dr)          (reg_map[dr])  #define DR(dr)          (reg_map[dr])
88  #define HI(opcode)      ((opcode) << 26)  #define HI(opcode)      ((opcode) << 26)
89  #define LO(opcode)      (opcode)  #define LO(opcode)      (opcode)
90  #define FMT_D           (17 << 21)  /* S = (16 << 21) D = (17 << 21) */
91    #define FMT_SD          (16 << 21)
92    
93  #define ABS_D           (HI(17) | FMT_D | LO(5))  #define ABS_fmt         (HI(17) | FMT_SD | LO(5))
94  #define ADD_D           (HI(17) | FMT_D | LO(0))  #define ADD_fmt         (HI(17) | FMT_SD | LO(0))
95  #define ADDU            (HI(0) | LO(33))  #define ADDU            (HI(0) | LO(33))
96  #define ADDIU           (HI(9))  #define ADDIU           (HI(9))
97  #define AND             (HI(0) | LO(36))  #define AND             (HI(0) | LO(36))
# Line 106  static SLJIT_CONST sljit_ub reg_map[SLJI Line 107  static SLJIT_CONST sljit_ub reg_map[SLJI
107  #define BLTZ            (HI(1) | (0 << 16))  #define BLTZ            (HI(1) | (0 << 16))
108  #define BNE             (HI(5))  #define BNE             (HI(5))
109  #define BREAK           (HI(0) | LO(13))  #define BREAK           (HI(0) | LO(13))
110  #define C_UN_D          (HI(17) | FMT_D | LO(49))  #define CFC1            (HI(17) | (2 << 21))
111  #define C_UEQ_D         (HI(17) | FMT_D | LO(51))  #define C_UN_fmt        (HI(17) | FMT_SD | LO(49))
112  #define C_ULE_D         (HI(17) | FMT_D | LO(55))  #define C_UEQ_fmt       (HI(17) | FMT_SD | LO(51))
113  #define C_ULT_D         (HI(17) | FMT_D | LO(53))  #define C_ULE_fmt       (HI(17) | FMT_SD | LO(55))
114    #define C_ULT_fmt       (HI(17) | FMT_SD | LO(53))
115  #define DIV             (HI(0) | LO(26))  #define DIV             (HI(0) | LO(26))
116  #define DIVU            (HI(0) | LO(27))  #define DIVU            (HI(0) | LO(27))
117  #define DIV_D           (HI(17) | FMT_D | LO(3))  #define DIV_fmt         (HI(17) | FMT_SD | LO(3))
118  #define J               (HI(2))  #define J               (HI(2))
119  #define JAL             (HI(3))  #define JAL             (HI(3))
120  #define JALR            (HI(0) | LO(9))  #define JALR            (HI(0) | LO(9))
# Line 120  static SLJIT_CONST sljit_ub reg_map[SLJI Line 122  static SLJIT_CONST sljit_ub reg_map[SLJI
122  #define LD              (HI(55))  #define LD              (HI(55))
123  #define LUI             (HI(15))  #define LUI             (HI(15))
124  #define LW              (HI(35))  #define LW              (HI(35))
 #define NEG_D           (HI(17) | FMT_D | LO(7))  
125  #define MFHI            (HI(0) | LO(16))  #define MFHI            (HI(0) | LO(16))
126  #define MFLO            (HI(0) | LO(18))  #define MFLO            (HI(0) | LO(18))
127  #define MOV_D           (HI(17) | FMT_D | LO(6))  #define MOV_fmt         (HI(17) | FMT_SD | LO(6))
 #define CFC1            (HI(17) | (2 << 21))  
128  #define MOVN            (HI(0) | LO(11))  #define MOVN            (HI(0) | LO(11))
129  #define MOVZ            (HI(0) | LO(10))  #define MOVZ            (HI(0) | LO(10))
130  #define MUL_D           (HI(17) | FMT_D | LO(2))  #define MUL_fmt         (HI(17) | FMT_SD | LO(2))
131  #define MULT            (HI(0) | LO(24))  #define MULT            (HI(0) | LO(24))
132  #define MULTU           (HI(0) | LO(25))  #define MULTU           (HI(0) | LO(25))
133    #define NEG_fmt         (HI(17) | FMT_SD | LO(7))
134  #define NOP             (HI(0) | LO(0))  #define NOP             (HI(0) | LO(0))
135  #define NOR             (HI(0) | LO(39))  #define NOR             (HI(0) | LO(39))
136  #define OR              (HI(0) | LO(37))  #define OR              (HI(0) | LO(37))
# Line 145  static SLJIT_CONST sljit_ub reg_map[SLJI Line 146  static SLJIT_CONST sljit_ub reg_map[SLJI
146  #define SRLV            (HI(0) | LO(6))  #define SRLV            (HI(0) | LO(6))
147  #define SRA             (HI(0) | LO(3))  #define SRA             (HI(0) | LO(3))
148  #define SRAV            (HI(0) | LO(7))  #define SRAV            (HI(0) | LO(7))
149  #define SUB_D           (HI(17) | FMT_D | LO(1))  #define SUB_fmt         (HI(17) | FMT_SD | LO(1))
150  #define SUBU            (HI(0) | LO(35))  #define SUBU            (HI(0) | LO(35))
151  #define SW              (HI(43))  #define SW              (HI(43))
152  #define XOR             (HI(0) | LO(38))  #define XOR             (HI(0) | LO(38))
# Line 176  static SLJIT_CONST sljit_ub reg_map[SLJI Line 177  static SLJIT_CONST sljit_ub reg_map[SLJI
177    
178  /* dest_reg is the absolute name of the register  /* dest_reg is the absolute name of the register
179     Useful for reordering instructions in the delay slot. */     Useful for reordering instructions in the delay slot. */
180  static int push_inst(struct sljit_compiler *compiler, sljit_ins ins, int delay_slot)  static sljit_si push_inst(struct sljit_compiler *compiler, sljit_ins ins, sljit_si delay_slot)
181  {  {
182          SLJIT_ASSERT(delay_slot == MOVABLE_INS || delay_slot >= UNMOVABLE_INS          SLJIT_ASSERT(delay_slot == MOVABLE_INS || delay_slot >= UNMOVABLE_INS
183                  || delay_slot == ((ins >> 11) & 0x1f) || delay_slot == ((ins >> 16) & 0x1f));                  || delay_slot == ((ins >> 11) & 0x1f) || delay_slot == ((ins >> 16) & 0x1f));
# Line 188  static int push_inst(struct sljit_compil Line 189  static int push_inst(struct sljit_compil
189          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
190  }  }
191    
192  static SLJIT_INLINE sljit_ins invert_branch(int flags)  static SLJIT_INLINE sljit_ins invert_branch(sljit_si flags)
193  {  {
194          return (flags & IS_BIT26_COND) ? (1 << 26) : (1 << 16);          return (flags & IS_BIT26_COND) ? (1 << 26) : (1 << 16);
195  }  }
196    
197  static SLJIT_INLINE sljit_ins* optimize_jump(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code)  static SLJIT_INLINE sljit_ins* optimize_jump(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code)
198  {  {
199          sljit_w diff;          sljit_sw diff;
200          sljit_uw target_addr;          sljit_uw target_addr;
201          sljit_ins *inst;          sljit_ins *inst;
202          sljit_ins saved_inst;          sljit_ins saved_inst;
# Line 215  static SLJIT_INLINE sljit_ins* optimize_ Line 216  static SLJIT_INLINE sljit_ins* optimize_
216    
217          /* B instructions. */          /* B instructions. */
218          if (jump->flags & IS_MOVABLE) {          if (jump->flags & IS_MOVABLE) {
219                  diff = ((sljit_w)target_addr - (sljit_w)(inst)) >> 2;                  diff = ((sljit_sw)target_addr - (sljit_sw)(inst)) >> 2;
220                  if (diff <= SIMM_MAX && diff >= SIMM_MIN) {                  if (diff <= SIMM_MAX && diff >= SIMM_MIN) {
221                          jump->flags |= PATCH_B;                          jump->flags |= PATCH_B;
222    
# Line 233  static SLJIT_INLINE sljit_ins* optimize_ Line 234  static SLJIT_INLINE sljit_ins* optimize_
234                  }                  }
235          }          }
236    
237          diff = ((sljit_w)target_addr - (sljit_w)(inst + 1)) >> 2;          diff = ((sljit_sw)target_addr - (sljit_sw)(inst + 1)) >> 2;
238          if (diff <= SIMM_MAX && diff >= SIMM_MIN) {          if (diff <= SIMM_MAX && diff >= SIMM_MIN) {
239                  jump->flags |= PATCH_B;                  jump->flags |= PATCH_B;
240    
# Line 361  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 362  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
362          SLJIT_ASSERT(!label);          SLJIT_ASSERT(!label);
363          SLJIT_ASSERT(!jump);          SLJIT_ASSERT(!jump);
364          SLJIT_ASSERT(!const_);          SLJIT_ASSERT(!const_);
365          SLJIT_ASSERT(code_ptr - code <= (int)compiler->size);          SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size);
366    
367          jump = compiler->jumps;          jump = compiler->jumps;
368          while (jump) {          while (jump) {
# Line 370  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 371  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
371                          buf_ptr = (sljit_ins*)jump->addr;                          buf_ptr = (sljit_ins*)jump->addr;
372    
373                          if (jump->flags & PATCH_B) {                          if (jump->flags & PATCH_B) {
374                                  addr = (sljit_w)(addr - (jump->addr + sizeof(sljit_ins))) >> 2;                                  addr = (sljit_sw)(addr - (jump->addr + sizeof(sljit_ins))) >> 2;
375                                  SLJIT_ASSERT((sljit_w)addr <= SIMM_MAX && (sljit_w)addr >= SIMM_MIN);                                  SLJIT_ASSERT((sljit_sw)addr <= SIMM_MAX && (sljit_sw)addr >= SIMM_MIN);
376                                  buf_ptr[0] = (buf_ptr[0] & 0xffff0000) | (addr & 0xffff);                                  buf_ptr[0] = (buf_ptr[0] & 0xffff0000) | (addr & 0xffff);
377                                  break;                                  break;
378                          }                          }
# Line 453  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 454  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
454  #include "sljitNativeMIPS_64.c"  #include "sljitNativeMIPS_64.c"
455  #endif  #endif
456    
457  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_enter(struct sljit_compiler *compiler, sljit_si args, sljit_si temporaries, sljit_si saveds, sljit_si local_size)
458  {  {
459          sljit_ins base;          sljit_ins base;
460    
# Line 466  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 467  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
467          compiler->logical_local_size = local_size;          compiler->logical_local_size = local_size;
468  #endif  #endif
469    
470          local_size += (saveds + 1 + 4) * sizeof(sljit_w);          local_size += (saveds + 1 + 4) * sizeof(sljit_sw);
471          local_size = (local_size + 15) & ~0xf;          local_size = (local_size + 15) & ~0xf;
472          compiler->local_size = local_size;          compiler->local_size = local_size;
473    
# Line 483  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 484  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
484                  local_size = 0;                  local_size = 0;
485          }          }
486    
487          FAIL_IF(push_inst(compiler, STACK_STORE | base | TA(RETURN_ADDR_REG) | IMM(local_size - 1 * (int)sizeof(sljit_w)), MOVABLE_INS));          FAIL_IF(push_inst(compiler, STACK_STORE | base | TA(RETURN_ADDR_REG) | IMM(local_size - 1 * (sljit_si)sizeof(sljit_sw)), MOVABLE_INS));
488          if (saveds >= 1)          if (saveds >= 1)
489                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG1) | IMM(local_size - 2 * (int)sizeof(sljit_w)), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG1) | IMM(local_size - 2 * (sljit_si)sizeof(sljit_sw)), MOVABLE_INS));
490          if (saveds >= 2)          if (saveds >= 2)
491                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG2) | IMM(local_size - 3 * (int)sizeof(sljit_w)), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG2) | IMM(local_size - 3 * (sljit_si)sizeof(sljit_sw)), MOVABLE_INS));
492          if (saveds >= 3)          if (saveds >= 3)
493                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG3) | IMM(local_size - 4 * (int)sizeof(sljit_w)), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_REG3) | IMM(local_size - 4 * (sljit_si)sizeof(sljit_sw)), MOVABLE_INS));
494          if (saveds >= 4)          if (saveds >= 4)
495                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_EREG1) | IMM(local_size - 5 * (int)sizeof(sljit_w)), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_EREG1) | IMM(local_size - 5 * (sljit_si)sizeof(sljit_sw)), MOVABLE_INS));
496          if (saveds >= 5)          if (saveds >= 5)
497                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_EREG2) | IMM(local_size - 6 * (int)sizeof(sljit_w)), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, STACK_STORE | base | T(SLJIT_SAVED_EREG2) | IMM(local_size - 6 * (sljit_si)sizeof(sljit_sw)), MOVABLE_INS));
498    
499          if (args >= 1)          if (args >= 1)
500                  FAIL_IF(push_inst(compiler, ADDU_W | SA(4) | TA(0) | D(SLJIT_SAVED_REG1), DR(SLJIT_SAVED_REG1)));                  FAIL_IF(push_inst(compiler, ADDU_W | SA(4) | TA(0) | D(SLJIT_SAVED_REG1), DR(SLJIT_SAVED_REG1)));
# Line 505  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 506  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
506          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
507  }  }
508    
509  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, int args, int temporaries, int saveds, int local_size)  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_context(struct sljit_compiler *compiler, sljit_si args, sljit_si temporaries, sljit_si saveds, sljit_si local_size)
510  {  {
511          CHECK_ERROR_VOID();          CHECK_ERROR_VOID();
512          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);
# Line 516  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_ Line 517  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_
517          compiler->logical_local_size = local_size;          compiler->logical_local_size = local_size;
518  #endif  #endif
519    
520          local_size += (saveds + 1 + 4) * sizeof(sljit_w);          local_size += (saveds + 1 + 4) * sizeof(sljit_sw);
521          compiler->local_size = (local_size + 15) & ~0xf;          compiler->local_size = (local_size + 15) & ~0xf;
522  }  }
523    
524  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int op, int src, sljit_w srcw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_return(struct sljit_compiler *compiler, sljit_si op, sljit_si src, sljit_sw srcw)
525  {  {
526          int local_size;          sljit_si local_size;
527          sljit_ins base;          sljit_ins base;
528    
529          CHECK_ERROR();          CHECK_ERROR();
# Line 540  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 541  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
541                  local_size = 0;                  local_size = 0;
542          }          }
543    
544          FAIL_IF(push_inst(compiler, STACK_LOAD | base | TA(RETURN_ADDR_REG) | IMM(local_size - 1 * (int)sizeof(sljit_w)), RETURN_ADDR_REG));          FAIL_IF(push_inst(compiler, STACK_LOAD | base | TA(RETURN_ADDR_REG) | IMM(local_size - 1 * (sljit_si)sizeof(sljit_sw)), RETURN_ADDR_REG));
545          if (compiler->saveds >= 5)          if (compiler->saveds >= 5)
546                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_EREG2) | IMM(local_size - 6 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_EREG2)));                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_EREG2) | IMM(local_size - 6 * (sljit_si)sizeof(sljit_sw)), DR(SLJIT_SAVED_EREG2)));
547          if (compiler->saveds >= 4)          if (compiler->saveds >= 4)
548                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_EREG1) | IMM(local_size - 5 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_EREG1)));                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_EREG1) | IMM(local_size - 5 * (sljit_si)sizeof(sljit_sw)), DR(SLJIT_SAVED_EREG1)));
549          if (compiler->saveds >= 3)          if (compiler->saveds >= 3)
550                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG3) | IMM(local_size - 4 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG3)));                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG3) | IMM(local_size - 4 * (sljit_si)sizeof(sljit_sw)), DR(SLJIT_SAVED_REG3)));
551          if (compiler->saveds >= 2)          if (compiler->saveds >= 2)
552                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG2) | IMM(local_size - 3 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG2)));                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG2) | IMM(local_size - 3 * (sljit_si)sizeof(sljit_sw)), DR(SLJIT_SAVED_REG2)));
553          if (compiler->saveds >= 1)          if (compiler->saveds >= 1)
554                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG1) | IMM(local_size - 2 * (int)sizeof(sljit_w)), DR(SLJIT_SAVED_REG1)));                  FAIL_IF(push_inst(compiler, STACK_LOAD | base | T(SLJIT_SAVED_REG1) | IMM(local_size - 2 * (sljit_si)sizeof(sljit_sw)), DR(SLJIT_SAVED_REG1)));
555    
556          FAIL_IF(push_inst(compiler, JR | SA(RETURN_ADDR_REG), UNMOVABLE_INS));          FAIL_IF(push_inst(compiler, JR | SA(RETURN_ADDR_REG), UNMOVABLE_INS));
557          if (compiler->local_size <= SIMM_MAX)          if (compiler->local_size <= SIMM_MAX)
# Line 572  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 573  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
573  #define ARCH_32_64(a, b)        b  #define ARCH_32_64(a, b)        b
574  #endif  #endif
575    
576  static SLJIT_CONST sljit_ins data_transfer_insts[16 + 2] = {  static SLJIT_CONST sljit_ins data_transfer_insts[16 + 4] = {
577  /* u w s */ ARCH_32_64(HI(43) /* sw */, HI(63) /* sd */),  /* u w s */ ARCH_32_64(HI(43) /* sw */, HI(63) /* sd */),
578  /* u w l */ ARCH_32_64(HI(35) /* lw */, HI(55) /* ld */),  /* u w l */ ARCH_32_64(HI(35) /* lw */, HI(55) /* ld */),
579  /* u b s */ HI(40) /* sb */,  /* u b s */ HI(40) /* sb */,
# Line 593  static SLJIT_CONST sljit_ins data_transf Line 594  static SLJIT_CONST sljit_ins data_transf
594    
595  /* d   s */ HI(61) /* sdc1 */,  /* d   s */ HI(61) /* sdc1 */,
596  /* d   l */ HI(53) /* ldc1 */,  /* d   l */ HI(53) /* ldc1 */,
597    /* s   s */ HI(57) /* swc1 */,
598    /* s   l */ HI(49) /* lwc1 */,
599  };  };
600    
601  #undef ARCH_32_64  #undef ARCH_32_64
# Line 600  static SLJIT_CONST sljit_ins data_transf Line 603  static SLJIT_CONST sljit_ins data_transf
603  /* reg_ar is an absoulute register! */  /* reg_ar is an absoulute register! */
604    
605  /* Can perform an operation using at most 1 instruction. */  /* Can perform an operation using at most 1 instruction. */
606  static int getput_arg_fast(struct sljit_compiler *compiler, int flags, int reg_ar, int arg, sljit_w argw)  static sljit_si getput_arg_fast(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg_ar, sljit_si arg, sljit_sw argw)
607  {  {
608          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
609    
# Line 618  static int getput_arg_fast(struct sljit_ Line 621  static int getput_arg_fast(struct sljit_
621  /* See getput_arg below.  /* See getput_arg below.
622     Note: can_cache is called only for binary operators. Those     Note: can_cache is called only for binary operators. Those
623     operators always uses word arguments without write back. */     operators always uses word arguments without write back. */
624  static int can_cache(int arg, sljit_w argw, int next_arg, sljit_w next_argw)  static sljit_si can_cache(sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
625  {  {
626          SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM));          SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM));
627    
# Line 641  static int can_cache(int arg, sljit_w ar Line 644  static int can_cache(int arg, sljit_w ar
644  }  }
645    
646  /* Emit the necessary instructions. See can_cache above. */  /* Emit the necessary instructions. See can_cache above. */
647  static int getput_arg(struct sljit_compiler *compiler, int flags, int reg_ar, int arg, sljit_w argw, int next_arg, sljit_w next_argw)  static sljit_si getput_arg(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg_ar, sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
648  {  {
649          int tmp_ar, base, delay_slot;          sljit_si tmp_ar, base, delay_slot;
650    
651          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
652          if (!(next_arg & SLJIT_MEM)) {          if (!(next_arg & SLJIT_MEM)) {
# Line 780  static int getput_arg(struct sljit_compi Line 783  static int getput_arg(struct sljit_compi
783          return push_inst(compiler, data_transfer_insts[flags & MEM_MASK] | SA(tmp_ar) | TA(reg_ar), delay_slot);          return push_inst(compiler, data_transfer_insts[flags & MEM_MASK] | SA(tmp_ar) | TA(reg_ar), delay_slot);
784  }  }
785    
786  static SLJIT_INLINE int emit_op_mem(struct sljit_compiler *compiler, int flags, int reg_ar, int arg, sljit_w argw)  static SLJIT_INLINE sljit_si emit_op_mem(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg_ar, sljit_si arg, sljit_sw argw)
787  {  {
788          if (getput_arg_fast(compiler, flags, reg_ar, arg, argw))          if (getput_arg_fast(compiler, flags, reg_ar, arg, argw))
789                  return compiler->error;                  return compiler->error;
# Line 789  static SLJIT_INLINE int emit_op_mem(stru Line 792  static SLJIT_INLINE int emit_op_mem(stru
792          return getput_arg(compiler, flags, reg_ar, arg, argw, 0, 0);          return getput_arg(compiler, flags, reg_ar, arg, argw, 0, 0);
793  }  }
794    
795  static SLJIT_INLINE int emit_op_mem2(struct sljit_compiler *compiler, int flags, int reg, int arg1, sljit_w arg1w, int arg2, sljit_w arg2w)  static SLJIT_INLINE sljit_si emit_op_mem2(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg1, sljit_sw arg1w, sljit_si arg2, sljit_sw arg2w)
796  {  {
797          if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))          if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))
798                  return compiler->error;                  return compiler->error;
799          return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);          return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);
800  }  }
801    
802  static int emit_op(struct sljit_compiler *compiler, int op, int flags,  static sljit_si emit_op(struct sljit_compiler *compiler, sljit_si op, sljit_si flags,
803          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
804          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
805          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
806  {  {
807          /* arg1 goes to TMP_REG1 or src reg          /* arg1 goes to TMP_REG1 or src reg
808             arg2 goes to TMP_REG2, imm or src reg             arg2 goes to TMP_REG2, imm or src reg
809             TMP_REG3 can be used for caching             TMP_REG3 can be used for caching
810             result goes to TMP_REG2, so put result can use TMP_REG1 and TMP_REG3. */             result goes to TMP_REG2, so put result can use TMP_REG1 and TMP_REG3. */
811          int dst_r = TMP_REG2;          sljit_si dst_r = TMP_REG2;
812          int src1_r;          sljit_si src1_r;
813          sljit_w src2_r = 0;          sljit_sw src2_r = 0;
814          int sugg_src2_r = TMP_REG2;          sljit_si sugg_src2_r = TMP_REG2;
815    
816          compiler->cache_arg = 0;          compiler->cache_arg = 0;
817          compiler->cache_argw = 0;          compiler->cache_argw = 0;
# Line 926  static int emit_op(struct sljit_compiler Line 929  static int emit_op(struct sljit_compiler
929          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
930  }  }
931    
932  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)
933  {  {
934          CHECK_ERROR();          CHECK_ERROR();
935          check_sljit_emit_op0(compiler, op);          check_sljit_emit_op0(compiler, op);
# Line 956  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 959  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
959          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
960  }  }
961    
962  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,
963          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
964          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
965  {  {
966  #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)  #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
967          #define flags 0          #define flags 0
# Line 984  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 987  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
987                  return emit_op(compiler, SLJIT_MOV_UB, flags | BYTE_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_ub)srcw : srcw);                  return emit_op(compiler, SLJIT_MOV_UB, flags | BYTE_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_ub)srcw : srcw);
988    
989          case SLJIT_MOV_SB:          case SLJIT_MOV_SB:
990                  return emit_op(compiler, SLJIT_MOV_SB, flags | BYTE_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_b)srcw : srcw);                  return emit_op(compiler, SLJIT_MOV_SB, flags | BYTE_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_sb)srcw : srcw);
991    
992          case SLJIT_MOV_UH:          case SLJIT_MOV_UH:
993                  return emit_op(compiler, SLJIT_MOV_UH, flags | HALF_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_uh)srcw : srcw);                  return emit_op(compiler, SLJIT_MOV_UH, flags | HALF_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_uh)srcw : srcw);
994    
995          case SLJIT_MOV_SH:          case SLJIT_MOV_SH:
996                  return emit_op(compiler, SLJIT_MOV_SH, flags | HALF_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_h)srcw : srcw);                  return emit_op(compiler, SLJIT_MOV_SH, flags | HALF_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_sh)srcw : srcw);
997    
998          case SLJIT_MOVU:          case SLJIT_MOVU:
999          case SLJIT_MOVU_P:          case SLJIT_MOVU_P:
# Line 1006  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1009  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1009                  return emit_op(compiler, SLJIT_MOV_UB, flags | BYTE_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_ub)srcw : srcw);                  return emit_op(compiler, SLJIT_MOV_UB, flags | BYTE_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_ub)srcw : srcw);
1010    
1011          case SLJIT_MOVU_SB:          case SLJIT_MOVU_SB:
1012                  return emit_op(compiler, SLJIT_MOV_SB, flags | BYTE_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_b)srcw : srcw);                  return emit_op(compiler, SLJIT_MOV_SB, flags | BYTE_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_sb)srcw : srcw);
1013    
1014          case SLJIT_MOVU_UH:          case SLJIT_MOVU_UH:
1015                  return emit_op(compiler, SLJIT_MOV_UH, flags | HALF_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_uh)srcw : srcw);                  return emit_op(compiler, SLJIT_MOV_UH, flags | HALF_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_uh)srcw : srcw);
1016    
1017          case SLJIT_MOVU_SH:          case SLJIT_MOVU_SH:
1018                  return emit_op(compiler, SLJIT_MOV_SH, flags | HALF_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_h)srcw : srcw);                  return emit_op(compiler, SLJIT_MOV_SH, flags | HALF_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? (sljit_sh)srcw : srcw);
1019    
1020          case SLJIT_NOT:          case SLJIT_NOT:
1021                  return emit_op(compiler, op, flags, dst, dstw, TMP_REG1, 0, src, srcw);                  return emit_op(compiler, op, flags, dst, dstw, TMP_REG1, 0, src, srcw);
# Line 1030  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1033  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1033  #endif  #endif
1034  }  }
1035    
1036  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,
1037          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1038          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1039          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1040  {  {
1041  #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)  #if (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)
1042          #define flags 0          #define flags 0
# Line 1080  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1083  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1083  #endif  #endif
1084  }  }
1085    
1086  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_register_index(sljit_si reg)
1087  {  {
1088          check_sljit_get_register_index(reg);          check_sljit_get_register_index(reg);
1089          return reg_map[reg];          return reg_map[reg];
1090  }  }
1091    
1092  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,
1093          void *instruction, int size)          void *instruction, sljit_si size)
1094  {  {
1095          CHECK_ERROR();          CHECK_ERROR();
1096          check_sljit_emit_op_custom(compiler, instruction, size);          check_sljit_emit_op_custom(compiler, instruction, size);
# Line 1100  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1103  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1103  /*  Floating point operators                                             */  /*  Floating point operators                                             */
1104  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1105    
1106  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_is_fpu_available(void)
1107  {  {
1108  #if (defined SLJIT_QEMU && SLJIT_QEMU)  #if (defined SLJIT_QEMU && SLJIT_QEMU)
1109          /* Qemu says fir is 0 by default. */          /* Qemu says fir is 0 by default. */
1110          return 1;          return 1;
1111  #elif defined(__GNUC__)  #elif defined(__GNUC__)
1112          sljit_w fir;          sljit_sw fir;
1113          asm ("cfc1 %0, $0" : "=r"(fir));          asm ("cfc1 %0, $0" : "=r"(fir));
1114          return (fir >> 22) & 0x1;          return (fir >> 22) & 0x1;
1115  #else  #else
# Line 1114  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fp Line 1117  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fp
1117  #endif  #endif
1118  }  }
1119    
1120  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,  #define FLOAT_DATA(op) (DOUBLE_DATA | ((op & SLJIT_SINGLE_OP) >> 7))
1121          int dst, sljit_w dstw,  #define FMT(op) (((op & SLJIT_SINGLE_OP) ^ SLJIT_SINGLE_OP) << (21 - 8))
1122          int src, sljit_w srcw)  
1123    SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op,
1124            sljit_si dst, sljit_sw dstw,
1125            sljit_si src, sljit_sw srcw)
1126  {  {
1127          int dst_fr;          sljit_si dst_fr;
1128    
1129          CHECK_ERROR();          CHECK_ERROR();
1130          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);
1131            SLJIT_COMPILE_ASSERT((SLJIT_SINGLE_OP == 0x100) && !(DOUBLE_DATA & 0x2), float_transfer_bit_error);
1132    
1133          compiler->cache_arg = 0;          compiler->cache_arg = 0;
1134          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1135    
1136          if (GET_OPCODE(op) == SLJIT_FCMP) {          if (GET_OPCODE(op) == SLJIT_CMPD) {
1137                  if (dst > SLJIT_FLOAT_REG4) {                  if (dst > SLJIT_FLOAT_REG6) {
1138                          FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, dst, dstw, src, srcw));                          FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, dst, dstw, src, srcw));
1139                          dst = TMP_FREG1;                          dst = TMP_FREG1;
1140                  }                  }
1141                  else                  else
1142                          dst <<= 1;                          dst <<= 1;
1143    
1144                  if (src > SLJIT_FLOAT_REG4) {                  if (src > SLJIT_FLOAT_REG6) {
1145                          FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src, srcw, 0, 0));                          FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src, srcw, 0, 0));
1146                          src = TMP_FREG2;                          src = TMP_FREG2;
1147                  }                  }
1148                  else                  else
# Line 1143  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1150  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1150    
1151                  /* src and dst are swapped. */                  /* src and dst are swapped. */
1152                  if (op & SLJIT_SET_E) {                  if (op & SLJIT_SET_E) {
1153                          FAIL_IF(push_inst(compiler, C_UEQ_D | FT(src) | FS(dst), UNMOVABLE_INS));                          FAIL_IF(push_inst(compiler, C_UEQ_fmt | FMT(op) | FT(src) | FS(dst), UNMOVABLE_INS));
1154                          FAIL_IF(push_inst(compiler, CFC1 | TA(EQUAL_FLAG) | DA(FCSR_REG), EQUAL_FLAG));                          FAIL_IF(push_inst(compiler, CFC1 | TA(EQUAL_FLAG) | DA(FCSR_REG), EQUAL_FLAG));
1155                          FAIL_IF(push_inst(compiler, SRL | TA(EQUAL_FLAG) | DA(EQUAL_FLAG) | SH_IMM(23), EQUAL_FLAG));                          FAIL_IF(push_inst(compiler, SRL | TA(EQUAL_FLAG) | DA(EQUAL_FLAG) | SH_IMM(23), EQUAL_FLAG));
1156                          FAIL_IF(push_inst(compiler, ANDI | SA(EQUAL_FLAG) | TA(EQUAL_FLAG) | IMM(1), EQUAL_FLAG));                          FAIL_IF(push_inst(compiler, ANDI | SA(EQUAL_FLAG) | TA(EQUAL_FLAG) | IMM(1), EQUAL_FLAG));
1157                  }                  }
1158                  if (op & SLJIT_SET_S) {                  if (op & SLJIT_SET_S) {
1159                          /* Mixing the instructions for the two checks. */                          /* Mixing the instructions for the two checks. */
1160                          FAIL_IF(push_inst(compiler, C_ULT_D | FT(src) | FS(dst), UNMOVABLE_INS));                          FAIL_IF(push_inst(compiler, C_ULT_fmt | FMT(op) | FT(src) | FS(dst), UNMOVABLE_INS));
1161                          FAIL_IF(push_inst(compiler, CFC1 | TA(ULESS_FLAG) | DA(FCSR_REG), ULESS_FLAG));                          FAIL_IF(push_inst(compiler, CFC1 | TA(ULESS_FLAG) | DA(FCSR_REG), ULESS_FLAG));
1162                          FAIL_IF(push_inst(compiler, C_ULT_D | FT(dst) | FS(src), UNMOVABLE_INS));                          FAIL_IF(push_inst(compiler, C_ULT_fmt | FMT(op) | FT(dst) | FS(src), UNMOVABLE_INS));
1163                          FAIL_IF(push_inst(compiler, SRL | TA(ULESS_FLAG) | DA(ULESS_FLAG) | SH_IMM(23), ULESS_FLAG));                          FAIL_IF(push_inst(compiler, SRL | TA(ULESS_FLAG) | DA(ULESS_FLAG) | SH_IMM(23), ULESS_FLAG));
1164                          FAIL_IF(push_inst(compiler, ANDI | SA(ULESS_FLAG) | TA(ULESS_FLAG) | IMM(1), ULESS_FLAG));                          FAIL_IF(push_inst(compiler, ANDI | SA(ULESS_FLAG) | TA(ULESS_FLAG) | IMM(1), ULESS_FLAG));
1165                          FAIL_IF(push_inst(compiler, CFC1 | TA(UGREATER_FLAG) | DA(FCSR_REG), UGREATER_FLAG));                          FAIL_IF(push_inst(compiler, CFC1 | TA(UGREATER_FLAG) | DA(FCSR_REG), UGREATER_FLAG));
1166                          FAIL_IF(push_inst(compiler, SRL | TA(UGREATER_FLAG) | DA(UGREATER_FLAG) | SH_IMM(23), UGREATER_FLAG));                          FAIL_IF(push_inst(compiler, SRL | TA(UGREATER_FLAG) | DA(UGREATER_FLAG) | SH_IMM(23), UGREATER_FLAG));
1167                          FAIL_IF(push_inst(compiler, ANDI | SA(UGREATER_FLAG) | TA(UGREATER_FLAG) | IMM(1), UGREATER_FLAG));                          FAIL_IF(push_inst(compiler, ANDI | SA(UGREATER_FLAG) | TA(UGREATER_FLAG) | IMM(1), UGREATER_FLAG));
1168                  }                  }
1169                  return push_inst(compiler, C_UN_D | FT(src) | FS(dst), FCSR_FCC);                  return push_inst(compiler, C_UN_fmt | FMT(op) | FT(src) | FS(dst), FCSR_FCC);
1170          }          }
1171    
1172          dst_fr = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG1 : (dst << 1);          dst_fr = (dst > SLJIT_FLOAT_REG6) ? TMP_FREG1 : (dst << 1);
1173    
1174          if (src > SLJIT_FLOAT_REG4) {          if (src > SLJIT_FLOAT_REG6) {
1175                  FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, dst_fr, src, srcw, dst, dstw));                  FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op) | LOAD_DATA, dst_fr, src, srcw, dst, dstw));
1176                  src = dst_fr;                  src = dst_fr;
1177          }          }
1178          else          else
1179                  src <<= 1;                  src <<= 1;
1180    
1181          switch (op) {          switch (GET_OPCODE(op)) {
1182                  case SLJIT_FMOV:                  case SLJIT_MOVD:
1183                          if (src != dst_fr && dst_fr != TMP_FREG1)                          if (src != dst_fr && dst_fr != TMP_FREG1)
1184                                  FAIL_IF(push_inst(compiler, MOV_D | FS(src) | FD(dst_fr), MOVABLE_INS));                                  FAIL_IF(push_inst(compiler, MOV_fmt | FMT(op) | FS(src) | FD(dst_fr), MOVABLE_INS));
1185                          break;                          break;
1186                  case SLJIT_FNEG:                  case SLJIT_NEGD:
1187                          FAIL_IF(push_inst(compiler, NEG_D | FS(src) | FD(dst_fr), MOVABLE_INS));                          FAIL_IF(push_inst(compiler, NEG_fmt | FMT(op) | FS(src) | FD(dst_fr), MOVABLE_INS));
1188                          break;                          break;
1189                  case SLJIT_FABS:                  case SLJIT_ABSD:
1190                          FAIL_IF(push_inst(compiler, ABS_D | FS(src) | FD(dst_fr), MOVABLE_INS));                          FAIL_IF(push_inst(compiler, ABS_fmt | FMT(op) | FS(src) | FD(dst_fr), MOVABLE_INS));
1191                          break;                          break;
1192          }          }
1193    
1194          if (dst_fr == TMP_FREG1) {          if (dst_fr == TMP_FREG1) {
1195                  if (op == SLJIT_FMOV)                  if (GET_OPCODE(op) == SLJIT_MOVD)
1196                          dst_fr = src;                          dst_fr = src;
1197                  FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA, dst_fr, dst, dstw, 0, 0));                  FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op), dst_fr, dst, dstw, 0, 0));
1198          }          }
1199    
1200          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1201  }  }
1202    
1203  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,
1204          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1205          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1206          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1207  {  {
1208          int dst_fr, flags = 0;          sljit_si dst_fr, flags = 0;
1209    
1210          CHECK_ERROR();          CHECK_ERROR();
1211          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 1206  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1213  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1213          compiler->cache_arg = 0;          compiler->cache_arg = 0;
1214          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1215    
1216          dst_fr = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG2 : (dst << 1);          dst_fr = (dst > SLJIT_FLOAT_REG6) ? TMP_FREG2 : (dst << 1);
1217    
1218          if (src1 > SLJIT_FLOAT_REG4) {          if (src1 > SLJIT_FLOAT_REG6) {
1219                  if (getput_arg_fast(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w)) {                  if (getput_arg_fast(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w)) {
1220                          FAIL_IF(compiler->error);                          FAIL_IF(compiler->error);
1221                          src1 = TMP_FREG1;                          src1 = TMP_FREG1;
1222                  } else                  } else
# Line 1218  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1225  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1225          else          else
1226                  src1 <<= 1;                  src1 <<= 1;
1227    
1228          if (src2 > SLJIT_FLOAT_REG4) {          if (src2 > SLJIT_FLOAT_REG6) {
1229                  if (getput_arg_fast(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w)) {                  if (getput_arg_fast(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w)) {
1230                          FAIL_IF(compiler->error);                          FAIL_IF(compiler->error);
1231                          src2 = TMP_FREG2;                          src2 = TMP_FREG2;
1232                  } else                  } else
# Line 1230  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1237  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1237    
1238          if ((flags & (SLOW_SRC1 | SLOW_SRC2)) == (SLOW_SRC1 | SLOW_SRC2)) {          if ((flags & (SLOW_SRC1 | SLOW_SRC2)) == (SLOW_SRC1 | SLOW_SRC2)) {
1239                  if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) {                  if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) {
1240                          FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w, src1, src1w));                          FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w, src1, src1w));
1241                          FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w, dst, dstw));                          FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w, dst, dstw));
1242                  }                  }
1243                  else {                  else {
1244                          FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w, src2, src2w));                          FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w, src2, src2w));
1245                          FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w, dst, dstw));                          FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w, dst, dstw));
1246                  }                  }
1247          }          }
1248          else if (flags & SLOW_SRC1)          else if (flags & SLOW_SRC1)
1249                  FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w, dst, dstw));                  FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG1, src1, src1w, dst, dstw));
1250          else if (flags & SLOW_SRC2)          else if (flags & SLOW_SRC2)
1251                  FAIL_IF(getput_arg(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w, dst, dstw));                  FAIL_IF(getput_arg(compiler, FLOAT_DATA(op) | LOAD_DATA, TMP_FREG2, src2, src2w, dst, dstw));
1252    
1253          if (flags & SLOW_SRC1)          if (flags & SLOW_SRC1)
1254                  src1 = TMP_FREG1;                  src1 = TMP_FREG1;
1255          if (flags & SLOW_SRC2)          if (flags & SLOW_SRC2)
1256                  src2 = TMP_FREG2;                  src2 = TMP_FREG2;
1257    
1258          switch (op) {          switch (GET_OPCODE(op)) {
1259          case SLJIT_FADD:          case SLJIT_ADDD:
1260                  FAIL_IF(push_inst(compiler, ADD_D | FT(src2) | FS(src1) | FD(dst_fr), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, ADD_fmt | FMT(op) | FT(src2) | FS(src1) | FD(dst_fr), MOVABLE_INS));
1261                  break;                  break;
1262    
1263          case SLJIT_FSUB:          case SLJIT_SUBD:
1264                  FAIL_IF(push_inst(compiler, SUB_D | FT(src2) | FS(src1) | FD(dst_fr), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, SUB_fmt | FMT(op) | FT(src2) | FS(src1) | FD(dst_fr), MOVABLE_INS));
1265                  break;                  break;
1266    
1267          case SLJIT_FMUL:          case SLJIT_MULD:
1268                  FAIL_IF(push_inst(compiler, MUL_D | FT(src2) | FS(src1) | FD(dst_fr), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, MUL_fmt | FMT(op) | FT(src2) | FS(src1) | FD(dst_fr), MOVABLE_INS));
1269                  break;                  break;
1270    
1271          case SLJIT_FDIV:          case SLJIT_DIVD:
1272                  FAIL_IF(push_inst(compiler, DIV_D | FT(src2) | FS(src1) | FD(dst_fr), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, DIV_fmt | FMT(op) | FT(src2) | FS(src1) | FD(dst_fr), MOVABLE_INS));
1273                  break;                  break;
1274          }          }
1275    
1276          if (dst_fr == TMP_FREG2)          if (dst_fr == TMP_FREG2)
1277                  FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA, TMP_FREG2, dst, dstw, 0, 0));                  FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(op), TMP_FREG2, dst, dstw, 0, 0));
1278    
1279          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1280  }  }
# Line 1276  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1283  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1283  /*  Other instructions                                                   */  /*  Other instructions                                                   */
1284  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1285    
1286  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_si dst, sljit_sw dstw)
1287  {  {
1288          CHECK_ERROR();          CHECK_ERROR();
1289          check_sljit_emit_fast_enter(compiler, dst, dstw);          check_sljit_emit_fast_enter(compiler, dst, dstw);
# Line 1291  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1298  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1298          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1299  }  }
1300    
1301  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_si src, sljit_sw srcw)
1302  {  {
1303          CHECK_ERROR();          CHECK_ERROR();
1304          check_sljit_emit_fast_return(compiler, src, srcw);          check_sljit_emit_fast_return(compiler, src, srcw);
# Line 1355  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la Line 1362  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la
1362          flags = IS_BIT16_COND; \          flags = IS_BIT16_COND; \
1363          delay_check = FCSR_FCC;          delay_check = FCSR_FCC;
1364    
1365  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)
1366  {  {
1367          struct sljit_jump *jump;          struct sljit_jump *jump;
1368          sljit_ins inst;          sljit_ins inst;
1369          int flags = 0;          sljit_si flags = 0;
1370          int delay_check = UNMOVABLE_INS;          sljit_si delay_check = UNMOVABLE_INS;
1371    
1372          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
1373          check_sljit_emit_jump(compiler, type);          check_sljit_emit_jump(compiler, type);
# Line 1471  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1478  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1478                          src2 = 0; \                          src2 = 0; \
1479          }          }
1480    
1481  SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, int type,  SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_cmp(struct sljit_compiler *compiler, sljit_si type,
1482          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1483          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1484  {  {
1485          struct sljit_jump *jump;          struct sljit_jump *jump;
1486          int flags;          sljit_si flags;
1487          sljit_ins inst;          sljit_ins inst;
1488    
1489          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
# Line 1592  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1599  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1599  #undef RESOLVE_IMM1  #undef RESOLVE_IMM1
1600  #undef RESOLVE_IMM2  #undef RESOLVE_IMM2
1601    
1602  SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, int type,  SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_fcmp(struct sljit_compiler *compiler, sljit_si type,
1603          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1604          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1605  {  {
1606          struct sljit_jump *jump;          struct sljit_jump *jump;
1607          sljit_ins inst;          sljit_ins inst;
1608          int if_true;          sljit_si if_true;
1609    
1610          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
1611          check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w);          check_sljit_emit_fcmp(compiler, type, src1, src1w, src2, src2w);
# Line 1606  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1613  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1613          compiler->cache_arg = 0;          compiler->cache_arg = 0;
1614          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1615    
1616          if (src1 > SLJIT_FLOAT_REG4) {          if (src1 > SLJIT_FLOAT_REG6) {
1617                  PTR_FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG1, src1, src1w, src2, src2w));                  PTR_FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(type) | LOAD_DATA, TMP_FREG1, src1, src1w, src2, src2w));
1618                  src1 = TMP_FREG1;                  src1 = TMP_FREG1;
1619          }          }
1620          else          else
1621                  src1 <<= 1;                  src1 <<= 1;
1622    
1623          if (src2 > SLJIT_FLOAT_REG4) {          if (src2 > SLJIT_FLOAT_REG6) {
1624                  PTR_FAIL_IF(emit_op_mem2(compiler, DOUBLE_DATA | LOAD_DATA, TMP_FREG2, src2, src2w, 0, 0));                  PTR_FAIL_IF(emit_op_mem2(compiler, FLOAT_DATA(type) | LOAD_DATA, TMP_FREG2, src2, src2w, 0, 0));
1625                  src2 = TMP_FREG2;                  src2 = TMP_FREG2;
1626          }          }
1627          else          else
# Line 1624  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1631  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1631          PTR_FAIL_IF(!jump);          PTR_FAIL_IF(!jump);
1632          set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);          set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
1633          jump->flags |= IS_BIT16_COND;          jump->flags |= IS_BIT16_COND;
         type &= 0xff;  
1634    
1635          switch (type) {          switch (type & 0xff) {
1636          case SLJIT_C_FLOAT_EQUAL:          case SLJIT_C_FLOAT_EQUAL:
1637                  inst = C_UEQ_D;                  inst = C_UEQ_fmt;
1638                  if_true = 1;                  if_true = 1;
1639                  break;                  break;
1640          case SLJIT_C_FLOAT_NOT_EQUAL:          case SLJIT_C_FLOAT_NOT_EQUAL:
1641                  inst = C_UEQ_D;                  inst = C_UEQ_fmt;
1642                  if_true = 0;                  if_true = 0;
1643                  break;                  break;
1644          case SLJIT_C_FLOAT_LESS:          case SLJIT_C_FLOAT_LESS:
1645                  inst = C_ULT_D;                  inst = C_ULT_fmt;
1646                  if_true = 1;                  if_true = 1;
1647                  break;                  break;
1648          case SLJIT_C_FLOAT_GREATER_EQUAL:          case SLJIT_C_FLOAT_GREATER_EQUAL:
1649                  inst = C_ULT_D;                  inst = C_ULT_fmt;
1650                  if_true = 0;                  if_true = 0;
1651                  break;                  break;
1652          case SLJIT_C_FLOAT_GREATER:          case SLJIT_C_FLOAT_GREATER:
1653                  inst = C_ULE_D;                  inst = C_ULE_fmt;
1654                  if_true = 0;                  if_true = 0;
1655                  break;                  break;
1656          case SLJIT_C_FLOAT_LESS_EQUAL:          case SLJIT_C_FLOAT_LESS_EQUAL:
1657                  inst = C_ULE_D;                  inst = C_ULE_fmt;
1658                  if_true = 1;                  if_true = 1;
1659                  break;                  break;
1660          case SLJIT_C_FLOAT_UNORDERED:          case SLJIT_C_FLOAT_UNORDERED:
1661                  inst = C_UN_D;                  inst = C_UN_fmt;
1662                  if_true = 1;                  if_true = 1;
1663                  break;                  break;
1664          case SLJIT_C_FLOAT_ORDERED:          case SLJIT_C_FLOAT_ORDERED:
1665          default: /* Make compilers happy. */          default: /* Make compilers happy. */
1666                  inst = C_UN_D;                  inst = C_UN_fmt;
1667                  if_true = 0;                  if_true = 0;
1668                  break;                  break;
1669          }          }
1670    
1671          PTR_FAIL_IF(push_inst(compiler, inst | FT(src2) | FS(src1), UNMOVABLE_INS));          PTR_FAIL_IF(push_inst(compiler, inst | FMT(type) | FT(src2) | FS(src1), UNMOVABLE_INS));
1672          /* Intentionally the other opcode. */          /* Intentionally the other opcode. */
1673          PTR_FAIL_IF(push_inst(compiler, (if_true ? BC1F : BC1T) | JUMP_LENGTH, UNMOVABLE_INS));          PTR_FAIL_IF(push_inst(compiler, (if_true ? BC1F : BC1T) | JUMP_LENGTH, UNMOVABLE_INS));
1674          PTR_FAIL_IF(emit_const(compiler, TMP_REG2, 0));          PTR_FAIL_IF(emit_const(compiler, TMP_REG2, 0));
# Line 1678  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1684  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1684  #undef BR_T  #undef BR_T
1685  #undef BR_F  #undef BR_F
1686    
1687  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)  #undef FLOAT_DATA
1688    #undef FMT
1689    
1690    SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
1691  {  {
1692          int src_r = TMP_REG2;          sljit_si src_r = TMP_REG2;
1693          struct sljit_jump *jump = NULL;          struct sljit_jump *jump = NULL;
1694    
1695          CHECK_ERROR();          CHECK_ERROR();
# Line 1736  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1745  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1745          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1746  }  }
1747    
1748  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)
1749  {  {
1750          int sugg_dst_ar, dst_ar;          sljit_si sugg_dst_ar, dst_ar;
1751    
1752          CHECK_ERROR();          CHECK_ERROR();
1753          check_sljit_emit_cond_value(compiler, op, dst, dstw, type);          check_sljit_emit_cond_value(compiler, op, dst, dstw, type);
# Line 1823  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1832  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1832          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1833  }  }
1834    
1835  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)
1836  {  {
1837          struct sljit_const *const_;          struct sljit_const *const_;
1838          int reg;          sljit_si reg;
1839    
1840          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
1841          check_sljit_emit_const(compiler, dst, dstw, init_value);          check_sljit_emit_const(compiler, dst, dstw, init_value);

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

  ViewVC Help
Powered by ViewVC 1.1.5