Annotation of embedaddon/pcre/sljit/sljitNativeX86_32.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Stack-less Just-In-Time compiler
3: *
4: * Copyright 2009-2010 Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without modification, are
7: * permitted provided that the following conditions are met:
8: *
9: * 1. Redistributions of source code must retain the above copyright notice, this list of
10: * conditions and the following disclaimer.
11: *
12: * 2. Redistributions in binary form must reproduce the above copyright notice, this list
13: * of conditions and the following disclaimer in the documentation and/or other materials
14: * provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
17: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
19: * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
21: * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
22: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
24: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25: */
26:
27: /* x86 32-bit arch dependent functions. */
28:
29: static int emit_do_imm(struct sljit_compiler *compiler, sljit_ub opcode, sljit_w imm)
30: {
31: sljit_ub *buf;
32:
33: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1 + sizeof(sljit_w));
34: FAIL_IF(!buf);
35: INC_SIZE(1 + sizeof(sljit_w));
36: *buf++ = opcode;
37: *(sljit_w*)buf = imm;
38: return SLJIT_SUCCESS;
39: }
40:
41: static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, int type)
42: {
43: if (type == SLJIT_JUMP) {
44: *code_ptr++ = 0xe9;
45: jump->addr++;
46: }
47: else if (type >= SLJIT_FAST_CALL) {
48: *code_ptr++ = 0xe8;
49: jump->addr++;
50: }
51: else {
52: *code_ptr++ = 0x0f;
53: *code_ptr++ = get_jump_code(type);
54: jump->addr += 2;
55: }
56:
57: if (jump->flags & JUMP_LABEL)
58: jump->flags |= PATCH_MW;
59: else
60: *(sljit_w*)code_ptr = jump->u.target - (jump->addr + 4);
61: code_ptr += 4;
62:
63: return code_ptr;
64: }
65:
66: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size)
67: {
68: int size;
69: sljit_ub *buf;
70:
71: CHECK_ERROR();
72: check_sljit_emit_enter(compiler, args, temporaries, generals, local_size);
73:
74: compiler->temporaries = temporaries;
75: compiler->generals = generals;
76: compiler->args = args;
77: compiler->flags_saved = 0;
78:
79: #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
80: size = 1 + (generals <= 3 ? generals : 3) + (args > 0 ? (args * 2) : 0) + (args > 2 ? 2 : 0);
81: #else
82: size = 1 + (generals <= 3 ? generals : 3) + (args > 0 ? (2 + args * 3) : 0);
83: #endif
84: buf = (sljit_ub*)ensure_buf(compiler, 1 + size);
85: FAIL_IF(!buf);
86:
87: INC_SIZE(size);
88: PUSH_REG(reg_map[TMP_REGISTER]);
89: #if !(defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
90: if (args > 0) {
91: *buf++ = 0x8b;
92: *buf++ = 0xc4 | (reg_map[TMP_REGISTER] << 3);
93: }
94: #endif
95: if (generals > 2)
96: PUSH_REG(reg_map[SLJIT_GENERAL_REG3]);
97: if (generals > 1)
98: PUSH_REG(reg_map[SLJIT_GENERAL_REG2]);
99: if (generals > 0)
100: PUSH_REG(reg_map[SLJIT_GENERAL_REG1]);
101:
102: #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
103: if (args > 0) {
104: *buf++ = 0x8b;
105: *buf++ = 0xc0 | (reg_map[SLJIT_GENERAL_REG1] << 3) | reg_map[SLJIT_TEMPORARY_REG3];
106: }
107: if (args > 1) {
108: *buf++ = 0x8b;
109: *buf++ = 0xc0 | (reg_map[SLJIT_GENERAL_REG2] << 3) | reg_map[SLJIT_TEMPORARY_REG2];
110: }
111: if (args > 2) {
112: *buf++ = 0x8b;
113: *buf++ = 0x44 | (reg_map[SLJIT_GENERAL_REG3] << 3);
114: *buf++ = 0x24;
115: *buf++ = sizeof(sljit_w) * (3 + 2); /* generals >= 3 as well. */
116: }
117: #else
118: if (args > 0) {
119: *buf++ = 0x8b;
120: *buf++ = 0x40 | (reg_map[SLJIT_GENERAL_REG1] << 3) | reg_map[TMP_REGISTER];
121: *buf++ = sizeof(sljit_w) * 2;
122: }
123: if (args > 1) {
124: *buf++ = 0x8b;
125: *buf++ = 0x40 | (reg_map[SLJIT_GENERAL_REG2] << 3) | reg_map[TMP_REGISTER];
126: *buf++ = sizeof(sljit_w) * 3;
127: }
128: if (args > 2) {
129: *buf++ = 0x8b;
130: *buf++ = 0x40 | (reg_map[SLJIT_GENERAL_REG3] << 3) | reg_map[TMP_REGISTER];
131: *buf++ = sizeof(sljit_w) * 4;
132: }
133: #endif
134:
135: local_size = (local_size + sizeof(sljit_uw) - 1) & ~(sizeof(sljit_uw) - 1);
136: compiler->temporaries_start = local_size;
137: if (temporaries > 3)
138: local_size += (temporaries - 3) * sizeof(sljit_uw);
139: compiler->generals_start = local_size;
140: if (generals > 3)
141: local_size += (generals - 3) * sizeof(sljit_uw);
142:
143: #ifdef _WIN32
144: if (local_size > 1024) {
145: FAIL_IF(emit_do_imm(compiler, 0xb8 + reg_map[SLJIT_TEMPORARY_REG1], local_size));
146: FAIL_IF(sljit_emit_ijump(compiler, SLJIT_CALL1, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_touch_stack)));
147: }
148: #endif
149:
150: compiler->local_size = local_size;
151: if (local_size > 0)
152: return emit_non_cum_binary(compiler, 0x2b, 0x29, 0x5 << 3, 0x2d,
153: SLJIT_LOCALS_REG, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, local_size);
154:
155: /* Mov arguments to general registers. */
156: return SLJIT_SUCCESS;
157: }
158:
159: SLJIT_API_FUNC_ATTRIBUTE void sljit_fake_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size)
160: {
161: CHECK_ERROR_VOID();
162: check_sljit_fake_enter(compiler, args, temporaries, generals, local_size);
163:
164: compiler->temporaries = temporaries;
165: compiler->generals = generals;
166: compiler->args = args;
167: compiler->local_size = (local_size + sizeof(sljit_uw) - 1) & ~(sizeof(sljit_uw) - 1);
168: compiler->temporaries_start = compiler->local_size;
169: if (temporaries > 3)
170: compiler->local_size += (temporaries - 3) * sizeof(sljit_uw);
171: compiler->generals_start = compiler->local_size;
172: if (generals > 3)
173: compiler->local_size += (generals - 3) * sizeof(sljit_uw);
174: }
175:
176: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
177: {
178: int size;
179: sljit_ub *buf;
180:
181: CHECK_ERROR();
182: check_sljit_emit_return(compiler, src, srcw);
183: SLJIT_ASSERT(compiler->args >= 0);
184:
185: compiler->flags_saved = 0;
186: CHECK_EXTRA_REGS(src, srcw, (void)0);
187:
188: if (src != SLJIT_UNUSED && src != SLJIT_RETURN_REG)
189: FAIL_IF(emit_mov(compiler, SLJIT_RETURN_REG, 0, src, srcw));
190:
191: if (compiler->local_size > 0)
192: FAIL_IF(emit_cum_binary(compiler, 0x03, 0x01, 0x0 << 3, 0x05,
193: SLJIT_LOCALS_REG, 0, SLJIT_LOCALS_REG, 0, SLJIT_IMM, compiler->local_size));
194:
195: size = 2 + (compiler->generals <= 3 ? compiler->generals : 3);
196: #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
197: if (compiler->args > 2)
198: size += 2;
199: #else
200: if (compiler->args > 0)
201: size += 2;
202: #endif
203: buf = (sljit_ub*)ensure_buf(compiler, 1 + size);
204: FAIL_IF(!buf);
205:
206: INC_SIZE(size);
207:
208: if (compiler->generals > 0)
209: POP_REG(reg_map[SLJIT_GENERAL_REG1]);
210: if (compiler->generals > 1)
211: POP_REG(reg_map[SLJIT_GENERAL_REG2]);
212: if (compiler->generals > 2)
213: POP_REG(reg_map[SLJIT_GENERAL_REG3]);
214: POP_REG(reg_map[TMP_REGISTER]);
215: #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
216: if (compiler->args > 2)
217: RETN(sizeof(sljit_w));
218: else
219: RET();
220: #else
221: if (compiler->args > 0)
222: RETN(compiler->args * sizeof(sljit_w));
223: else
224: RET();
225: #endif
226:
227: return SLJIT_SUCCESS;
228: }
229:
230: /* --------------------------------------------------------------------- */
231: /* Operators */
232: /* --------------------------------------------------------------------- */
233:
234: /* Size contains the flags as well. */
235: static sljit_ub* emit_x86_instruction(struct sljit_compiler *compiler, int size,
236: /* The register or immediate operand. */
237: int a, sljit_w imma,
238: /* The general operand (not immediate). */
239: int b, sljit_w immb)
240: {
241: sljit_ub *buf;
242: sljit_ub *buf_ptr;
243: int flags = size & ~0xf;
244: int inst_size;
245:
246: /* Both cannot be switched on. */
247: SLJIT_ASSERT((flags & (EX86_BIN_INS | EX86_SHIFT_INS)) != (EX86_BIN_INS | EX86_SHIFT_INS));
248: /* Size flags not allowed for typed instructions. */
249: SLJIT_ASSERT(!(flags & (EX86_BIN_INS | EX86_SHIFT_INS)) || (flags & (EX86_BYTE_ARG | EX86_HALF_ARG)) == 0);
250: /* Both size flags cannot be switched on. */
251: SLJIT_ASSERT((flags & (EX86_BYTE_ARG | EX86_HALF_ARG)) != (EX86_BYTE_ARG | EX86_HALF_ARG));
252: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
253: /* SSE2 and immediate is not possible. */
254: SLJIT_ASSERT(!(a & SLJIT_IMM) || !(flags & EX86_SSE2));
255: #endif
256:
257: size &= 0xf;
258: inst_size = size;
259:
260: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
261: if (flags & EX86_PREF_F2)
262: inst_size++;
263: #endif
264: if (flags & EX86_PREF_66)
265: inst_size++;
266:
267: /* Calculate size of b. */
268: inst_size += 1; /* mod r/m byte. */
269: if (b & SLJIT_MEM) {
270: if ((b & 0x0f) == SLJIT_UNUSED)
271: inst_size += sizeof(sljit_w);
272: else if (immb != 0 && !(b & 0xf0)) {
273: /* Immediate operand. */
274: if (immb <= 127 && immb >= -128)
275: inst_size += sizeof(sljit_b);
276: else
277: inst_size += sizeof(sljit_w);
278: }
279:
280: if ((b & 0xf) == SLJIT_LOCALS_REG && !(b & 0xf0))
281: b |= SLJIT_LOCALS_REG << 4;
282:
283: if ((b & 0xf0) != SLJIT_UNUSED)
284: inst_size += 1; /* SIB byte. */
285: }
286:
287: /* Calculate size of a. */
288: if (a & SLJIT_IMM) {
289: if (flags & EX86_BIN_INS) {
290: if (imma <= 127 && imma >= -128) {
291: inst_size += 1;
292: flags |= EX86_BYTE_ARG;
293: } else
294: inst_size += 4;
295: }
296: else if (flags & EX86_SHIFT_INS) {
297: imma &= 0x1f;
298: if (imma != 1) {
299: inst_size ++;
300: flags |= EX86_BYTE_ARG;
301: }
302: } else if (flags & EX86_BYTE_ARG)
303: inst_size++;
304: else if (flags & EX86_HALF_ARG)
305: inst_size += sizeof(short);
306: else
307: inst_size += sizeof(sljit_w);
308: }
309: else
310: SLJIT_ASSERT(!(flags & EX86_SHIFT_INS) || a == SLJIT_PREF_SHIFT_REG);
311:
312: buf = (sljit_ub*)ensure_buf(compiler, 1 + inst_size);
313: PTR_FAIL_IF(!buf);
314:
315: /* Encoding the byte. */
316: INC_SIZE(inst_size);
317: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
318: if (flags & EX86_PREF_F2)
319: *buf++ = 0xf2;
320: #endif
321: if (flags & EX86_PREF_66)
322: *buf++ = 0x66;
323:
324: buf_ptr = buf + size;
325:
326: /* Encode mod/rm byte. */
327: if (!(flags & EX86_SHIFT_INS)) {
328: if ((flags & EX86_BIN_INS) && (a & SLJIT_IMM))
329: *buf = (flags & EX86_BYTE_ARG) ? 0x83 : 0x81;
330:
331: if ((a & SLJIT_IMM) || (a == 0))
332: *buf_ptr = 0;
333: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
334: else if (!(flags & EX86_SSE2))
335: *buf_ptr = reg_map[a] << 3;
336: else
337: *buf_ptr = a << 3;
338: #else
339: else
340: *buf_ptr = reg_map[a] << 3;
341: #endif
342: }
343: else {
344: if (a & SLJIT_IMM) {
345: if (imma == 1)
346: *buf = 0xd1;
347: else
348: *buf = 0xc1;
349: } else
350: *buf = 0xd3;
351: *buf_ptr = 0;
352: }
353:
354: if (!(b & SLJIT_MEM))
355: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
356: *buf_ptr++ |= 0xc0 + ((!(flags & EX86_SSE2)) ? reg_map[b] : b);
357: #else
358: *buf_ptr++ |= 0xc0 + reg_map[b];
359: #endif
360: else if ((b & 0x0f) != SLJIT_UNUSED) {
361: if ((b & 0xf0) == SLJIT_UNUSED || (b & 0xf0) == (SLJIT_LOCALS_REG << 4)) {
362: if (immb != 0) {
363: if (immb <= 127 && immb >= -128)
364: *buf_ptr |= 0x40;
365: else
366: *buf_ptr |= 0x80;
367: }
368:
369: if ((b & 0xf0) == SLJIT_UNUSED)
370: *buf_ptr++ |= reg_map[b & 0x0f];
371: else {
372: *buf_ptr++ |= 0x04;
373: *buf_ptr++ = reg_map[b & 0x0f] | (reg_map[(b >> 4) & 0x0f] << 3);
374: }
375:
376: if (immb != 0) {
377: if (immb <= 127 && immb >= -128)
378: *buf_ptr++ = immb; /* 8 bit displacement. */
379: else {
380: *(sljit_w*)buf_ptr = immb; /* 32 bit displacement. */
381: buf_ptr += sizeof(sljit_w);
382: }
383: }
384: }
385: else {
386: *buf_ptr++ |= 0x04;
387: *buf_ptr++ = reg_map[b & 0x0f] | (reg_map[(b >> 4) & 0x0f] << 3) | (immb << 6);
388: }
389: }
390: else {
391: *buf_ptr++ |= 0x05;
392: *(sljit_w*)buf_ptr = immb; /* 32 bit displacement. */
393: buf_ptr += sizeof(sljit_w);
394: }
395:
396: if (a & SLJIT_IMM) {
397: if (flags & EX86_BYTE_ARG)
398: *buf_ptr = imma;
399: else if (flags & EX86_HALF_ARG)
400: *(short*)buf_ptr = imma;
401: else if (!(flags & EX86_SHIFT_INS))
402: *(sljit_w*)buf_ptr = imma;
403: }
404:
405: return !(flags & EX86_SHIFT_INS) ? buf : (buf + 1);
406: }
407:
408: /* --------------------------------------------------------------------- */
409: /* Call / return instructions */
410: /* --------------------------------------------------------------------- */
411:
412: static SLJIT_INLINE int call_with_args(struct sljit_compiler *compiler, int type)
413: {
414: sljit_ub *buf;
415:
416: #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
417: buf = (sljit_ub*)ensure_buf(compiler, type >= SLJIT_CALL3 ? 1 + 2 + 1 : 1 + 2);
418: FAIL_IF(!buf);
419: INC_SIZE(type >= SLJIT_CALL3 ? 2 + 1 : 2);
420:
421: if (type >= SLJIT_CALL3)
422: PUSH_REG(reg_map[SLJIT_TEMPORARY_REG3]);
423: *buf++ = 0x8b;
424: *buf++ = 0xc0 | (reg_map[SLJIT_TEMPORARY_REG3] << 3) | reg_map[SLJIT_TEMPORARY_REG1];
425: #else
426: buf = (sljit_ub*)ensure_buf(compiler, type - SLJIT_CALL0 + 1);
427: FAIL_IF(!buf);
428: INC_SIZE(type - SLJIT_CALL0);
429: if (type >= SLJIT_CALL3)
430: PUSH_REG(reg_map[SLJIT_TEMPORARY_REG3]);
431: if (type >= SLJIT_CALL2)
432: PUSH_REG(reg_map[SLJIT_TEMPORARY_REG2]);
433: PUSH_REG(reg_map[SLJIT_TEMPORARY_REG1]);
434: #endif
435: return SLJIT_SUCCESS;
436: }
437:
438: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_enter(struct sljit_compiler *compiler, int dst, sljit_w dstw, int args, int temporaries, int generals, int local_size)
439: {
440: sljit_ub *buf;
441:
442: CHECK_ERROR();
443: check_sljit_emit_fast_enter(compiler, dst, dstw, args, temporaries, generals, local_size);
444:
445: compiler->temporaries = temporaries;
446: compiler->generals = generals;
447: compiler->args = args;
448: compiler->local_size = (local_size + sizeof(sljit_uw) - 1) & ~(sizeof(sljit_uw) - 1);
449: compiler->temporaries_start = compiler->local_size;
450: if (temporaries > 3)
451: compiler->local_size += (temporaries - 3) * sizeof(sljit_uw);
452: compiler->generals_start = compiler->local_size;
453: if (generals > 3)
454: compiler->local_size += (generals - 3) * sizeof(sljit_uw);
455:
456: CHECK_EXTRA_REGS(dst, dstw, (void)0);
457:
458: if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
459: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1);
460: FAIL_IF(!buf);
461:
462: INC_SIZE(1);
463: POP_REG(reg_map[dst]);
464: return SLJIT_SUCCESS;
465: }
466: else if (dst & SLJIT_MEM) {
467: buf = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
468: FAIL_IF(!buf);
469: *buf++ = 0x8f;
470: return SLJIT_SUCCESS;
471: }
472:
473: /* For UNUSED dst. Uncommon, but possible. */
474: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1);
475: FAIL_IF(!buf);
476:
477: INC_SIZE(1);
478: POP_REG(reg_map[TMP_REGISTER]);
479: return SLJIT_SUCCESS;
480: }
481:
482: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
483: {
484: sljit_ub *buf;
485:
486: CHECK_ERROR();
487: check_sljit_emit_fast_return(compiler, src, srcw);
488:
489: CHECK_EXTRA_REGS(src, srcw, (void)0);
490:
491: if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS) {
492: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1 + 1);
493: FAIL_IF(!buf);
494:
495: INC_SIZE(1 + 1);
496: PUSH_REG(reg_map[src]);
497: }
498: else if (src & SLJIT_MEM) {
499: buf = emit_x86_instruction(compiler, 1, 0, 0, src, srcw);
500: FAIL_IF(!buf);
501: *buf++ = 0xff;
502: *buf |= 6 << 3;
503:
504: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1);
505: FAIL_IF(!buf);
506: INC_SIZE(1);
507: }
508: else {
509: /* SLJIT_IMM. */
510: buf = (sljit_ub*)ensure_buf(compiler, 1 + 5 + 1);
511: FAIL_IF(!buf);
512:
513: INC_SIZE(5 + 1);
514: *buf++ = 0x68;
515: *(sljit_w*)buf = srcw;
516: buf += sizeof(sljit_w);
517: }
518:
519: RET();
520: return SLJIT_SUCCESS;
521: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sljitNativeX86_32.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre / sljit