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

Diff of /code/trunk/sljit/sljitNativeX86_32.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 32-bit arch dependent functions. */  /* x86 32-bit arch dependent functions. */
28    
29  static int emit_do_imm(struct sljit_compiler *compiler, sljit_ub opcode, sljit_w imm)  static sljit_si emit_do_imm(struct sljit_compiler *compiler, sljit_ub opcode, sljit_sw imm)
30  {  {
31          sljit_ub *buf;          sljit_ub *buf;
32    
33          buf = (sljit_ub*)ensure_buf(compiler, 1 + 1 + sizeof(sljit_w));          buf = (sljit_ub*)ensure_buf(compiler, 1 + 1 + sizeof(sljit_sw));
34          FAIL_IF(!buf);          FAIL_IF(!buf);
35          INC_SIZE(1 + sizeof(sljit_w));          INC_SIZE(1 + sizeof(sljit_sw));
36          *buf++ = opcode;          *buf++ = opcode;
37          *(sljit_w*)buf = imm;          *(sljit_sw*)buf = imm;
38          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
39  }  }
40    
41  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)
42  {  {
43          if (type == SLJIT_JUMP) {          if (type == SLJIT_JUMP) {
44                  *code_ptr++ = 0xe9;                  *code_ptr++ = 0xe9;
# Line 57  static sljit_ub* generate_far_jump_code( Line 57  static sljit_ub* generate_far_jump_code(
57          if (jump->flags & JUMP_LABEL)          if (jump->flags & JUMP_LABEL)
58                  jump->flags |= PATCH_MW;                  jump->flags |= PATCH_MW;
59          else          else
60                  *(sljit_w*)code_ptr = jump->u.target - (jump->addr + 4);                  *(sljit_sw*)code_ptr = jump->u.target - (jump->addr + 4);
61          code_ptr += 4;          code_ptr += 4;
62    
63          return code_ptr;          return code_ptr;
64  }  }
65    
66  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)
67  {  {
68          int size;          sljit_si size;
69          int locals_offset;          sljit_si locals_offset;
70          sljit_ub *buf;          sljit_ub *buf;
71    
72          CHECK_ERROR();          CHECK_ERROR();
# Line 116  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 116  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
116                  *buf++ = 0x8b;                  *buf++ = 0x8b;
117                  *buf++ = 0x44 | (reg_map[SLJIT_SAVED_REG3] << 3);                  *buf++ = 0x44 | (reg_map[SLJIT_SAVED_REG3] << 3);
118                  *buf++ = 0x24;                  *buf++ = 0x24;
119                  *buf++ = sizeof(sljit_w) * (3 + 2); /* saveds >= 3 as well. */                  *buf++ = sizeof(sljit_sw) * (3 + 2); /* saveds >= 3 as well. */
120          }          }
121  #else  #else
122          if (args > 0) {          if (args > 0) {
123                  *buf++ = 0x8b;                  *buf++ = 0x8b;
124                  *buf++ = 0x40 | (reg_map[SLJIT_SAVED_REG1] << 3) | reg_map[TMP_REGISTER];                  *buf++ = 0x40 | (reg_map[SLJIT_SAVED_REG1] << 3) | reg_map[TMP_REGISTER];
125                  *buf++ = sizeof(sljit_w) * 2;                  *buf++ = sizeof(sljit_sw) * 2;
126          }          }
127          if (args > 1) {          if (args > 1) {
128                  *buf++ = 0x8b;                  *buf++ = 0x8b;
129                  *buf++ = 0x40 | (reg_map[SLJIT_SAVED_REG2] << 3) | reg_map[TMP_REGISTER];                  *buf++ = 0x40 | (reg_map[SLJIT_SAVED_REG2] << 3) | reg_map[TMP_REGISTER];
130                  *buf++ = sizeof(sljit_w) * 3;                  *buf++ = sizeof(sljit_sw) * 3;
131          }          }
132          if (args > 2) {          if (args > 2) {
133                  *buf++ = 0x8b;                  *buf++ = 0x8b;
134                  *buf++ = 0x40 | (reg_map[SLJIT_SAVED_REG3] << 3) | reg_map[TMP_REGISTER];                  *buf++ = 0x40 | (reg_map[SLJIT_SAVED_REG3] << 3) | reg_map[TMP_REGISTER];
135                  *buf++ = sizeof(sljit_w) * 4;                  *buf++ = sizeof(sljit_sw) * 4;
136          }          }
137  #endif  #endif
138    
# Line 161  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 161  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
161          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
162  }  }
163    
164  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)
165  {  {
166          int locals_offset;          sljit_si locals_offset;
167    
168          CHECK_ERROR_VOID();          CHECK_ERROR_VOID();
169          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);          check_sljit_set_context(compiler, args, temporaries, saveds, local_size);
# Line 186  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_ Line 186  SLJIT_API_FUNC_ATTRIBUTE void sljit_set_
186          compiler->local_size = locals_offset + ((local_size + sizeof(sljit_uw) - 1) & ~(sizeof(sljit_uw) - 1));          compiler->local_size = locals_offset + ((local_size + sizeof(sljit_uw) - 1) & ~(sizeof(sljit_uw) - 1));
187  }  }
188    
189  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)
190  {  {
191          int size;          sljit_si size;
192          sljit_ub *buf;          sljit_ub *buf;
193    
194          CHECK_ERROR();          CHECK_ERROR();
# Line 224  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 224  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
224          POP_REG(reg_map[TMP_REGISTER]);          POP_REG(reg_map[TMP_REGISTER]);
225  #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)  #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
226          if (compiler->args > 2)          if (compiler->args > 2)
227                  RETN(sizeof(sljit_w));                  RETN(sizeof(sljit_sw));
228          else          else
229                  RET();                  RET();
230  #else  #else
231          if (compiler->args > 0)          if (compiler->args > 0)
232                  RETN(compiler->args * sizeof(sljit_w));                  RETN(compiler->args * sizeof(sljit_sw));
233          else          else
234                  RET();                  RET();
235  #endif  #endif
# Line 242  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 242  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
242  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
243    
244  /* Size contains the flags as well. */  /* Size contains the flags as well. */
245  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,
246          /* The register or immediate operand. */          /* The register or immediate operand. */
247          int a, sljit_w imma,          sljit_si a, sljit_sw imma,
248          /* The general operand (not immediate). */          /* The general operand (not immediate). */
249          int b, sljit_w immb)          sljit_si b, sljit_sw immb)
250  {  {
251          sljit_ub *buf;          sljit_ub *buf;
252          sljit_ub *buf_ptr;          sljit_ub *buf_ptr;
253          int flags = size & ~0xf;          sljit_si flags = size & ~0xf;
254          int inst_size;          sljit_si inst_size;
255    
256          /* Both cannot be switched on. */          /* Both cannot be switched on. */
257          SLJIT_ASSERT((flags & (EX86_BIN_INS | EX86_SHIFT_INS)) != (EX86_BIN_INS | EX86_SHIFT_INS));          SLJIT_ASSERT((flags & (EX86_BIN_INS | EX86_SHIFT_INS)) != (EX86_BIN_INS | EX86_SHIFT_INS));
# Line 262  static sljit_ub* emit_x86_instruction(st Line 262  static sljit_ub* emit_x86_instruction(st
262  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
263          /* SSE2 and immediate is not possible. */          /* SSE2 and immediate is not possible. */
264          SLJIT_ASSERT(!(a & SLJIT_IMM) || !(flags & EX86_SSE2));          SLJIT_ASSERT(!(a & SLJIT_IMM) || !(flags & EX86_SSE2));
265            SLJIT_ASSERT((flags & (EX86_PREF_F2 | EX86_PREF_F3)) != (EX86_PREF_F2 | EX86_PREF_F3)
266                    && (flags & (EX86_PREF_F2 | EX86_PREF_66)) != (EX86_PREF_F2 | EX86_PREF_66)
267                    && (flags & (EX86_PREF_F3 | EX86_PREF_66)) != (EX86_PREF_F3 | EX86_PREF_66));
268  #endif  #endif
269    
270          size &= 0xf;          size &= 0xf;
271          inst_size = size;          inst_size = size;
272    
273  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
274          if (flags & EX86_PREF_F2)          if (flags & (EX86_PREF_F2 | EX86_PREF_F3))
275                  inst_size++;                  inst_size++;
276  #endif  #endif
277          if (flags & EX86_PREF_66)          if (flags & EX86_PREF_66)
# Line 278  static sljit_ub* emit_x86_instruction(st Line 281  static sljit_ub* emit_x86_instruction(st
281          inst_size += 1; /* mod r/m byte. */          inst_size += 1; /* mod r/m byte. */
282          if (b & SLJIT_MEM) {          if (b & SLJIT_MEM) {
283                  if ((b & 0x0f) == SLJIT_UNUSED)                  if ((b & 0x0f) == SLJIT_UNUSED)
284                          inst_size += sizeof(sljit_w);                          inst_size += sizeof(sljit_sw);
285                  else if (immb != 0 && !(b & 0xf0)) {                  else if (immb != 0 && !(b & 0xf0)) {
286                          /* Immediate operand. */                          /* Immediate operand. */
287                          if (immb <= 127 && immb >= -128)                          if (immb <= 127 && immb >= -128)
288                                  inst_size += sizeof(sljit_b);                                  inst_size += sizeof(sljit_sb);
289                          else                          else
290                                  inst_size += sizeof(sljit_w);                                  inst_size += sizeof(sljit_sw);
291                  }                  }
292    
293                  if ((b & 0xf) == SLJIT_LOCALS_REG && !(b & 0xf0))                  if ((b & 0xf) == SLJIT_LOCALS_REG && !(b & 0xf0))
# Line 314  static sljit_ub* emit_x86_instruction(st Line 317  static sljit_ub* emit_x86_instruction(st
317                  else if (flags & EX86_HALF_ARG)                  else if (flags & EX86_HALF_ARG)
318                          inst_size += sizeof(short);                          inst_size += sizeof(short);
319                  else                  else
320                          inst_size += sizeof(sljit_w);                          inst_size += sizeof(sljit_sw);
321          }          }
322          else          else
323                  SLJIT_ASSERT(!(flags & EX86_SHIFT_INS) || a == SLJIT_PREF_SHIFT_REG);                  SLJIT_ASSERT(!(flags & EX86_SHIFT_INS) || a == SLJIT_PREF_SHIFT_REG);
# Line 327  static sljit_ub* emit_x86_instruction(st Line 330  static sljit_ub* emit_x86_instruction(st
330  #if (defined SLJIT_SSE2 && SLJIT_SSE2)  #if (defined SLJIT_SSE2 && SLJIT_SSE2)
331          if (flags & EX86_PREF_F2)          if (flags & EX86_PREF_F2)
332                  *buf++ = 0xf2;                  *buf++ = 0xf2;
333            if (flags & EX86_PREF_F3)
334                    *buf++ = 0xf3;
335  #endif  #endif
336          if (flags & EX86_PREF_66)          if (flags & EX86_PREF_66)
337                  *buf++ = 0x66;                  *buf++ = 0x66;
# Line 387  static sljit_ub* emit_x86_instruction(st Line 392  static sljit_ub* emit_x86_instruction(st
392                                  if (immb <= 127 && immb >= -128)                                  if (immb <= 127 && immb >= -128)
393                                          *buf_ptr++ = immb; /* 8 bit displacement. */                                          *buf_ptr++ = immb; /* 8 bit displacement. */
394                                  else {                                  else {
395                                          *(sljit_w*)buf_ptr = immb; /* 32 bit displacement. */                                          *(sljit_sw*)buf_ptr = immb; /* 32 bit displacement. */
396                                          buf_ptr += sizeof(sljit_w);                                          buf_ptr += sizeof(sljit_sw);
397                                  }                                  }
398                          }                          }
399                  }                  }
# Line 399  static sljit_ub* emit_x86_instruction(st Line 404  static sljit_ub* emit_x86_instruction(st
404          }          }
405          else {          else {
406                  *buf_ptr++ |= 0x05;                  *buf_ptr++ |= 0x05;
407                  *(sljit_w*)buf_ptr = immb; /* 32 bit displacement. */                  *(sljit_sw*)buf_ptr = immb; /* 32 bit displacement. */
408                  buf_ptr += sizeof(sljit_w);                  buf_ptr += sizeof(sljit_sw);
409          }          }
410    
411          if (a & SLJIT_IMM) {          if (a & SLJIT_IMM) {
# Line 409  static sljit_ub* emit_x86_instruction(st Line 414  static sljit_ub* emit_x86_instruction(st
414                  else if (flags & EX86_HALF_ARG)                  else if (flags & EX86_HALF_ARG)
415                          *(short*)buf_ptr = imma;                          *(short*)buf_ptr = imma;
416                  else if (!(flags & EX86_SHIFT_INS))                  else if (!(flags & EX86_SHIFT_INS))
417                          *(sljit_w*)buf_ptr = imma;                          *(sljit_sw*)buf_ptr = imma;
418          }          }
419    
420          return !(flags & EX86_SHIFT_INS) ? buf : (buf + 1);          return !(flags & EX86_SHIFT_INS) ? buf : (buf + 1);
# Line 419  static sljit_ub* emit_x86_instruction(st Line 424  static sljit_ub* emit_x86_instruction(st
424  /*  Call / return instructions                                           */  /*  Call / return instructions                                           */
425  /* --------------------------------------------------------------------- */  /* --------------------------------------------------------------------- */
426    
427  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)
428  {  {
429          sljit_ub *buf;          sljit_ub *buf;
430    
# Line 445  static SLJIT_INLINE int call_with_args(s Line 450  static SLJIT_INLINE int call_with_args(s
450          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
451  }  }
452    
453  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)
454  {  {
455          sljit_ub *buf;          sljit_ub *buf;
456    
# Line 479  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 484  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
484          return SLJIT_SUCCESS;          return SLJIT_SUCCESS;
485  }  }
486    
487  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)
488  {  {
489          sljit_ub *buf;          sljit_ub *buf;
490    
# Line 513  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ Line 518  SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_
518    
519                  INC_SIZE(5 + 1);                  INC_SIZE(5 + 1);
520                  *buf++ = 0x68;                  *buf++ = 0x68;
521                  *(sljit_w*)buf = srcw;                  *(sljit_sw*)buf = srcw;
522                  buf += sizeof(sljit_w);                  buf += sizeof(sljit_sw);
523          }          }
524    
525          RET();          RET();

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

  ViewVC Help
Powered by ViewVC 1.1.5