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

Diff of /code/trunk/sljit/sljitNativeSPARC_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 64  static void sparc_cache_flush(sljit_ins Line 64  static void sparc_cache_flush(sljit_ins
64  #define TMP_REG4        (SLJIT_NO_REGISTERS + 4)  #define TMP_REG4        (SLJIT_NO_REGISTERS + 4)
65  #define LINK_REG        (SLJIT_NO_REGISTERS + 5)  #define LINK_REG        (SLJIT_NO_REGISTERS + 5)
66    
67  #define TMP_FREG1       ((SLJIT_FLOAT_REG4 + 1) << 1)  #define TMP_FREG1       (0)
68  #define TMP_FREG2       ((SLJIT_FLOAT_REG4 + 2) << 1)  #define TMP_FREG2       ((SLJIT_FLOAT_REG6 + 1) << 1)
69    
70  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 7] = {  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 7] = {
71          0, 8, 9, 10, 11, 12, 16, 17, 18, 19, 20, 14, 1, 24, 25, 26, 15          0, 8, 9, 10, 11, 12, 16, 17, 18, 19, 20, 14, 1, 24, 25, 26, 15
# Line 98  static SLJIT_CONST sljit_ub reg_map[SLJI Line 98  static SLJIT_CONST sljit_ub reg_map[SLJI
98  #define CALL            (OPC1(0x1))  #define CALL            (OPC1(0x1))
99  #define FABSS           (OPC1(0x2) | OPC3(0x34) | DOP(0x09))  #define FABSS           (OPC1(0x2) | OPC3(0x34) | DOP(0x09))
100  #define FADDD           (OPC1(0x2) | OPC3(0x34) | DOP(0x42))  #define FADDD           (OPC1(0x2) | OPC3(0x34) | DOP(0x42))
101    #define FADDS           (OPC1(0x2) | OPC3(0x34) | DOP(0x41))
102  #define FCMPD           (OPC1(0x2) | OPC3(0x35) | DOP(0x52))  #define FCMPD           (OPC1(0x2) | OPC3(0x35) | DOP(0x52))
103    #define FCMPS           (OPC1(0x2) | OPC3(0x35) | DOP(0x51))
104  #define FDIVD           (OPC1(0x2) | OPC3(0x34) | DOP(0x4e))  #define FDIVD           (OPC1(0x2) | OPC3(0x34) | DOP(0x4e))
105    #define FDIVS           (OPC1(0x2) | OPC3(0x34) | DOP(0x4d))
106  #define FMOVS           (OPC1(0x2) | OPC3(0x34) | DOP(0x01))  #define FMOVS           (OPC1(0x2) | OPC3(0x34) | DOP(0x01))
107  #define FMULD           (OPC1(0x2) | OPC3(0x34) | DOP(0x4a))  #define FMULD           (OPC1(0x2) | OPC3(0x34) | DOP(0x4a))
108    #define FMULS           (OPC1(0x2) | OPC3(0x34) | DOP(0x49))
109  #define FNEGS           (OPC1(0x2) | OPC3(0x34) | DOP(0x05))  #define FNEGS           (OPC1(0x2) | OPC3(0x34) | DOP(0x05))
110  #define FSUBD           (OPC1(0x2) | OPC3(0x34) | DOP(0x46))  #define FSUBD           (OPC1(0x2) | OPC3(0x34) | DOP(0x46))
111    #define FSUBS           (OPC1(0x2) | OPC3(0x34) | DOP(0x45))
112  #define JMPL            (OPC1(0x2) | OPC3(0x38))  #define JMPL            (OPC1(0x2) | OPC3(0x38))
113  #define NOP             (OPC1(0x0) | OPC2(0x04))  #define NOP             (OPC1(0x0) | OPC2(0x04))
114  #define OR              (OPC1(0x2) | OPC3(0x02))  #define OR              (OPC1(0x2) | OPC3(0x02))
# Line 146  static SLJIT_CONST sljit_ub reg_map[SLJI Line 151  static SLJIT_CONST sljit_ub reg_map[SLJI
151    
152  /* dest_reg is the absolute name of the register  /* dest_reg is the absolute name of the register
153     Useful for reordering instructions in the delay slot. */     Useful for reordering instructions in the delay slot. */
154  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)
155  {  {
156          SLJIT_ASSERT((delay_slot & DST_INS_MASK) == UNMOVABLE_INS          SLJIT_ASSERT((delay_slot & DST_INS_MASK) == UNMOVABLE_INS
157                  || (delay_slot & DST_INS_MASK) == MOVABLE_INS                  || (delay_slot & DST_INS_MASK) == MOVABLE_INS
# Line 161  static int push_inst(struct sljit_compil Line 166  static int push_inst(struct sljit_compil
166    
167  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)
168  {  {
169          sljit_w diff;          sljit_sw diff;
170          sljit_uw target_addr;          sljit_uw target_addr;
171          sljit_ins *inst;          sljit_ins *inst;
172          sljit_ins saved_inst;          sljit_ins saved_inst;
# Line 200  static SLJIT_INLINE sljit_ins* optimize_ Line 205  static SLJIT_INLINE sljit_ins* optimize_
205                  inst--;                  inst--;
206    
207          if (jump->flags & IS_MOVABLE) {          if (jump->flags & IS_MOVABLE) {
208                  diff = ((sljit_w)target_addr - (sljit_w)(inst - 1)) >> 2;                  diff = ((sljit_sw)target_addr - (sljit_sw)(inst - 1)) >> 2;
209                  if (diff <= MAX_DISP && diff >= MIN_DISP) {                  if (diff <= MAX_DISP && diff >= MIN_DISP) {
210                          jump->flags |= PATCH_B;                          jump->flags |= PATCH_B;
211                          inst--;                          inst--;
# Line 217  static SLJIT_INLINE sljit_ins* optimize_ Line 222  static SLJIT_INLINE sljit_ins* optimize_
222                  }                  }
223          }          }
224    
225          diff = ((sljit_w)target_addr - (sljit_w)(inst)) >> 2;          diff = ((sljit_sw)target_addr - (sljit_sw)(inst)) >> 2;
226          if (diff <= MAX_DISP && diff >= MIN_DISP) {          if (diff <= MAX_DISP && diff >= MIN_DISP) {
227                  jump->flags |= PATCH_B;                  jump->flags |= PATCH_B;
228                  if (jump->flags & IS_COND)                  if (jump->flags & IS_COND)
# Line 304  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 309  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
309          SLJIT_ASSERT(!label);          SLJIT_ASSERT(!label);
310          SLJIT_ASSERT(!jump);          SLJIT_ASSERT(!jump);
311          SLJIT_ASSERT(!const_);          SLJIT_ASSERT(!const_);
312          SLJIT_ASSERT(code_ptr - code <= (int)compiler->size);          SLJIT_ASSERT(code_ptr - code <= (sljit_si)compiler->size);
313    
314          jump = compiler->jumps;          jump = compiler->jumps;
315          while (jump) {          while (jump) {
# Line 313  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 318  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
318                          buf_ptr = (sljit_ins*)jump->addr;                          buf_ptr = (sljit_ins*)jump->addr;
319    
320                          if (jump->flags & PATCH_CALL) {                          if (jump->flags & PATCH_CALL) {
321                                  addr = (sljit_w)(addr - jump->addr) >> 2;                                  addr = (sljit_sw)(addr - jump->addr) >> 2;
322                                  SLJIT_ASSERT((sljit_w)addr <= 0x1fffffff && (sljit_w)addr >= -0x20000000);                                  SLJIT_ASSERT((sljit_sw)addr <= 0x1fffffff && (sljit_sw)addr >= -0x20000000);
323                                  buf_ptr[0] = CALL | (addr & 0x3fffffff);                                  buf_ptr[0] = CALL | (addr & 0x3fffffff);
324                                  break;                                  break;
325                          }                          }
326                          if (jump->flags & PATCH_B) {                          if (jump->flags & PATCH_B) {
327                                  addr = (sljit_w)(addr - jump->addr) >> 2;                                  addr = (sljit_sw)(addr - jump->addr) >> 2;
328                                  SLJIT_ASSERT((sljit_w)addr <= MAX_DISP && (sljit_w)addr >= MIN_DISP);                                  SLJIT_ASSERT((sljit_sw)addr <= MAX_DISP && (sljit_sw)addr >= MIN_DISP);
329                                  buf_ptr[0] = (buf_ptr[0] & ~DISP_MASK) | (addr & DISP_MASK);                                  buf_ptr[0] = (buf_ptr[0] & ~DISP_MASK) | (addr & DISP_MASK);
330                                  break;                                  break;
331                          }                          }
# Line 379  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 384  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
384  #include "sljitNativeSPARC_64.c"  #include "sljitNativeSPARC_64.c"
385  #endif  #endif
386    
387  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)
388  {  {
389          CHECK_ERROR();          CHECK_ERROR();
390          check_sljit_emit_enter(compiler, args, temporaries, saveds, local_size);          check_sljit_emit_enter(compiler, args, temporaries, saveds, local_size);
# Line 390  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 395  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
395          compiler->logical_local_size = local_size;          compiler->logical_local_size = local_size;
396  #endif  #endif
397    
398          local_size += 23 * sizeof(sljit_w);          local_size += 23 * sizeof(sljit_sw);
399          local_size = (local_size + 7) & ~0x7;          local_size = (local_size + 7) & ~0x7;
400          compiler->local_size = local_size;          compiler->local_size = local_size;
401    
# Line 412  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 417  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
417          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
418  }  }
419    
420  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)
421  {  {
422          CHECK_ERROR_VOID();          CHECK_ERROR_VOID();
423          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);
# Line 423  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_ Line 428  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_
428          compiler->logical_local_size = local_size;          compiler->logical_local_size = local_size;
429  #endif  #endif
430    
431          local_size += 23 * sizeof(sljit_w);          local_size += 23 * sizeof(sljit_sw);
432          compiler->local_size = (local_size + 7) & ~0x7;          compiler->local_size = (local_size + 7) & ~0x7;
433  }  }
434    
435  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)
436  {  {
437          CHECK_ERROR();          CHECK_ERROR();
438          check_sljit_emit_return(compiler, op, src, srcw);          check_sljit_emit_return(compiler, op, src, srcw);
# Line 451  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 456  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
456  #define ARCH_32_64(a, b)        b  #define ARCH_32_64(a, b)        b
457  #endif  #endif
458    
459  static SLJIT_CONST sljit_ins data_transfer_insts[16 + 2] = {  static SLJIT_CONST sljit_ins data_transfer_insts[16 + 4] = {
460  /* u w s */ ARCH_32_64(OPC1(3) | OPC3(0x04) /* stw */, OPC1(3) | OPC3(0x0e) /* stx */),  /* u w s */ ARCH_32_64(OPC1(3) | OPC3(0x04) /* stw */, OPC1(3) | OPC3(0x0e) /* stx */),
461  /* u w l */ ARCH_32_64(OPC1(3) | OPC3(0x00) /* lduw */, OPC1(3) | OPC3(0x0b) /* ldx */),  /* u w l */ ARCH_32_64(OPC1(3) | OPC3(0x00) /* lduw */, OPC1(3) | OPC3(0x0b) /* ldx */),
462  /* u b s */ OPC1(3) | OPC3(0x05) /* stb */,  /* u b s */ OPC1(3) | OPC3(0x05) /* stb */,
# Line 472  static SLJIT_CONST sljit_ins data_transf Line 477  static SLJIT_CONST sljit_ins data_transf
477    
478  /* d   s */ OPC1(3) | OPC3(0x27),  /* d   s */ OPC1(3) | OPC3(0x27),
479  /* d   l */ OPC1(3) | OPC3(0x23),  /* d   l */ OPC1(3) | OPC3(0x23),
480    /* s   s */ OPC1(3) | OPC3(0x24),
481    /* s   l */ OPC1(3) | OPC3(0x20),
482  };  };
483    
484  #undef ARCH_32_64  #undef ARCH_32_64
485    
486  /* Can perform an operation using at most 1 instruction. */  /* Can perform an operation using at most 1 instruction. */
487  static int getput_arg_fast(struct sljit_compiler *compiler, int flags, int reg, int arg, sljit_w argw)  static sljit_si getput_arg_fast(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
488  {  {
489          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
490    
# Line 500  static int getput_arg_fast(struct sljit_ Line 507  static int getput_arg_fast(struct sljit_
507  /* See getput_arg below.  /* See getput_arg below.
508     Note: can_cache is called only for binary operators. Those     Note: can_cache is called only for binary operators. Those
509     operators always uses word arguments without write back. */     operators always uses word arguments without write back. */
510  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)
511  {  {
512          SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM));          SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM));
513    
# Line 520  static int can_cache(int arg, sljit_w ar Line 527  static int can_cache(int arg, sljit_w ar
527  }  }
528    
529  /* Emit the necessary instructions. See can_cache above. */  /* Emit the necessary instructions. See can_cache above. */
530  static int getput_arg(struct sljit_compiler *compiler, int flags, int reg, int arg, sljit_w argw, int next_arg, sljit_w next_argw)  static sljit_si getput_arg(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
531  {  {
532          int base, arg2, delay_slot;          sljit_si base, arg2, delay_slot;
533          sljit_ins dest;          sljit_ins dest;
534    
535          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
# Line 584  static int getput_arg(struct sljit_compi Line 591  static int getput_arg(struct sljit_compi
591          return push_inst(compiler, ADD | D(base) | S1(base) | S2(arg2), DR(base));          return push_inst(compiler, ADD | D(base) | S1(base) | S2(arg2), DR(base));
592  }  }
593    
594  static SLJIT_INLINE int emit_op_mem(struct sljit_compiler *compiler, int flags, int reg, int arg, sljit_w argw)  static SLJIT_INLINE sljit_si emit_op_mem(struct sljit_compiler *compiler, sljit_si flags, sljit_si reg, sljit_si arg, sljit_sw argw)
595  {  {
596          if (getput_arg_fast(compiler, flags, reg, arg, argw))          if (getput_arg_fast(compiler, flags, reg, arg, argw))
597                  return compiler->error;                  return compiler->error;
# Line 593  static SLJIT_INLINE int emit_op_mem(stru Line 600  static SLJIT_INLINE int emit_op_mem(stru
600          return getput_arg(compiler, flags, reg, arg, argw, 0, 0);          return getput_arg(compiler, flags, reg, arg, argw, 0, 0);
601  }  }
602    
603  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)
604  {  {
605          if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))          if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))
606                  return compiler->error;                  return compiler->error;
607          return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);          return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);
608  }  }
609    
610  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,
611          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
612          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
613          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
614  {  {
615          /* arg1 goes to TMP_REG1 or src reg          /* arg1 goes to TMP_REG1 or src reg
616             arg2 goes to TMP_REG2, imm or src reg             arg2 goes to TMP_REG2, imm or src reg
617             TMP_REG3 can be used for caching             TMP_REG3 can be used for caching
618             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. */
619          int dst_r = TMP_REG2;          sljit_si dst_r = TMP_REG2;
620          int src1_r;          sljit_si src1_r;
621          sljit_w src2_r = 0;          sljit_sw src2_r = 0;
622          int sugg_src2_r = TMP_REG2;          sljit_si sugg_src2_r = TMP_REG2;
623    
624          compiler->cache_arg = 0;          compiler->cache_arg = 0;
625          compiler->cache_argw = 0;          compiler->cache_argw = 0;
# Line 724  static int emit_op(struct sljit_compiler Line 731  static int emit_op(struct sljit_compiler
731          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
732  }  }
733    
734  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)
735  {  {
736          CHECK_ERROR();          CHECK_ERROR();
737          check_sljit_emit_op0(compiler, op);          check_sljit_emit_op0(compiler, op);
# Line 765  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 772  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
772          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
773  }  }
774    
775  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,
776          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
777          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
778  {  {
779          int flags = GET_FLAGS(op) ? SET_FLAGS : 0;          sljit_si flags = GET_FLAGS(op) ? SET_FLAGS : 0;
780    
781          CHECK_ERROR();          CHECK_ERROR();
782          check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);
# Line 792  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 799  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
799                  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);
800    
801          case SLJIT_MOV_SB:          case SLJIT_MOV_SB:
802                  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);
803    
804          case SLJIT_MOV_UH:          case SLJIT_MOV_UH:
805                  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);
806    
807          case SLJIT_MOV_SH:          case SLJIT_MOV_SH:
808                  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);
809    
810          case SLJIT_MOVU:          case SLJIT_MOVU:
811          case SLJIT_MOVU_P:          case SLJIT_MOVU_P:
# Line 814  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 821  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
821                  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);
822    
823          case SLJIT_MOVU_SB:          case SLJIT_MOVU_SB:
824                  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);
825    
826          case SLJIT_MOVU_UH:          case SLJIT_MOVU_UH:
827                  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);
828    
829          case SLJIT_MOVU_SH:          case SLJIT_MOVU_SH:
830                  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);
831    
832          case SLJIT_NOT:          case SLJIT_NOT:
833          case SLJIT_CLZ:          case SLJIT_CLZ:
# Line 833  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 840  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
840          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
841  }  }
842    
843  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,
844          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
845          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
846          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
847  {  {
848          int flags = GET_FLAGS(op) ? SET_FLAGS : 0;          sljit_si flags = GET_FLAGS(op) ? SET_FLAGS : 0;
849    
850          CHECK_ERROR();          CHECK_ERROR();
851          check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);          check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
# Line 875  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 882  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
882          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
883  }  }
884    
885  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_register_index(sljit_si reg)
886  {  {
887          check_sljit_get_register_index(reg);          check_sljit_get_register_index(reg);
888          return reg_map[reg];          return reg_map[reg];
889  }  }
890    
891  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,
892          void *instruction, int size)          void *instruction, sljit_si size)
893  {  {
894          CHECK_ERROR();          CHECK_ERROR();
895          check_sljit_emit_op_custom(compiler, instruction, size);          check_sljit_emit_op_custom(compiler, instruction, size);
# Line 895  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 902  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
902  /*  Floating point operators                                             */  /*  Floating point operators                                             */
903  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
904    
905  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_is_fpu_available(void)
906  {  {
907          return 1;          return 1;
908  }  }
909    
910  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))
911          int dst, sljit_w dstw,  #define SELECT_FOP(op, single, double) ((op & SLJIT_SINGLE_OP) ? single : double)
912          int src, sljit_w srcw)  
913    SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op,
914            sljit_si dst, sljit_sw dstw,
915            sljit_si src, sljit_sw srcw)
916  {  {
917          int dst_fr;          sljit_si dst_fr;
918    
919          CHECK_ERROR();          CHECK_ERROR();
920          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);
921            SLJIT_COMPILE_ASSERT((SLJIT_SINGLE_OP == 0x100) && !(DOUBLE_DATA & 0x2), float_transfer_bit_error);
922    
923          compiler->cache_arg = 0;          compiler->cache_arg = 0;
924          compiler->cache_argw = 0;          compiler->cache_argw = 0;
925    
926          if (GET_OPCODE(op) == SLJIT_FCMP) {          if (GET_OPCODE(op) == SLJIT_CMPD) {
927                  if (dst > SLJIT_FLOAT_REG4) {                  if (dst > SLJIT_FLOAT_REG6) {
928                          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));
929                          dst = TMP_FREG1;                          dst = TMP_FREG1;
930                  }                  }
931                  else                  else
932                          dst <<= 1;                          dst <<= 1;
933    
934                  if (src > SLJIT_FLOAT_REG4) {                  if (src > SLJIT_FLOAT_REG6) {
935                          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));
936                          src = TMP_FREG2;                          src = TMP_FREG2;
937                  }                  }
938                  else                  else
939                          src <<= 1;                          src <<= 1;
940    
941                  return push_inst(compiler, FCMPD | S1A(dst) | S2A(src), FCC_IS_SET | MOVABLE_INS);                  return push_inst(compiler, SELECT_FOP(op, FCMPS, FCMPD) | S1A(dst) | S2A(src), FCC_IS_SET | MOVABLE_INS);
942          }          }
943    
944          dst_fr = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG1 : (dst << 1);          dst_fr = (dst > SLJIT_FLOAT_REG6) ? TMP_FREG1 : (dst << 1);
945    
946          if (src > SLJIT_FLOAT_REG4) {          if (src > SLJIT_FLOAT_REG6) {
947                  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));
948                  src = dst_fr;                  src = dst_fr;
949          }          }
950          else          else
951                  src <<= 1;                  src <<= 1;
952    
953          switch (op) {          switch (GET_OPCODE(op)) {
954                  case SLJIT_FMOV:                  case SLJIT_MOVD:
955                          if (src != dst_fr && dst_fr != TMP_FREG1) {                          if (src != dst_fr && dst_fr != TMP_FREG1) {
956                                  FAIL_IF(push_inst(compiler, FMOVS | DA(dst_fr) | S2A(src), MOVABLE_INS));                                  FAIL_IF(push_inst(compiler, FMOVS | DA(dst_fr) | S2A(src), MOVABLE_INS));
957                                  FAIL_IF(push_inst(compiler, FMOVS | DA(dst_fr | 1) | S2A(src | 1), MOVABLE_INS));                                  if (!(op & SLJIT_SINGLE_OP))
958                                            FAIL_IF(push_inst(compiler, FMOVS | DA(dst_fr | 1) | S2A(src | 1), MOVABLE_INS));
959                          }                          }
960                          break;                          break;
961                  case SLJIT_FNEG:                  case SLJIT_NEGD:
962                          FAIL_IF(push_inst(compiler, FNEGS | DA(dst_fr) | S2A(src), MOVABLE_INS));                          FAIL_IF(push_inst(compiler, FNEGS | DA(dst_fr) | S2A(src), MOVABLE_INS));
963                          if (dst_fr != src)                          if (dst_fr != src && !(op & SLJIT_SINGLE_OP))
964                                  FAIL_IF(push_inst(compiler, FMOVS | DA(dst_fr | 1) | S2A(src | 1), MOVABLE_INS));                                  FAIL_IF(push_inst(compiler, FMOVS | DA(dst_fr | 1) | S2A(src | 1), MOVABLE_INS));
965                          break;                          break;
966                  case SLJIT_FABS:                  case SLJIT_ABSD:
967                          FAIL_IF(push_inst(compiler, FABSS | DA(dst_fr) | S2A(src), MOVABLE_INS));                          FAIL_IF(push_inst(compiler, FABSS | DA(dst_fr) | S2A(src), MOVABLE_INS));
968                          if (dst_fr != src)                          if (dst_fr != src && !(op & SLJIT_SINGLE_OP))
969                                  FAIL_IF(push_inst(compiler, FMOVS | DA(dst_fr | 1) | S2A(src | 1), MOVABLE_INS));                                  FAIL_IF(push_inst(compiler, FMOVS | DA(dst_fr | 1) | S2A(src | 1), MOVABLE_INS));
970                          break;                          break;
971          }          }
972    
973          if (dst_fr == TMP_FREG1) {          if (dst_fr == TMP_FREG1) {
974                  if (op == SLJIT_FMOV)                  if (GET_OPCODE(op) == SLJIT_MOVD)
975                          dst_fr = src;                          dst_fr = src;
976                  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));
977          }          }
978    
979          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
980  }  }
981    
982  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,
983          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
984          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
985          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
986  {  {
987          int dst_fr, flags = 0;          sljit_si dst_fr, flags = 0;
988    
989          CHECK_ERROR();          CHECK_ERROR();
990          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 980  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 992  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
992          compiler->cache_arg = 0;          compiler->cache_arg = 0;
993          compiler->cache_argw = 0;          compiler->cache_argw = 0;
994    
995          dst_fr = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG2 : (dst << 1);          dst_fr = (dst > SLJIT_FLOAT_REG6) ? TMP_FREG2 : (dst << 1);
996    
997          if (src1 > SLJIT_FLOAT_REG4) {          if (src1 > SLJIT_FLOAT_REG6) {
998                  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)) {
999                          FAIL_IF(compiler->error);                          FAIL_IF(compiler->error);
1000                          src1 = TMP_FREG1;                          src1 = TMP_FREG1;
1001                  } else                  } else
# Line 992  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1004  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1004          else          else
1005                  src1 <<= 1;                  src1 <<= 1;
1006    
1007          if (src2 > SLJIT_FLOAT_REG4) {          if (src2 > SLJIT_FLOAT_REG6) {
1008                  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)) {
1009                          FAIL_IF(compiler->error);                          FAIL_IF(compiler->error);
1010                          src2 = TMP_FREG2;                          src2 = TMP_FREG2;
1011                  } else                  } else
# Line 1004  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1016  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1016    
1017          if ((flags & (SLOW_SRC1 | SLOW_SRC2)) == (SLOW_SRC1 | SLOW_SRC2)) {          if ((flags & (SLOW_SRC1 | SLOW_SRC2)) == (SLOW_SRC1 | SLOW_SRC2)) {
1018                  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)) {
1019                          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));
1020                          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));
1021                  }                  }
1022                  else {                  else {
1023                          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));
1024                          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));
1025                  }                  }
1026          }          }
1027          else if (flags & SLOW_SRC1)          else if (flags & SLOW_SRC1)
1028                  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));
1029          else if (flags & SLOW_SRC2)          else if (flags & SLOW_SRC2)
1030                  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));
1031    
1032          if (flags & SLOW_SRC1)          if (flags & SLOW_SRC1)
1033                  src1 = TMP_FREG1;                  src1 = TMP_FREG1;
1034          if (flags & SLOW_SRC2)          if (flags & SLOW_SRC2)
1035                  src2 = TMP_FREG2;                  src2 = TMP_FREG2;
1036    
1037          switch (op) {          switch (GET_OPCODE(op)) {
1038          case SLJIT_FADD:          case SLJIT_ADDD:
1039                  FAIL_IF(push_inst(compiler, FADDD | DA(dst_fr) | S1A(src1) | S2A(src2), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, SELECT_FOP(op, FADDS, FADDD) | DA(dst_fr) | S1A(src1) | S2A(src2), MOVABLE_INS));
1040                  break;                  break;
1041    
1042          case SLJIT_FSUB:          case SLJIT_SUBD:
1043                  FAIL_IF(push_inst(compiler, FSUBD | DA(dst_fr) | S1A(src1) | S2A(src2), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, SELECT_FOP(op, FSUBS, FSUBD) | DA(dst_fr) | S1A(src1) | S2A(src2), MOVABLE_INS));
1044                  break;                  break;
1045    
1046          case SLJIT_FMUL:          case SLJIT_MULD:
1047                  FAIL_IF(push_inst(compiler, FMULD | DA(dst_fr) | S1A(src1) | S2A(src2), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, SELECT_FOP(op, FMULS, FMULD) | DA(dst_fr) | S1A(src1) | S2A(src2), MOVABLE_INS));
1048                  break;                  break;
1049    
1050          case SLJIT_FDIV:          case SLJIT_DIVD:
1051                  FAIL_IF(push_inst(compiler, FDIVD | DA(dst_fr) | S1A(src1) | S2A(src2), MOVABLE_INS));                  FAIL_IF(push_inst(compiler, SELECT_FOP(op, FDIVS, FDIVD) | DA(dst_fr) | S1A(src1) | S2A(src2), MOVABLE_INS));
1052                  break;                  break;
1053          }          }
1054    
1055          if (dst_fr == TMP_FREG2)          if (dst_fr == TMP_FREG2)
1056                  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));
1057    
1058          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1059  }  }
1060    
1061    #undef FLOAT_DATA
1062    #undef SELECT_FOP
1063    
1064  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1065  /*  Other instructions                                                   */  /*  Other instructions                                                   */
1066  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1067    
1068  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)
1069  {  {
1070          CHECK_ERROR();          CHECK_ERROR();
1071          check_sljit_emit_fast_enter(compiler, dst, dstw);          check_sljit_emit_fast_enter(compiler, dst, dstw);
# Line 1065  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1080  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1080          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1081  }  }
1082    
1083  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)
1084  {  {
1085          CHECK_ERROR();          CHECK_ERROR();
1086          check_sljit_emit_fast_return(compiler, src, srcw);          check_sljit_emit_fast_return(compiler, src, srcw);
# Line 1103  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la Line 1118  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la
1118          return label;          return label;
1119  }  }
1120    
1121  static sljit_ins get_cc(int type)  static sljit_ins get_cc(sljit_si type)
1122  {  {
1123          switch (type) {          switch (type) {
1124          case SLJIT_C_EQUAL:          case SLJIT_C_EQUAL:
# Line 1174  static sljit_ins get_cc(int type) Line 1189  static sljit_ins get_cc(int type)
1189          }          }
1190  }  }
1191    
1192  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)
1193  {  {
1194          struct sljit_jump *jump;          struct sljit_jump *jump;
1195    
# Line 1220  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1235  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1235          return jump;          return jump;
1236  }  }
1237    
1238  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_ijump(struct sljit_compiler *compiler, sljit_si type, sljit_si src, sljit_sw srcw)
1239  {  {
1240          struct sljit_jump *jump = NULL;          struct sljit_jump *jump = NULL;
1241          int src_r;          sljit_si src_r;
1242    
1243          CHECK_ERROR();          CHECK_ERROR();
1244          check_sljit_emit_ijump(compiler, type, src, srcw);          check_sljit_emit_ijump(compiler, type, src, srcw);
# Line 1255  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1270  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1270          return push_inst(compiler, NOP, UNMOVABLE_INS);          return push_inst(compiler, NOP, UNMOVABLE_INS);
1271  }  }
1272    
1273  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)
1274  {  {
1275          int reg;          sljit_si reg;
1276    
1277          CHECK_ERROR();          CHECK_ERROR();
1278          check_sljit_emit_cond_value(compiler, op, dst, dstw, type);          check_sljit_emit_cond_value(compiler, op, dst, dstw, type);
# Line 1286  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1301  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1301  #endif  #endif
1302  }  }
1303    
1304  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)
1305  {  {
1306          int reg;          sljit_si reg;
1307          struct sljit_const *const_;          struct sljit_const *const_;
1308    
1309          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();

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

  ViewVC Help
Powered by ViewVC 1.1.5