Annotation of embedaddon/pcre/sljit/sljitNativeX86_64.c, revision 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 64-bit arch dependent functions. */
! 28:
! 29: static int emit_load_imm64(struct sljit_compiler *compiler, int reg, sljit_w imm)
! 30: {
! 31: sljit_ub *buf;
! 32:
! 33: buf = (sljit_ub*)ensure_buf(compiler, 1 + 2 + sizeof(sljit_w));
! 34: FAIL_IF(!buf);
! 35: INC_SIZE(2 + sizeof(sljit_w));
! 36: *buf++ = REX_W | ((reg_map[reg] <= 7) ? 0 : REX_B);
! 37: *buf++ = 0xb8 + (reg_map[reg] & 0x7);
! 38: *(sljit_w*)buf = imm;
! 39: return SLJIT_SUCCESS;
! 40: }
! 41:
! 42: static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, int type)
! 43: {
! 44: if (type < SLJIT_JUMP) {
! 45: *code_ptr++ = get_jump_code(type ^ 0x1) - 0x10;
! 46: *code_ptr++ = 10 + 3;
! 47: }
! 48:
! 49: SLJIT_COMPILE_ASSERT(reg_map[TMP_REG3] == 9, tmp3_is_9_first);
! 50: *code_ptr++ = REX_W | REX_B;
! 51: *code_ptr++ = 0xb8 + 1;
! 52: jump->addr = (sljit_uw)code_ptr;
! 53:
! 54: if (jump->flags & JUMP_LABEL)
! 55: jump->flags |= PATCH_MD;
! 56: else
! 57: *(sljit_w*)code_ptr = jump->u.target;
! 58:
! 59: code_ptr += sizeof(sljit_w);
! 60: *code_ptr++ = REX_B;
! 61: *code_ptr++ = 0xff;
! 62: *code_ptr++ = (type >= SLJIT_FAST_CALL) ? 0xd1 /* call */ : 0xe1 /* jmp */;
! 63:
! 64: return code_ptr;
! 65: }
! 66:
! 67: static sljit_ub* generate_fixed_jump(sljit_ub *code_ptr, sljit_w addr, int type)
! 68: {
! 69: sljit_w delta = addr - ((sljit_w)code_ptr + 1 + sizeof(sljit_hw));
! 70:
! 71: if (delta <= SLJIT_W(0x7fffffff) && delta >= SLJIT_W(-0x80000000)) {
! 72: *code_ptr++ = (type == 2) ? 0xe8 /* call */ : 0xe9 /* jmp */;
! 73: *(sljit_w*)code_ptr = delta;
! 74: }
! 75: else {
! 76: SLJIT_COMPILE_ASSERT(reg_map[TMP_REG3] == 9, tmp3_is_9_second);
! 77: *code_ptr++ = REX_W | REX_B;
! 78: *code_ptr++ = 0xb8 + 1;
! 79: *(sljit_w*)code_ptr = addr;
! 80: code_ptr += sizeof(sljit_w);
! 81: *code_ptr++ = REX_B;
! 82: *code_ptr++ = 0xff;
! 83: *code_ptr++ = (type == 2) ? 0xd1 /* call */ : 0xe1 /* jmp */;
! 84: }
! 85:
! 86: return code_ptr;
! 87: }
! 88:
! 89: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size)
! 90: {
! 91: int size, pushed_size;
! 92: sljit_ub *buf;
! 93:
! 94: CHECK_ERROR();
! 95: check_sljit_emit_enter(compiler, args, temporaries, generals, local_size);
! 96:
! 97: compiler->temporaries = temporaries;
! 98: compiler->generals = generals;
! 99: compiler->flags_saved = 0;
! 100:
! 101: size = generals;
! 102: /* Including the return address saved by the call instruction. */
! 103: pushed_size = (generals + 1) * sizeof(sljit_w);
! 104: #ifndef _WIN64
! 105: if (generals >= 2)
! 106: size += generals - 1;
! 107: #else
! 108: /* Saving the virtual stack pointer. */
! 109: compiler->has_locals = local_size > 0;
! 110: if (local_size > 0) {
! 111: size += 2;
! 112: pushed_size += sizeof(sljit_w);
! 113: }
! 114: if (generals >= 4)
! 115: size += generals - 3;
! 116: if (temporaries >= 5) {
! 117: size += (5 - 4) * 2;
! 118: pushed_size += sizeof(sljit_w);
! 119: }
! 120: #endif
! 121: size += args * 3;
! 122: if (size > 0) {
! 123: buf = (sljit_ub*)ensure_buf(compiler, 1 + size);
! 124: FAIL_IF(!buf);
! 125:
! 126: INC_SIZE(size);
! 127: if (generals >= 5) {
! 128: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_GENERAL_EREG2] >= 8, general_ereg2_is_hireg);
! 129: *buf++ = REX_B;
! 130: PUSH_REG(reg_lmap[SLJIT_GENERAL_EREG2]);
! 131: }
! 132: if (generals >= 4) {
! 133: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_GENERAL_EREG1] >= 8, general_ereg1_is_hireg);
! 134: *buf++ = REX_B;
! 135: PUSH_REG(reg_lmap[SLJIT_GENERAL_EREG1]);
! 136: }
! 137: if (generals >= 3) {
! 138: #ifndef _WIN64
! 139: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_GENERAL_REG3] >= 8, general_reg3_is_hireg);
! 140: *buf++ = REX_B;
! 141: #else
! 142: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_GENERAL_REG3] < 8, general_reg3_is_loreg);
! 143: #endif
! 144: PUSH_REG(reg_lmap[SLJIT_GENERAL_REG3]);
! 145: }
! 146: if (generals >= 2) {
! 147: #ifndef _WIN64
! 148: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_GENERAL_REG2] >= 8, general_reg2_is_hireg);
! 149: *buf++ = REX_B;
! 150: #else
! 151: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_GENERAL_REG2] < 8, general_reg2_is_loreg);
! 152: #endif
! 153: PUSH_REG(reg_lmap[SLJIT_GENERAL_REG2]);
! 154: }
! 155: if (generals >= 1) {
! 156: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_GENERAL_REG1] < 8, general_reg1_is_loreg);
! 157: PUSH_REG(reg_lmap[SLJIT_GENERAL_REG1]);
! 158: }
! 159: #ifdef _WIN64
! 160: if (temporaries >= 5) {
! 161: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_TEMPORARY_EREG2] >= 8, temporary_ereg2_is_hireg);
! 162: *buf++ = REX_B;
! 163: PUSH_REG(reg_lmap[SLJIT_TEMPORARY_EREG2]);
! 164: }
! 165: if (local_size > 0) {
! 166: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_LOCALS_REG] >= 8, locals_reg_is_hireg);
! 167: *buf++ = REX_B;
! 168: PUSH_REG(reg_lmap[SLJIT_LOCALS_REG]);
! 169: }
! 170: #endif
! 171:
! 172: #ifndef _WIN64
! 173: if (args > 0) {
! 174: *buf++ = REX_W;
! 175: *buf++ = 0x8b;
! 176: *buf++ = 0xc0 | (reg_map[SLJIT_GENERAL_REG1] << 3) | 0x7;
! 177: }
! 178: if (args > 1) {
! 179: *buf++ = REX_W | REX_R;
! 180: *buf++ = 0x8b;
! 181: *buf++ = 0xc0 | (reg_lmap[SLJIT_GENERAL_REG2] << 3) | 0x6;
! 182: }
! 183: if (args > 2) {
! 184: *buf++ = REX_W | REX_R;
! 185: *buf++ = 0x8b;
! 186: *buf++ = 0xc0 | (reg_lmap[SLJIT_GENERAL_REG3] << 3) | 0x2;
! 187: }
! 188: #else
! 189: if (args > 0) {
! 190: *buf++ = REX_W;
! 191: *buf++ = 0x8b;
! 192: *buf++ = 0xc0 | (reg_map[SLJIT_GENERAL_REG1] << 3) | 0x1;
! 193: }
! 194: if (args > 1) {
! 195: *buf++ = REX_W;
! 196: *buf++ = 0x8b;
! 197: *buf++ = 0xc0 | (reg_map[SLJIT_GENERAL_REG2] << 3) | 0x2;
! 198: }
! 199: if (args > 2) {
! 200: *buf++ = REX_W | REX_B;
! 201: *buf++ = 0x8b;
! 202: *buf++ = 0xc0 | (reg_map[SLJIT_GENERAL_REG3] << 3) | 0x0;
! 203: }
! 204: #endif
! 205: }
! 206:
! 207: local_size = ((local_size + pushed_size + 16 - 1) & ~(16 - 1)) - pushed_size;
! 208: #ifdef _WIN64
! 209: local_size += 4 * sizeof(sljit_w);
! 210: compiler->local_size = local_size;
! 211: if (local_size > 1024) {
! 212: /* Allocate the stack for the function itself. */
! 213: buf = (sljit_ub*)ensure_buf(compiler, 1 + 4);
! 214: FAIL_IF(!buf);
! 215: INC_SIZE(4);
! 216: *buf++ = REX_W;
! 217: *buf++ = 0x83;
! 218: *buf++ = 0xc0 | (5 << 3) | 4;
! 219: /* Pushed size must be divisible by 8. */
! 220: SLJIT_ASSERT(!(pushed_size & 0x7));
! 221: if (pushed_size & 0x8) {
! 222: *buf++ = 5 * sizeof(sljit_w);
! 223: local_size -= 5 * sizeof(sljit_w);
! 224: } else {
! 225: *buf++ = 4 * sizeof(sljit_w);
! 226: local_size -= 4 * sizeof(sljit_w);
! 227: }
! 228: FAIL_IF(emit_load_imm64(compiler, SLJIT_TEMPORARY_REG1, local_size));
! 229: FAIL_IF(sljit_emit_ijump(compiler, SLJIT_CALL1, SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_touch_stack)));
! 230: }
! 231: #else
! 232: compiler->local_size = local_size;
! 233: if (local_size > 0) {
! 234: #endif
! 235: /* In case of Win64, local_size is always > 4 * sizeof(sljit_w) */
! 236: if (local_size <= 127) {
! 237: buf = (sljit_ub*)ensure_buf(compiler, 1 + 4);
! 238: FAIL_IF(!buf);
! 239: INC_SIZE(4);
! 240: *buf++ = REX_W;
! 241: *buf++ = 0x83;
! 242: *buf++ = 0xc0 | (5 << 3) | 4;
! 243: *buf++ = local_size;
! 244: }
! 245: else {
! 246: buf = (sljit_ub*)ensure_buf(compiler, 1 + 7);
! 247: FAIL_IF(!buf);
! 248: INC_SIZE(7);
! 249: *buf++ = REX_W;
! 250: *buf++ = 0x81;
! 251: *buf++ = 0xc0 | (5 << 3) | 4;
! 252: *(sljit_hw*)buf = local_size;
! 253: buf += sizeof(sljit_hw);
! 254: }
! 255: #ifndef _WIN64
! 256: }
! 257: #endif
! 258:
! 259: #ifdef _WIN64
! 260: if (compiler->has_locals) {
! 261: buf = (sljit_ub*)ensure_buf(compiler, 1 + 5);
! 262: FAIL_IF(!buf);
! 263: INC_SIZE(5);
! 264: *buf++ = REX_W | REX_R;
! 265: *buf++ = 0x8d;
! 266: *buf++ = 0x40 | (reg_lmap[SLJIT_LOCALS_REG] << 3) | 0x4;
! 267: *buf++ = 0x24;
! 268: *buf = 4 * sizeof(sljit_w);
! 269: }
! 270: #endif
! 271:
! 272: /* Mov arguments to general registers. */
! 273: return SLJIT_SUCCESS;
! 274: }
! 275:
! 276: SLJIT_API_FUNC_ATTRIBUTE void sljit_fake_enter(struct sljit_compiler *compiler, int args, int temporaries, int generals, int local_size)
! 277: {
! 278: int pushed_size;
! 279:
! 280: CHECK_ERROR_VOID();
! 281: check_sljit_fake_enter(compiler, args, temporaries, generals, local_size);
! 282:
! 283: compiler->temporaries = temporaries;
! 284: compiler->generals = generals;
! 285: /* Including the return address saved by the call instruction. */
! 286: pushed_size = (generals + 1) * sizeof(sljit_w);
! 287: #ifdef _WIN64
! 288: compiler->has_locals = local_size > 0;
! 289: if (local_size > 0)
! 290: pushed_size += sizeof(sljit_w);
! 291: if (temporaries >= 5)
! 292: pushed_size += sizeof(sljit_w);
! 293: #endif
! 294: compiler->local_size = ((local_size + pushed_size + 16 - 1) & ~(16 - 1)) - pushed_size;
! 295: #ifdef _WIN64
! 296: compiler->local_size += 4 * sizeof(sljit_w);
! 297: #endif
! 298: }
! 299:
! 300: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
! 301: {
! 302: int size;
! 303: sljit_ub *buf;
! 304:
! 305: CHECK_ERROR();
! 306: check_sljit_emit_return(compiler, src, srcw);
! 307:
! 308: compiler->flags_saved = 0;
! 309:
! 310: if (src != SLJIT_UNUSED && src != SLJIT_RETURN_REG) {
! 311: compiler->mode32 = 0;
! 312: FAIL_IF(emit_mov(compiler, SLJIT_RETURN_REG, 0, src, srcw));
! 313: }
! 314:
! 315: if (compiler->local_size > 0) {
! 316: if (compiler->local_size <= 127) {
! 317: buf = (sljit_ub*)ensure_buf(compiler, 1 + 4);
! 318: FAIL_IF(!buf);
! 319: INC_SIZE(4);
! 320: *buf++ = REX_W;
! 321: *buf++ = 0x83;
! 322: *buf++ = 0xc0 | (0 << 3) | 4;
! 323: *buf = compiler->local_size;
! 324: }
! 325: else {
! 326: buf = (sljit_ub*)ensure_buf(compiler, 1 + 7);
! 327: FAIL_IF(!buf);
! 328: INC_SIZE(7);
! 329: *buf++ = REX_W;
! 330: *buf++ = 0x81;
! 331: *buf++ = 0xc0 | (0 << 3) | 4;
! 332: *(sljit_hw*)buf = compiler->local_size;
! 333: }
! 334: }
! 335:
! 336: size = 1 + compiler->generals;
! 337: #ifndef _WIN64
! 338: if (compiler->generals >= 2)
! 339: size += compiler->generals - 1;
! 340: #else
! 341: if (compiler->has_locals)
! 342: size += 2;
! 343: if (compiler->generals >= 4)
! 344: size += compiler->generals - 3;
! 345: if (compiler->temporaries >= 5)
! 346: size += (5 - 4) * 2;
! 347: #endif
! 348: buf = (sljit_ub*)ensure_buf(compiler, 1 + size);
! 349: FAIL_IF(!buf);
! 350:
! 351: INC_SIZE(size);
! 352:
! 353: #ifdef _WIN64
! 354: if (compiler->has_locals) {
! 355: *buf++ = REX_B;
! 356: POP_REG(reg_lmap[SLJIT_LOCALS_REG]);
! 357: }
! 358: if (compiler->temporaries >= 5) {
! 359: *buf++ = REX_B;
! 360: POP_REG(reg_lmap[SLJIT_TEMPORARY_EREG2]);
! 361: }
! 362: #endif
! 363: if (compiler->generals >= 1)
! 364: POP_REG(reg_map[SLJIT_GENERAL_REG1]);
! 365: if (compiler->generals >= 2) {
! 366: #ifndef _WIN64
! 367: *buf++ = REX_B;
! 368: #endif
! 369: POP_REG(reg_lmap[SLJIT_GENERAL_REG2]);
! 370: }
! 371: if (compiler->generals >= 3) {
! 372: #ifndef _WIN64
! 373: *buf++ = REX_B;
! 374: #endif
! 375: POP_REG(reg_lmap[SLJIT_GENERAL_REG3]);
! 376: }
! 377: if (compiler->generals >= 4) {
! 378: *buf++ = REX_B;
! 379: POP_REG(reg_lmap[SLJIT_GENERAL_EREG1]);
! 380: }
! 381: if (compiler->generals >= 5) {
! 382: *buf++ = REX_B;
! 383: POP_REG(reg_lmap[SLJIT_GENERAL_EREG2]);
! 384: }
! 385:
! 386: RET();
! 387: return SLJIT_SUCCESS;
! 388: }
! 389:
! 390: /* --------------------------------------------------------------------- */
! 391: /* Operators */
! 392: /* --------------------------------------------------------------------- */
! 393:
! 394: static int emit_do_imm32(struct sljit_compiler *compiler, sljit_ub rex, sljit_ub opcode, sljit_w imm)
! 395: {
! 396: sljit_ub *buf;
! 397:
! 398: if (rex != 0) {
! 399: buf = (sljit_ub*)ensure_buf(compiler, 1 + 2 + sizeof(sljit_hw));
! 400: FAIL_IF(!buf);
! 401: INC_SIZE(2 + sizeof(sljit_hw));
! 402: *buf++ = rex;
! 403: *buf++ = opcode;
! 404: *(sljit_hw*)buf = imm;
! 405: }
! 406: else {
! 407: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1 + sizeof(sljit_hw));
! 408: FAIL_IF(!buf);
! 409: INC_SIZE(1 + sizeof(sljit_hw));
! 410: *buf++ = opcode;
! 411: *(sljit_hw*)buf = imm;
! 412: }
! 413: return SLJIT_SUCCESS;
! 414: }
! 415:
! 416: static sljit_ub* emit_x86_instruction(struct sljit_compiler *compiler, int size,
! 417: /* The register or immediate operand. */
! 418: int a, sljit_w imma,
! 419: /* The general operand (not immediate). */
! 420: int b, sljit_w immb)
! 421: {
! 422: sljit_ub *buf;
! 423: sljit_ub *buf_ptr;
! 424: sljit_ub rex = 0;
! 425: int flags = size & ~0xf;
! 426: int inst_size;
! 427:
! 428: /* The immediate operand must be 32 bit. */
! 429: SLJIT_ASSERT(!(a & SLJIT_IMM) || compiler->mode32 || IS_HALFWORD(imma));
! 430: /* Both cannot be switched on. */
! 431: SLJIT_ASSERT((flags & (EX86_BIN_INS | EX86_SHIFT_INS)) != (EX86_BIN_INS | EX86_SHIFT_INS));
! 432: /* Size flags not allowed for typed instructions. */
! 433: SLJIT_ASSERT(!(flags & (EX86_BIN_INS | EX86_SHIFT_INS)) || (flags & (EX86_BYTE_ARG | EX86_HALF_ARG)) == 0);
! 434: /* Both size flags cannot be switched on. */
! 435: SLJIT_ASSERT((flags & (EX86_BYTE_ARG | EX86_HALF_ARG)) != (EX86_BYTE_ARG | EX86_HALF_ARG));
! 436: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
! 437: /* SSE2 and immediate is not possible. */
! 438: SLJIT_ASSERT(!(a & SLJIT_IMM) || !(flags & EX86_SSE2));
! 439: #endif
! 440:
! 441: size &= 0xf;
! 442: inst_size = size;
! 443:
! 444: if ((b & SLJIT_MEM) && !(b & 0xf0) && NOT_HALFWORD(immb)) {
! 445: if (emit_load_imm64(compiler, TMP_REG3, immb))
! 446: return NULL;
! 447: immb = 0;
! 448: if (b & 0xf)
! 449: b |= TMP_REG3 << 4;
! 450: else
! 451: b |= TMP_REG3;
! 452: }
! 453:
! 454: if (!compiler->mode32 && !(flags & EX86_NO_REXW))
! 455: rex |= REX_W;
! 456: else if (flags & EX86_REX)
! 457: rex |= REX;
! 458:
! 459: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
! 460: if (flags & EX86_PREF_F2)
! 461: inst_size++;
! 462: #endif
! 463: if (flags & EX86_PREF_66)
! 464: inst_size++;
! 465:
! 466: /* Calculate size of b. */
! 467: inst_size += 1; /* mod r/m byte. */
! 468: if (b & SLJIT_MEM) {
! 469: if ((b & 0x0f) == SLJIT_UNUSED)
! 470: inst_size += 1 + sizeof(sljit_hw); /* SIB byte required to avoid RIP based addressing. */
! 471: else {
! 472: if (reg_map[b & 0x0f] >= 8)
! 473: rex |= REX_B;
! 474: if (immb != 0 && !(b & 0xf0)) {
! 475: /* Immediate operand. */
! 476: if (immb <= 127 && immb >= -128)
! 477: inst_size += sizeof(sljit_b);
! 478: else
! 479: inst_size += sizeof(sljit_hw);
! 480: }
! 481: }
! 482:
! 483: #ifndef _WIN64
! 484: if ((b & 0xf) == SLJIT_LOCALS_REG && (b & 0xf0) == 0)
! 485: b |= SLJIT_LOCALS_REG << 4;
! 486: #endif
! 487:
! 488: if ((b & 0xf0) != SLJIT_UNUSED) {
! 489: inst_size += 1; /* SIB byte. */
! 490: if (reg_map[(b >> 4) & 0x0f] >= 8)
! 491: rex |= REX_X;
! 492: }
! 493: }
! 494: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
! 495: else if (!(flags & EX86_SSE2) && reg_map[b] >= 8)
! 496: rex |= REX_B;
! 497: #else
! 498: else if (reg_map[b] >= 8)
! 499: rex |= REX_B;
! 500: #endif
! 501:
! 502: if (a & SLJIT_IMM) {
! 503: if (flags & EX86_BIN_INS) {
! 504: if (imma <= 127 && imma >= -128) {
! 505: inst_size += 1;
! 506: flags |= EX86_BYTE_ARG;
! 507: } else
! 508: inst_size += 4;
! 509: }
! 510: else if (flags & EX86_SHIFT_INS) {
! 511: imma &= 0x3f;
! 512: if (imma != 1) {
! 513: inst_size ++;
! 514: flags |= EX86_BYTE_ARG;
! 515: }
! 516: } else if (flags & EX86_BYTE_ARG)
! 517: inst_size++;
! 518: else if (flags & EX86_HALF_ARG)
! 519: inst_size += sizeof(short);
! 520: else
! 521: inst_size += sizeof(sljit_hw);
! 522: }
! 523: else {
! 524: SLJIT_ASSERT(!(flags & EX86_SHIFT_INS) || a == SLJIT_PREF_SHIFT_REG);
! 525: /* reg_map[SLJIT_PREF_SHIFT_REG] is less than 8. */
! 526: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
! 527: if (!(flags & EX86_SSE2) && reg_map[a] >= 8)
! 528: rex |= REX_R;
! 529: #else
! 530: if (reg_map[a] >= 8)
! 531: rex |= REX_R;
! 532: #endif
! 533: }
! 534:
! 535: if (rex)
! 536: inst_size++;
! 537:
! 538: buf = (sljit_ub*)ensure_buf(compiler, 1 + inst_size);
! 539: PTR_FAIL_IF(!buf);
! 540:
! 541: /* Encoding the byte. */
! 542: INC_SIZE(inst_size);
! 543: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
! 544: if (flags & EX86_PREF_F2)
! 545: *buf++ = 0xf2;
! 546: #endif
! 547: if (flags & EX86_PREF_66)
! 548: *buf++ = 0x66;
! 549: if (rex)
! 550: *buf++ = rex;
! 551: buf_ptr = buf + size;
! 552:
! 553: /* Encode mod/rm byte. */
! 554: if (!(flags & EX86_SHIFT_INS)) {
! 555: if ((flags & EX86_BIN_INS) && (a & SLJIT_IMM))
! 556: *buf = (flags & EX86_BYTE_ARG) ? 0x83 : 0x81;
! 557:
! 558: if ((a & SLJIT_IMM) || (a == 0))
! 559: *buf_ptr = 0;
! 560: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
! 561: else if (!(flags & EX86_SSE2))
! 562: *buf_ptr = reg_lmap[a] << 3;
! 563: else
! 564: *buf_ptr = a << 3;
! 565: #else
! 566: else
! 567: *buf_ptr = reg_lmap[a] << 3;
! 568: #endif
! 569: }
! 570: else {
! 571: if (a & SLJIT_IMM) {
! 572: if (imma == 1)
! 573: *buf = 0xd1;
! 574: else
! 575: *buf = 0xc1;
! 576: } else
! 577: *buf = 0xd3;
! 578: *buf_ptr = 0;
! 579: }
! 580:
! 581: if (!(b & SLJIT_MEM))
! 582: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
! 583: *buf_ptr++ |= 0xc0 + ((!(flags & EX86_SSE2)) ? reg_lmap[b] : b);
! 584: #else
! 585: *buf_ptr++ |= 0xc0 + reg_lmap[b];
! 586: #endif
! 587: else if ((b & 0x0f) != SLJIT_UNUSED) {
! 588: #ifdef _WIN64
! 589: SLJIT_ASSERT((b & 0xf0) != (SLJIT_LOCALS_REG << 4));
! 590: #endif
! 591: if ((b & 0xf0) == SLJIT_UNUSED || (b & 0xf0) == (SLJIT_LOCALS_REG << 4)) {
! 592: if (immb != 0) {
! 593: if (immb <= 127 && immb >= -128)
! 594: *buf_ptr |= 0x40;
! 595: else
! 596: *buf_ptr |= 0x80;
! 597: }
! 598:
! 599: if ((b & 0xf0) == SLJIT_UNUSED)
! 600: *buf_ptr++ |= reg_lmap[b & 0x0f];
! 601: else {
! 602: *buf_ptr++ |= 0x04;
! 603: *buf_ptr++ = reg_lmap[b & 0x0f] | (reg_lmap[(b >> 4) & 0x0f] << 3);
! 604: }
! 605:
! 606: if (immb != 0) {
! 607: if (immb <= 127 && immb >= -128)
! 608: *buf_ptr++ = immb; /* 8 bit displacement. */
! 609: else {
! 610: *(sljit_hw*)buf_ptr = immb; /* 32 bit displacement. */
! 611: buf_ptr += sizeof(sljit_hw);
! 612: }
! 613: }
! 614: }
! 615: else {
! 616: *buf_ptr++ |= 0x04;
! 617: *buf_ptr++ = reg_lmap[b & 0x0f] | (reg_lmap[(b >> 4) & 0x0f] << 3) | (immb << 6);
! 618: }
! 619: }
! 620: else {
! 621: *buf_ptr++ |= 0x04;
! 622: *buf_ptr++ = 0x25;
! 623: *(sljit_hw*)buf_ptr = immb; /* 32 bit displacement. */
! 624: buf_ptr += sizeof(sljit_hw);
! 625: }
! 626:
! 627: if (a & SLJIT_IMM) {
! 628: if (flags & EX86_BYTE_ARG)
! 629: *buf_ptr = imma;
! 630: else if (flags & EX86_HALF_ARG)
! 631: *(short*)buf_ptr = imma;
! 632: else if (!(flags & EX86_SHIFT_INS))
! 633: *(sljit_hw*)buf_ptr = imma;
! 634: }
! 635:
! 636: return !(flags & EX86_SHIFT_INS) ? buf : (buf + 1);
! 637: }
! 638:
! 639: /* --------------------------------------------------------------------- */
! 640: /* Call / return instructions */
! 641: /* --------------------------------------------------------------------- */
! 642:
! 643: static SLJIT_INLINE int call_with_args(struct sljit_compiler *compiler, int type)
! 644: {
! 645: sljit_ub *buf;
! 646:
! 647: #ifndef _WIN64
! 648: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_TEMPORARY_REG2] == 6 && reg_map[SLJIT_TEMPORARY_REG1] < 8 && reg_map[SLJIT_TEMPORARY_REG3] < 8, args_registers);
! 649:
! 650: buf = (sljit_ub*)ensure_buf(compiler, 1 + ((type < SLJIT_CALL3) ? 3 : 6));
! 651: FAIL_IF(!buf);
! 652: INC_SIZE((type < SLJIT_CALL3) ? 3 : 6);
! 653: if (type >= SLJIT_CALL3) {
! 654: *buf++ = REX_W;
! 655: *buf++ = 0x8b;
! 656: *buf++ = 0xc0 | (0x2 << 3) | reg_lmap[SLJIT_TEMPORARY_REG3];
! 657: }
! 658: *buf++ = REX_W;
! 659: *buf++ = 0x8b;
! 660: *buf++ = 0xc0 | (0x7 << 3) | reg_lmap[SLJIT_TEMPORARY_REG1];
! 661: #else
! 662: SLJIT_COMPILE_ASSERT(reg_map[SLJIT_TEMPORARY_REG2] == 2 && reg_map[SLJIT_TEMPORARY_REG1] < 8 && reg_map[SLJIT_TEMPORARY_REG3] < 8, args_registers);
! 663:
! 664: buf = (sljit_ub*)ensure_buf(compiler, 1 + ((type < SLJIT_CALL3) ? 3 : 6));
! 665: FAIL_IF(!buf);
! 666: INC_SIZE((type < SLJIT_CALL3) ? 3 : 6);
! 667: if (type >= SLJIT_CALL3) {
! 668: *buf++ = REX_W | REX_R;
! 669: *buf++ = 0x8b;
! 670: *buf++ = 0xc0 | (0x0 << 3) | reg_lmap[SLJIT_TEMPORARY_REG3];
! 671: }
! 672: *buf++ = REX_W;
! 673: *buf++ = 0x8b;
! 674: *buf++ = 0xc0 | (0x1 << 3) | reg_lmap[SLJIT_TEMPORARY_REG1];
! 675: #endif
! 676: return SLJIT_SUCCESS;
! 677: }
! 678:
! 679: 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)
! 680: {
! 681: sljit_ub *buf;
! 682:
! 683: CHECK_ERROR();
! 684: check_sljit_emit_fast_enter(compiler, dst, dstw, args, temporaries, generals, local_size);
! 685:
! 686: compiler->temporaries = temporaries;
! 687: compiler->generals = generals;
! 688: compiler->local_size = (local_size + sizeof(sljit_uw) - 1) & ~(sizeof(sljit_uw) - 1);
! 689: #ifdef _WIN64
! 690: compiler->local_size += 4 * sizeof(sljit_w);
! 691: #endif
! 692:
! 693: /* For UNUSED dst. Uncommon, but possible. */
! 694: if (dst == SLJIT_UNUSED)
! 695: dst = TMP_REGISTER;
! 696:
! 697: if (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) {
! 698: if (reg_map[dst] < 8) {
! 699: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1);
! 700: FAIL_IF(!buf);
! 701:
! 702: INC_SIZE(1);
! 703: POP_REG(reg_lmap[dst]);
! 704: }
! 705: else {
! 706: buf = (sljit_ub*)ensure_buf(compiler, 1 + 2);
! 707: FAIL_IF(!buf);
! 708:
! 709: INC_SIZE(2);
! 710: *buf++ = REX_B;
! 711: POP_REG(reg_lmap[dst]);
! 712: }
! 713: }
! 714: else if (dst & SLJIT_MEM) {
! 715: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
! 716: /* REX_W is not necessary (src is not immediate). */
! 717: compiler->mode32 = 1;
! 718: #endif
! 719: buf = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
! 720: FAIL_IF(!buf);
! 721: *buf++ = 0x8f;
! 722: }
! 723: return SLJIT_SUCCESS;
! 724: }
! 725:
! 726: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fast_return(struct sljit_compiler *compiler, int src, sljit_w srcw)
! 727: {
! 728: sljit_ub *buf;
! 729:
! 730: CHECK_ERROR();
! 731: check_sljit_emit_fast_return(compiler, src, srcw);
! 732:
! 733: CHECK_EXTRA_REGS(src, srcw, (void)0);
! 734:
! 735: if ((src & SLJIT_IMM) && NOT_HALFWORD(srcw)) {
! 736: FAIL_IF(emit_load_imm64(compiler, TMP_REGISTER, srcw));
! 737: src = TMP_REGISTER;
! 738: }
! 739:
! 740: if (src >= SLJIT_TEMPORARY_REG1 && src <= TMP_REGISTER) {
! 741: if (reg_map[src] < 8) {
! 742: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1 + 1);
! 743: FAIL_IF(!buf);
! 744:
! 745: INC_SIZE(1 + 1);
! 746: PUSH_REG(reg_lmap[src]);
! 747: }
! 748: else {
! 749: buf = (sljit_ub*)ensure_buf(compiler, 1 + 2 + 1);
! 750: FAIL_IF(!buf);
! 751:
! 752: INC_SIZE(2 + 1);
! 753: *buf++ = REX_B;
! 754: PUSH_REG(reg_lmap[src]);
! 755: }
! 756: }
! 757: else if (src & SLJIT_MEM) {
! 758: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
! 759: /* REX_W is not necessary (src is not immediate). */
! 760: compiler->mode32 = 1;
! 761: #endif
! 762: buf = emit_x86_instruction(compiler, 1, 0, 0, src, srcw);
! 763: FAIL_IF(!buf);
! 764: *buf++ = 0xff;
! 765: *buf |= 6 << 3;
! 766:
! 767: buf = (sljit_ub*)ensure_buf(compiler, 1 + 1);
! 768: FAIL_IF(!buf);
! 769: INC_SIZE(1);
! 770: }
! 771: else {
! 772: SLJIT_ASSERT(IS_HALFWORD(srcw));
! 773: /* SLJIT_IMM. */
! 774: buf = (sljit_ub*)ensure_buf(compiler, 1 + 5 + 1);
! 775: FAIL_IF(!buf);
! 776:
! 777: INC_SIZE(5 + 1);
! 778: *buf++ = 0x68;
! 779: *(sljit_hw*)buf = srcw;
! 780: buf += sizeof(sljit_hw);
! 781: }
! 782:
! 783: RET();
! 784: return SLJIT_SUCCESS;
! 785: }
! 786:
! 787:
! 788: /* --------------------------------------------------------------------- */
! 789: /* Extend input */
! 790: /* --------------------------------------------------------------------- */
! 791:
! 792: static int emit_mov_int(struct sljit_compiler *compiler, int sign,
! 793: int dst, sljit_w dstw,
! 794: int src, sljit_w srcw)
! 795: {
! 796: sljit_ub* code;
! 797: int dst_r;
! 798:
! 799: compiler->mode32 = 0;
! 800:
! 801: if (dst == SLJIT_UNUSED && !(src & SLJIT_MEM))
! 802: return SLJIT_SUCCESS; /* Empty instruction. */
! 803:
! 804: if (src & SLJIT_IMM) {
! 805: if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS)
! 806: return emit_load_imm64(compiler, dst, srcw);
! 807: compiler->mode32 = 1;
! 808: code = emit_x86_instruction(compiler, 1, SLJIT_IMM, (sljit_w)(int)srcw, dst, dstw);
! 809: FAIL_IF(!code);
! 810: *code = 0xc7;
! 811: compiler->mode32 = 0;
! 812: return SLJIT_SUCCESS;
! 813: }
! 814:
! 815: dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_GENERAL_REG3) ? dst : TMP_REGISTER;
! 816:
! 817: if ((dst & SLJIT_MEM) && (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_GENERAL_REG3))
! 818: dst_r = src;
! 819: else {
! 820: if (sign) {
! 821: code = emit_x86_instruction(compiler, 1, dst_r, 0, src, srcw);
! 822: FAIL_IF(!code);
! 823: *code++ = 0x63;
! 824: }
! 825: else {
! 826: if (dst_r == src) {
! 827: compiler->mode32 = 1;
! 828: code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src, 0);
! 829: FAIL_IF(!code);
! 830: *code++ = 0x8b;
! 831: compiler->mode32 = 0;
! 832: }
! 833: /* xor reg, reg. */
! 834: code = emit_x86_instruction(compiler, 1, dst_r, 0, dst_r, 0);
! 835: FAIL_IF(!code);
! 836: *code++ = 0x33;
! 837: if (dst_r != src) {
! 838: compiler->mode32 = 1;
! 839: code = emit_x86_instruction(compiler, 1, dst_r, 0, src, srcw);
! 840: FAIL_IF(!code);
! 841: *code++ = 0x8b;
! 842: compiler->mode32 = 0;
! 843: }
! 844: else {
! 845: compiler->mode32 = 1;
! 846: code = emit_x86_instruction(compiler, 1, src, 0, TMP_REGISTER, 0);
! 847: FAIL_IF(!code);
! 848: *code++ = 0x8b;
! 849: compiler->mode32 = 0;
! 850: }
! 851: }
! 852: }
! 853:
! 854: if (dst & SLJIT_MEM) {
! 855: compiler->mode32 = 1;
! 856: code = emit_x86_instruction(compiler, 1, dst_r, 0, dst, dstw);
! 857: FAIL_IF(!code);
! 858: *code = 0x89;
! 859: compiler->mode32 = 0;
! 860: }
! 861:
! 862: return SLJIT_SUCCESS;
! 863: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sljitNativeX86_64.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