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

Diff of /code/trunk/sljit/sljitNativePPC_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 83  static void ppc_cache_flush(sljit_ins *f Line 83  static void ppc_cache_flush(sljit_ins *f
83  #define TMP_REG3        (SLJIT_NO_REGISTERS + 3)  #define TMP_REG3        (SLJIT_NO_REGISTERS + 3)
84  #define ZERO_REG        (SLJIT_NO_REGISTERS + 4)  #define ZERO_REG        (SLJIT_NO_REGISTERS + 4)
85    
86  #define TMP_FREG1       (SLJIT_FLOAT_REG4 + 1)  #define TMP_FREG1       (0)
87  #define TMP_FREG2       (SLJIT_FLOAT_REG4 + 2)  #define TMP_FREG2       (SLJIT_FLOAT_REG6 + 1)
88    
89  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 5] = {  static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 5] = {
90          0, 3, 4, 5, 6, 7, 30, 29, 28, 27, 26, 1, 8, 9, 10, 31          0, 3, 4, 5, 6, 7, 30, 29, 28, 27, 26, 1, 8, 9, 10, 31
# Line 143  static SLJIT_CONST sljit_ub reg_map[SLJI Line 143  static SLJIT_CONST sljit_ub reg_map[SLJI
143  #define EXTSW           (HI(31) | LO(986))  #define EXTSW           (HI(31) | LO(986))
144  #define FABS            (HI(63) | LO(264))  #define FABS            (HI(63) | LO(264))
145  #define FADD            (HI(63) | LO(21))  #define FADD            (HI(63) | LO(21))
146    #define FADDS           (HI(59) | LO(21))
147  #define FCMPU           (HI(63) | LO(0))  #define FCMPU           (HI(63) | LO(0))
148  #define FDIV            (HI(63) | LO(18))  #define FDIV            (HI(63) | LO(18))
149    #define FDIVS           (HI(59) | LO(18))
150  #define FMR             (HI(63) | LO(72))  #define FMR             (HI(63) | LO(72))
151  #define FMUL            (HI(63) | LO(25))  #define FMUL            (HI(63) | LO(25))
152    #define FMULS           (HI(59) | LO(25))
153  #define FNEG            (HI(63) | LO(40))  #define FNEG            (HI(63) | LO(40))
154  #define FSUB            (HI(63) | LO(20))  #define FSUB            (HI(63) | LO(20))
155    #define FSUBS           (HI(59) | LO(20))
156  #define LD              (HI(58) | 0)  #define LD              (HI(58) | 0)
157  #define LWZ             (HI(32))  #define LWZ             (HI(32))
158  #define MFCR            (HI(31) | LO(19))  #define MFCR            (HI(31) | LO(19))
# Line 199  static SLJIT_CONST sljit_ub reg_map[SLJI Line 203  static SLJIT_CONST sljit_ub reg_map[SLJI
203  #define UIMM_MAX        (0xffff)  #define UIMM_MAX        (0xffff)
204    
205  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
206  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_function_context(void** func_ptr, struct sljit_function_context* context, sljit_w addr, void* func)  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_function_context(void** func_ptr, struct sljit_function_context* context, sljit_sw addr, void* func)
207  {  {
208          sljit_w* ptrs;          sljit_sw* ptrs;
209          if (func_ptr)          if (func_ptr)
210                  *func_ptr = (void*)context;                  *func_ptr = (void*)context;
211          ptrs = (sljit_w*)func;          ptrs = (sljit_sw*)func;
212          context->addr = addr ? addr : ptrs[0];          context->addr = addr ? addr : ptrs[0];
213          context->r2 = ptrs[1];          context->r2 = ptrs[1];
214          context->r11 = ptrs[2];          context->r11 = ptrs[2];
215  }  }
216  #endif  #endif
217    
218  static int push_inst(struct sljit_compiler *compiler, sljit_ins ins)  static sljit_si push_inst(struct sljit_compiler *compiler, sljit_ins ins)
219  {  {
220          sljit_ins *ptr = (sljit_ins*)ensure_buf(compiler, sizeof(sljit_ins));          sljit_ins *ptr = (sljit_ins*)ensure_buf(compiler, sizeof(sljit_ins));
221          FAIL_IF(!ptr);          FAIL_IF(!ptr);
# Line 220  static int push_inst(struct sljit_compil Line 224  static int push_inst(struct sljit_compil
224          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
225  }  }
226    
227  static SLJIT_INLINE int optimize_jump(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code)  static SLJIT_INLINE sljit_si optimize_jump(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code)
228  {  {
229          sljit_w diff;          sljit_sw diff;
230          sljit_uw target_addr;          sljit_uw target_addr;
231    
232          if (jump->flags & SLJIT_REWRITABLE_JUMP)          if (jump->flags & SLJIT_REWRITABLE_JUMP)
# Line 234  static SLJIT_INLINE int optimize_jump(st Line 238  static SLJIT_INLINE int optimize_jump(st
238                  SLJIT_ASSERT(jump->flags & JUMP_LABEL);                  SLJIT_ASSERT(jump->flags & JUMP_LABEL);
239                  target_addr = (sljit_uw)(code + jump->u.label->size);                  target_addr = (sljit_uw)(code + jump->u.label->size);
240          }          }
241          diff = ((sljit_w)target_addr - (sljit_w)(code_ptr)) & ~0x3l;          diff = ((sljit_sw)target_addr - (sljit_sw)(code_ptr)) & ~0x3l;
242    
243          if (jump->flags & UNCOND_B) {          if (jump->flags & UNCOND_B) {
244                  if (diff <= 0x01ffffff && diff >= -0x02000000) {                  if (diff <= 0x01ffffff && diff >= -0x02000000) {
# Line 347  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 351  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
351          SLJIT_ASSERT(!jump);          SLJIT_ASSERT(!jump);
352          SLJIT_ASSERT(!const_);          SLJIT_ASSERT(!const_);
353  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
354          SLJIT_ASSERT(code_ptr - code <= (int)compiler->size - (sizeof(struct sljit_function_context) / sizeof(sljit_ins)));          SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size - (sizeof(struct sljit_function_context) / sizeof(sljit_ins)));
355  #else  #else
356          SLJIT_ASSERT(code_ptr - code <= (int)compiler->size);          SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size);
357  #endif  #endif
358    
359          jump = compiler->jumps;          jump = compiler->jumps;
# Line 361  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 365  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
365                                  if (jump->flags & UNCOND_B) {                                  if (jump->flags & UNCOND_B) {
366                                          if (!(jump->flags & ABSOLUTE_B)) {                                          if (!(jump->flags & ABSOLUTE_B)) {
367                                                  addr = addr - jump->addr;                                                  addr = addr - jump->addr;
368                                                  SLJIT_ASSERT((sljit_w)addr <= 0x01ffffff && (sljit_w)addr >= -0x02000000);                                                  SLJIT_ASSERT((sljit_sw)addr <= 0x01ffffff && (sljit_sw)addr >= -0x02000000);
369                                                  *buf_ptr = Bx | (addr & 0x03fffffc) | ((*buf_ptr) & 0x1);                                                  *buf_ptr = Bx | (addr & 0x03fffffc) | ((*buf_ptr) & 0x1);
370                                          }                                          }
371                                          else {                                          else {
# Line 372  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 376  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
376                                  else {                                  else {
377                                          if (!(jump->flags & ABSOLUTE_B)) {                                          if (!(jump->flags & ABSOLUTE_B)) {
378                                                  addr = addr - jump->addr;                                                  addr = addr - jump->addr;
379                                                  SLJIT_ASSERT((sljit_w)addr <= 0x7fff && (sljit_w)addr >= -0x8000);                                                  SLJIT_ASSERT((sljit_sw)addr <= 0x7fff && (sljit_sw)addr >= -0x8000);
380                                                  *buf_ptr = BCx | (addr & 0xfffc) | ((*buf_ptr) & 0x03ff0001);                                                  *buf_ptr = BCx | (addr & 0xfffc) | ((*buf_ptr) & 0x03ff0001);
381                                          }                                          }
382                                          else {                                          else {
# Line 404  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen Line 408  SLJIT_API_FUNC_ATTRIBUTE void* sljit_gen
408    
409  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
410  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
411          if (((sljit_w)code_ptr) & 0x4)          if (((sljit_sw)code_ptr) & 0x4)
412                  code_ptr++;                  code_ptr++;
413          sljit_set_function_context(NULL, (struct sljit_function_context*)code_ptr, (sljit_w)code, (void*)sljit_generate_code);          sljit_set_function_context(NULL, (struct sljit_function_context*)code_ptr, (sljit_sw)code, (void*)sljit_generate_code);
414          return code_ptr;          return code_ptr;
415  #else  #else
416          sljit_set_function_context(NULL, (struct sljit_function_context*)code_ptr, (sljit_w)code, (void*)sljit_generate_code);          sljit_set_function_context(NULL, (struct sljit_function_context*)code_ptr, (sljit_sw)code, (void*)sljit_generate_code);
417          return code_ptr;          return code_ptr;
418  #endif  #endif
419  #else  #else
# Line 481  ALT_FORM6              0x200000 */ Line 485  ALT_FORM6              0x200000 */
485  #define STACK_LOAD      LD  #define STACK_LOAD      LD
486  #endif  #endif
487    
488  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)
489  {  {
490          CHECK_ERROR();          CHECK_ERROR();
491          check_sljit_emit_enter(compiler, args, temporaries, saveds, local_size);          check_sljit_emit_enter(compiler, args, temporaries, saveds, local_size);
# Line 493  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 497  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
497  #endif  #endif
498    
499          FAIL_IF(push_inst(compiler, MFLR | D(0)));          FAIL_IF(push_inst(compiler, MFLR | D(0)));
500          FAIL_IF(push_inst(compiler, STACK_STORE | S(ZERO_REG) | A(SLJIT_LOCALS_REG) | IMM(-(int)(sizeof(sljit_w))) ));          FAIL_IF(push_inst(compiler, STACK_STORE | S(ZERO_REG) | A(SLJIT_LOCALS_REG) | IMM(-(sljit_si)(sizeof(sljit_sw))) ));
501          if (saveds >= 1)          if (saveds >= 1)
502                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG1) | A(SLJIT_LOCALS_REG) | IMM(-2 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG1) | A(SLJIT_LOCALS_REG) | IMM(-2 * (sljit_si)(sizeof(sljit_sw))) ));
503          if (saveds >= 2)          if (saveds >= 2)
504                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG2) | A(SLJIT_LOCALS_REG) | IMM(-3 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG2) | A(SLJIT_LOCALS_REG) | IMM(-3 * (sljit_si)(sizeof(sljit_sw))) ));
505          if (saveds >= 3)          if (saveds >= 3)
506                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG3) | A(SLJIT_LOCALS_REG) | IMM(-4 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_REG3) | A(SLJIT_LOCALS_REG) | IMM(-4 * (sljit_si)(sizeof(sljit_sw))) ));
507          if (saveds >= 4)          if (saveds >= 4)
508                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_EREG1) | A(SLJIT_LOCALS_REG) | IMM(-5 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_EREG1) | A(SLJIT_LOCALS_REG) | IMM(-5 * (sljit_si)(sizeof(sljit_sw))) ));
509          if (saveds >= 5)          if (saveds >= 5)
510                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_EREG2) | A(SLJIT_LOCALS_REG) | IMM(-6 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_STORE | S(SLJIT_SAVED_EREG2) | A(SLJIT_LOCALS_REG) | IMM(-6 * (sljit_si)(sizeof(sljit_sw))) ));
511          FAIL_IF(push_inst(compiler, STACK_STORE | S(0) | A(SLJIT_LOCALS_REG) | IMM(sizeof(sljit_w)) ));          FAIL_IF(push_inst(compiler, STACK_STORE | S(0) | A(SLJIT_LOCALS_REG) | IMM(sizeof(sljit_sw)) ));
512    
513          FAIL_IF(push_inst(compiler, ADDI | D(ZERO_REG) | A(0) | 0));          FAIL_IF(push_inst(compiler, ADDI | D(ZERO_REG) | A(0) | 0));
514          if (args >= 1)          if (args >= 1)
# Line 515  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 519  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
519                  FAIL_IF(push_inst(compiler, OR | S(SLJIT_TEMPORARY_REG3) | A(SLJIT_SAVED_REG3) | B(SLJIT_TEMPORARY_REG3)));                  FAIL_IF(push_inst(compiler, OR | S(SLJIT_TEMPORARY_REG3) | A(SLJIT_SAVED_REG3) | B(SLJIT_TEMPORARY_REG3)));
520    
521  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
522          compiler->local_size = (1 + saveds + 6 + 8) * sizeof(sljit_w) + local_size;          compiler->local_size = (1 + saveds + 6 + 8) * sizeof(sljit_sw) + local_size;
523  #else  #else
524          compiler->local_size = (1 + saveds + 2) * sizeof(sljit_w) + local_size;          compiler->local_size = (1 + saveds + 2) * sizeof(sljit_sw) + local_size;
525  #endif  #endif
526          compiler->local_size = (compiler->local_size + 15) & ~0xf;          compiler->local_size = (compiler->local_size + 15) & ~0xf;
527    
# Line 540  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 544  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
544          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
545  }  }
546    
547  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)
548  {  {
549          CHECK_ERROR_VOID();          CHECK_ERROR_VOID();
550          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);
# Line 552  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_ Line 556  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_
556  #endif  #endif
557    
558  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)  #if (defined SLJIT_INDIRECT_CALL && SLJIT_INDIRECT_CALL)
559          compiler->local_size = (1 + saveds + 6 + 8) * sizeof(sljit_w) + local_size;          compiler->local_size = (1 + saveds + 6 + 8) * sizeof(sljit_sw) + local_size;
560  #else  #else
561          compiler->local_size = (1 + saveds + 2) * sizeof(sljit_w) + local_size;          compiler->local_size = (1 + saveds + 2) * sizeof(sljit_sw) + local_size;
562  #endif  #endif
563          compiler->local_size = (compiler->local_size + 15) & ~0xf;          compiler->local_size = (compiler->local_size + 15) & ~0xf;
564  }  }
565    
566  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)
567  {  {
568          CHECK_ERROR();          CHECK_ERROR();
569          check_sljit_emit_return(compiler, op, src, srcw);          check_sljit_emit_return(compiler, op, src, srcw);
# Line 573  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 577  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
577                  FAIL_IF(push_inst(compiler, ADD | D(SLJIT_LOCALS_REG) | A(SLJIT_LOCALS_REG) | B(0)));                  FAIL_IF(push_inst(compiler, ADD | D(SLJIT_LOCALS_REG) | A(SLJIT_LOCALS_REG) | B(0)));
578          }          }
579    
580          FAIL_IF(push_inst(compiler, STACK_LOAD | D(0) | A(SLJIT_LOCALS_REG) | IMM(sizeof(sljit_w))));          FAIL_IF(push_inst(compiler, STACK_LOAD | D(0) | A(SLJIT_LOCALS_REG) | IMM(sizeof(sljit_sw))));
581          if (compiler->saveds >= 5)          if (compiler->saveds >= 5)
582                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_EREG2) | A(SLJIT_LOCALS_REG) | IMM(-6 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_EREG2) | A(SLJIT_LOCALS_REG) | IMM(-6 * (sljit_si)(sizeof(sljit_sw))) ));
583          if (compiler->saveds >= 4)          if (compiler->saveds >= 4)
584                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_EREG1) | A(SLJIT_LOCALS_REG) | IMM(-5 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_EREG1) | A(SLJIT_LOCALS_REG) | IMM(-5 * (sljit_si)(sizeof(sljit_sw))) ));
585          if (compiler->saveds >= 3)          if (compiler->saveds >= 3)
586                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG3) | A(SLJIT_LOCALS_REG) | IMM(-4 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG3) | A(SLJIT_LOCALS_REG) | IMM(-4 * (sljit_si)(sizeof(sljit_sw))) ));
587          if (compiler->saveds >= 2)          if (compiler->saveds >= 2)
588                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG2) | A(SLJIT_LOCALS_REG) | IMM(-3 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG2) | A(SLJIT_LOCALS_REG) | IMM(-3 * (sljit_si)(sizeof(sljit_sw))) ));
589          if (compiler->saveds >= 1)          if (compiler->saveds >= 1)
590                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG1) | A(SLJIT_LOCALS_REG) | IMM(-2 * (int)(sizeof(sljit_w))) ));                  FAIL_IF(push_inst(compiler, STACK_LOAD | D(SLJIT_SAVED_REG1) | A(SLJIT_LOCALS_REG) | IMM(-2 * (sljit_si)(sizeof(sljit_sw))) ));
591          FAIL_IF(push_inst(compiler, STACK_LOAD | D(ZERO_REG) | A(SLJIT_LOCALS_REG) | IMM(-(int)(sizeof(sljit_w))) ));          FAIL_IF(push_inst(compiler, STACK_LOAD | D(ZERO_REG) | A(SLJIT_LOCALS_REG) | IMM(-(sljit_si)(sizeof(sljit_sw))) ));
592    
593          FAIL_IF(push_inst(compiler, MTLR | S(0)));          FAIL_IF(push_inst(compiler, MTLR | S(0)));
594          FAIL_IF(push_inst(compiler, BLR));          FAIL_IF(push_inst(compiler, BLR));
# Line 621  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 625  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
625          (((inst) & ~(ADDR_MODE2 | UPDATE_REQ)) | (((flags) & MEM_MASK) <= GPR_REG ? D(reg) : FD(reg)))          (((inst) & ~(ADDR_MODE2 | UPDATE_REQ)) | (((flags) & MEM_MASK) <= GPR_REG ? D(reg) : FD(reg)))
626  #endif  #endif
627    
628  static SLJIT_CONST sljit_ins data_transfer_insts[64 + 4] = {  static SLJIT_CONST sljit_ins data_transfer_insts[64 + 8] = {
629    
630  /* -------- Unsigned -------- */  /* -------- Unsigned -------- */
631    
# Line 730  static SLJIT_CONST sljit_ins data_transf Line 734  static SLJIT_CONST sljit_ins data_transf
734  /* d   n x s */ HI(31) | LO(727) /* stfdx */,  /* d   n x s */ HI(31) | LO(727) /* stfdx */,
735  /* d   n x l */ HI(31) | LO(599) /* lfdx */,  /* d   n x l */ HI(31) | LO(599) /* lfdx */,
736    
737    /* s   n i s */ HI(52) /* stfs */,
738    /* s   n i l */ HI(48) /* lfs */,
739    /* s   n x s */ HI(31) | LO(663) /* stfsx */,
740    /* s   n x l */ HI(31) | LO(535) /* lfsx */,
741    
742  };  };
743    
744  #undef ARCH_32_64  #undef ARCH_32_64
745    
746  /* Simple cases, (no caching is required). */  /* Simple cases, (no caching is required). */
747  static int getput_arg_fast(struct sljit_compiler *compiler, int inp_flags, int reg, int arg, sljit_w argw)  static sljit_si getput_arg_fast(struct sljit_compiler *compiler, sljit_si inp_flags, sljit_si reg, sljit_si arg, sljit_sw argw)
748  {  {
749          sljit_ins inst;          sljit_ins inst;
750  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
751          int tmp_reg;          sljit_si tmp_reg;
752  #endif  #endif
753    
754          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
# Line 811  static int getput_arg_fast(struct sljit_ Line 820  static int getput_arg_fast(struct sljit_
820  /* See getput_arg below.  /* See getput_arg below.
821     Note: can_cache is called only for binary operators. Those operator always     Note: can_cache is called only for binary operators. Those operator always
822     uses word arguments without write back. */     uses word arguments without write back. */
823  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)
824  {  {
825          SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM));          SLJIT_ASSERT((arg & SLJIT_MEM) && (next_arg & SLJIT_MEM));
826    
# Line 845  static int can_cache(int arg, sljit_w ar Line 854  static int can_cache(int arg, sljit_w ar
854  #endif  #endif
855    
856  /* Emit the necessary instructions. See can_cache above. */  /* Emit the necessary instructions. See can_cache above. */
857  static int getput_arg(struct sljit_compiler *compiler, int inp_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 inp_flags, sljit_si reg, sljit_si arg, sljit_sw argw, sljit_si next_arg, sljit_sw next_argw)
858  {  {
859          int tmp_r;          sljit_si tmp_r;
860          sljit_ins inst;          sljit_ins inst;
861    
862          SLJIT_ASSERT(arg & SLJIT_MEM);          SLJIT_ASSERT(arg & SLJIT_MEM);
# Line 947  static int getput_arg(struct sljit_compi Line 956  static int getput_arg(struct sljit_compi
956          return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | B(tmp_r));          return push_inst(compiler, INST_CODE_AND_DST(inst, inp_flags, reg) | A(arg & 0xf) | B(tmp_r));
957  }  }
958    
959  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)
960  {  {
961          if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))          if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))
962                  return compiler->error;                  return compiler->error;
963          return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);          return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);
964  }  }
965    
966  static int emit_op(struct sljit_compiler *compiler, int op, int input_flags,  static sljit_si emit_op(struct sljit_compiler *compiler, sljit_si op, sljit_si input_flags,
967          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
968          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
969          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
970  {  {
971          /* arg1 goes to TMP_REG1 or src reg          /* arg1 goes to TMP_REG1 or src reg
972             arg2 goes to TMP_REG2, imm or src reg             arg2 goes to TMP_REG2, imm or src reg
973             TMP_REG3 can be used for caching             TMP_REG3 can be used for caching
974             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. */
975          int dst_r;          sljit_si dst_r;
976          int src1_r;          sljit_si src1_r;
977          int src2_r;          sljit_si src2_r;
978          int sugg_src2_r = TMP_REG2;          sljit_si sugg_src2_r = TMP_REG2;
979          int flags = input_flags & (ALT_FORM1 | ALT_FORM2 | ALT_FORM3 | ALT_FORM4 | ALT_FORM5 | ALT_FORM6 | ALT_SIGN_EXT | ALT_SET_FLAGS);          sljit_si flags = input_flags & (ALT_FORM1 | ALT_FORM2 | ALT_FORM3 | ALT_FORM4 | ALT_FORM5 | ALT_FORM6 | ALT_SIGN_EXT | ALT_SET_FLAGS);
980    
981          compiler->cache_arg = 0;          compiler->cache_arg = 0;
982          compiler->cache_argw = 0;          compiler->cache_argw = 0;
# Line 1002  static int emit_op(struct sljit_compiler Line 1011  static int emit_op(struct sljit_compiler
1011                  flags |= REG1_SOURCE;                  flags |= REG1_SOURCE;
1012          }          }
1013          else if (src1 & SLJIT_IMM) {          else if (src1 & SLJIT_IMM) {
 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  
                 SLJIT_COMPILE_ASSERT(INT_DATA == 0x18, int_data_check1);  
                 if ((input_flags & 0x18) == INT_DATA) {  
                         if (input_flags & SIGNED_DATA)  
                                 src1w = (signed int)src1w;  
                         else  
                                 src1w = (unsigned int)src1w;  
                 }  
 #endif  
1014                  FAIL_IF(load_immediate(compiler, TMP_REG1, src1w));                  FAIL_IF(load_immediate(compiler, TMP_REG1, src1w));
1015                  src1_r = TMP_REG1;                  src1_r = TMP_REG1;
1016          }          }
# Line 1029  static int emit_op(struct sljit_compiler Line 1029  static int emit_op(struct sljit_compiler
1029                          dst_r = src2_r;                          dst_r = src2_r;
1030          }          }
1031          else if (src2 & SLJIT_IMM) {          else if (src2 & SLJIT_IMM) {
 #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  
                 SLJIT_COMPILE_ASSERT(INT_DATA == 0x18, int_data_check2);  
                 if ((input_flags & 0x18) == INT_DATA) {  
                         if (input_flags & SIGNED_DATA)  
                                 src2w = (signed int)src2w;  
                         else  
                                 src2w = (unsigned int)src2w;  
                 }  
 #endif  
1032                  FAIL_IF(load_immediate(compiler, sugg_src2_r, src2w));                  FAIL_IF(load_immediate(compiler, sugg_src2_r, src2w));
1033                  src2_r = sugg_src2_r;                  src2_r = sugg_src2_r;
1034          }          }
# Line 1099  static int emit_op(struct sljit_compiler Line 1090  static int emit_op(struct sljit_compiler
1090          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1091  }  }
1092    
1093  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)
1094  {  {
1095          CHECK_ERROR();          CHECK_ERROR();
1096          check_sljit_emit_op0(compiler, op);          check_sljit_emit_op0(compiler, op);
# Line 1144  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1135  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1135  #define EMIT_MOV(type, type_flags, type_cast) \  #define EMIT_MOV(type, type_flags, type_cast) \
1136          emit_op(compiler, (src & SLJIT_IMM) ? SLJIT_MOV : type, flags | (type_flags), dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? type_cast srcw : srcw)          emit_op(compiler, (src & SLJIT_IMM) ? SLJIT_MOV : type, flags | (type_flags), dst, dstw, TMP_REG1, 0, src, (src & SLJIT_IMM) ? type_cast srcw : srcw)
1137    
1138  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,
1139          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1140          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
1141  {  {
1142          int flags = GET_FLAGS(op) ? ALT_SET_FLAGS : 0;          sljit_si flags = GET_FLAGS(op) ? ALT_SET_FLAGS : 0;
1143            sljit_si op_flags = GET_ALL_FLAGS(op);
1144    
1145          CHECK_ERROR();          CHECK_ERROR();
1146          check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);
1147          ADJUST_LOCAL_OFFSET(dst, dstw);          ADJUST_LOCAL_OFFSET(dst, dstw);
1148          ADJUST_LOCAL_OFFSET(src, srcw);          ADJUST_LOCAL_OFFSET(src, srcw);
1149    
1150          if ((src & SLJIT_IMM) && srcw == 0 && GET_OPCODE(op) >= SLJIT_NOT)          op = GET_OPCODE(op);
1151            if ((src & SLJIT_IMM) && srcw == 0 && op >= SLJIT_NOT)
1152                  src = ZERO_REG;                  src = ZERO_REG;
1153    
1154            if (op_flags & SLJIT_SET_O)
1155                    FAIL_IF(push_inst(compiler, MTXER | S(ZERO_REG)));
1156    
1157            if (op_flags & SLJIT_INT_OP) {
1158                    if (op >= SLJIT_MOV && op <= SLJIT_MOVU_P) {
1159                            if (src <= SLJIT_NO_REGISTERS && src == dst) {
1160                                    if (!TYPE_CAST_NEEDED(op))
1161                                            return SLJIT_SUCCESS;
1162                            }
1163  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1164          if (op & SLJIT_INT_OP) {                          if (op == SLJIT_MOV_SI && (src & SLJIT_MEM))
1165                  flags |= INT_DATA | SIGNED_DATA;                                  op = SLJIT_MOV_UI;
1166                  if (src & SLJIT_IMM)                          if (op == SLJIT_MOVU_SI && (src & SLJIT_MEM))
1167                          srcw = (int)srcw;                                  op = SLJIT_MOVU_UI;
1168          }                          if (op == SLJIT_MOV_UI && (src & SLJIT_IMM))
1169                                    op = SLJIT_MOV_SI;
1170                            if (op == SLJIT_MOVU_UI && (src & SLJIT_IMM))
1171                                    op = SLJIT_MOVU_SI;
1172  #endif  #endif
1173          if (op & SLJIT_SET_O)                  }
1174                  FAIL_IF(push_inst(compiler, MTXER | S(ZERO_REG)));  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1175                    else {
1176                            /* Most operations expect sign extended arguments. */
1177                            flags |= INT_DATA | SIGNED_DATA;
1178                            if (src & SLJIT_IMM)
1179                                    srcw = (sljit_si)srcw;
1180                    }
1181    #endif
1182            }
1183    
1184          switch (GET_OPCODE(op)) {          switch (op) {
1185          case SLJIT_MOV:          case SLJIT_MOV:
1186          case SLJIT_MOV_P:          case SLJIT_MOV_P:
1187    #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
1188            case SLJIT_MOV_UI:
1189            case SLJIT_MOV_SI:
1190    #endif
1191                  return emit_op(compiler, SLJIT_MOV, flags | WORD_DATA, dst, dstw, TMP_REG1, 0, src, srcw);                  return emit_op(compiler, SLJIT_MOV, flags | WORD_DATA, dst, dstw, TMP_REG1, 0, src, srcw);
1192    
1193    #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1194          case SLJIT_MOV_UI:          case SLJIT_MOV_UI:
1195                  return emit_op(compiler, SLJIT_MOV_UI, flags | INT_DATA, dst, dstw, TMP_REG1, 0, src, srcw);                  return EMIT_MOV(SLJIT_MOV_UI, INT_DATA, (sljit_ui));
1196    
1197          case SLJIT_MOV_SI:          case SLJIT_MOV_SI:
1198                  return emit_op(compiler, SLJIT_MOV_SI, flags | INT_DATA | SIGNED_DATA, dst, dstw, TMP_REG1, 0, src, srcw);                  return EMIT_MOV(SLJIT_MOV_SI, INT_DATA | SIGNED_DATA, (sljit_si));
1199    #endif
1200    
1201          case SLJIT_MOV_UB:          case SLJIT_MOV_UB:
1202                  return EMIT_MOV(SLJIT_MOV_UB, BYTE_DATA, (sljit_ub));                  return EMIT_MOV(SLJIT_MOV_UB, BYTE_DATA, (sljit_ub));
1203    
1204          case SLJIT_MOV_SB:          case SLJIT_MOV_SB:
1205                  return EMIT_MOV(SLJIT_MOV_SB, BYTE_DATA | SIGNED_DATA, (sljit_b));                  return EMIT_MOV(SLJIT_MOV_SB, BYTE_DATA | SIGNED_DATA, (sljit_sb));
1206    
1207          case SLJIT_MOV_UH:          case SLJIT_MOV_UH:
1208                  return EMIT_MOV(SLJIT_MOV_UH, HALF_DATA, (sljit_uh));                  return EMIT_MOV(SLJIT_MOV_UH, HALF_DATA, (sljit_uh));
1209    
1210          case SLJIT_MOV_SH:          case SLJIT_MOV_SH:
1211                  return EMIT_MOV(SLJIT_MOV_SH, HALF_DATA | SIGNED_DATA, (sljit_h));                  return EMIT_MOV(SLJIT_MOV_SH, HALF_DATA | SIGNED_DATA, (sljit_sh));
1212    
1213          case SLJIT_MOVU:          case SLJIT_MOVU:
1214          case SLJIT_MOVU_P:          case SLJIT_MOVU_P:
1215    #if (defined SLJIT_CONFIG_PPC_32 && SLJIT_CONFIG_PPC_32)
1216            case SLJIT_MOVU_UI:
1217            case SLJIT_MOVU_SI:
1218    #endif
1219                  return emit_op(compiler, SLJIT_MOV, flags | WORD_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);                  return emit_op(compiler, SLJIT_MOV, flags | WORD_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);
1220    
1221    #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1222          case SLJIT_MOVU_UI:          case SLJIT_MOVU_UI:
1223                  return emit_op(compiler, SLJIT_MOV_UI, flags | INT_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);                  return EMIT_MOV(SLJIT_MOV_UI, INT_DATA | WRITE_BACK, (sljit_ui));
1224    
1225          case SLJIT_MOVU_SI:          case SLJIT_MOVU_SI:
1226                  return emit_op(compiler, SLJIT_MOV_SI, flags | INT_DATA | SIGNED_DATA | WRITE_BACK, dst, dstw, TMP_REG1, 0, src, srcw);                  return EMIT_MOV(SLJIT_MOV_SI, INT_DATA | SIGNED_DATA | WRITE_BACK, (sljit_si));
1227    #endif
1228    
1229          case SLJIT_MOVU_UB:          case SLJIT_MOVU_UB:
1230                  return EMIT_MOV(SLJIT_MOV_UB, BYTE_DATA | WRITE_BACK, (sljit_ub));                  return EMIT_MOV(SLJIT_MOV_UB, BYTE_DATA | WRITE_BACK, (sljit_ub));
1231    
1232          case SLJIT_MOVU_SB:          case SLJIT_MOVU_SB:
1233                  return EMIT_MOV(SLJIT_MOV_SB, BYTE_DATA | SIGNED_DATA | WRITE_BACK, (sljit_b));                  return EMIT_MOV(SLJIT_MOV_SB, BYTE_DATA | SIGNED_DATA | WRITE_BACK, (sljit_sb));
1234    
1235          case SLJIT_MOVU_UH:          case SLJIT_MOVU_UH:
1236                  return EMIT_MOV(SLJIT_MOV_UH, HALF_DATA | WRITE_BACK, (sljit_uh));                  return EMIT_MOV(SLJIT_MOV_UH, HALF_DATA | WRITE_BACK, (sljit_uh));
1237    
1238          case SLJIT_MOVU_SH:          case SLJIT_MOVU_SH:
1239                  return EMIT_MOV(SLJIT_MOV_SH, HALF_DATA | SIGNED_DATA | WRITE_BACK, (sljit_h));                  return EMIT_MOV(SLJIT_MOV_SH, HALF_DATA | SIGNED_DATA | WRITE_BACK, (sljit_sh));
1240    
1241          case SLJIT_NOT:          case SLJIT_NOT:
1242                  return emit_op(compiler, SLJIT_NOT, flags, dst, dstw, TMP_REG1, 0, src, srcw);                  return emit_op(compiler, SLJIT_NOT, flags, dst, dstw, TMP_REG1, 0, src, srcw);
# Line 1221  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1246  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1246    
1247          case SLJIT_CLZ:          case SLJIT_CLZ:
1248  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1249                  return emit_op(compiler, SLJIT_CLZ, flags | (!(op & SLJIT_INT_OP) ? 0 : ALT_FORM1), dst, dstw, TMP_REG1, 0, src, srcw);                  return emit_op(compiler, SLJIT_CLZ, flags | (!(op_flags & SLJIT_INT_OP) ? 0 : ALT_FORM1), dst, dstw, TMP_REG1, 0, src, srcw);
1250  #else  #else
1251                  return emit_op(compiler, SLJIT_CLZ, flags, dst, dstw, TMP_REG1, 0, src, srcw);                  return emit_op(compiler, SLJIT_CLZ, flags, dst, dstw, TMP_REG1, 0, src, srcw);
1252  #endif  #endif
# Line 1265  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1290  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1290          ((src) & SLJIT_IMM)          ((src) & SLJIT_IMM)
1291  #endif  #endif
1292    
1293  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,
1294          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1295          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1296          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1297  {  {
1298          int flags = GET_FLAGS(op) ? ALT_SET_FLAGS : 0;          sljit_si flags = GET_FLAGS(op) ? ALT_SET_FLAGS : 0;
1299    
1300          CHECK_ERROR();          CHECK_ERROR();
1301          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 1285  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1310  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1310    
1311  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1312          if (op & SLJIT_INT_OP) {          if (op & SLJIT_INT_OP) {
1313                    /* Most operations expect sign extended arguments. */
1314                  flags |= INT_DATA | SIGNED_DATA;                  flags |= INT_DATA | SIGNED_DATA;
1315                  if (src1 & SLJIT_IMM)                  if (src1 & SLJIT_IMM)
1316                          src1w = (src1w << 32) >> 32;                          src1w = (sljit_si)(src1w);
1317                  if (src2 & SLJIT_IMM)                  if (src2 & SLJIT_IMM)
1318                          src2w = (src2w << 32) >> 32;                          src2w = (sljit_si)(src2w);
1319                  if (GET_FLAGS(op))                  if (GET_FLAGS(op))
1320                          flags |= ALT_SIGN_EXT;                          flags |= ALT_SIGN_EXT;
1321          }          }
# Line 1450  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1476  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1476                  }                  }
1477                  return emit_op(compiler, GET_OPCODE(op), flags, dst, dstw, src1, src1w, src2, src2w);                  return emit_op(compiler, GET_OPCODE(op), flags, dst, dstw, src1, src1w, src2, src2w);
1478    
1479            case SLJIT_ASHR:
1480                    if (op & SLJIT_KEEP_FLAGS)
1481                            flags |= ALT_FORM3;
1482                    /* Fall through. */
1483          case SLJIT_SHL:          case SLJIT_SHL:
1484          case SLJIT_LSHR:          case SLJIT_LSHR:
         case SLJIT_ASHR:  
1485  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)  #if (defined SLJIT_CONFIG_PPC_64 && SLJIT_CONFIG_PPC_64)
1486                  if (op & SLJIT_INT_OP)                  if (op & SLJIT_INT_OP)
1487                          flags |= ALT_FORM2;                          flags |= ALT_FORM2;
# Line 1467  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1496  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1496          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1497  }  }
1498    
1499  SLJIT_API_FUNC_ATTRIBUTE int sljit_get_register_index(int reg)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_get_register_index(sljit_si reg)
1500  {  {
1501          check_sljit_get_register_index(reg);          check_sljit_get_register_index(reg);
1502          return reg_map[reg];          return reg_map[reg];
1503  }  }
1504    
1505  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,
1506          void *instruction, int size)          void *instruction, sljit_si size)
1507  {  {
1508          CHECK_ERROR();          CHECK_ERROR();
1509          check_sljit_emit_op_custom(compiler, instruction, size);          check_sljit_emit_op_custom(compiler, instruction, size);
# Line 1487  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1516  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1516  /*  Floating point operators                                             */  /*  Floating point operators                                             */
1517  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1518    
1519  SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)  SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_is_fpu_available(void)
1520  {  {
1521          /* Always available. */          /* Always available. */
1522          return 1;          return 1;
1523  }  }
1524    
1525  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,  #define FLOAT_DATA(op) (DOUBLE_DATA | ((op & SLJIT_SINGLE_OP) >> 6))
1526          int dst, sljit_w dstw,  #define SELECT_FOP(op, single, double) ((op & SLJIT_SINGLE_OP) ? single : double)
1527          int src, sljit_w srcw)  
1528    SLJIT_API_FUNC_ATTRIBUTE sljit_si sljit_emit_fop1(struct sljit_compiler *compiler, sljit_si op,
1529            sljit_si dst, sljit_sw dstw,
1530            sljit_si src, sljit_sw srcw)
1531  {  {
1532          int dst_fr;          sljit_si dst_fr;
1533    
1534          CHECK_ERROR();          CHECK_ERROR();
1535          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);          check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);
1536            SLJIT_COMPILE_ASSERT((SLJIT_SINGLE_OP == 0x100) && !(DOUBLE_DATA & 0x4), float_transfer_bit_error);
1537    
1538          compiler->cache_arg = 0;          compiler->cache_arg = 0;
1539          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1540    
1541          if (GET_OPCODE(op) == SLJIT_FCMP) {          if (GET_OPCODE(op) == SLJIT_CMPD) {
1542                  if (dst > SLJIT_FLOAT_REG4) {                  if (dst > SLJIT_FLOAT_REG6) {
1543                          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));
1544                          dst = TMP_FREG1;                          dst = TMP_FREG1;
1545                  }                  }
1546    
1547                  if (src > SLJIT_FLOAT_REG4) {                  if (src > SLJIT_FLOAT_REG6) {
1548                          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));
1549                          src = TMP_FREG2;                          src = TMP_FREG2;
1550                  }                  }
1551    
1552                  return push_inst(compiler, FCMPU | CRD(4) | FA(dst) | FB(src));                  return push_inst(compiler, FCMPU | CRD(4) | FA(dst) | FB(src));
1553          }          }
1554    
1555          dst_fr = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG1 : dst;          dst_fr = (dst > SLJIT_FLOAT_REG6) ? TMP_FREG1 : dst;
1556    
1557          if (src > SLJIT_FLOAT_REG4) {          if (src > SLJIT_FLOAT_REG6) {
1558                  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));
1559                  src = dst_fr;                  src = dst_fr;
1560          }          }
1561    
1562          switch (op) {          switch (GET_OPCODE(op)) {
1563                  case SLJIT_FMOV:                  case SLJIT_MOVD:
1564                          if (src != dst_fr && dst_fr != TMP_FREG1)                          if (src != dst_fr && dst_fr != TMP_FREG1)
1565                                  FAIL_IF(push_inst(compiler, FMR | FD(dst_fr) | FB(src)));                                  FAIL_IF(push_inst(compiler, FMR | FD(dst_fr) | FB(src)));
1566                          break;                          break;
1567                  case SLJIT_FNEG:                  case SLJIT_NEGD:
1568                          FAIL_IF(push_inst(compiler, FNEG | FD(dst_fr) | FB(src)));                          FAIL_IF(push_inst(compiler, FNEG | FD(dst_fr) | FB(src)));
1569                          break;                          break;
1570                  case SLJIT_FABS:                  case SLJIT_ABSD:
1571                          FAIL_IF(push_inst(compiler, FABS | FD(dst_fr) | FB(src)));                          FAIL_IF(push_inst(compiler, FABS | FD(dst_fr) | FB(src)));
1572                          break;                          break;
1573          }          }
1574    
1575          if (dst_fr == TMP_FREG1) {          if (dst_fr == TMP_FREG1) {
1576                  if (op == SLJIT_FMOV)                  if (GET_OPCODE(op) == SLJIT_MOVD)
1577                          dst_fr = src;                          dst_fr = src;
1578                  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));
1579          }          }
1580    
1581          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1582  }  }
1583    
1584  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,
1585          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
1586          int src1, sljit_w src1w,          sljit_si src1, sljit_sw src1w,
1587          int src2, sljit_w src2w)          sljit_si src2, sljit_sw src2w)
1588  {  {
1589          int dst_fr, flags = 0;          sljit_si dst_fr, flags = 0;
1590    
1591          CHECK_ERROR();          CHECK_ERROR();
1592          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 1561  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1594  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1594          compiler->cache_arg = 0;          compiler->cache_arg = 0;
1595          compiler->cache_argw = 0;          compiler->cache_argw = 0;
1596    
1597          dst_fr = (dst > SLJIT_FLOAT_REG4) ? TMP_FREG2 : dst;          dst_fr = (dst > SLJIT_FLOAT_REG6) ? TMP_FREG2 : dst;
1598    
1599          if (src1 > SLJIT_FLOAT_REG4) {          if (src1 > SLJIT_FLOAT_REG6) {
1600                  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)) {
1601                          FAIL_IF(compiler->error);                          FAIL_IF(compiler->error);
1602                          src1 = TMP_FREG1;                          src1 = TMP_FREG1;
1603                  } else                  } else
1604                          flags |= ALT_FORM1;                          flags |= ALT_FORM1;
1605          }          }
1606    
1607          if (src2 > SLJIT_FLOAT_REG4) {          if (src2 > SLJIT_FLOAT_REG6) {
1608                  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)) {
1609                          FAIL_IF(compiler->error);                          FAIL_IF(compiler->error);
1610                          src2 = TMP_FREG2;                          src2 = TMP_FREG2;
1611                  } else                  } else
# Line 1581  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1614  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1614    
1615          if ((flags & (ALT_FORM1 | ALT_FORM2)) == (ALT_FORM1 | ALT_FORM2)) {          if ((flags & (ALT_FORM1 | ALT_FORM2)) == (ALT_FORM1 | ALT_FORM2)) {
1616                  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)) {
1617                          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));
1618                          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));
1619                  }                  }
1620                  else {                  else {
1621                          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));
1622                          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));
1623                  }                  }
1624          }          }
1625          else if (flags & ALT_FORM1)          else if (flags & ALT_FORM1)
1626                  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));
1627          else if (flags & ALT_FORM2)          else if (flags & ALT_FORM2)
1628                  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));
1629    
1630          if (flags & ALT_FORM1)          if (flags & ALT_FORM1)
1631                  src1 = TMP_FREG1;                  src1 = TMP_FREG1;
1632          if (flags & ALT_FORM2)          if (flags & ALT_FORM2)
1633                  src2 = TMP_FREG2;                  src2 = TMP_FREG2;
1634    
1635          switch (op) {          switch (GET_OPCODE(op)) {
1636          case SLJIT_FADD:          case SLJIT_ADDD:
1637                  FAIL_IF(push_inst(compiler, FADD | FD(dst_fr) | FA(src1) | FB(src2)));                  FAIL_IF(push_inst(compiler, SELECT_FOP(op, FADDS, FADD) | FD(dst_fr) | FA(src1) | FB(src2)));
1638                  break;                  break;
1639    
1640          case SLJIT_FSUB:          case SLJIT_SUBD:
1641                  FAIL_IF(push_inst(compiler, FSUB | FD(dst_fr) | FA(src1) | FB(src2)));                  FAIL_IF(push_inst(compiler, SELECT_FOP(op, FSUBS, FSUB) | FD(dst_fr) | FA(src1) | FB(src2)));
1642                  break;                  break;
1643    
1644          case SLJIT_FMUL:          case SLJIT_MULD:
1645                  FAIL_IF(push_inst(compiler, FMUL | FD(dst_fr) | FA(src1) | FC(src2) /* FMUL use FC as src2 */));                  FAIL_IF(push_inst(compiler, SELECT_FOP(op, FMULS, FMUL) | FD(dst_fr) | FA(src1) | FC(src2) /* FMUL use FC as src2 */));
1646                  break;                  break;
1647    
1648          case SLJIT_FDIV:          case SLJIT_DIVD:
1649                  FAIL_IF(push_inst(compiler, FDIV | FD(dst_fr) | FA(src1) | FB(src2)));                  FAIL_IF(push_inst(compiler, SELECT_FOP(op, FDIVS, FDIV) | FD(dst_fr) | FA(src1) | FB(src2)));
1650                  break;                  break;
1651          }          }
1652    
1653          if (dst_fr == TMP_FREG2)          if (dst_fr == TMP_FREG2)
1654                  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));
1655    
1656          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1657  }  }
1658    
1659    #undef FLOAT_DATA
1660    #undef SELECT_FOP
1661    
1662  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1663  /*  Other instructions                                                   */  /*  Other instructions                                                   */
1664  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
1665    
1666  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)
1667  {  {
1668          CHECK_ERROR();          CHECK_ERROR();
1669          check_sljit_emit_fast_enter(compiler, dst, dstw);          check_sljit_emit_fast_enter(compiler, dst, dstw);
# Line 1644  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1680  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1680          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
1681  }  }
1682    
1683  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)
1684  {  {
1685          CHECK_ERROR();          CHECK_ERROR();
1686          check_sljit_emit_fast_return(compiler, src, srcw);          check_sljit_emit_fast_return(compiler, src, srcw);
# Line 1682  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la Line 1718  SLJIT_API_FUNC_ATTRIBUTE struct sljit_la
1718          return label;          return label;
1719  }  }
1720    
1721  static sljit_ins get_bo_bi_flags(int type)  static sljit_ins get_bo_bi_flags(sljit_si type)
1722  {  {
1723          switch (type) {          switch (type) {
1724          case SLJIT_C_EQUAL:          case SLJIT_C_EQUAL:
# Line 1745  static sljit_ins get_bo_bi_flags(int typ Line 1781  static sljit_ins get_bo_bi_flags(int typ
1781          }          }
1782  }  }
1783    
1784  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)
1785  {  {
1786          struct sljit_jump *jump;          struct sljit_jump *jump;
1787          sljit_ins bo_bi_flags;          sljit_ins bo_bi_flags;
# Line 1773  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju Line 1809  SLJIT_API_FUNC_ATTRIBUTE struct sljit_ju
1809          return jump;          return jump;
1810  }  }
1811    
1812  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)
1813  {  {
1814          struct sljit_jump *jump = NULL;          struct sljit_jump *jump = NULL;
1815          int src_r;          sljit_si src_r;
1816    
1817          CHECK_ERROR();          CHECK_ERROR();
1818          check_sljit_emit_ijump(compiler, type, src, srcw);          check_sljit_emit_ijump(compiler, type, src, srcw);
# Line 1812  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1848  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1848  #define INVERT_BIT(dst) \  #define INVERT_BIT(dst) \
1849          FAIL_IF(push_inst(compiler, XORI | S(dst) | A(dst) | 0x1));          FAIL_IF(push_inst(compiler, XORI | S(dst) | A(dst) | 0x1));
1850    
1851  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)
1852  {  {
1853          int reg;          sljit_si reg;
1854    
1855          CHECK_ERROR();          CHECK_ERROR();
1856          check_sljit_emit_cond_value(compiler, op, dst, dstw, type);          check_sljit_emit_cond_value(compiler, op, dst, dstw, type);
# Line 1915  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 1951  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
1951          return (reg == TMP_REG2) ? emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, TMP_REG2, 0) : SLJIT_SUCCESS;          return (reg == TMP_REG2) ? emit_op(compiler, SLJIT_MOV, WORD_DATA, dst, dstw, TMP_REG1, 0, TMP_REG2, 0) : SLJIT_SUCCESS;
1952  }  }
1953    
1954  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)
1955  {  {
1956          struct sljit_const *const_;          struct sljit_const *const_;
1957          int reg;          sljit_si reg;
1958    
1959          CHECK_ERROR_PTR();          CHECK_ERROR_PTR();
1960          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