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

Diff of /code/trunk/sljit/sljitNativeX86_64.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1194 by zherczeg, Sat Oct 20 21:33:38 2012 UTC revision 1195 by zherczeg, Thu Nov 1 15:21:27 2012 UTC
# Line 26  Line 26 
26    
27  /* x86 64-bit arch dependent functions. */  /* x86 64-bit arch dependent functions. */
28    
29  static int emit_load_imm64(struct sljit_compiler *compiler, int reg, sljit_w imm)  static sljit_si emit_load_imm64(struct sljit_compiler *compiler, sljit_si reg, sljit_sw imm)
30  {  {
31          sljit_ub *buf;          sljit_ub *buf;
32    
33          buf = (sljit_ub*)ensure_buf(compiler, 1 + 2 + sizeof(sljit_w));          buf = (sljit_ub*)ensure_buf(compiler, 1 + 2 + sizeof(sljit_sw));
34          FAIL_IF(!buf);          FAIL_IF(!buf);
35          INC_SIZE(2 + sizeof(sljit_w));          INC_SIZE(2 + sizeof(sljit_sw));
36          *buf++ = REX_W | ((reg_map[reg] <= 7) ? 0 : REX_B);          *buf++ = REX_W | ((reg_map[reg] <= 7) ? 0 : REX_B);
37          *buf++ = 0xb8 + (reg_map[reg] & 0x7);          *buf++ = 0xb8 + (reg_map[reg] & 0x7);
38          *(sljit_w*)buf = imm;          *(sljit_sw*)buf = imm;
39          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
40  }  }
41    
42  static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, int type)  static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_si type)
43  {  {
44          if (type < SLJIT_JUMP) {          if (type < SLJIT_JUMP) {
45                  *code_ptr++ = get_jump_code(type ^ 0x1) - 0x10;                  *code_ptr++ = get_jump_code(type ^ 0x1) - 0x10;
# Line 54  static sljit_ub* generate_far_jump_code( Line 54  static sljit_ub* generate_far_jump_code(
54          if (jump->flags & JUMP_LABEL)          if (jump->flags & JUMP_LABEL)
55                  jump->flags |= PATCH_MD;                  jump->flags |= PATCH_MD;
56          else          else
57                  *(sljit_w*)code_ptr = jump->u.target;                  *(sljit_sw*)code_ptr = jump->u.target;
58    
59          code_ptr += sizeof(sljit_w);          code_ptr += sizeof(sljit_sw);
60          *code_ptr++ = REX_B;          *code_ptr++ = REX_B;
61          *code_ptr++ = 0xff;          *code_ptr++ = 0xff;
62          *code_ptr++ = (type >= SLJIT_FAST_CALL) ? 0xd1 /* call */ : 0xe1 /* jmp */;          *code_ptr++ = (type >= SLJIT_FAST_CALL) ? 0xd1 /* call */ : 0xe1 /* jmp */;
# Line 64  static sljit_ub* generate_far_jump_code( Line 64  static sljit_ub* generate_far_jump_code(
64          return code_ptr;          return code_ptr;
65  }  }
66    
67  static sljit_ub* generate_fixed_jump(sljit_ub *code_ptr, sljit_w addr, int type)  static sljit_ub* generate_fixed_jump(sljit_ub *code_ptr, sljit_sw addr, sljit_si type)
68  {  {
69          sljit_w delta = addr - ((sljit_w)code_ptr + 1 + sizeof(sljit_hw));          sljit_sw delta = addr - ((sljit_sw)code_ptr + 1 + sizeof(sljit_si));
70    
71          if (delta <= SLJIT_W(0x7fffffff) && delta >= SLJIT_W(-0x80000000)) {          if (delta <= SLJIT_W(0x7fffffff) && delta >= SLJIT_W(-0x80000000)) {
72                  *code_ptr++ = (type == 2) ? 0xe8 /* call */ : 0xe9 /* jmp */;                  *code_ptr++ = (type == 2) ? 0xe8 /* call */ : 0xe9 /* jmp */;
73                  *(sljit_w*)code_ptr = delta;                  *(sljit_sw*)code_ptr = delta;
74          }          }
75          else {          else {
76                  SLJIT_COMPILE_ASSERT(reg_map[TMP_REG3] == 9, tmp3_is_9_second);                  SLJIT_COMPILE_ASSERT(reg_map[TMP_REG3] == 9, tmp3_is_9_second);
77                  *code_ptr++ = REX_W | REX_B;                  *code_ptr++ = REX_W | REX_B;
78                  *code_ptr++ = 0xb8 + 1;                  *code_ptr++ = 0xb8 + 1;
79                  *(sljit_w*)code_ptr = addr;                  *(sljit_sw*)code_ptr = addr;
80                  code_ptr += sizeof(sljit_w);                  code_ptr += sizeof(sljit_sw);
81                  *code_ptr++ = REX_B;                  *code_ptr++ = REX_B;
82                  *code_ptr++ = 0xff;                  *code_ptr++ = 0xff;
83                  *code_ptr++ = (type == 2) ? 0xd1 /* call */ : 0xe1 /* jmp */;                  *code_ptr++ = (type == 2) ? 0xd1 /* call */ : 0xe1 /* jmp */;
# Line 86  static sljit_ub* generate_fixed_jump(slj Line 86  static sljit_ub* generate_fixed_jump(slj
86          return code_ptr;          return code_ptr;
87  }  }
88    
89  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)
90  {  {
91          int size, pushed_size;          sljit_si size, pushed_size;
92          sljit_ub *buf;          sljit_ub *buf;
93    
94          CHECK_ERROR();          CHECK_ERROR();
# Line 103  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 103  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
103    
104          size = saveds;          size = saveds;
105          /* Including the return address saved by the call instruction. */          /* Including the return address saved by the call instruction. */
106          pushed_size = (saveds + 1) * sizeof(sljit_w);          pushed_size = (saveds + 1) * sizeof(sljit_sw);
107  #ifndef _WIN64  #ifndef _WIN64
108          if (saveds >= 2)          if (saveds >= 2)
109                  size += saveds - 1;                  size += saveds - 1;
# Line 112  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 112  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
112                  size += saveds - 3;                  size += saveds - 3;
113          if (temporaries >= 5) {          if (temporaries >= 5) {
114                  size += (5 - 4) * 2;                  size += (5 - 4) * 2;
115                  pushed_size += sizeof(sljit_w);                  pushed_size += sizeof(sljit_sw);
116          }          }
117  #endif  #endif
118          size += args * 3;          size += args * 3;
# Line 210  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 210  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
210                  /* Pushed size must be divisible by 8. */                  /* Pushed size must be divisible by 8. */
211                  SLJIT_ASSERT(!(pushed_size & 0x7));                  SLJIT_ASSERT(!(pushed_size & 0x7));
212                  if (pushed_size & 0x8) {                  if (pushed_size & 0x8) {
213                          *buf++ = 5 * sizeof(sljit_w);                          *buf++ = 5 * sizeof(sljit_sw);
214                          local_size -= 5 * sizeof(sljit_w);                          local_size -= 5 * sizeof(sljit_sw);
215                  } else {                  } else {
216                          *buf++ = 4 * sizeof(sljit_w);                          *buf++ = 4 * sizeof(sljit_sw);
217                          local_size -= 4 * sizeof(sljit_w);                          local_size -= 4 * sizeof(sljit_sw);
218                  }                  }
219                  FAIL_IF(emit_load_imm64(compiler, SLJIT_TEMPORARY_REG1, local_size));                  FAIL_IF(emit_load_imm64(compiler, SLJIT_TEMPORARY_REG1, local_size));
220                  FAIL_IF(sljit_emit_ijump(compiler, SLJIT_CALL1, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_grow_stack)));                  FAIL_IF(sljit_emit_ijump(compiler, SLJIT_CALL1, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_grow_stack)));
# Line 237  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 237  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
237                  *buf++ = REX_W;                  *buf++ = REX_W;
238                  *buf++ = 0x81;                  *buf++ = 0x81;
239                  *buf++ = 0xc0 | (5 << 3) | 4;                  *buf++ = 0xc0 | (5 << 3) | 4;
240                  *(sljit_hw*)buf = local_size;                  *(sljit_si*)buf = local_size;
241                  buf += sizeof(sljit_hw);                  buf += sizeof(sljit_si);
242          }          }
243    
244          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
245  }  }
246    
247  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)
248  {  {
249          int pushed_size;          sljit_si pushed_size;
250    
251          CHECK_ERROR_VOID();          CHECK_ERROR_VOID();
252          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);
# Line 258  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_ Line 258  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_
258  #endif  #endif
259    
260          /* Including the return address saved by the call instruction. */          /* Including the return address saved by the call instruction. */
261          pushed_size = (saveds + 1) * sizeof(sljit_w);          pushed_size = (saveds + 1) * sizeof(sljit_sw);
262  #ifdef _WIN64  #ifdef _WIN64
263          if (temporaries >= 5)          if (temporaries >= 5)
264                  pushed_size += sizeof(sljit_w);                  pushed_size += sizeof(sljit_sw);
265  #endif  #endif
266          compiler->local_size = ((local_size + FIXED_LOCALS_OFFSET + pushed_size + 16 - 1) & ~(16 - 1)) - pushed_size;          compiler->local_size = ((local_size + FIXED_LOCALS_OFFSET + pushed_size + 16 - 1) & ~(16 - 1)) - pushed_size;
267  }  }
268    
269  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)
270  {  {
271          int size;          sljit_si size;
272          sljit_ub *buf;          sljit_ub *buf;
273    
274          CHECK_ERROR();          CHECK_ERROR();
# Line 294  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 294  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
294                  *buf++ = REX_W;                  *buf++ = REX_W;
295                  *buf++ = 0x81;                  *buf++ = 0x81;
296                  *buf++ = 0xc0 | (0 << 3) | 4;                  *buf++ = 0xc0 | (0 << 3) | 4;
297                  *(sljit_hw*)buf = compiler->local_size;                  *(sljit_si*)buf = compiler->local_size;
298          }          }
299    
300          size = 1 + compiler->saveds;          size = 1 + compiler->saveds;
# Line 349  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 349  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
349  /*  Operators                                                            */  /*  Operators                                                            */
350  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
351    
352  static int emit_do_imm32(struct sljit_compiler *compiler, sljit_ub rex, sljit_ub opcode, sljit_w imm)  static sljit_si emit_do_imm32(struct sljit_compiler *compiler, sljit_ub rex, sljit_ub opcode, sljit_sw imm)
353  {  {
354          sljit_ub *buf;          sljit_ub *buf;
355    
356          if (rex != 0) {          if (rex != 0) {
357                  buf = (sljit_ub*)ensure_buf(compiler, 1 + 2 + sizeof(sljit_hw));                  buf = (sljit_ub*)ensure_buf(compiler, 1 + 2 + sizeof(sljit_si));
358                  FAIL_IF(!buf);                  FAIL_IF(!buf);
359                  INC_SIZE(2 + sizeof(sljit_hw));                  INC_SIZE(2 + sizeof(sljit_si));
360                  *buf++ = rex;                  *buf++ = rex;
361                  *buf++ = opcode;                  *buf++ = opcode;
362                  *(sljit_hw*)buf = imm;                  *(sljit_si*)buf = imm;
363          }          }
364          else {          else {
365                  buf = (sljit_ub*)ensure_buf(compiler, 1 + 1 + sizeof(sljit_hw));                  buf = (sljit_ub*)ensure_buf(compiler, 1 + 1 + sizeof(sljit_si));
366                  FAIL_IF(!buf);                  FAIL_IF(!buf);
367                  INC_SIZE(1 + sizeof(sljit_hw));                  INC_SIZE(1 + sizeof(sljit_si));
368                  *buf++ = opcode;                  *buf++ = opcode;
369                  *(sljit_hw*)buf = imm;                  *(sljit_si*)buf = imm;
370          }          }
371          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
372  }  }
373    
374  static sljit_ub* emit_x86_instruction(struct sljit_compiler *compiler, int size,  static sljit_ub* emit_x86_instruction(struct sljit_compiler *compiler, sljit_si size,
375          /* The register or immediate operand. */          /* The register or immediate operand. */
376          int a, sljit_w imma,          sljit_si a, sljit_sw imma,
377          /* The general operand (not immediate). */          /* The general operand (not immediate). */
378          int b, sljit_w immb)          sljit_si b, sljit_sw immb)
379  {  {
380          sljit_ub *buf;          sljit_ub *buf;
381          sljit_ub *buf_ptr;          sljit_ub *buf_ptr;
382          sljit_ub rex = 0;          sljit_ub rex = 0;
383          int flags = size & ~0xf;          sljit_si flags = size & ~0xf;
384          int inst_size;          sljit_si inst_size;
385    
386          /* The immediate operand must be 32 bit. */          /* The immediate operand must be 32 bit. */
387          SLJIT_ASSERT(!(a & SLJIT_IMM) || compiler->mode32 || IS_HALFWORD(imma));          SLJIT_ASSERT(!(a & SLJIT_IMM) || compiler->mode32 || IS_HALFWORD(imma));
# Line 394  static sljit_ub* emit_x86_instruction(st Line 394  static sljit_ub* emit_x86_instruction(st
394  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
395          /* SSE2 and immediate is not possible. */          /* SSE2 and immediate is not possible. */
396          SLJIT_ASSERT(!(a & SLJIT_IMM) || !(flags & EX86_SSE2));          SLJIT_ASSERT(!(a & SLJIT_IMM) || !(flags & EX86_SSE2));
397            SLJIT_ASSERT((flags & (EX86_PREF_F2 | EX86_PREF_F3)) != (EX86_PREF_F2 | EX86_PREF_F3)
398                    && (flags & (EX86_PREF_F2 | EX86_PREF_66)) != (EX86_PREF_F2 | EX86_PREF_66)
399                    && (flags & (EX86_PREF_F3 | EX86_PREF_66)) != (EX86_PREF_F3 | EX86_PREF_66));
400  #endif  #endif
401    
402          size &= 0xf;          size &= 0xf;
# Line 415  static sljit_ub* emit_x86_instruction(st Line 418  static sljit_ub* emit_x86_instruction(st
418                  rex |= REX;                  rex |= REX;
419    
420  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
421          if (flags & EX86_PREF_F2)          if (flags & (EX86_PREF_F2 | EX86_PREF_F3))
422                  inst_size++;                  inst_size++;
423  #endif  #endif
424          if (flags & EX86_PREF_66)          if (flags & EX86_PREF_66)
# Line 425  static sljit_ub* emit_x86_instruction(st Line 428  static sljit_ub* emit_x86_instruction(st
428          inst_size += 1; /* mod r/m byte. */          inst_size += 1; /* mod r/m byte. */
429          if (b & SLJIT_MEM) {          if (b & SLJIT_MEM) {
430                  if ((b & 0x0f) == SLJIT_UNUSED)                  if ((b & 0x0f) == SLJIT_UNUSED)
431                          inst_size += 1 + sizeof(sljit_hw); /* SIB byte required to avoid RIP based addressing. */                          inst_size += 1 + sizeof(sljit_si); /* SIB byte required to avoid RIP based addressing. */
432                  else {                  else {
433                          if (reg_map[b & 0x0f] >= 8)                          if (reg_map[b & 0x0f] >= 8)
434                                  rex |= REX_B;                                  rex |= REX_B;
435                          if (immb != 0 && !(b & 0xf0)) {                          if (immb != 0 && !(b & 0xf0)) {
436                                  /* Immediate operand. */                                  /* Immediate operand. */
437                                  if (immb <= 127 && immb >= -128)                                  if (immb <= 127 && immb >= -128)
438                                          inst_size += sizeof(sljit_b);                                          inst_size += sizeof(sljit_sb);
439                                  else                                  else
440                                          inst_size += sizeof(sljit_hw);                                          inst_size += sizeof(sljit_si);
441                          }                          }
442                  }                  }
443    
# Line 474  static sljit_ub* emit_x86_instruction(st Line 477  static sljit_ub* emit_x86_instruction(st
477                  else if (flags & EX86_HALF_ARG)                  else if (flags & EX86_HALF_ARG)
478                          inst_size += sizeof(short);                          inst_size += sizeof(short);
479                  else                  else
480                          inst_size += sizeof(sljit_hw);                          inst_size += sizeof(sljit_si);
481          }          }
482          else {          else {
483                  SLJIT_ASSERT(!(flags & EX86_SHIFT_INS) || a == SLJIT_PREF_SHIFT_REG);                  SLJIT_ASSERT(!(flags & EX86_SHIFT_INS) || a == SLJIT_PREF_SHIFT_REG);
# Line 499  static sljit_ub* emit_x86_instruction(st Line 502  static sljit_ub* emit_x86_instruction(st
502  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
503          if (flags & EX86_PREF_F2)          if (flags & EX86_PREF_F2)
504                  *buf++ = 0xf2;                  *buf++ = 0xf2;
505            if (flags & EX86_PREF_F3)
506                    *buf++ = 0xf3;
507  #endif  #endif
508          if (flags & EX86_PREF_66)          if (flags & EX86_PREF_66)
509                  *buf++ = 0x66;                  *buf++ = 0x66;
# Line 560  static sljit_ub* emit_x86_instruction(st Line 565  static sljit_ub* emit_x86_instruction(st
565                                  if (immb <= 127 && immb >= -128)                                  if (immb <= 127 && immb >= -128)
566                                          *buf_ptr++ = immb; /* 8 bit displacement. */                                          *buf_ptr++ = immb; /* 8 bit displacement. */
567                                  else {                                  else {
568                                          *(sljit_hw*)buf_ptr = immb; /* 32 bit displacement. */                                          *(sljit_si*)buf_ptr = immb; /* 32 bit displacement. */
569                                          buf_ptr += sizeof(sljit_hw);                                          buf_ptr += sizeof(sljit_si);
570                                  }                                  }
571                          }                          }
572                  }                  }
# Line 573  static sljit_ub* emit_x86_instruction(st Line 578  static sljit_ub* emit_x86_instruction(st
578          else {          else {
579                  *buf_ptr++ |= 0x04;                  *buf_ptr++ |= 0x04;
580                  *buf_ptr++ = 0x25;                  *buf_ptr++ = 0x25;
581                  *(sljit_hw*)buf_ptr = immb; /* 32 bit displacement. */                  *(sljit_si*)buf_ptr = immb; /* 32 bit displacement. */
582                  buf_ptr += sizeof(sljit_hw);                  buf_ptr += sizeof(sljit_si);
583          }          }
584    
585          if (a & SLJIT_IMM) {          if (a & SLJIT_IMM) {
# Line 583  static sljit_ub* emit_x86_instruction(st Line 588  static sljit_ub* emit_x86_instruction(st
588                  else if (flags & EX86_HALF_ARG)                  else if (flags & EX86_HALF_ARG)
589                          *(short*)buf_ptr = imma;                          *(short*)buf_ptr = imma;
590                  else if (!(flags & EX86_SHIFT_INS))                  else if (!(flags & EX86_SHIFT_INS))
591                          *(sljit_hw*)buf_ptr = imma;                          *(sljit_si*)buf_ptr = imma;
592          }          }
593    
594          return !(flags & EX86_SHIFT_INS) ? buf : (buf + 1);          return !(flags & EX86_SHIFT_INS) ? buf : (buf + 1);
# Line 593  static sljit_ub* emit_x86_instruction(st Line 598  static sljit_ub* emit_x86_instruction(st
598  /*  Call / return instructions                                           */  /*  Call / return instructions                                           */
599  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
600    
601  static SLJIT_INLINE int call_with_args(struct sljit_compiler *compiler, int type)  static SLJIT_INLINE sljit_si call_with_args(struct sljit_compiler *compiler, sljit_si type)
602  {  {
603          sljit_ub *buf;          sljit_ub *buf;
604    
# Line 629  static SLJIT_INLINE int call_with_args(s Line 634  static SLJIT_INLINE int call_with_args(s
634          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
635  }  }
636    
637  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)
638  {  {
639          sljit_ub *buf;          sljit_ub *buf;
640    
# Line 668  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 673  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
673          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
674  }  }
675    
676  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)
677  {  {
678          sljit_ub *buf;          sljit_ub *buf;
679    
# Line 718  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 723  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
723    
724                  INC_SIZE(5 + 1);                  INC_SIZE(5 + 1);
725                  *buf++ = 0x68;                  *buf++ = 0x68;
726                  *(sljit_hw*)buf = srcw;                  *(sljit_si*)buf = srcw;
727                  buf += sizeof(sljit_hw);                  buf += sizeof(sljit_si);
728          }          }
729    
730          RET();          RET();
# Line 731  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 736  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
736  /*  Extend input                                                         */  /*  Extend input                                                         */
737  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
738    
739  static int emit_mov_int(struct sljit_compiler *compiler, int sign,  static sljit_si emit_mov_int(struct sljit_compiler *compiler, sljit_si sign,
740          int dst, sljit_w dstw,          sljit_si dst, sljit_sw dstw,
741          int src, sljit_w srcw)          sljit_si src, sljit_sw srcw)
742  {  {
743          sljit_ub* code;          sljit_ub* code;
744          int dst_r;          sljit_si dst_r;
745    
746          compiler->mode32 = 0;          compiler->mode32 = 0;
747    
# Line 746  static int emit_mov_int(struct sljit_com Line 751  static int emit_mov_int(struct sljit_com
751          if (src & SLJIT_IMM) {          if (src & SLJIT_IMM) {
752                  if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {                  if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
753                          if (sign || ((sljit_uw)srcw <= 0x7fffffff)) {                          if (sign || ((sljit_uw)srcw <= 0x7fffffff)) {
754                                  code = emit_x86_instruction(compiler, 1, SLJIT_IMM, (sljit_w)(sljit_i)srcw, dst, dstw);                                  code = emit_x86_instruction(compiler, 1, SLJIT_IMM, (sljit_sw)(sljit_si)srcw, dst, dstw);
755                                  FAIL_IF(!code);                                  FAIL_IF(!code);
756                                  *code = 0xc7;                                  *code = 0xc7;
757                                  return SLJIT_SUCCESS;                                  return SLJIT_SUCCESS;
# Line 754  static int emit_mov_int(struct sljit_com Line 759  static int emit_mov_int(struct sljit_com
759                          return emit_load_imm64(compiler, dst, srcw);                          return emit_load_imm64(compiler, dst, srcw);
760                  }                  }
761                  compiler->mode32 = 1;                  compiler->mode32 = 1;
762                  code = emit_x86_instruction(compiler, 1, SLJIT_IMM, (sljit_w)(sljit_i)srcw, dst, dstw);                  code = emit_x86_instruction(compiler, 1, SLJIT_IMM, (sljit_sw)(sljit_si)srcw, dst, dstw);
763                  FAIL_IF(!code);                  FAIL_IF(!code);
764                  *code = 0xc7;                  *code = 0xc7;
765                  compiler->mode32 = 0;                  compiler->mode32 = 0;

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

  ViewVC Help
Powered by ViewVC 1.1.5