Annotation of embedaddon/pcre/sljit/sljitNativeX86_common.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: SLJIT_API_FUNC_ATTRIBUTE SLJIT_CONST char* sljit_get_platform_name()
        !            28: {
        !            29: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !            30:        return "x86-32";
        !            31: #else
        !            32:        return "x86-64";
        !            33: #endif
        !            34: }
        !            35: 
        !            36: /*
        !            37:    32b register indexes:
        !            38:      0 - EAX
        !            39:      1 - ECX
        !            40:      2 - EDX
        !            41:      3 - EBX
        !            42:      4 - none
        !            43:      5 - EBP
        !            44:      6 - ESI
        !            45:      7 - EDI
        !            46: */
        !            47: 
        !            48: /*
        !            49:    64b register indexes:
        !            50:      0 - RAX
        !            51:      1 - RCX
        !            52:      2 - RDX
        !            53:      3 - RBX
        !            54:      4 - none
        !            55:      5 - RBP
        !            56:      6 - RSI
        !            57:      7 - RDI
        !            58:      8 - R8   - From now on REX prefix is required
        !            59:      9 - R9
        !            60:     10 - R10
        !            61:     11 - R11
        !            62:     12 - R12
        !            63:     13 - R13
        !            64:     14 - R14
        !            65:     15 - R15
        !            66: */
        !            67: 
        !            68: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !            69: 
        !            70: /* Last register + 1. */
        !            71: #define TMP_REGISTER   (SLJIT_NO_REGISTERS + 1)
        !            72: 
        !            73: static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 2] = {
        !            74:   0, 0, 2, 1, 0, 0, 3, 6, 7, 0, 0, 4, 5
        !            75: };
        !            76: 
        !            77: #define CHECK_EXTRA_REGS(p, w, do) \
        !            78:        if (p >= SLJIT_TEMPORARY_EREG1 && p <= SLJIT_TEMPORARY_EREG2) { \
        !            79:                w = compiler->temporaries_start + (p - SLJIT_TEMPORARY_EREG1) * sizeof(sljit_w); \
        !            80:                p = SLJIT_MEM1(SLJIT_LOCALS_REG); \
        !            81:                do; \
        !            82:        } \
        !            83:        else if (p >= SLJIT_GENERAL_EREG1 && p <= SLJIT_GENERAL_EREG2) { \
        !            84:                w = compiler->generals_start + (p - SLJIT_GENERAL_EREG1) * sizeof(sljit_w); \
        !            85:                p = SLJIT_MEM1(SLJIT_LOCALS_REG); \
        !            86:                do; \
        !            87:        }
        !            88: 
        !            89: #else /* SLJIT_CONFIG_X86_32 */
        !            90: 
        !            91: /* Last register + 1. */
        !            92: #define TMP_REGISTER   (SLJIT_NO_REGISTERS + 1)
        !            93: #define TMP_REG2       (SLJIT_NO_REGISTERS + 2)
        !            94: #define TMP_REG3       (SLJIT_NO_REGISTERS + 3)
        !            95: 
        !            96: /* Note: r12 & 0x7 == 0b100, which decoded as SIB byte present
        !            97:    Note: avoid to use r12 and r13 for memory addessing
        !            98:    therefore r12 is better for GENERAL_EREG than GENERAL_REG. */
        !            99: #ifndef _WIN64
        !           100: /* 1st passed in rdi, 2nd argument passed in rsi, 3rd in rdx. */
        !           101: static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 4] = {
        !           102:   0, 0, 6, 1, 8, 11, 3, 15, 14, 13, 12, 4, 2, 7, 9
        !           103: };
        !           104: /* low-map. reg_map & 0x7. */
        !           105: static SLJIT_CONST sljit_ub reg_lmap[SLJIT_NO_REGISTERS + 4] = {
        !           106:   0, 0, 6, 1, 0, 3,  3, 7,  6,  5,  4,  4, 2, 7, 1
        !           107: };
        !           108: #else
        !           109: /* 1st passed in rcx, 2nd argument passed in rdx, 3rd in r8. */
        !           110: static SLJIT_CONST sljit_ub reg_map[SLJIT_NO_REGISTERS + 4] = {
        !           111:   0, 0, 2, 1, 11, 13, 3, 6, 7, 14, 12, 15, 10, 8, 9
        !           112: };
        !           113: /* low-map. reg_map & 0x7. */
        !           114: static SLJIT_CONST sljit_ub reg_lmap[SLJIT_NO_REGISTERS + 4] = {
        !           115:   0, 0, 2, 1, 3,  5,  3, 6, 7,  6,  4,  7, 2,  0, 1
        !           116: };
        !           117: #endif
        !           118: 
        !           119: #define REX_W          0x48
        !           120: #define REX_R          0x44
        !           121: #define REX_X          0x42
        !           122: #define REX_B          0x41
        !           123: #define REX            0x40
        !           124: 
        !           125: typedef unsigned int sljit_uhw;
        !           126: typedef int sljit_hw;
        !           127: 
        !           128: #define IS_HALFWORD(x)         ((x) <= 0x7fffffffll && (x) >= -0x80000000ll)
        !           129: #define NOT_HALFWORD(x)                ((x) > 0x7fffffffll || (x) < -0x80000000ll)
        !           130: 
        !           131: #define CHECK_EXTRA_REGS(p, w, do)
        !           132: 
        !           133: #endif /* SLJIT_CONFIG_X86_32 */
        !           134: 
        !           135: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
        !           136: #define TMP_FREG       (SLJIT_FLOAT_REG4 + 1)
        !           137: #endif
        !           138: 
        !           139: /* Size flags for emit_x86_instruction: */
        !           140: #define EX86_BIN_INS           0x0010
        !           141: #define EX86_SHIFT_INS         0x0020
        !           142: #define EX86_REX               0x0040
        !           143: #define EX86_NO_REXW           0x0080
        !           144: #define EX86_BYTE_ARG          0x0100
        !           145: #define EX86_HALF_ARG          0x0200
        !           146: #define EX86_PREF_66           0x0400
        !           147: 
        !           148: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
        !           149: #define EX86_PREF_F2           0x0800
        !           150: #define EX86_SSE2              0x1000
        !           151: #endif
        !           152: 
        !           153: #define INC_SIZE(s)                    (*buf++ = (s), compiler->size += (s))
        !           154: #define INC_CSIZE(s)                   (*code++ = (s), compiler->size += (s))
        !           155: 
        !           156: #define PUSH_REG(r)                    (*buf++ = (0x50 + (r)))
        !           157: #define POP_REG(r)                     (*buf++ = (0x58 + (r)))
        !           158: #define RET()                          (*buf++ = (0xc3))
        !           159: #define RETN(n)                                (*buf++ = (0xc2), *buf++ = n, *buf++ = 0)
        !           160: /* r32, r/m32 */
        !           161: #define MOV_RM(mod, reg, rm)           (*buf++ = (0x8b), *buf++ = (mod) << 6 | (reg) << 3 | (rm))
        !           162: 
        !           163: static sljit_ub get_jump_code(int type)
        !           164: {
        !           165:        switch (type) {
        !           166:        case SLJIT_C_EQUAL:
        !           167:        case SLJIT_C_FLOAT_EQUAL:
        !           168:                return 0x84;
        !           169: 
        !           170:        case SLJIT_C_NOT_EQUAL:
        !           171:        case SLJIT_C_FLOAT_NOT_EQUAL:
        !           172:                return 0x85;
        !           173: 
        !           174:        case SLJIT_C_LESS:
        !           175:        case SLJIT_C_FLOAT_LESS:
        !           176:                return 0x82;
        !           177: 
        !           178:        case SLJIT_C_GREATER_EQUAL:
        !           179:        case SLJIT_C_FLOAT_GREATER_EQUAL:
        !           180:                return 0x83;
        !           181: 
        !           182:        case SLJIT_C_GREATER:
        !           183:        case SLJIT_C_FLOAT_GREATER:
        !           184:                return 0x87;
        !           185: 
        !           186:        case SLJIT_C_LESS_EQUAL:
        !           187:        case SLJIT_C_FLOAT_LESS_EQUAL:
        !           188:                return 0x86;
        !           189: 
        !           190:        case SLJIT_C_SIG_LESS:
        !           191:                return 0x8c;
        !           192: 
        !           193:        case SLJIT_C_SIG_GREATER_EQUAL:
        !           194:                return 0x8d;
        !           195: 
        !           196:        case SLJIT_C_SIG_GREATER:
        !           197:                return 0x8f;
        !           198: 
        !           199:        case SLJIT_C_SIG_LESS_EQUAL:
        !           200:                return 0x8e;
        !           201: 
        !           202:        case SLJIT_C_OVERFLOW:
        !           203:        case SLJIT_C_MUL_OVERFLOW:
        !           204:                return 0x80;
        !           205: 
        !           206:        case SLJIT_C_NOT_OVERFLOW:
        !           207:        case SLJIT_C_MUL_NOT_OVERFLOW:
        !           208:                return 0x81;
        !           209: 
        !           210:        case SLJIT_C_FLOAT_NAN:
        !           211:                return 0x8a;
        !           212: 
        !           213:        case SLJIT_C_FLOAT_NOT_NAN:
        !           214:                return 0x8b;
        !           215:        }
        !           216:        return 0;
        !           217: }
        !           218: 
        !           219: static sljit_ub* generate_far_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, int type);
        !           220: 
        !           221: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           222: static sljit_ub* generate_fixed_jump(sljit_ub *code_ptr, sljit_w addr, int type);
        !           223: #endif
        !           224: 
        !           225: static sljit_ub* generate_near_jump_code(struct sljit_jump *jump, sljit_ub *code_ptr, sljit_ub *code, int type)
        !           226: {
        !           227:        int short_jump;
        !           228:        sljit_uw label_addr;
        !           229: 
        !           230:        if (jump->flags & JUMP_LABEL)
        !           231:                label_addr = (sljit_uw)(code + jump->u.label->size);
        !           232:        else
        !           233:                label_addr = jump->u.target;
        !           234:        short_jump = (sljit_w)(label_addr - (jump->addr + 2)) >= -128 && (sljit_w)(label_addr - (jump->addr + 2)) <= 127;
        !           235: 
        !           236: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           237:        if ((sljit_w)(label_addr - (jump->addr + 1)) > 0x7fffffffll || (sljit_w)(label_addr - (jump->addr + 1)) < -0x80000000ll)
        !           238:                return generate_far_jump_code(jump, code_ptr, type);
        !           239: #endif
        !           240: 
        !           241:        if (type == SLJIT_JUMP) {
        !           242:                if (short_jump)
        !           243:                        *code_ptr++ = 0xeb;
        !           244:                else
        !           245:                        *code_ptr++ = 0xe9;
        !           246:                jump->addr++;
        !           247:        }
        !           248:        else if (type >= SLJIT_FAST_CALL) {
        !           249:                short_jump = 0;
        !           250:                *code_ptr++ = 0xe8;
        !           251:                jump->addr++;
        !           252:        }
        !           253:        else if (short_jump) {
        !           254:                *code_ptr++ = get_jump_code(type) - 0x10;
        !           255:                jump->addr++;
        !           256:        }
        !           257:        else {
        !           258:                *code_ptr++ = 0x0f;
        !           259:                *code_ptr++ = get_jump_code(type);
        !           260:                jump->addr += 2;
        !           261:        }
        !           262: 
        !           263:        if (short_jump) {
        !           264:                jump->flags |= PATCH_MB;
        !           265:                code_ptr += sizeof(sljit_b);
        !           266:        } else {
        !           267:                jump->flags |= PATCH_MW;
        !           268: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           269:                code_ptr += sizeof(sljit_w);
        !           270: #else
        !           271:                code_ptr += sizeof(sljit_hw);
        !           272: #endif
        !           273:        }
        !           274: 
        !           275:        return code_ptr;
        !           276: }
        !           277: 
        !           278: SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
        !           279: {
        !           280:        struct sljit_memory_fragment *buf;
        !           281:        sljit_ub *code;
        !           282:        sljit_ub *code_ptr;
        !           283:        sljit_ub *buf_ptr;
        !           284:        sljit_ub *buf_end;
        !           285:        sljit_ub len;
        !           286: 
        !           287:        struct sljit_label *label;
        !           288:        struct sljit_jump *jump;
        !           289:        struct sljit_const *const_;
        !           290: 
        !           291:        CHECK_ERROR_PTR();
        !           292:        check_sljit_generate_code(compiler);
        !           293:        reverse_buf(compiler);
        !           294: 
        !           295:        /* Second code generation pass. */
        !           296:        code = (sljit_ub*)SLJIT_MALLOC_EXEC(compiler->size);
        !           297:        PTR_FAIL_WITH_EXEC_IF(code);
        !           298:        buf = compiler->buf;
        !           299: 
        !           300:        code_ptr = code;
        !           301:        label = compiler->labels;
        !           302:        jump = compiler->jumps;
        !           303:        const_ = compiler->consts;
        !           304:        do {
        !           305:                buf_ptr = buf->memory;
        !           306:                buf_end = buf_ptr + buf->used_size;
        !           307:                do {
        !           308:                        len = *buf_ptr++;
        !           309:                        if (len > 0) {
        !           310:                                /* The code is already generated. */
        !           311:                                SLJIT_MEMMOVE(code_ptr, buf_ptr, len);
        !           312:                                code_ptr += len;
        !           313:                                buf_ptr += len;
        !           314:                        }
        !           315:                        else {
        !           316:                                if (*buf_ptr >= 4) {
        !           317:                                        jump->addr = (sljit_uw)code_ptr;
        !           318:                                        if (!(jump->flags & SLJIT_REWRITABLE_JUMP))
        !           319:                                                code_ptr = generate_near_jump_code(jump, code_ptr, code, *buf_ptr - 4);
        !           320:                                        else
        !           321:                                                code_ptr = generate_far_jump_code(jump, code_ptr, *buf_ptr - 4);
        !           322:                                        jump = jump->next;
        !           323:                                }
        !           324:                                else if (*buf_ptr == 0) {
        !           325:                                        label->addr = (sljit_uw)code_ptr;
        !           326:                                        label->size = code_ptr - code;
        !           327:                                        label = label->next;
        !           328:                                }
        !           329:                                else if (*buf_ptr == 1) {
        !           330:                                        const_->addr = ((sljit_uw)code_ptr) - sizeof(sljit_w);
        !           331:                                        const_ = const_->next;
        !           332:                                }
        !           333:                                else {
        !           334: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           335:                                        *code_ptr++ = (*buf_ptr == 2) ? 0xe8 /* call */ : 0xe9 /* jmp */;
        !           336:                                        buf_ptr++;
        !           337:                                        *(sljit_w*)code_ptr = *(sljit_w*)buf_ptr - ((sljit_w)code_ptr + sizeof(sljit_w));
        !           338:                                        code_ptr += sizeof(sljit_w);
        !           339:                                        buf_ptr += sizeof(sljit_w) - 1;
        !           340: #else
        !           341:                                        code_ptr = generate_fixed_jump(code_ptr, *(sljit_w*)(buf_ptr + 1), *buf_ptr);
        !           342:                                        buf_ptr += sizeof(sljit_w);
        !           343: #endif
        !           344:                                }
        !           345:                                buf_ptr++;
        !           346:                        }
        !           347:                } while (buf_ptr < buf_end);
        !           348:                SLJIT_ASSERT(buf_ptr == buf_end);
        !           349:                buf = buf->next;
        !           350:        } while (buf);
        !           351: 
        !           352:        SLJIT_ASSERT(!label);
        !           353:        SLJIT_ASSERT(!jump);
        !           354:        SLJIT_ASSERT(!const_);
        !           355: 
        !           356:        jump = compiler->jumps;
        !           357:        while (jump) {
        !           358:                if (jump->flags & PATCH_MB) {
        !           359:                        SLJIT_ASSERT((sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_b))) >= -128 && (sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_b))) <= 127);
        !           360:                        *(sljit_ub*)jump->addr = (sljit_ub)(jump->u.label->addr - (jump->addr + sizeof(sljit_b)));
        !           361:                } else if (jump->flags & PATCH_MW) {
        !           362:                        if (jump->flags & JUMP_LABEL) {
        !           363: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           364:                                *(sljit_w*)jump->addr = (sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_w)));
        !           365: #else
        !           366:                                SLJIT_ASSERT((sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_hw))) >= -0x80000000ll && (sljit_w)(jump->u.label->addr - (jump->addr + sizeof(sljit_hw))) <= 0x7fffffffll);
        !           367:                                *(sljit_hw*)jump->addr = (sljit_hw)(jump->u.label->addr - (jump->addr + sizeof(sljit_hw)));
        !           368: #endif
        !           369:                        }
        !           370:                        else {
        !           371: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           372:                                *(sljit_w*)jump->addr = (sljit_w)(jump->u.target - (jump->addr + sizeof(sljit_w)));
        !           373: #else
        !           374:                                SLJIT_ASSERT((sljit_w)(jump->u.target - (jump->addr + sizeof(sljit_hw))) >= -0x80000000ll && (sljit_w)(jump->u.target - (jump->addr + sizeof(sljit_hw))) <= 0x7fffffffll);
        !           375:                                *(sljit_hw*)jump->addr = (sljit_hw)(jump->u.target - (jump->addr + sizeof(sljit_hw)));
        !           376: #endif
        !           377:                        }
        !           378:                }
        !           379: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           380:                else if (jump->flags & PATCH_MD)
        !           381:                        *(sljit_w*)jump->addr = jump->u.label->addr;
        !           382: #endif
        !           383: 
        !           384:                jump = jump->next;
        !           385:        }
        !           386: 
        !           387:        /* Maybe we waste some space because of short jumps. */
        !           388:        SLJIT_ASSERT(code_ptr <= code + compiler->size);
        !           389:        compiler->error = SLJIT_ERR_COMPILED;
        !           390:        compiler->executable_size = compiler->size;
        !           391:        return (void*)code;
        !           392: }
        !           393: 
        !           394: /* --------------------------------------------------------------------- */
        !           395: /*  Operators                                                            */
        !           396: /* --------------------------------------------------------------------- */
        !           397: 
        !           398: static int emit_cum_binary(struct sljit_compiler *compiler,
        !           399:        sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,
        !           400:        int dst, sljit_w dstw,
        !           401:        int src1, sljit_w src1w,
        !           402:        int src2, sljit_w src2w);
        !           403: 
        !           404: static int emit_non_cum_binary(struct sljit_compiler *compiler,
        !           405:        sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,
        !           406:        int dst, sljit_w dstw,
        !           407:        int src1, sljit_w src1w,
        !           408:        int src2, sljit_w src2w);
        !           409: 
        !           410: static int emit_mov(struct sljit_compiler *compiler,
        !           411:        int dst, sljit_w dstw,
        !           412:        int src, sljit_w srcw);
        !           413: 
        !           414: static SLJIT_INLINE int emit_save_flags(struct sljit_compiler *compiler)
        !           415: {
        !           416:        sljit_ub *buf;
        !           417: 
        !           418: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           419:        buf = (sljit_ub*)ensure_buf(compiler, 1 + 5);
        !           420:        FAIL_IF(!buf);
        !           421:        INC_SIZE(5);
        !           422:        *buf++ = 0x9c; /* pushfd */
        !           423: #else
        !           424:        buf = (sljit_ub*)ensure_buf(compiler, 1 + 6);
        !           425:        FAIL_IF(!buf);
        !           426:        INC_SIZE(6);
        !           427:        *buf++ = 0x9c; /* pushfq */
        !           428:        *buf++ = 0x48;
        !           429: #endif
        !           430:        *buf++ = 0x8d; /* lea esp/rsp, [esp/rsp + sizeof(sljit_w)] */
        !           431:        *buf++ = 0x64;
        !           432:        *buf++ = 0x24;
        !           433:        *buf++ = sizeof(sljit_w);
        !           434:        compiler->flags_saved = 1;
        !           435:        return SLJIT_SUCCESS;
        !           436: }
        !           437: 
        !           438: static SLJIT_INLINE int emit_restore_flags(struct sljit_compiler *compiler, int keep_flags)
        !           439: {
        !           440:        sljit_ub *buf;
        !           441: 
        !           442: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           443:        buf = (sljit_ub*)ensure_buf(compiler, 1 + 5);
        !           444:        FAIL_IF(!buf);
        !           445:        INC_SIZE(5);
        !           446: #else
        !           447:        buf = (sljit_ub*)ensure_buf(compiler, 1 + 6);
        !           448:        FAIL_IF(!buf);
        !           449:        INC_SIZE(6);
        !           450:        *buf++ = 0x48;
        !           451: #endif
        !           452:        *buf++ = 0x8d; /* lea esp/rsp, [esp/rsp - sizeof(sljit_w)] */
        !           453:        *buf++ = 0x64;
        !           454:        *buf++ = 0x24;
        !           455:        *buf++ = (sljit_ub)-(int)sizeof(sljit_w);
        !           456:        *buf++ = 0x9d; /* popfd / popfq */
        !           457:        compiler->flags_saved = keep_flags;
        !           458:        return SLJIT_SUCCESS;
        !           459: }
        !           460: 
        !           461: #ifdef _WIN32
        !           462: #include <malloc.h>
        !           463: 
        !           464: static void SLJIT_CALL sljit_touch_stack(sljit_w local_size)
        !           465: {
        !           466:        /* Workaround for calling _chkstk. */
        !           467:        alloca(local_size);
        !           468: }
        !           469: #endif
        !           470: 
        !           471: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           472: #include "sljitNativeX86_32.c"
        !           473: #else
        !           474: #include "sljitNativeX86_64.c"
        !           475: #endif
        !           476: 
        !           477: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op0(struct sljit_compiler *compiler, int op)
        !           478: {
        !           479:        sljit_ub *buf;
        !           480: 
        !           481:        CHECK_ERROR();
        !           482:        check_sljit_emit_op0(compiler, op);
        !           483: 
        !           484:        op = GET_OPCODE(op);
        !           485:        switch (op) {
        !           486:        case SLJIT_BREAKPOINT:
        !           487:                buf = (sljit_ub*)ensure_buf(compiler, 1 + 1);
        !           488:                FAIL_IF(!buf);
        !           489:                INC_SIZE(1);
        !           490:                *buf = 0xcc;
        !           491:                break;
        !           492:        case SLJIT_NOP:
        !           493:                buf = (sljit_ub*)ensure_buf(compiler, 1 + 1);
        !           494:                FAIL_IF(!buf);
        !           495:                INC_SIZE(1);
        !           496:                *buf = 0x90;
        !           497:                break;
        !           498:        }
        !           499: 
        !           500:        return SLJIT_SUCCESS;
        !           501: }
        !           502: 
        !           503: static int emit_mov(struct sljit_compiler *compiler,
        !           504:        int dst, sljit_w dstw,
        !           505:        int src, sljit_w srcw)
        !           506: {
        !           507:        sljit_ub* code;
        !           508: 
        !           509:        if (dst == SLJIT_UNUSED) {
        !           510:                /* No destination, doesn't need to setup flags. */
        !           511:                if (src & SLJIT_MEM) {
        !           512:                        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src, srcw);
        !           513:                        FAIL_IF(!code);
        !           514:                        *code = 0x8b;
        !           515:                }
        !           516:                return SLJIT_SUCCESS;
        !           517:        }
        !           518:        if (src >= SLJIT_TEMPORARY_REG1 && src <= TMP_REGISTER) {
        !           519:                code = emit_x86_instruction(compiler, 1, src, 0, dst, dstw);
        !           520:                FAIL_IF(!code);
        !           521:                *code = 0x89;
        !           522:                return SLJIT_SUCCESS;
        !           523:        }
        !           524:        if (src & SLJIT_IMM) {
        !           525:                if (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) {
        !           526: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           527:                        return emit_do_imm(compiler, 0xb8 + reg_map[dst], srcw);
        !           528: #else
        !           529:                        if (!compiler->mode32) {
        !           530:                                if (NOT_HALFWORD(srcw))
        !           531:                                        return emit_load_imm64(compiler, dst, srcw);
        !           532:                        }
        !           533:                        else
        !           534:                                return emit_do_imm32(compiler, (reg_map[dst] >= 8) ? REX_B : 0, 0xb8 + reg_lmap[dst], srcw);
        !           535: #endif
        !           536:                }
        !           537: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           538:                if (!compiler->mode32 && NOT_HALFWORD(srcw)) {
        !           539:                        FAIL_IF(emit_load_imm64(compiler, TMP_REG2, srcw));
        !           540:                        code = emit_x86_instruction(compiler, 1, TMP_REG2, 0, dst, dstw);
        !           541:                        FAIL_IF(!code);
        !           542:                        *code = 0x89;
        !           543:                        return SLJIT_SUCCESS;
        !           544:                }
        !           545: #endif
        !           546:                code = emit_x86_instruction(compiler, 1, SLJIT_IMM, srcw, dst, dstw);
        !           547:                FAIL_IF(!code);
        !           548:                *code = 0xc7;
        !           549:                return SLJIT_SUCCESS;
        !           550:        }
        !           551:        if (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) {
        !           552:                code = emit_x86_instruction(compiler, 1, dst, 0, src, srcw);
        !           553:                FAIL_IF(!code);
        !           554:                *code = 0x8b;
        !           555:                return SLJIT_SUCCESS;
        !           556:        }
        !           557: 
        !           558:        /* Memory to memory move. Requires two instruction. */
        !           559:        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src, srcw);
        !           560:        FAIL_IF(!code);
        !           561:        *code = 0x8b;
        !           562:        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, dst, dstw);
        !           563:        FAIL_IF(!code);
        !           564:        *code = 0x89;
        !           565:        return SLJIT_SUCCESS;
        !           566: }
        !           567: 
        !           568: #define EMIT_MOV(compiler, dst, dstw, src, srcw) \
        !           569:        FAIL_IF(emit_mov(compiler, dst, dstw, src, srcw));
        !           570: 
        !           571: #define ENCODE_PREFIX(prefix) \
        !           572:        do { \
        !           573:                code = (sljit_ub*)ensure_buf(compiler, 1 + 1); \
        !           574:                FAIL_IF(!code); \
        !           575:                INC_CSIZE(1); \
        !           576:                *code = (prefix); \
        !           577:        } while (0)
        !           578: 
        !           579: static int emit_mov_byte(struct sljit_compiler *compiler, int sign,
        !           580:        int dst, sljit_w dstw,
        !           581:        int src, sljit_w srcw)
        !           582: {
        !           583:        sljit_ub* code;
        !           584:        int dst_r;
        !           585: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           586:        int work_r;
        !           587: #endif
        !           588: 
        !           589: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           590:        compiler->mode32 = 0;
        !           591: #endif
        !           592: 
        !           593:        if (dst == SLJIT_UNUSED && !(src & SLJIT_MEM))
        !           594:                return SLJIT_SUCCESS; /* Empty instruction. */
        !           595: 
        !           596:        if (src & SLJIT_IMM) {
        !           597:                if (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) {
        !           598: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           599:                        return emit_do_imm(compiler, 0xb8 + reg_map[dst], srcw);
        !           600: #else
        !           601:                        return emit_load_imm64(compiler, dst, srcw);
        !           602: #endif
        !           603:                }
        !           604:                code = emit_x86_instruction(compiler, 1 | EX86_BYTE_ARG | EX86_NO_REXW, SLJIT_IMM, srcw, dst, dstw);
        !           605:                FAIL_IF(!code);
        !           606:                *code = 0xc6;
        !           607:                return SLJIT_SUCCESS;
        !           608:        }
        !           609: 
        !           610:        dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) ? dst : TMP_REGISTER;
        !           611: 
        !           612:        if ((dst & SLJIT_MEM) && src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS) {
        !           613: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           614:                if (reg_map[src] >= 4) {
        !           615:                        SLJIT_ASSERT(dst_r == TMP_REGISTER);
        !           616:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src, 0);
        !           617:                } else
        !           618:                        dst_r = src;
        !           619: #else
        !           620:                dst_r = src;
        !           621: #endif
        !           622:        }
        !           623: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           624:        else if (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS && reg_map[src] >= 4) {
        !           625:                /* src, dst are registers. */
        !           626:                SLJIT_ASSERT(dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER);
        !           627:                if (reg_map[dst] < 4) {
        !           628:                        if (dst != src)
        !           629:                                EMIT_MOV(compiler, dst, 0, src, 0);
        !           630:                        code = emit_x86_instruction(compiler, 2, dst, 0, dst, 0);
        !           631:                        FAIL_IF(!code);
        !           632:                        *code++ = 0x0f;
        !           633:                        *code = sign ? 0xbe : 0xb6;
        !           634:                }
        !           635:                else {
        !           636:                        if (dst != src)
        !           637:                                EMIT_MOV(compiler, dst, 0, src, 0);
        !           638:                        if (sign) {
        !           639:                                /* shl reg, 24 */
        !           640:                                code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, 24, dst, 0);
        !           641:                                FAIL_IF(!code);
        !           642:                                *code |= 0x4 << 3;
        !           643:                                code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, 24, dst, 0);
        !           644:                                FAIL_IF(!code);
        !           645:                                /* shr/sar reg, 24 */
        !           646:                                *code |= 0x7 << 3;
        !           647:                        }
        !           648:                        else {
        !           649:                                /* and dst, 0xff */
        !           650:                                code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, 255, dst, 0);
        !           651:                                FAIL_IF(!code);
        !           652:                                *(code + 1) |= 0x4 << 3;
        !           653:                        }
        !           654:                }
        !           655:                return SLJIT_SUCCESS;
        !           656:        }
        !           657: #endif
        !           658:        else {
        !           659:                /* src can be memory addr or reg_map[src] < 4 on x86_32 architectures. */
        !           660:                code = emit_x86_instruction(compiler, 2, dst_r, 0, src, srcw);
        !           661:                FAIL_IF(!code);
        !           662:                *code++ = 0x0f;
        !           663:                *code = sign ? 0xbe : 0xb6;
        !           664:        }
        !           665: 
        !           666:        if (dst & SLJIT_MEM) {
        !           667: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           668:                if (dst_r == TMP_REGISTER) {
        !           669:                        /* Find a non-used register, whose reg_map[src] < 4. */
        !           670:                        if ((dst & 0xf) == SLJIT_TEMPORARY_REG1) {
        !           671:                                if ((dst & 0xf0) == (SLJIT_TEMPORARY_REG2 << 4))
        !           672:                                        work_r = SLJIT_TEMPORARY_REG3;
        !           673:                                else
        !           674:                                        work_r = SLJIT_TEMPORARY_REG2;
        !           675:                        }
        !           676:                        else {
        !           677:                                if ((dst & 0xf0) != (SLJIT_TEMPORARY_REG1 << 4))
        !           678:                                        work_r = SLJIT_TEMPORARY_REG1;
        !           679:                                else if ((dst & 0xf) == SLJIT_TEMPORARY_REG2)
        !           680:                                        work_r = SLJIT_TEMPORARY_REG3;
        !           681:                                else
        !           682:                                        work_r = SLJIT_TEMPORARY_REG2;
        !           683:                        }
        !           684: 
        !           685:                        if (work_r == SLJIT_TEMPORARY_REG1) {
        !           686:                                ENCODE_PREFIX(0x90 + reg_map[TMP_REGISTER]);
        !           687:                        }
        !           688:                        else {
        !           689:                                code = emit_x86_instruction(compiler, 1, work_r, 0, dst_r, 0);
        !           690:                                FAIL_IF(!code);
        !           691:                                *code = 0x87;
        !           692:                        }
        !           693: 
        !           694:                        code = emit_x86_instruction(compiler, 1, work_r, 0, dst, dstw);
        !           695:                        FAIL_IF(!code);
        !           696:                        *code = 0x88;
        !           697: 
        !           698:                        if (work_r == SLJIT_TEMPORARY_REG1) {
        !           699:                                ENCODE_PREFIX(0x90 + reg_map[TMP_REGISTER]);
        !           700:                        }
        !           701:                        else {
        !           702:                                code = emit_x86_instruction(compiler, 1, work_r, 0, dst_r, 0);
        !           703:                                FAIL_IF(!code);
        !           704:                                *code = 0x87;
        !           705:                        }
        !           706:                }
        !           707:                else {
        !           708:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, dst, dstw);
        !           709:                        FAIL_IF(!code);
        !           710:                        *code = 0x88;
        !           711:                }
        !           712: #else
        !           713:                code = emit_x86_instruction(compiler, 1 | EX86_REX | EX86_NO_REXW, dst_r, 0, dst, dstw);
        !           714:                FAIL_IF(!code);
        !           715:                *code = 0x88;
        !           716: #endif
        !           717:        }
        !           718: 
        !           719:        return SLJIT_SUCCESS;
        !           720: }
        !           721: 
        !           722: static int emit_mov_half(struct sljit_compiler *compiler, int sign,
        !           723:        int dst, sljit_w dstw,
        !           724:        int src, sljit_w srcw)
        !           725: {
        !           726:        sljit_ub* code;
        !           727:        int dst_r;
        !           728: 
        !           729: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           730:        compiler->mode32 = 0;
        !           731: #endif
        !           732: 
        !           733:        if (dst == SLJIT_UNUSED && !(src & SLJIT_MEM))
        !           734:                return SLJIT_SUCCESS; /* Empty instruction. */
        !           735: 
        !           736:        if (src & SLJIT_IMM) {
        !           737:                if (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) {
        !           738: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           739:                        return emit_do_imm(compiler, 0xb8 + reg_map[dst], srcw);
        !           740: #else
        !           741:                        return emit_load_imm64(compiler, dst, srcw);
        !           742: #endif
        !           743:                }
        !           744:                code = emit_x86_instruction(compiler, 1 | EX86_HALF_ARG | EX86_NO_REXW | EX86_PREF_66, SLJIT_IMM, srcw, dst, dstw);
        !           745:                FAIL_IF(!code);
        !           746:                *code = 0xc7;
        !           747:                return SLJIT_SUCCESS;
        !           748:        }
        !           749: 
        !           750:        dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) ? dst : TMP_REGISTER;
        !           751: 
        !           752:        if ((dst & SLJIT_MEM) && (src >= SLJIT_TEMPORARY_REG1 && src <= SLJIT_NO_REGISTERS))
        !           753:                dst_r = src;
        !           754:        else {
        !           755:                code = emit_x86_instruction(compiler, 2, dst_r, 0, src, srcw);
        !           756:                FAIL_IF(!code);
        !           757:                *code++ = 0x0f;
        !           758:                *code = sign ? 0xbf : 0xb7;
        !           759:        }
        !           760: 
        !           761:        if (dst & SLJIT_MEM) {
        !           762:                code = emit_x86_instruction(compiler, 1 | EX86_NO_REXW | EX86_PREF_66, dst_r, 0, dst, dstw);
        !           763:                FAIL_IF(!code);
        !           764:                *code = 0x89;
        !           765:        }
        !           766: 
        !           767:        return SLJIT_SUCCESS;
        !           768: }
        !           769: 
        !           770: static int emit_unary(struct sljit_compiler *compiler, int un_index,
        !           771:        int dst, sljit_w dstw,
        !           772:        int src, sljit_w srcw)
        !           773: {
        !           774:        sljit_ub* code;
        !           775: 
        !           776:        if (dst == SLJIT_UNUSED) {
        !           777:                EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
        !           778:                code = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);
        !           779:                FAIL_IF(!code);
        !           780:                *code++ = 0xf7;
        !           781:                *code |= (un_index) << 3;
        !           782:                return SLJIT_SUCCESS;
        !           783:        }
        !           784:        if (dst == src && dstw == srcw) {
        !           785:                /* Same input and output */
        !           786:                code = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
        !           787:                FAIL_IF(!code);
        !           788:                *code++ = 0xf7;
        !           789:                *code |= (un_index) << 3;
        !           790:                return SLJIT_SUCCESS;
        !           791:        }
        !           792:        if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
        !           793:                EMIT_MOV(compiler, dst, 0, src, srcw);
        !           794:                code = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
        !           795:                FAIL_IF(!code);
        !           796:                *code++ = 0xf7;
        !           797:                *code |= (un_index) << 3;
        !           798:                return SLJIT_SUCCESS;
        !           799:        }
        !           800:        EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
        !           801:        code = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);
        !           802:        FAIL_IF(!code);
        !           803:        *code++ = 0xf7;
        !           804:        *code |= (un_index) << 3;
        !           805:        EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
        !           806:        return SLJIT_SUCCESS;
        !           807: }
        !           808: 
        !           809: static int emit_not_with_flags(struct sljit_compiler *compiler,
        !           810:        int dst, sljit_w dstw,
        !           811:        int src, sljit_w srcw)
        !           812: {
        !           813:        sljit_ub* code;
        !           814: 
        !           815:        if (dst == SLJIT_UNUSED) {
        !           816:                EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
        !           817:                code = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);
        !           818:                FAIL_IF(!code);
        !           819:                *code++ = 0xf7;
        !           820:                *code |= 0x2 << 3;
        !           821:                code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, TMP_REGISTER, 0);
        !           822:                FAIL_IF(!code);
        !           823:                *code = 0x0b;
        !           824:                return SLJIT_SUCCESS;
        !           825:        }
        !           826:        if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
        !           827:                EMIT_MOV(compiler, dst, 0, src, srcw);
        !           828:                code = emit_x86_instruction(compiler, 1, 0, 0, dst, dstw);
        !           829:                FAIL_IF(!code);
        !           830:                *code++ = 0xf7;
        !           831:                *code |= 0x2 << 3;
        !           832:                code = emit_x86_instruction(compiler, 1, dst, 0, dst, 0);
        !           833:                FAIL_IF(!code);
        !           834:                *code = 0x0b;
        !           835:                return SLJIT_SUCCESS;
        !           836:        }
        !           837:        EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
        !           838:        code = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);
        !           839:        FAIL_IF(!code);
        !           840:        *code++ = 0xf7;
        !           841:        *code |= 0x2 << 3;
        !           842:        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, TMP_REGISTER, 0);
        !           843:        FAIL_IF(!code);
        !           844:        *code = 0x0b;
        !           845:        EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
        !           846:        return SLJIT_SUCCESS;
        !           847: }
        !           848: 
        !           849: static int emit_clz(struct sljit_compiler *compiler, int op,
        !           850:        int dst, sljit_w dstw,
        !           851:        int src, sljit_w srcw)
        !           852: {
        !           853:        sljit_ub* code;
        !           854:        int dst_r;
        !           855: 
        !           856:        if (SLJIT_UNLIKELY(dst == SLJIT_UNUSED)) {
        !           857:                /* Just set the zero flag. */
        !           858:                EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
        !           859:                code = emit_x86_instruction(compiler, 1, 0, 0, TMP_REGISTER, 0);
        !           860:                FAIL_IF(!code);
        !           861:                *code++ = 0xf7;
        !           862:                *code |= 0x2 << 3;
        !           863: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           864:                code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, 31, TMP_REGISTER, 0);
        !           865: #else
        !           866:                code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_IMM, !(op & SLJIT_INT_OP) ? 63 : 31, TMP_REGISTER, 0);
        !           867: #endif
        !           868:                FAIL_IF(!code);
        !           869:                *code |= 0x5 << 3;
        !           870:                return SLJIT_SUCCESS;
        !           871:        }
        !           872: 
        !           873:        if (SLJIT_UNLIKELY(src & SLJIT_IMM)) {
        !           874:                EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
        !           875:                src = TMP_REGISTER;
        !           876:                srcw = 0;
        !           877:        }
        !           878: 
        !           879:        code = emit_x86_instruction(compiler, 2, TMP_REGISTER, 0, src, srcw);
        !           880:        FAIL_IF(!code);
        !           881:        *code++ = 0x0f;
        !           882:        *code = 0xbd;
        !           883: 
        !           884: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           885:        if (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER)
        !           886:                dst_r = dst;
        !           887:        else {
        !           888:                /* Find an unused temporary register. */
        !           889:                if ((dst & 0xf) != SLJIT_TEMPORARY_REG1 && (dst & 0xf0) != (SLJIT_TEMPORARY_REG1 << 4))
        !           890:                        dst_r = SLJIT_TEMPORARY_REG1;
        !           891:                else if ((dst & 0xf) != SLJIT_TEMPORARY_REG2 && (dst & 0xf0) != (SLJIT_TEMPORARY_REG2 << 4))
        !           892:                        dst_r = SLJIT_TEMPORARY_REG2;
        !           893:                else
        !           894:                        dst_r = SLJIT_TEMPORARY_REG3;
        !           895:                EMIT_MOV(compiler, dst, dstw, dst_r, 0);
        !           896:        }
        !           897:        EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, 32 + 31);
        !           898: #else
        !           899:        dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= TMP_REGISTER) ? dst : TMP_REG2;
        !           900:        compiler->mode32 = 0;
        !           901:        EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, !(op & SLJIT_INT_OP) ? 64 + 63 : 32 + 31);
        !           902:        compiler->mode32 = op & SLJIT_INT_OP;
        !           903: #endif
        !           904: 
        !           905:        code = emit_x86_instruction(compiler, 2, dst_r, 0, TMP_REGISTER, 0);
        !           906:        FAIL_IF(!code);
        !           907:        *code++ = 0x0f;
        !           908:        *code = 0x45;
        !           909: 
        !           910: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           911:        code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, 31, dst_r, 0);
        !           912: #else
        !           913:        code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, !(op & SLJIT_INT_OP) ? 63 : 31, dst_r, 0);
        !           914: #endif
        !           915:        FAIL_IF(!code);
        !           916:        *(code + 1) |= 0x6 << 3;
        !           917: 
        !           918: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           919:        if (dst & SLJIT_MEM) {
        !           920:                code = emit_x86_instruction(compiler, 1, dst_r, 0, dst, dstw);
        !           921:                FAIL_IF(!code);
        !           922:                *code = 0x87;
        !           923:        }
        !           924: #else
        !           925:        if (dst & SLJIT_MEM)
        !           926:                EMIT_MOV(compiler, dst, dstw, TMP_REG2, 0);
        !           927: #endif
        !           928:        return SLJIT_SUCCESS;
        !           929: }
        !           930: 
        !           931: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op1(struct sljit_compiler *compiler, int op,
        !           932:        int dst, sljit_w dstw,
        !           933:        int src, sljit_w srcw)
        !           934: {
        !           935:        sljit_ub* code;
        !           936:        int update = 0;
        !           937: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           938:        int dst_is_ereg = 0;
        !           939:        int src_is_ereg = 0;
        !           940: #else
        !           941:        #define src_is_ereg 0
        !           942: #endif
        !           943: 
        !           944:        CHECK_ERROR();
        !           945:        check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw);
        !           946: 
        !           947: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           948:        compiler->mode32 = op & SLJIT_INT_OP;
        !           949: #endif
        !           950:        CHECK_EXTRA_REGS(dst, dstw, dst_is_ereg = 1);
        !           951:        CHECK_EXTRA_REGS(src, srcw, src_is_ereg = 1);
        !           952: 
        !           953:        if (GET_OPCODE(op) >= SLJIT_MOV && GET_OPCODE(op) <= SLJIT_MOVU_SI) {
        !           954:                op = GET_OPCODE(op);
        !           955: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           956:                compiler->mode32 = 0;
        !           957: #endif
        !           958: 
        !           959:                SLJIT_COMPILE_ASSERT(SLJIT_MOV + 7 == SLJIT_MOVU, movu_offset);
        !           960:                if (op >= SLJIT_MOVU) {
        !           961:                        update = 1;
        !           962:                        op -= 7;
        !           963:                }
        !           964: 
        !           965:                if (src & SLJIT_IMM) {
        !           966:                        switch (op) {
        !           967:                        case SLJIT_MOV_UB:
        !           968:                                srcw = (unsigned char)srcw;
        !           969:                                break;
        !           970:                        case SLJIT_MOV_SB:
        !           971:                                srcw = (signed char)srcw;
        !           972:                                break;
        !           973:                        case SLJIT_MOV_UH:
        !           974:                                srcw = (unsigned short)srcw;
        !           975:                                break;
        !           976:                        case SLJIT_MOV_SH:
        !           977:                                srcw = (signed short)srcw;
        !           978:                                break;
        !           979: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !           980:                        case SLJIT_MOV_UI:
        !           981:                                srcw = (unsigned int)srcw;
        !           982:                                break;
        !           983:                        case SLJIT_MOV_SI:
        !           984:                                srcw = (signed int)srcw;
        !           985:                                break;
        !           986: #endif
        !           987:                        }
        !           988: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !           989:                        if (SLJIT_UNLIKELY(dst_is_ereg))
        !           990:                                return emit_mov(compiler, dst, dstw, src, srcw);
        !           991: #endif
        !           992:                }
        !           993: 
        !           994:                if (SLJIT_UNLIKELY(update) && (src & SLJIT_MEM) && !src_is_ereg && (src & 0xf) && (srcw != 0 || (src & 0xf0) != 0)) {
        !           995:                        code = emit_x86_instruction(compiler, 1, src & 0xf, 0, src, srcw);
        !           996:                        FAIL_IF(!code);
        !           997:                        *code = 0x8d;
        !           998:                        src &= SLJIT_MEM | 0xf;
        !           999:                        srcw = 0;
        !          1000:                }
        !          1001: 
        !          1002: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          1003:                if (SLJIT_UNLIKELY(dst_is_ereg) && (!(op == SLJIT_MOV || op == SLJIT_MOV_UI || op == SLJIT_MOV_SI) || (src & SLJIT_MEM))) {
        !          1004:                        SLJIT_ASSERT(dst == SLJIT_MEM1(SLJIT_LOCALS_REG));
        !          1005:                        dst = TMP_REGISTER;
        !          1006:                }
        !          1007: #endif
        !          1008: 
        !          1009:                switch (op) {
        !          1010:                case SLJIT_MOV:
        !          1011: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          1012:                case SLJIT_MOV_UI:
        !          1013:                case SLJIT_MOV_SI:
        !          1014: #endif
        !          1015:                        FAIL_IF(emit_mov(compiler, dst, dstw, src, srcw));
        !          1016:                        break;
        !          1017:                case SLJIT_MOV_UB:
        !          1018:                        FAIL_IF(emit_mov_byte(compiler, 0, dst, dstw, src, (src & SLJIT_IMM) ? (unsigned char)srcw : srcw));
        !          1019:                        break;
        !          1020:                case SLJIT_MOV_SB:
        !          1021:                        FAIL_IF(emit_mov_byte(compiler, 1, dst, dstw, src, (src & SLJIT_IMM) ? (signed char)srcw : srcw));
        !          1022:                        break;
        !          1023:                case SLJIT_MOV_UH:
        !          1024:                        FAIL_IF(emit_mov_half(compiler, 0, dst, dstw, src, (src & SLJIT_IMM) ? (unsigned short)srcw : srcw));
        !          1025:                        break;
        !          1026:                case SLJIT_MOV_SH:
        !          1027:                        FAIL_IF(emit_mov_half(compiler, 1, dst, dstw, src, (src & SLJIT_IMM) ? (signed short)srcw : srcw));
        !          1028:                        break;
        !          1029: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1030:                case SLJIT_MOV_UI:
        !          1031:                        FAIL_IF(emit_mov_int(compiler, 0, dst, dstw, src, (src & SLJIT_IMM) ? (unsigned int)srcw : srcw));
        !          1032:                        break;
        !          1033:                case SLJIT_MOV_SI:
        !          1034:                        FAIL_IF(emit_mov_int(compiler, 1, dst, dstw, src, (src & SLJIT_IMM) ? (signed int)srcw : srcw));
        !          1035:                        break;
        !          1036: #endif
        !          1037:                }
        !          1038: 
        !          1039: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          1040:                if (SLJIT_UNLIKELY(dst_is_ereg) && dst == TMP_REGISTER)
        !          1041:                        return emit_mov(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), dstw, TMP_REGISTER, 0);
        !          1042: #endif
        !          1043: 
        !          1044:                if (SLJIT_UNLIKELY(update) && (dst & SLJIT_MEM) && (dst & 0xf) && (dstw != 0 || (dst & 0xf0) != 0)) {
        !          1045:                        code = emit_x86_instruction(compiler, 1, dst & 0xf, 0, dst, dstw);
        !          1046:                        FAIL_IF(!code);
        !          1047:                        *code = 0x8d;
        !          1048:                }
        !          1049:                return SLJIT_SUCCESS;
        !          1050:        }
        !          1051: 
        !          1052:        if (SLJIT_UNLIKELY(GET_FLAGS(op)))
        !          1053:                compiler->flags_saved = 0;
        !          1054: 
        !          1055:        switch (GET_OPCODE(op)) {
        !          1056:        case SLJIT_NOT:
        !          1057:                if (SLJIT_UNLIKELY(op & SLJIT_SET_E))
        !          1058:                        return emit_not_with_flags(compiler, dst, dstw, src, srcw);
        !          1059:                return emit_unary(compiler, 0x2, dst, dstw, src, srcw);
        !          1060: 
        !          1061:        case SLJIT_NEG:
        !          1062:                if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)
        !          1063:                        FAIL_IF(emit_save_flags(compiler));
        !          1064:                return emit_unary(compiler, 0x3, dst, dstw, src, srcw);
        !          1065: 
        !          1066:        case SLJIT_CLZ:
        !          1067:                if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)
        !          1068:                        FAIL_IF(emit_save_flags(compiler));
        !          1069:                return emit_clz(compiler, op, dst, dstw, src, srcw);
        !          1070:        }
        !          1071: 
        !          1072:        return SLJIT_SUCCESS;
        !          1073: 
        !          1074: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1075:        #undef src_is_ereg
        !          1076: #endif
        !          1077: }
        !          1078: 
        !          1079: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1080: 
        !          1081: #define BINARY_IMM(_op_imm_, _op_mr_, immw, arg, argw) \
        !          1082:        if (IS_HALFWORD(immw) || compiler->mode32) { \
        !          1083:                code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, immw, arg, argw); \
        !          1084:                FAIL_IF(!code); \
        !          1085:                *(code + 1) |= (_op_imm_); \
        !          1086:        } \
        !          1087:        else { \
        !          1088:                FAIL_IF(emit_load_imm64(compiler, TMP_REG2, immw)); \
        !          1089:                code = emit_x86_instruction(compiler, 1, TMP_REG2, 0, arg, argw); \
        !          1090:                FAIL_IF(!code); \
        !          1091:                *code = (_op_mr_); \
        !          1092:        }
        !          1093: 
        !          1094: #define BINARY_EAX_IMM(_op_eax_imm_, immw) \
        !          1095:        FAIL_IF(emit_do_imm32(compiler, (!compiler->mode32) ? REX_W : 0, (_op_eax_imm_), immw))
        !          1096: 
        !          1097: #else
        !          1098: 
        !          1099: #define BINARY_IMM(_op_imm_, _op_mr_, immw, arg, argw) \
        !          1100:        code = emit_x86_instruction(compiler, 1 | EX86_BIN_INS, SLJIT_IMM, immw, arg, argw); \
        !          1101:        FAIL_IF(!code); \
        !          1102:        *(code + 1) |= (_op_imm_);
        !          1103: 
        !          1104: #define BINARY_EAX_IMM(_op_eax_imm_, immw) \
        !          1105:        FAIL_IF(emit_do_imm(compiler, (_op_eax_imm_), immw))
        !          1106: 
        !          1107: #endif
        !          1108: 
        !          1109: static int emit_cum_binary(struct sljit_compiler *compiler,
        !          1110:        sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,
        !          1111:        int dst, sljit_w dstw,
        !          1112:        int src1, sljit_w src1w,
        !          1113:        int src2, sljit_w src2w)
        !          1114: {
        !          1115:        sljit_ub* code;
        !          1116: 
        !          1117:        if (dst == SLJIT_UNUSED) {
        !          1118:                EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1119:                if (src2 & SLJIT_IMM) {
        !          1120:                        BINARY_IMM(op_imm, op_mr, src2w, TMP_REGISTER, 0);
        !          1121:                }
        !          1122:                else {
        !          1123:                        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);
        !          1124:                        FAIL_IF(!code);
        !          1125:                        *code = op_rm;
        !          1126:                }
        !          1127:                return SLJIT_SUCCESS;
        !          1128:        }
        !          1129: 
        !          1130:        if (dst == src1 && dstw == src1w) {
        !          1131:                if (src2 & SLJIT_IMM) {
        !          1132: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1133:                        if ((dst == SLJIT_TEMPORARY_REG1) && (src2w > 127 || src2w < -128) && (compiler->mode32 || IS_HALFWORD(src2w))) {
        !          1134: #else
        !          1135:                        if ((dst == SLJIT_TEMPORARY_REG1) && (src2w > 127 || src2w < -128)) {
        !          1136: #endif
        !          1137:                                BINARY_EAX_IMM(op_eax_imm, src2w);
        !          1138:                        }
        !          1139:                        else {
        !          1140:                                BINARY_IMM(op_imm, op_mr, src2w, dst, dstw);
        !          1141:                        }
        !          1142:                }
        !          1143:                else if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
        !          1144:                        code = emit_x86_instruction(compiler, 1, dst, dstw, src2, src2w);
        !          1145:                        FAIL_IF(!code);
        !          1146:                        *code = op_rm;
        !          1147:                }
        !          1148:                else if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= TMP_REGISTER) {
        !          1149:                        /* Special exception for sljit_emit_cond_value. */
        !          1150:                        code = emit_x86_instruction(compiler, 1, src2, src2w, dst, dstw);
        !          1151:                        FAIL_IF(!code);
        !          1152:                        *code = op_mr;
        !          1153:                }
        !          1154:                else {
        !          1155:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src2, src2w);
        !          1156:                        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, dst, dstw);
        !          1157:                        FAIL_IF(!code);
        !          1158:                        *code = op_mr;
        !          1159:                }
        !          1160:                return SLJIT_SUCCESS;
        !          1161:        }
        !          1162: 
        !          1163:        /* Only for cumulative operations. */
        !          1164:        if (dst == src2 && dstw == src2w) {
        !          1165:                if (src1 & SLJIT_IMM) {
        !          1166: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1167:                        if ((dst == SLJIT_TEMPORARY_REG1) && (src1w > 127 || src1w < -128) && (compiler->mode32 || IS_HALFWORD(src1w))) {
        !          1168: #else
        !          1169:                        if ((dst == SLJIT_TEMPORARY_REG1) && (src1w > 127 || src1w < -128)) {
        !          1170: #endif
        !          1171:                                BINARY_EAX_IMM(op_eax_imm, src1w);
        !          1172:                        }
        !          1173:                        else {
        !          1174:                                BINARY_IMM(op_imm, op_mr, src1w, dst, dstw);
        !          1175:                        }
        !          1176:                }
        !          1177:                else if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
        !          1178:                        code = emit_x86_instruction(compiler, 1, dst, dstw, src1, src1w);
        !          1179:                        FAIL_IF(!code);
        !          1180:                        *code = op_rm;
        !          1181:                }
        !          1182:                else if (src1 >= SLJIT_TEMPORARY_REG1 && src1 <= SLJIT_NO_REGISTERS) {
        !          1183:                        code = emit_x86_instruction(compiler, 1, src1, src1w, dst, dstw);
        !          1184:                        FAIL_IF(!code);
        !          1185:                        *code = op_mr;
        !          1186:                }
        !          1187:                else {
        !          1188:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1189:                        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, dst, dstw);
        !          1190:                        FAIL_IF(!code);
        !          1191:                        *code = op_mr;
        !          1192:                }
        !          1193:                return SLJIT_SUCCESS;
        !          1194:        }
        !          1195: 
        !          1196:        /* General version. */
        !          1197:        if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
        !          1198:                EMIT_MOV(compiler, dst, 0, src1, src1w);
        !          1199:                if (src2 & SLJIT_IMM) {
        !          1200:                        BINARY_IMM(op_imm, op_mr, src2w, dst, 0);
        !          1201:                }
        !          1202:                else {
        !          1203:                        code = emit_x86_instruction(compiler, 1, dst, 0, src2, src2w);
        !          1204:                        FAIL_IF(!code);
        !          1205:                        *code = op_rm;
        !          1206:                }
        !          1207:        }
        !          1208:        else {
        !          1209:                /* This version requires less memory writing. */
        !          1210:                EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1211:                if (src2 & SLJIT_IMM) {
        !          1212:                        BINARY_IMM(op_imm, op_mr, src2w, TMP_REGISTER, 0);
        !          1213:                }
        !          1214:                else {
        !          1215:                        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);
        !          1216:                        FAIL_IF(!code);
        !          1217:                        *code = op_rm;
        !          1218:                }
        !          1219:                EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
        !          1220:        }
        !          1221: 
        !          1222:        return SLJIT_SUCCESS;
        !          1223: }
        !          1224: 
        !          1225: static int emit_non_cum_binary(struct sljit_compiler *compiler,
        !          1226:        sljit_ub op_rm, sljit_ub op_mr, sljit_ub op_imm, sljit_ub op_eax_imm,
        !          1227:        int dst, sljit_w dstw,
        !          1228:        int src1, sljit_w src1w,
        !          1229:        int src2, sljit_w src2w)
        !          1230: {
        !          1231:        sljit_ub* code;
        !          1232: 
        !          1233:        if (dst == SLJIT_UNUSED) {
        !          1234:                EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1235:                if (src2 & SLJIT_IMM) {
        !          1236:                        BINARY_IMM(op_imm, op_mr, src2w, TMP_REGISTER, 0);
        !          1237:                }
        !          1238:                else {
        !          1239:                        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);
        !          1240:                        FAIL_IF(!code);
        !          1241:                        *code = op_rm;
        !          1242:                }
        !          1243:                return SLJIT_SUCCESS;
        !          1244:        }
        !          1245: 
        !          1246:        if (dst == src1 && dstw == src1w) {
        !          1247:                if (src2 & SLJIT_IMM) {
        !          1248: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1249:                        if ((dst == SLJIT_TEMPORARY_REG1) && (src2w > 127 || src2w < -128) && (compiler->mode32 || IS_HALFWORD(src2w))) {
        !          1250: #else
        !          1251:                        if ((dst == SLJIT_TEMPORARY_REG1) && (src2w > 127 || src2w < -128)) {
        !          1252: #endif
        !          1253:                                BINARY_EAX_IMM(op_eax_imm, src2w);
        !          1254:                        }
        !          1255:                        else {
        !          1256:                                BINARY_IMM(op_imm, op_mr, src2w, dst, dstw);
        !          1257:                        }
        !          1258:                }
        !          1259:                else if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
        !          1260:                        code = emit_x86_instruction(compiler, 1, dst, dstw, src2, src2w);
        !          1261:                        FAIL_IF(!code);
        !          1262:                        *code = op_rm;
        !          1263:                }
        !          1264:                else if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= SLJIT_NO_REGISTERS) {
        !          1265:                        code = emit_x86_instruction(compiler, 1, src2, src2w, dst, dstw);
        !          1266:                        FAIL_IF(!code);
        !          1267:                        *code = op_mr;
        !          1268:                }
        !          1269:                else {
        !          1270:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src2, src2w);
        !          1271:                        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, dst, dstw);
        !          1272:                        FAIL_IF(!code);
        !          1273:                        *code = op_mr;
        !          1274:                }
        !          1275:                return SLJIT_SUCCESS;
        !          1276:        }
        !          1277: 
        !          1278:        /* General version. */
        !          1279:        if ((dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) && dst != src2) {
        !          1280:                EMIT_MOV(compiler, dst, 0, src1, src1w);
        !          1281:                if (src2 & SLJIT_IMM) {
        !          1282:                        BINARY_IMM(op_imm, op_mr, src2w, dst, 0);
        !          1283:                }
        !          1284:                else {
        !          1285:                        code = emit_x86_instruction(compiler, 1, dst, 0, src2, src2w);
        !          1286:                        FAIL_IF(!code);
        !          1287:                        *code = op_rm;
        !          1288:                }
        !          1289:        }
        !          1290:        else {
        !          1291:                /* This version requires less memory writing. */
        !          1292:                EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1293:                if (src2 & SLJIT_IMM) {
        !          1294:                        BINARY_IMM(op_imm, op_mr, src2w, TMP_REGISTER, 0);
        !          1295:                }
        !          1296:                else {
        !          1297:                        code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);
        !          1298:                        FAIL_IF(!code);
        !          1299:                        *code = op_rm;
        !          1300:                }
        !          1301:                EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
        !          1302:        }
        !          1303: 
        !          1304:        return SLJIT_SUCCESS;
        !          1305: }
        !          1306: 
        !          1307: static int emit_mul(struct sljit_compiler *compiler,
        !          1308:        int dst, sljit_w dstw,
        !          1309:        int src1, sljit_w src1w,
        !          1310:        int src2, sljit_w src2w)
        !          1311: {
        !          1312:        sljit_ub* code;
        !          1313:        int dst_r;
        !          1314: 
        !          1315:        dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REGISTER;
        !          1316: 
        !          1317:        /* Register destination. */
        !          1318:        if (dst_r == src1 && !(src2 & SLJIT_IMM)) {
        !          1319:                code = emit_x86_instruction(compiler, 2, dst_r, 0, src2, src2w);
        !          1320:                FAIL_IF(!code);
        !          1321:                *code++ = 0x0f;
        !          1322:                *code = 0xaf;
        !          1323:        }
        !          1324:        else if (dst_r == src2 && !(src1 & SLJIT_IMM)) {
        !          1325:                code = emit_x86_instruction(compiler, 2, dst_r, 0, src1, src1w);
        !          1326:                FAIL_IF(!code);
        !          1327:                *code++ = 0x0f;
        !          1328:                *code = 0xaf;
        !          1329:        }
        !          1330:        else if (src1 & SLJIT_IMM) {
        !          1331:                if (src2 & SLJIT_IMM) {
        !          1332:                        EMIT_MOV(compiler, dst_r, 0, SLJIT_IMM, src2w);
        !          1333:                        src2 = dst_r;
        !          1334:                        src2w = 0;
        !          1335:                }
        !          1336: 
        !          1337:                if (src1w <= 127 && src1w >= -128) {
        !          1338:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, src2, src2w);
        !          1339:                        FAIL_IF(!code);
        !          1340:                        *code = 0x6b;
        !          1341:                        code = (sljit_ub*)ensure_buf(compiler, 1 + 1);
        !          1342:                        FAIL_IF(!code);
        !          1343:                        INC_CSIZE(1);
        !          1344:                        *code = (sljit_b)src1w;
        !          1345:                }
        !          1346: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          1347:                else {
        !          1348:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, src2, src2w);
        !          1349:                        FAIL_IF(!code);
        !          1350:                        *code = 0x69;
        !          1351:                        code = (sljit_ub*)ensure_buf(compiler, 1 + 4);
        !          1352:                        FAIL_IF(!code);
        !          1353:                        INC_CSIZE(4);
        !          1354:                        *(sljit_w*)code = src1w;
        !          1355:                }
        !          1356: #else
        !          1357:                else if (IS_HALFWORD(src1w)) {
        !          1358:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, src2, src2w);
        !          1359:                        FAIL_IF(!code);
        !          1360:                        *code = 0x69;
        !          1361:                        code = (sljit_ub*)ensure_buf(compiler, 1 + 4);
        !          1362:                        FAIL_IF(!code);
        !          1363:                        INC_CSIZE(4);
        !          1364:                        *(sljit_hw*)code = (sljit_hw)src1w;
        !          1365:                }
        !          1366:                else {
        !          1367:                        EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_IMM, src1w);
        !          1368:                        if (dst_r != src2)
        !          1369:                                EMIT_MOV(compiler, dst_r, 0, src2, src2w);
        !          1370:                        code = emit_x86_instruction(compiler, 2, dst_r, 0, TMP_REG2, 0);
        !          1371:                        FAIL_IF(!code);
        !          1372:                        *code++ = 0x0f;
        !          1373:                        *code = 0xaf;
        !          1374:                }
        !          1375: #endif
        !          1376:        }
        !          1377:        else if (src2 & SLJIT_IMM) {
        !          1378:                /* Note: src1 is NOT immediate. */
        !          1379: 
        !          1380:                if (src2w <= 127 && src2w >= -128) {
        !          1381:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, src1, src1w);
        !          1382:                        FAIL_IF(!code);
        !          1383:                        *code = 0x6b;
        !          1384:                        code = (sljit_ub*)ensure_buf(compiler, 1 + 1);
        !          1385:                        FAIL_IF(!code);
        !          1386:                        INC_CSIZE(1);
        !          1387:                        *code = (sljit_b)src2w;
        !          1388:                }
        !          1389: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          1390:                else {
        !          1391:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, src1, src1w);
        !          1392:                        FAIL_IF(!code);
        !          1393:                        *code = 0x69;
        !          1394:                        code = (sljit_ub*)ensure_buf(compiler, 1 + 4);
        !          1395:                        FAIL_IF(!code);
        !          1396:                        INC_CSIZE(4);
        !          1397:                        *(sljit_w*)code = src2w;
        !          1398:                }
        !          1399: #else
        !          1400:                else if (IS_HALFWORD(src2w)) {
        !          1401:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, src1, src1w);
        !          1402:                        FAIL_IF(!code);
        !          1403:                        *code = 0x69;
        !          1404:                        code = (sljit_ub*)ensure_buf(compiler, 1 + 4);
        !          1405:                        FAIL_IF(!code);
        !          1406:                        INC_CSIZE(4);
        !          1407:                        *(sljit_hw*)code = (sljit_hw)src2w;
        !          1408:                }
        !          1409:                else {
        !          1410:                        EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_IMM, src1w);
        !          1411:                        if (dst_r != src1)
        !          1412:                                EMIT_MOV(compiler, dst_r, 0, src1, src1w);
        !          1413:                        code = emit_x86_instruction(compiler, 2, dst_r, 0, TMP_REG2, 0);
        !          1414:                        FAIL_IF(!code);
        !          1415:                        *code++ = 0x0f;
        !          1416:                        *code = 0xaf;
        !          1417:                }
        !          1418: #endif
        !          1419:        }
        !          1420:        else {
        !          1421:                /* Neither argument is immediate. */
        !          1422:                if (ADDRESSING_DEPENDS_ON(src2, dst_r))
        !          1423:                        dst_r = TMP_REGISTER;
        !          1424:                EMIT_MOV(compiler, dst_r, 0, src1, src1w);
        !          1425:                code = emit_x86_instruction(compiler, 2, dst_r, 0, src2, src2w);
        !          1426:                FAIL_IF(!code);
        !          1427:                *code++ = 0x0f;
        !          1428:                *code = 0xaf;
        !          1429:        }
        !          1430: 
        !          1431:        if (dst_r == TMP_REGISTER)
        !          1432:                EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
        !          1433: 
        !          1434:        return SLJIT_SUCCESS;
        !          1435: }
        !          1436: 
        !          1437: static int emit_lea_binary(struct sljit_compiler *compiler,
        !          1438:        int dst, sljit_w dstw,
        !          1439:        int src1, sljit_w src1w,
        !          1440:        int src2, sljit_w src2w)
        !          1441: {
        !          1442:        sljit_ub* code;
        !          1443:        int dst_r, done = 0;
        !          1444: 
        !          1445:        /* These cases better be left to handled by normal way. */
        !          1446:        if (dst == src1 && dstw == src1w)
        !          1447:                return SLJIT_ERR_UNSUPPORTED;
        !          1448:        if (dst == src2 && dstw == src2w)
        !          1449:                return SLJIT_ERR_UNSUPPORTED;
        !          1450: 
        !          1451:        dst_r = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REGISTER;
        !          1452: 
        !          1453:        if (src1 >= SLJIT_TEMPORARY_REG1 && src1 <= SLJIT_NO_REGISTERS) {
        !          1454:                if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= SLJIT_NO_REGISTERS) {
        !          1455:                        /* It is not possible to be both SLJIT_LOCALS_REG. */
        !          1456:                        if (src1 != SLJIT_LOCALS_REG || src2 != SLJIT_LOCALS_REG) {
        !          1457:                                code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM2(src1, src2), 0);
        !          1458:                                FAIL_IF(!code);
        !          1459:                                *code = 0x8d;
        !          1460:                                done = 1;
        !          1461:                        }
        !          1462:                }
        !          1463: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1464:                if ((src2 & SLJIT_IMM) && (compiler->mode32 || IS_HALFWORD(src2w))) {
        !          1465:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src1), (int)src2w);
        !          1466: #else
        !          1467:                if (src2 & SLJIT_IMM) {
        !          1468:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src1), src2w);
        !          1469: #endif
        !          1470:                        FAIL_IF(!code);
        !          1471:                        *code = 0x8d;
        !          1472:                        done = 1;
        !          1473:                }
        !          1474:        }
        !          1475:        else if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= SLJIT_NO_REGISTERS) {
        !          1476: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1477:                if ((src1 & SLJIT_IMM) && (compiler->mode32 || IS_HALFWORD(src1w))) {
        !          1478:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src2), (int)src1w);
        !          1479: #else
        !          1480:                if (src1 & SLJIT_IMM) {
        !          1481:                        code = emit_x86_instruction(compiler, 1, dst_r, 0, SLJIT_MEM1(src2), src1w);
        !          1482: #endif
        !          1483:                        FAIL_IF(!code);
        !          1484:                        *code = 0x8d;
        !          1485:                        done = 1;
        !          1486:                }
        !          1487:        }
        !          1488: 
        !          1489:        if (done) {
        !          1490:                if (dst_r == TMP_REGISTER)
        !          1491:                        return emit_mov(compiler, dst, dstw, TMP_REGISTER, 0);
        !          1492:                return SLJIT_SUCCESS;
        !          1493:        }
        !          1494:        return SLJIT_ERR_UNSUPPORTED;
        !          1495: }
        !          1496: 
        !          1497: static int emit_cmp_binary(struct sljit_compiler *compiler,
        !          1498:        int src1, sljit_w src1w,
        !          1499:        int src2, sljit_w src2w)
        !          1500: {
        !          1501:        sljit_ub* code;
        !          1502: 
        !          1503: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1504:        if (src1 == SLJIT_TEMPORARY_REG1 && (src2 & SLJIT_IMM) && (src2w > 127 || src2w < -128) && (compiler->mode32 || IS_HALFWORD(src2w))) {
        !          1505: #else
        !          1506:        if (src1 == SLJIT_TEMPORARY_REG1 && (src2 & SLJIT_IMM) && (src2w > 127 || src2w < -128)) {
        !          1507: #endif
        !          1508:                BINARY_EAX_IMM(0x3d, src2w);
        !          1509:                return SLJIT_SUCCESS;
        !          1510:        }
        !          1511: 
        !          1512:        if (src1 >= SLJIT_TEMPORARY_REG1 && src1 <= SLJIT_NO_REGISTERS) {
        !          1513:                if (src2 & SLJIT_IMM) {
        !          1514:                        BINARY_IMM(0x7 << 3, 0x39, src2w, src1, 0);
        !          1515:                }
        !          1516:                else {
        !          1517:                        code = emit_x86_instruction(compiler, 1, src1, 0, src2, src2w);
        !          1518:                        FAIL_IF(!code);
        !          1519:                        *code = 0x3b;
        !          1520:                }
        !          1521:                return SLJIT_SUCCESS;
        !          1522:        }
        !          1523: 
        !          1524:        if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= SLJIT_NO_REGISTERS && !(src1 & SLJIT_IMM)) {
        !          1525:                code = emit_x86_instruction(compiler, 1, src2, 0, src1, src1w);
        !          1526:                FAIL_IF(!code);
        !          1527:                *code = 0x39;
        !          1528:                return SLJIT_SUCCESS;
        !          1529:        }
        !          1530: 
        !          1531:        if (src2 & SLJIT_IMM) {
        !          1532:                if (src1 & SLJIT_IMM) {
        !          1533:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1534:                        src1 = TMP_REGISTER;
        !          1535:                        src1w = 0;
        !          1536:                }
        !          1537:                BINARY_IMM(0x7 << 3, 0x39, src2w, src1, src1w);
        !          1538:        }
        !          1539:        else {
        !          1540:                EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1541:                code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);
        !          1542:                FAIL_IF(!code);
        !          1543:                *code = 0x3b;
        !          1544:        }
        !          1545:        return SLJIT_SUCCESS;
        !          1546: }
        !          1547: 
        !          1548: static int emit_test_binary(struct sljit_compiler *compiler,
        !          1549:        int src1, sljit_w src1w,
        !          1550:        int src2, sljit_w src2w)
        !          1551: {
        !          1552:        sljit_ub* code;
        !          1553: 
        !          1554: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1555:        if (src1 == SLJIT_TEMPORARY_REG1 && (src2 & SLJIT_IMM) && (src2w > 127 || src2w < -128) && (compiler->mode32 || IS_HALFWORD(src2w))) {
        !          1556: #else
        !          1557:        if (src1 == SLJIT_TEMPORARY_REG1 && (src2 & SLJIT_IMM) && (src2w > 127 || src2w < -128)) {
        !          1558: #endif
        !          1559:                BINARY_EAX_IMM(0xa9, src2w);
        !          1560:                return SLJIT_SUCCESS;
        !          1561:        }
        !          1562: 
        !          1563: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1564:        if (src2 == SLJIT_TEMPORARY_REG1 && (src2 & SLJIT_IMM) && (src1w > 127 || src1w < -128) && (compiler->mode32 || IS_HALFWORD(src1w))) {
        !          1565: #else
        !          1566:        if (src2 == SLJIT_TEMPORARY_REG1 && (src1 & SLJIT_IMM) && (src1w > 127 || src1w < -128)) {
        !          1567: #endif
        !          1568:                BINARY_EAX_IMM(0xa9, src1w);
        !          1569:                return SLJIT_SUCCESS;
        !          1570:        }
        !          1571: 
        !          1572:        if (src1 >= SLJIT_TEMPORARY_REG1 && src1 <= SLJIT_NO_REGISTERS) {
        !          1573:                if (src2 & SLJIT_IMM) {
        !          1574: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1575:                        if (IS_HALFWORD(src2w) || compiler->mode32) {
        !          1576:                                code = emit_x86_instruction(compiler, 1, SLJIT_IMM, src2w, src1, 0);
        !          1577:                                FAIL_IF(!code);
        !          1578:                                *code = 0xf7;
        !          1579:                        }
        !          1580:                        else {
        !          1581:                                FAIL_IF(emit_load_imm64(compiler, TMP_REG2, src2w));
        !          1582:                                code = emit_x86_instruction(compiler, 1, TMP_REG2, 0, src1, 0);
        !          1583:                                FAIL_IF(!code);
        !          1584:                                *code = 0x85;
        !          1585:                        }
        !          1586: #else
        !          1587:                        code = emit_x86_instruction(compiler, 1, SLJIT_IMM, src2w, src1, 0);
        !          1588:                        FAIL_IF(!code);
        !          1589:                        *code = 0xf7;
        !          1590: #endif
        !          1591:                }
        !          1592:                else {
        !          1593:                        code = emit_x86_instruction(compiler, 1, src1, 0, src2, src2w);
        !          1594:                        FAIL_IF(!code);
        !          1595:                        *code = 0x85;
        !          1596:                }
        !          1597:                return SLJIT_SUCCESS;
        !          1598:        }
        !          1599: 
        !          1600:        if (src2 >= SLJIT_TEMPORARY_REG1 && src2 <= SLJIT_NO_REGISTERS) {
        !          1601:                if (src1 & SLJIT_IMM) {
        !          1602: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1603:                        if (IS_HALFWORD(src1w) || compiler->mode32) {
        !          1604:                                code = emit_x86_instruction(compiler, 1, SLJIT_IMM, src1w, src2, 0);
        !          1605:                                FAIL_IF(!code);
        !          1606:                                *code = 0xf7;
        !          1607:                        }
        !          1608:                        else {
        !          1609:                                FAIL_IF(emit_load_imm64(compiler, TMP_REG2, src1w));
        !          1610:                                code = emit_x86_instruction(compiler, 1, TMP_REG2, 0, src2, 0);
        !          1611:                                FAIL_IF(!code);
        !          1612:                                *code = 0x85;
        !          1613:                        }
        !          1614: #else
        !          1615:                        code = emit_x86_instruction(compiler, 1, src1, src1w, src2, 0);
        !          1616:                        FAIL_IF(!code);
        !          1617:                        *code = 0xf7;
        !          1618: #endif
        !          1619:                }
        !          1620:                else {
        !          1621:                        code = emit_x86_instruction(compiler, 1, src2, 0, src1, src1w);
        !          1622:                        FAIL_IF(!code);
        !          1623:                        *code = 0x85;
        !          1624:                }
        !          1625:                return SLJIT_SUCCESS;
        !          1626:        }
        !          1627: 
        !          1628:        EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1629:        if (src2 & SLJIT_IMM) {
        !          1630: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1631:                if (IS_HALFWORD(src2w) || compiler->mode32) {
        !          1632:                        code = emit_x86_instruction(compiler, 1, SLJIT_IMM, src2w, TMP_REGISTER, 0);
        !          1633:                        FAIL_IF(!code);
        !          1634:                        *code = 0xf7;
        !          1635:                }
        !          1636:                else {
        !          1637:                        FAIL_IF(emit_load_imm64(compiler, TMP_REG2, src2w));
        !          1638:                        code = emit_x86_instruction(compiler, 1, TMP_REG2, 0, TMP_REGISTER, 0);
        !          1639:                        FAIL_IF(!code);
        !          1640:                        *code = 0x85;
        !          1641:                }
        !          1642: #else
        !          1643:                code = emit_x86_instruction(compiler, 1, SLJIT_IMM, src2w, TMP_REGISTER, 0);
        !          1644:                FAIL_IF(!code);
        !          1645:                *code = 0xf7;
        !          1646: #endif
        !          1647:        }
        !          1648:        else {
        !          1649:                code = emit_x86_instruction(compiler, 1, TMP_REGISTER, 0, src2, src2w);
        !          1650:                FAIL_IF(!code);
        !          1651:                *code = 0x85;
        !          1652:        }
        !          1653:        return SLJIT_SUCCESS;
        !          1654: }
        !          1655: 
        !          1656: static int emit_shift(struct sljit_compiler *compiler,
        !          1657:        sljit_ub mode,
        !          1658:        int dst, sljit_w dstw,
        !          1659:        int src1, sljit_w src1w,
        !          1660:        int src2, sljit_w src2w)
        !          1661: {
        !          1662:        sljit_ub* code;
        !          1663: 
        !          1664:        if ((src2 & SLJIT_IMM) || (src2 == SLJIT_PREF_SHIFT_REG)) {
        !          1665:                if (dst == src1 && dstw == src1w) {
        !          1666:                        code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, dst, dstw);
        !          1667:                        FAIL_IF(!code);
        !          1668:                        *code |= mode;
        !          1669:                        return SLJIT_SUCCESS;
        !          1670:                }
        !          1671:                if (dst == SLJIT_UNUSED) {
        !          1672:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1673:                        code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, TMP_REGISTER, 0);
        !          1674:                        FAIL_IF(!code);
        !          1675:                        *code |= mode;
        !          1676:                        return SLJIT_SUCCESS;
        !          1677:                }
        !          1678:                if (dst == SLJIT_PREF_SHIFT_REG && src2 == SLJIT_PREF_SHIFT_REG) {
        !          1679:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1680:                        code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);
        !          1681:                        FAIL_IF(!code);
        !          1682:                        *code |= mode;
        !          1683:                        EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);
        !          1684:                        return SLJIT_SUCCESS;
        !          1685:                }
        !          1686:                if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) {
        !          1687:                        EMIT_MOV(compiler, dst, 0, src1, src1w);
        !          1688:                        code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, dst, 0);
        !          1689:                        FAIL_IF(!code);
        !          1690:                        *code |= mode;
        !          1691:                        return SLJIT_SUCCESS;
        !          1692:                }
        !          1693: 
        !          1694:                EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1695:                code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, src2, src2w, TMP_REGISTER, 0);
        !          1696:                FAIL_IF(!code);
        !          1697:                *code |= mode;
        !          1698:                EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
        !          1699:                return SLJIT_SUCCESS;
        !          1700:        }
        !          1701: 
        !          1702:        if (dst == SLJIT_PREF_SHIFT_REG) {
        !          1703:                EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1704:                EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);
        !          1705:                code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);
        !          1706:                FAIL_IF(!code);
        !          1707:                *code |= mode;
        !          1708:                EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);
        !          1709:        }
        !          1710:        else if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS && dst != src2 && !ADDRESSING_DEPENDS_ON(src2, dst)) {
        !          1711:                if (src1 != dst)
        !          1712:                        EMIT_MOV(compiler, dst, 0, src1, src1w);
        !          1713:                EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_PREF_SHIFT_REG, 0);
        !          1714:                EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);
        !          1715:                code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, dst, 0);
        !          1716:                FAIL_IF(!code);
        !          1717:                *code |= mode;
        !          1718:                EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);
        !          1719:        }
        !          1720:        else {
        !          1721:                /* This case is really difficult, since ecx can be used for
        !          1722:                   addressing as well, and we must ensure to work even in that case. */
        !          1723: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1724:                EMIT_MOV(compiler, TMP_REG2, 0, SLJIT_PREF_SHIFT_REG, 0);
        !          1725: #else
        !          1726:                /* [esp - 4] is reserved for eflags. */
        !          1727:                EMIT_MOV(compiler, SLJIT_MEM1(SLJIT_LOCALS_REG), -(int)(2 * sizeof(sljit_w)), SLJIT_PREF_SHIFT_REG, 0);
        !          1728: #endif
        !          1729: 
        !          1730:                EMIT_MOV(compiler, TMP_REGISTER, 0, src1, src1w);
        !          1731:                EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, src2, src2w);
        !          1732:                code = emit_x86_instruction(compiler, 1 | EX86_SHIFT_INS, SLJIT_PREF_SHIFT_REG, 0, TMP_REGISTER, 0);
        !          1733:                FAIL_IF(!code);
        !          1734:                *code |= mode;
        !          1735: 
        !          1736: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1737:                EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, TMP_REG2, 0);
        !          1738: #else
        !          1739:                /* [esp - 4] is reserved for eflags. */
        !          1740:                EMIT_MOV(compiler, SLJIT_PREF_SHIFT_REG, 0, SLJIT_MEM1(SLJIT_LOCALS_REG), -(int)(2 * sizeof(sljit_w)));
        !          1741: #endif
        !          1742:                EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
        !          1743:        }
        !          1744: 
        !          1745:        return SLJIT_SUCCESS;
        !          1746: }
        !          1747: 
        !          1748: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_op2(struct sljit_compiler *compiler, int op,
        !          1749:        int dst, sljit_w dstw,
        !          1750:        int src1, sljit_w src1w,
        !          1751:        int src2, sljit_w src2w)
        !          1752: {
        !          1753:        CHECK_ERROR();
        !          1754:        check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
        !          1755: 
        !          1756: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1757:        compiler->mode32 = op & SLJIT_INT_OP;
        !          1758: #endif
        !          1759:        CHECK_EXTRA_REGS(dst, dstw, (void)0);
        !          1760:        CHECK_EXTRA_REGS(src1, src1w, (void)0);
        !          1761:        CHECK_EXTRA_REGS(src2, src2w, (void)0);
        !          1762: 
        !          1763:        if (GET_OPCODE(op) >= SLJIT_MUL) {
        !          1764:                if (SLJIT_UNLIKELY(GET_FLAGS(op)))
        !          1765:                        compiler->flags_saved = 0;
        !          1766:                else if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)
        !          1767:                        FAIL_IF(emit_save_flags(compiler));
        !          1768:        }
        !          1769: 
        !          1770:        switch (GET_OPCODE(op)) {
        !          1771:        case SLJIT_ADD:
        !          1772:                if (!GET_FLAGS(op)) {
        !          1773:                        if (emit_lea_binary(compiler, dst, dstw, src1, src1w, src2, src2w) != SLJIT_ERR_UNSUPPORTED)
        !          1774:                                return compiler->error;
        !          1775:                } 
        !          1776:                else
        !          1777:                        compiler->flags_saved = 0;
        !          1778:                if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)
        !          1779:                        FAIL_IF(emit_save_flags(compiler));
        !          1780:                return emit_cum_binary(compiler, 0x03, 0x01, 0x0 << 3, 0x05,
        !          1781:                        dst, dstw, src1, src1w, src2, src2w);
        !          1782:        case SLJIT_ADDC:
        !          1783:                if (SLJIT_UNLIKELY(compiler->flags_saved)) /* C flag must be restored. */
        !          1784:                        FAIL_IF(emit_restore_flags(compiler, 1));
        !          1785:                else if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS))
        !          1786:                        FAIL_IF(emit_save_flags(compiler));
        !          1787:                if (SLJIT_UNLIKELY(GET_FLAGS(op)))
        !          1788:                        compiler->flags_saved = 0;
        !          1789:                return emit_cum_binary(compiler, 0x13, 0x11, 0x2 << 3, 0x15,
        !          1790:                        dst, dstw, src1, src1w, src2, src2w);
        !          1791:        case SLJIT_SUB:
        !          1792:                if (!GET_FLAGS(op)) {
        !          1793:                        if ((src2 & SLJIT_IMM) && emit_lea_binary(compiler, dst, dstw, src1, src1w, SLJIT_IMM, -src2w) != SLJIT_ERR_UNSUPPORTED)
        !          1794:                                return compiler->error;
        !          1795:                }
        !          1796:                else
        !          1797:                        compiler->flags_saved = 0;
        !          1798:                if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS) && !compiler->flags_saved)
        !          1799:                        FAIL_IF(emit_save_flags(compiler));
        !          1800:                if (dst == SLJIT_UNUSED)
        !          1801:                        return emit_cmp_binary(compiler, src1, src1w, src2, src2w);
        !          1802:                return emit_non_cum_binary(compiler, 0x2b, 0x29, 0x5 << 3, 0x2d,
        !          1803:                        dst, dstw, src1, src1w, src2, src2w);
        !          1804:        case SLJIT_SUBC:
        !          1805:                if (SLJIT_UNLIKELY(compiler->flags_saved)) /* C flag must be restored. */
        !          1806:                        FAIL_IF(emit_restore_flags(compiler, 1));
        !          1807:                else if (SLJIT_UNLIKELY(op & SLJIT_KEEP_FLAGS))
        !          1808:                        FAIL_IF(emit_save_flags(compiler));
        !          1809:                if (SLJIT_UNLIKELY(GET_FLAGS(op)))
        !          1810:                        compiler->flags_saved = 0;
        !          1811:                return emit_non_cum_binary(compiler, 0x1b, 0x19, 0x3 << 3, 0x1d,
        !          1812:                        dst, dstw, src1, src1w, src2, src2w);
        !          1813:        case SLJIT_MUL:
        !          1814:                return emit_mul(compiler, dst, dstw, src1, src1w, src2, src2w);
        !          1815:        case SLJIT_AND:
        !          1816:                if (dst == SLJIT_UNUSED)
        !          1817:                        return emit_test_binary(compiler, src1, src1w, src2, src2w);
        !          1818:                return emit_cum_binary(compiler, 0x23, 0x21, 0x4 << 3, 0x25,
        !          1819:                        dst, dstw, src1, src1w, src2, src2w);
        !          1820:        case SLJIT_OR:
        !          1821:                return emit_cum_binary(compiler, 0x0b, 0x09, 0x1 << 3, 0x0d,
        !          1822:                        dst, dstw, src1, src1w, src2, src2w);
        !          1823:        case SLJIT_XOR:
        !          1824:                return emit_cum_binary(compiler, 0x33, 0x31, 0x6 << 3, 0x35,
        !          1825:                        dst, dstw, src1, src1w, src2, src2w);
        !          1826:        case SLJIT_SHL:
        !          1827:                return emit_shift(compiler, 0x4 << 3,
        !          1828:                        dst, dstw, src1, src1w, src2, src2w);
        !          1829:        case SLJIT_LSHR:
        !          1830:                return emit_shift(compiler, 0x5 << 3,
        !          1831:                        dst, dstw, src1, src1w, src2, src2w);
        !          1832:        case SLJIT_ASHR:
        !          1833:                return emit_shift(compiler, 0x7 << 3,
        !          1834:                        dst, dstw, src1, src1w, src2, src2w);
        !          1835:        }
        !          1836: 
        !          1837:        return SLJIT_SUCCESS;
        !          1838: }
        !          1839: 
        !          1840: /* --------------------------------------------------------------------- */
        !          1841: /*  Floating point operators                                             */
        !          1842: /* --------------------------------------------------------------------- */
        !          1843: 
        !          1844: #if (defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO)
        !          1845: static int sse2_available = 0;
        !          1846: #endif
        !          1847: 
        !          1848: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
        !          1849: 
        !          1850: /* Alignment + 2 * 16 bytes. */
        !          1851: static sljit_i sse2_data[3 + 4 + 4];
        !          1852: static sljit_i *sse2_buffer;
        !          1853: 
        !          1854: static void init_compiler()
        !          1855: {
        !          1856: #if (defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO)
        !          1857:        int features = 0;
        !          1858: #endif
        !          1859: 
        !          1860:        sse2_buffer = (sljit_i*)(((sljit_uw)sse2_data + 15) & ~0xf);
        !          1861:        sse2_buffer[0] = 0;
        !          1862:        sse2_buffer[1] = 0x80000000;
        !          1863:        sse2_buffer[4] = 0xffffffff;
        !          1864:        sse2_buffer[5] = 0x7fffffff;
        !          1865: 
        !          1866: #if (defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO)
        !          1867: #ifdef __GNUC__
        !          1868:        /* AT&T syntax. */
        !          1869:        asm (
        !          1870:                "pushl %%ebx\n"
        !          1871:                "movl $0x1, %%eax\n"
        !          1872:                "cpuid\n"
        !          1873:                "popl %%ebx\n"
        !          1874:                "movl %%edx, %0\n"
        !          1875:                : "=g" (features)
        !          1876:                :
        !          1877:                : "%eax", "%ecx", "%edx"
        !          1878:        );
        !          1879: #elif defined(_MSC_VER) || defined(__BORLANDC__)
        !          1880:        /* Intel syntax. */
        !          1881:        __asm {
        !          1882:                mov eax, 1
        !          1883:                push ebx
        !          1884:                cpuid
        !          1885:                pop ebx
        !          1886:                mov features, edx
        !          1887:        }
        !          1888: #else
        !          1889:        #error "SLJIT_SSE2_AUTO is not implemented for this C compiler"
        !          1890: #endif
        !          1891:        sse2_available = (features >> 26) & 0x1;
        !          1892: #endif
        !          1893: }
        !          1894: 
        !          1895: #endif
        !          1896: 
        !          1897: SLJIT_API_FUNC_ATTRIBUTE int sljit_is_fpu_available(void)
        !          1898: {
        !          1899:        /* Always available. */
        !          1900:        return 1;
        !          1901: }
        !          1902: 
        !          1903: #if (defined SLJIT_SSE2 && SLJIT_SSE2)
        !          1904: 
        !          1905: static int emit_sse2(struct sljit_compiler *compiler, sljit_ub opcode,
        !          1906:        int xmm1, int xmm2, sljit_w xmm2w)
        !          1907: {
        !          1908:        sljit_ub *buf;
        !          1909: 
        !          1910:        buf = emit_x86_instruction(compiler, 2 | EX86_PREF_F2 | EX86_SSE2, xmm1, 0, xmm2, xmm2w);
        !          1911:        FAIL_IF(!buf);
        !          1912:        *buf++ = 0x0f;
        !          1913:        *buf = opcode;
        !          1914:        return SLJIT_SUCCESS;
        !          1915: }
        !          1916: 
        !          1917: static int emit_sse2_logic(struct sljit_compiler *compiler, sljit_ub opcode,
        !          1918:        int xmm1, int xmm2, sljit_w xmm2w)
        !          1919: {
        !          1920:        sljit_ub *buf;
        !          1921: 
        !          1922:        buf = emit_x86_instruction(compiler, 2 | EX86_PREF_66 | EX86_SSE2, xmm1, 0, xmm2, xmm2w);
        !          1923:        FAIL_IF(!buf);
        !          1924:        *buf++ = 0x0f;
        !          1925:        *buf = opcode;
        !          1926:        return SLJIT_SUCCESS;
        !          1927: }
        !          1928: 
        !          1929: static SLJIT_INLINE int emit_sse2_load(struct sljit_compiler *compiler,
        !          1930:        int dst, int src, sljit_w srcw)
        !          1931: {
        !          1932:        return emit_sse2(compiler, 0x10, dst, src, srcw);
        !          1933: }
        !          1934: 
        !          1935: static SLJIT_INLINE int emit_sse2_store(struct sljit_compiler *compiler,
        !          1936:        int dst, sljit_w dstw, int src)
        !          1937: {
        !          1938:        return emit_sse2(compiler, 0x11, src, dst, dstw);
        !          1939: }
        !          1940: 
        !          1941: #if !(defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO)
        !          1942: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,
        !          1943: #else
        !          1944: static int sljit_emit_sse2_fop1(struct sljit_compiler *compiler, int op,
        !          1945: #endif
        !          1946:        int dst, sljit_w dstw,
        !          1947:        int src, sljit_w srcw)
        !          1948: {
        !          1949:        int dst_r;
        !          1950: 
        !          1951:        CHECK_ERROR();
        !          1952:        check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);
        !          1953: 
        !          1954: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          1955:        compiler->mode32 = 1;
        !          1956: #endif
        !          1957: 
        !          1958:        if (GET_OPCODE(op) == SLJIT_FCMP) {
        !          1959:                compiler->flags_saved = 0;
        !          1960:                if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4)
        !          1961:                        dst_r = dst;
        !          1962:                else {
        !          1963:                        dst_r = TMP_FREG;
        !          1964:                        FAIL_IF(emit_sse2_load(compiler, dst_r, dst, dstw));
        !          1965:                }
        !          1966:                return emit_sse2_logic(compiler, 0x2e, dst_r, src, srcw);
        !          1967:        }
        !          1968: 
        !          1969:        if (op == SLJIT_FMOV) {
        !          1970:                if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4)
        !          1971:                        return emit_sse2_load(compiler, dst, src, srcw);
        !          1972:                if (src >= SLJIT_FLOAT_REG1 && src <= SLJIT_FLOAT_REG4)
        !          1973:                        return emit_sse2_store(compiler, dst, dstw, src);
        !          1974:                FAIL_IF(emit_sse2_load(compiler, TMP_FREG, src, srcw));
        !          1975:                return emit_sse2_store(compiler, dst, dstw, TMP_FREG);
        !          1976:        }
        !          1977: 
        !          1978:        if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4) {
        !          1979:                dst_r = dst;
        !          1980:                if (dst != src)
        !          1981:                        FAIL_IF(emit_sse2_load(compiler, dst_r, src, srcw));
        !          1982:        }
        !          1983:        else {
        !          1984:                dst_r = TMP_FREG;
        !          1985:                FAIL_IF(emit_sse2_load(compiler, dst_r, src, srcw));
        !          1986:        }
        !          1987: 
        !          1988:        switch (op) {
        !          1989:        case SLJIT_FNEG:
        !          1990:                FAIL_IF(emit_sse2_logic(compiler, 0x57, dst_r, SLJIT_MEM0(), (sljit_w)sse2_buffer));
        !          1991:                break;
        !          1992: 
        !          1993:        case SLJIT_FABS:
        !          1994:                FAIL_IF(emit_sse2_logic(compiler, 0x54, dst_r, SLJIT_MEM0(), (sljit_w)(sse2_buffer + 4)));
        !          1995:                break;
        !          1996:        }
        !          1997: 
        !          1998:        if (dst_r == TMP_FREG)
        !          1999:                return emit_sse2_store(compiler, dst, dstw, TMP_FREG);
        !          2000:        return SLJIT_SUCCESS;
        !          2001: }
        !          2002: 
        !          2003: #if !(defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO)
        !          2004: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,
        !          2005: #else
        !          2006: static int sljit_emit_sse2_fop2(struct sljit_compiler *compiler, int op,
        !          2007: #endif
        !          2008:        int dst, sljit_w dstw,
        !          2009:        int src1, sljit_w src1w,
        !          2010:        int src2, sljit_w src2w)
        !          2011: {
        !          2012:        int dst_r;
        !          2013: 
        !          2014:        CHECK_ERROR();
        !          2015:        check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
        !          2016: 
        !          2017: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2018:        compiler->mode32 = 1;
        !          2019: #endif
        !          2020: 
        !          2021:        if (dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4) {
        !          2022:                dst_r = dst;
        !          2023:                if (dst == src1)
        !          2024:                        ; /* Do nothing here. */
        !          2025:                else if (dst == src2 && (op == SLJIT_FADD || op == SLJIT_FMUL)) {
        !          2026:                        /* Swap arguments. */
        !          2027:                        src2 = src1;
        !          2028:                        src2w = src1w;
        !          2029:                }
        !          2030:                else if (dst != src2)
        !          2031:                        FAIL_IF(emit_sse2_load(compiler, dst_r, src1, src1w));
        !          2032:                else {
        !          2033:                        dst_r = TMP_FREG;
        !          2034:                        FAIL_IF(emit_sse2_load(compiler, TMP_FREG, src1, src1w));
        !          2035:                }
        !          2036:        }
        !          2037:        else {
        !          2038:                dst_r = TMP_FREG;
        !          2039:                FAIL_IF(emit_sse2_load(compiler, TMP_FREG, src1, src1w));
        !          2040:        }
        !          2041: 
        !          2042:        switch (op) {
        !          2043:        case SLJIT_FADD:
        !          2044:                FAIL_IF(emit_sse2(compiler, 0x58, dst_r, src2, src2w));
        !          2045:                break;
        !          2046: 
        !          2047:        case SLJIT_FSUB:
        !          2048:                FAIL_IF(emit_sse2(compiler, 0x5c, dst_r, src2, src2w));
        !          2049:                break;
        !          2050: 
        !          2051:        case SLJIT_FMUL:
        !          2052:                FAIL_IF(emit_sse2(compiler, 0x59, dst_r, src2, src2w));
        !          2053:                break;
        !          2054: 
        !          2055:        case SLJIT_FDIV:
        !          2056:                FAIL_IF(emit_sse2(compiler, 0x5e, dst_r, src2, src2w));
        !          2057:                break;
        !          2058:        }
        !          2059: 
        !          2060:        if (dst_r == TMP_FREG)
        !          2061:                return emit_sse2_store(compiler, dst, dstw, TMP_FREG);
        !          2062:        return SLJIT_SUCCESS;
        !          2063: }
        !          2064: 
        !          2065: #endif
        !          2066: 
        !          2067: #if (defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO) || !(defined SLJIT_SSE2 && SLJIT_SSE2)
        !          2068: 
        !          2069: static int emit_fld(struct sljit_compiler *compiler,
        !          2070:        int src, sljit_w srcw)
        !          2071: {
        !          2072:        sljit_ub *buf;
        !          2073: 
        !          2074:        if (src >= SLJIT_FLOAT_REG1 && src <= SLJIT_FLOAT_REG4) {
        !          2075:                buf = (sljit_ub*)ensure_buf(compiler, 1 + 2);
        !          2076:                FAIL_IF(!buf);
        !          2077:                INC_SIZE(2);
        !          2078:                *buf++ = 0xd9;
        !          2079:                *buf = 0xc0 + src - 1;
        !          2080:                return SLJIT_SUCCESS;
        !          2081:        }
        !          2082: 
        !          2083:        buf = emit_x86_instruction(compiler, 1, 0, 0, src, srcw);
        !          2084:        FAIL_IF(!buf);
        !          2085:        *buf = 0xdd;
        !          2086:        return SLJIT_SUCCESS;
        !          2087: }
        !          2088: 
        !          2089: static int emit_fop(struct sljit_compiler *compiler,
        !          2090:        sljit_ub st_arg, sljit_ub st_arg2,
        !          2091:        sljit_ub m64fp_arg, sljit_ub m64fp_arg2,
        !          2092:        int src, sljit_w srcw)
        !          2093: {
        !          2094:        sljit_ub *buf;
        !          2095: 
        !          2096:        if (src >= SLJIT_FLOAT_REG1 && src <= SLJIT_FLOAT_REG4) {
        !          2097:                buf = (sljit_ub*)ensure_buf(compiler, 1 + 2);
        !          2098:                FAIL_IF(!buf);
        !          2099:                INC_SIZE(2);
        !          2100:                *buf++ = st_arg;
        !          2101:                *buf = st_arg2 + src;
        !          2102:                return SLJIT_SUCCESS;
        !          2103:        }
        !          2104: 
        !          2105:        buf = emit_x86_instruction(compiler, 1, 0, 0, src, srcw);
        !          2106:        FAIL_IF(!buf);
        !          2107:        *buf++ = m64fp_arg;
        !          2108:        *buf |= m64fp_arg2;
        !          2109:        return SLJIT_SUCCESS;
        !          2110: }
        !          2111: 
        !          2112: static int emit_fop_regs(struct sljit_compiler *compiler,
        !          2113:        sljit_ub st_arg, sljit_ub st_arg2,
        !          2114:        int src)
        !          2115: {
        !          2116:        sljit_ub *buf;
        !          2117: 
        !          2118:        buf = (sljit_ub*)ensure_buf(compiler, 1 + 2);
        !          2119:        FAIL_IF(!buf);
        !          2120:        INC_SIZE(2);
        !          2121:        *buf++ = st_arg;
        !          2122:        *buf = st_arg2 + src;
        !          2123:        return SLJIT_SUCCESS;
        !          2124: }
        !          2125: 
        !          2126: #if !(defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO)
        !          2127: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,
        !          2128: #else
        !          2129: static int sljit_emit_fpu_fop1(struct sljit_compiler *compiler, int op,
        !          2130: #endif
        !          2131:        int dst, sljit_w dstw,
        !          2132:        int src, sljit_w srcw)
        !          2133: {
        !          2134: #if !(defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2135:        sljit_ub *buf;
        !          2136: #endif
        !          2137: 
        !          2138:        CHECK_ERROR();
        !          2139:        check_sljit_emit_fop1(compiler, op, dst, dstw, src, srcw);
        !          2140: 
        !          2141: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2142:        compiler->mode32 = 1;
        !          2143: #endif
        !          2144: 
        !          2145:        if (GET_OPCODE(op) == SLJIT_FCMP) {
        !          2146:                compiler->flags_saved = 0;
        !          2147: #if !(defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2148:                FAIL_IF(emit_fld(compiler, dst, dstw));
        !          2149:                FAIL_IF(emit_fop(compiler, 0xd8, 0xd8, 0xdc, 0x3 << 3, src, srcw));
        !          2150: 
        !          2151:                /* Copy flags. */
        !          2152:                EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_TEMPORARY_REG1, 0);
        !          2153:                buf = (sljit_ub*)ensure_buf(compiler, 1 + 3);
        !          2154:                FAIL_IF(!buf);
        !          2155:                INC_SIZE(3);
        !          2156:                *buf++ = 0xdf;
        !          2157:                *buf++ = 0xe0;
        !          2158:                /* Note: lahf is not supported on all x86-64 architectures. */
        !          2159:                *buf++ = 0x9e;
        !          2160:                EMIT_MOV(compiler, SLJIT_TEMPORARY_REG1, 0, TMP_REGISTER, 0);
        !          2161: #else
        !          2162:                if (src >= SLJIT_FLOAT_REG1 && src <= SLJIT_FLOAT_REG4) {
        !          2163:                        FAIL_IF(emit_fld(compiler, dst, dstw));
        !          2164:                        FAIL_IF(emit_fop_regs(compiler, 0xdf, 0xe8, src));
        !          2165:                } else {
        !          2166:                        FAIL_IF(emit_fld(compiler, src, srcw));
        !          2167:                        FAIL_IF(emit_fld(compiler, dst + ((dst >= SLJIT_FLOAT_REG1 && dst <= SLJIT_FLOAT_REG4) ? 1 : 0), dstw));
        !          2168:                        FAIL_IF(emit_fop_regs(compiler, 0xdf, 0xe8, src));
        !          2169:                        FAIL_IF(emit_fop_regs(compiler, 0xdd, 0xd8, 0));
        !          2170:                }
        !          2171: #endif
        !          2172:                return SLJIT_SUCCESS;
        !          2173:        }
        !          2174: 
        !          2175:        FAIL_IF(emit_fld(compiler, src, srcw));
        !          2176: 
        !          2177:        switch (op) {
        !          2178:        case SLJIT_FNEG:
        !          2179:                FAIL_IF(emit_fop_regs(compiler, 0xd9, 0xe0, 0));
        !          2180:                break;
        !          2181:        case SLJIT_FABS:
        !          2182:                FAIL_IF(emit_fop_regs(compiler, 0xd9, 0xe1, 0));
        !          2183:                break;
        !          2184:        }
        !          2185: 
        !          2186:        FAIL_IF(emit_fop(compiler, 0xdd, 0xd8, 0xdd, 0x3 << 3, dst, dstw));
        !          2187: 
        !          2188:        return SLJIT_SUCCESS;
        !          2189: }
        !          2190: 
        !          2191: #if !(defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO)
        !          2192: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,
        !          2193: #else
        !          2194: static int sljit_emit_fpu_fop2(struct sljit_compiler *compiler, int op,
        !          2195: #endif
        !          2196:        int dst, sljit_w dstw,
        !          2197:        int src1, sljit_w src1w,
        !          2198:        int src2, sljit_w src2w)
        !          2199: {
        !          2200:        CHECK_ERROR();
        !          2201:        check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
        !          2202: 
        !          2203: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2204:        compiler->mode32 = 1;
        !          2205: #endif
        !          2206: 
        !          2207:        if (src1 >= SLJIT_FLOAT_REG1 && src1 <= SLJIT_FLOAT_REG4 && dst == src1) {
        !          2208:                FAIL_IF(emit_fld(compiler, src2, src2w));
        !          2209: 
        !          2210:                switch (op) {
        !          2211:                case SLJIT_FADD:
        !          2212:                        FAIL_IF(emit_fop_regs(compiler, 0xde, 0xc0, src1));
        !          2213:                        break;
        !          2214:                case SLJIT_FSUB:
        !          2215:                        FAIL_IF(emit_fop_regs(compiler, 0xde, 0xe8, src1));
        !          2216:                        break;
        !          2217:                case SLJIT_FMUL:
        !          2218:                        FAIL_IF(emit_fop_regs(compiler, 0xde, 0xc8, src1));
        !          2219:                        break;
        !          2220:                case SLJIT_FDIV:
        !          2221:                        FAIL_IF(emit_fop_regs(compiler, 0xde, 0xf8, src1));
        !          2222:                        break;
        !          2223:                }
        !          2224:                return SLJIT_SUCCESS;
        !          2225:        }
        !          2226: 
        !          2227:        FAIL_IF(emit_fld(compiler, src1, src1w));
        !          2228: 
        !          2229:        if (src2 >= SLJIT_FLOAT_REG1 && src2 <= SLJIT_FLOAT_REG4 && dst == src2) {
        !          2230:                switch (op) {
        !          2231:                case SLJIT_FADD:
        !          2232:                        FAIL_IF(emit_fop_regs(compiler, 0xde, 0xc0, src2));
        !          2233:                        break;
        !          2234:                case SLJIT_FSUB:
        !          2235:                        FAIL_IF(emit_fop_regs(compiler, 0xde, 0xe0, src2));
        !          2236:                        break;
        !          2237:                case SLJIT_FMUL:
        !          2238:                        FAIL_IF(emit_fop_regs(compiler, 0xde, 0xc8, src2));
        !          2239:                        break;
        !          2240:                case SLJIT_FDIV:
        !          2241:                        FAIL_IF(emit_fop_regs(compiler, 0xde, 0xf0, src2));
        !          2242:                        break;
        !          2243:                }
        !          2244:                return SLJIT_SUCCESS;
        !          2245:        }
        !          2246: 
        !          2247:        switch (op) {
        !          2248:        case SLJIT_FADD:
        !          2249:                FAIL_IF(emit_fop(compiler, 0xd8, 0xc0, 0xdc, 0x0 << 3, src2, src2w));
        !          2250:                break;
        !          2251:        case SLJIT_FSUB:
        !          2252:                FAIL_IF(emit_fop(compiler, 0xd8, 0xe0, 0xdc, 0x4 << 3, src2, src2w));
        !          2253:                break;
        !          2254:        case SLJIT_FMUL:
        !          2255:                FAIL_IF(emit_fop(compiler, 0xd8, 0xc8, 0xdc, 0x1 << 3, src2, src2w));
        !          2256:                break;
        !          2257:        case SLJIT_FDIV:
        !          2258:                FAIL_IF(emit_fop(compiler, 0xd8, 0xf0, 0xdc, 0x6 << 3, src2, src2w));
        !          2259:                break;
        !          2260:        }
        !          2261: 
        !          2262:        FAIL_IF(emit_fop(compiler, 0xdd, 0xd8, 0xdd, 0x3 << 3, dst, dstw));
        !          2263: 
        !          2264:        return SLJIT_SUCCESS;
        !          2265: }
        !          2266: #endif
        !          2267: 
        !          2268: #if (defined SLJIT_SSE2_AUTO && SLJIT_SSE2_AUTO)
        !          2269: 
        !          2270: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop1(struct sljit_compiler *compiler, int op,
        !          2271:        int dst, sljit_w dstw,
        !          2272:        int src, sljit_w srcw)
        !          2273: {
        !          2274:        if (sse2_available)
        !          2275:                return sljit_emit_sse2_fop1(compiler, op, dst, dstw, src, srcw);
        !          2276:        else
        !          2277:                return sljit_emit_fpu_fop1(compiler, op, dst, dstw, src, srcw);
        !          2278: }
        !          2279: 
        !          2280: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_fop2(struct sljit_compiler *compiler, int op,
        !          2281:        int dst, sljit_w dstw,
        !          2282:        int src1, sljit_w src1w,
        !          2283:        int src2, sljit_w src2w)
        !          2284: {
        !          2285:        if (sse2_available)
        !          2286:                return sljit_emit_sse2_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
        !          2287:        else
        !          2288:                return sljit_emit_fpu_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w);
        !          2289: }
        !          2290: 
        !          2291: #endif
        !          2292: 
        !          2293: /* --------------------------------------------------------------------- */
        !          2294: /*  Conditional instructions                                             */
        !          2295: /* --------------------------------------------------------------------- */
        !          2296: 
        !          2297: SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
        !          2298: {
        !          2299:        sljit_ub *buf;
        !          2300:        struct sljit_label *label;
        !          2301: 
        !          2302:        CHECK_ERROR_PTR();
        !          2303:        check_sljit_emit_label(compiler);
        !          2304: 
        !          2305:        /* We should restore the flags before the label,
        !          2306:           since other taken jumps has their own flags as well. */
        !          2307:        if (SLJIT_UNLIKELY(compiler->flags_saved))
        !          2308:                PTR_FAIL_IF(emit_restore_flags(compiler, 0));
        !          2309: 
        !          2310:        if (compiler->last_label && compiler->last_label->size == compiler->size)
        !          2311:                return compiler->last_label;
        !          2312: 
        !          2313:        label = (struct sljit_label*)ensure_abuf(compiler, sizeof(struct sljit_label));
        !          2314:        PTR_FAIL_IF(!label);
        !          2315:        set_label(label, compiler);
        !          2316: 
        !          2317:        buf = (sljit_ub*)ensure_buf(compiler, 2);
        !          2318:        PTR_FAIL_IF(!buf);
        !          2319: 
        !          2320:        *buf++ = 0;
        !          2321:        *buf++ = 0;
        !          2322: 
        !          2323:        return label;
        !          2324: }
        !          2325: 
        !          2326: SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, int type)
        !          2327: {
        !          2328:        sljit_ub *buf;
        !          2329:        struct sljit_jump *jump;
        !          2330: 
        !          2331:        CHECK_ERROR_PTR();
        !          2332:        check_sljit_emit_jump(compiler, type);
        !          2333: 
        !          2334:        if (SLJIT_UNLIKELY(compiler->flags_saved)) {
        !          2335:                if ((type & 0xff) <= SLJIT_JUMP)
        !          2336:                        PTR_FAIL_IF(emit_restore_flags(compiler, 0));
        !          2337:                compiler->flags_saved = 0;
        !          2338:        }
        !          2339: 
        !          2340:        jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
        !          2341:        PTR_FAIL_IF_NULL(jump);
        !          2342:        set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
        !          2343:        type &= 0xff;
        !          2344: 
        !          2345:        if (type >= SLJIT_CALL1)
        !          2346:                PTR_FAIL_IF(call_with_args(compiler, type));
        !          2347: 
        !          2348:        /* Worst case size. */
        !          2349: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          2350:        compiler->size += (type >= SLJIT_JUMP) ? 5 : 6;
        !          2351: #else
        !          2352:        compiler->size += (type >= SLJIT_JUMP) ? (10 + 3) : (2 + 10 + 3);
        !          2353: #endif
        !          2354: 
        !          2355:        buf = (sljit_ub*)ensure_buf(compiler, 2);
        !          2356:        PTR_FAIL_IF_NULL(buf);
        !          2357: 
        !          2358:        *buf++ = 0;
        !          2359:        *buf++ = type + 4;
        !          2360:        return jump;
        !          2361: }
        !          2362: 
        !          2363: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_ijump(struct sljit_compiler *compiler, int type, int src, sljit_w srcw)
        !          2364: {
        !          2365:        sljit_ub *code;
        !          2366:        struct sljit_jump *jump;
        !          2367: 
        !          2368:        CHECK_ERROR();
        !          2369:        check_sljit_emit_ijump(compiler, type, src, srcw);
        !          2370: 
        !          2371:        CHECK_EXTRA_REGS(src, srcw, (void)0);
        !          2372:        if (SLJIT_UNLIKELY(compiler->flags_saved)) {
        !          2373:                if (type <= SLJIT_JUMP)
        !          2374:                        FAIL_IF(emit_restore_flags(compiler, 0));
        !          2375:                compiler->flags_saved = 0;
        !          2376:        }
        !          2377: 
        !          2378:        if (type >= SLJIT_CALL1) {
        !          2379: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          2380: #if (defined SLJIT_X86_32_FASTCALL && SLJIT_X86_32_FASTCALL)
        !          2381:                if (src == SLJIT_TEMPORARY_REG3) {
        !          2382:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src, 0);
        !          2383:                        src = TMP_REGISTER;
        !          2384:                }
        !          2385:                if ((src & SLJIT_MEM) && (src & 0xf) == SLJIT_LOCALS_REG && type >= SLJIT_CALL3) {
        !          2386:                        if (src & 0xf0) {
        !          2387:                                EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
        !          2388:                                src = TMP_REGISTER;
        !          2389:                        }
        !          2390:                        else
        !          2391:                                srcw += sizeof(sljit_w);
        !          2392:                }
        !          2393: #else
        !          2394:                if ((src & SLJIT_MEM) && (src & 0xf) == SLJIT_LOCALS_REG) {
        !          2395:                        if (src & 0xf0) {
        !          2396:                                EMIT_MOV(compiler, TMP_REGISTER, 0, src, srcw);
        !          2397:                                src = TMP_REGISTER;
        !          2398:                        }
        !          2399:                        else
        !          2400:                                srcw += sizeof(sljit_w) * (type - SLJIT_CALL0);
        !          2401:                }
        !          2402: #endif
        !          2403: #endif
        !          2404: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64) && defined(_WIN64)
        !          2405:                if (src == SLJIT_TEMPORARY_REG3) {
        !          2406:                        EMIT_MOV(compiler, TMP_REGISTER, 0, src, 0);
        !          2407:                        src = TMP_REGISTER;
        !          2408:                }
        !          2409: #endif
        !          2410:                FAIL_IF(call_with_args(compiler, type));
        !          2411:        }
        !          2412: 
        !          2413:        if (src == SLJIT_IMM) {
        !          2414:                jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
        !          2415:                FAIL_IF_NULL(jump);
        !          2416:                set_jump(jump, compiler, JUMP_ADDR);
        !          2417:                jump->u.target = srcw;
        !          2418: 
        !          2419:                /* Worst case size. */
        !          2420: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          2421:                compiler->size += 5;
        !          2422: #else
        !          2423:                compiler->size += 10 + 3;
        !          2424: #endif
        !          2425: 
        !          2426:                code = (sljit_ub*)ensure_buf(compiler, 2);
        !          2427:                FAIL_IF_NULL(code);
        !          2428: 
        !          2429:                *code++ = 0;
        !          2430:                *code++ = type + 4;
        !          2431:        }
        !          2432:        else {
        !          2433: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2434:                /* REX_W is not necessary (src is not immediate). */
        !          2435:                compiler->mode32 = 1;
        !          2436: #endif
        !          2437:                code = emit_x86_instruction(compiler, 1, 0, 0, src, srcw);
        !          2438:                FAIL_IF(!code);
        !          2439:                *code++ = 0xff;
        !          2440:                *code |= (type >= SLJIT_FAST_CALL) ? (2 << 3) : (4 << 3);
        !          2441:        }
        !          2442:        return SLJIT_SUCCESS;
        !          2443: }
        !          2444: 
        !          2445: SLJIT_API_FUNC_ATTRIBUTE int sljit_emit_cond_value(struct sljit_compiler *compiler, int op, int dst, sljit_w dstw, int type)
        !          2446: {
        !          2447:        sljit_ub *buf;
        !          2448:        sljit_ub cond_set = 0;
        !          2449: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2450:        int reg;
        !          2451: #endif
        !          2452: 
        !          2453:        CHECK_ERROR();
        !          2454:        check_sljit_emit_cond_value(compiler, op, dst, dstw, type);
        !          2455: 
        !          2456:        if (dst == SLJIT_UNUSED)
        !          2457:                return SLJIT_SUCCESS;
        !          2458: 
        !          2459:        CHECK_EXTRA_REGS(dst, dstw, (void)0);
        !          2460:        if (SLJIT_UNLIKELY(compiler->flags_saved))
        !          2461:                FAIL_IF(emit_restore_flags(compiler, 0));
        !          2462: 
        !          2463:        switch (type) {
        !          2464:        case SLJIT_C_EQUAL:
        !          2465:        case SLJIT_C_FLOAT_EQUAL:
        !          2466:                cond_set = 0x94;
        !          2467:                break;
        !          2468: 
        !          2469:        case SLJIT_C_NOT_EQUAL:
        !          2470:        case SLJIT_C_FLOAT_NOT_EQUAL:
        !          2471:                cond_set = 0x95;
        !          2472:                break;
        !          2473: 
        !          2474:        case SLJIT_C_LESS:
        !          2475:        case SLJIT_C_FLOAT_LESS:
        !          2476:                cond_set = 0x92;
        !          2477:                break;
        !          2478: 
        !          2479:        case SLJIT_C_GREATER_EQUAL:
        !          2480:        case SLJIT_C_FLOAT_GREATER_EQUAL:
        !          2481:                cond_set = 0x93;
        !          2482:                break;
        !          2483: 
        !          2484:        case SLJIT_C_GREATER:
        !          2485:        case SLJIT_C_FLOAT_GREATER:
        !          2486:                cond_set = 0x97;
        !          2487:                break;
        !          2488: 
        !          2489:        case SLJIT_C_LESS_EQUAL:
        !          2490:        case SLJIT_C_FLOAT_LESS_EQUAL:
        !          2491:                cond_set = 0x96;
        !          2492:                break;
        !          2493: 
        !          2494:        case SLJIT_C_SIG_LESS:
        !          2495:                cond_set = 0x9c;
        !          2496:                break;
        !          2497: 
        !          2498:        case SLJIT_C_SIG_GREATER_EQUAL:
        !          2499:                cond_set = 0x9d;
        !          2500:                break;
        !          2501: 
        !          2502:        case SLJIT_C_SIG_GREATER:
        !          2503:                cond_set = 0x9f;
        !          2504:                break;
        !          2505: 
        !          2506:        case SLJIT_C_SIG_LESS_EQUAL:
        !          2507:                cond_set = 0x9e;
        !          2508:                break;
        !          2509: 
        !          2510:        case SLJIT_C_OVERFLOW:
        !          2511:        case SLJIT_C_MUL_OVERFLOW:
        !          2512:                cond_set = 0x90;
        !          2513:                break;
        !          2514: 
        !          2515:        case SLJIT_C_NOT_OVERFLOW:
        !          2516:        case SLJIT_C_MUL_NOT_OVERFLOW:
        !          2517:                cond_set = 0x91;
        !          2518:                break;
        !          2519: 
        !          2520:        case SLJIT_C_FLOAT_NAN:
        !          2521:                cond_set = 0x9a;
        !          2522:                break;
        !          2523: 
        !          2524:        case SLJIT_C_FLOAT_NOT_NAN:
        !          2525:                cond_set = 0x9b;
        !          2526:                break;
        !          2527:        }
        !          2528: 
        !          2529: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2530:        reg = (op == SLJIT_MOV && dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REGISTER;
        !          2531: 
        !          2532:        buf = (sljit_ub*)ensure_buf(compiler, 1 + 4 + 4);
        !          2533:        FAIL_IF(!buf);
        !          2534:        INC_SIZE(4 + 4);
        !          2535:        /* Set low register to conditional flag. */
        !          2536:        *buf++ = (reg_map[reg] <= 7) ? 0x40 : REX_B;
        !          2537:        *buf++ = 0x0f;
        !          2538:        *buf++ = cond_set;
        !          2539:        *buf++ = 0xC0 | reg_lmap[reg];
        !          2540:        *buf++ = REX_W | (reg_map[reg] <= 7 ? 0 : (REX_B | REX_R));
        !          2541:        *buf++ = 0x0f;
        !          2542:        *buf++ = 0xb6;
        !          2543:        *buf = 0xC0 | (reg_lmap[reg] << 3) | reg_lmap[reg];
        !          2544: 
        !          2545:        if (reg == TMP_REGISTER) {
        !          2546:                if (op == SLJIT_MOV) {
        !          2547:                        compiler->mode32 = 0;
        !          2548:                        EMIT_MOV(compiler, dst, dstw, TMP_REGISTER, 0);
        !          2549:                }
        !          2550:                else {
        !          2551: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
        !          2552:                        compiler->skip_checks = 1;
        !          2553: #endif
        !          2554:                        return sljit_emit_op2(compiler, op, dst, dstw, dst, dstw, TMP_REGISTER, 0);
        !          2555:                }
        !          2556:        }
        !          2557: #else
        !          2558:        if (op == SLJIT_MOV) {
        !          2559:                if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_TEMPORARY_REG3) {
        !          2560:                        buf = (sljit_ub*)ensure_buf(compiler, 1 + 3 + 3);
        !          2561:                        FAIL_IF(!buf);
        !          2562:                        INC_SIZE(3 + 3);
        !          2563:                        /* Set low byte to conditional flag. */
        !          2564:                        *buf++ = 0x0f;
        !          2565:                        *buf++ = cond_set;
        !          2566:                        *buf++ = 0xC0 | reg_map[dst];
        !          2567: 
        !          2568:                        *buf++ = 0x0f;
        !          2569:                        *buf++ = 0xb6;
        !          2570:                        *buf = 0xC0 | (reg_map[dst] << 3) | reg_map[dst];
        !          2571:                }
        !          2572:                else {
        !          2573:                        EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_TEMPORARY_REG1, 0);
        !          2574: 
        !          2575:                        buf = (sljit_ub*)ensure_buf(compiler, 1 + 3 + 3);
        !          2576:                        FAIL_IF(!buf);
        !          2577:                        INC_SIZE(3 + 3);
        !          2578:                        /* Set al to conditional flag. */
        !          2579:                        *buf++ = 0x0f;
        !          2580:                        *buf++ = cond_set;
        !          2581:                        *buf++ = 0xC0;
        !          2582: 
        !          2583:                        *buf++ = 0x0f;
        !          2584:                        *buf++ = 0xb6;
        !          2585:                        if (dst >= SLJIT_GENERAL_REG1 && dst <= SLJIT_NO_REGISTERS)
        !          2586:                                *buf = 0xC0 | (reg_map[dst] << 3);
        !          2587:                        else {
        !          2588:                                *buf = 0xC0;
        !          2589:                                EMIT_MOV(compiler, dst, dstw, SLJIT_TEMPORARY_REG1, 0);
        !          2590:                        }
        !          2591: 
        !          2592:                        EMIT_MOV(compiler, SLJIT_TEMPORARY_REG1, 0, TMP_REGISTER, 0);
        !          2593:                }
        !          2594:        }
        !          2595:        else {
        !          2596:                if (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_TEMPORARY_REG3) {
        !          2597:                        EMIT_MOV(compiler, TMP_REGISTER, 0, dst, 0);
        !          2598:                        buf = (sljit_ub*)ensure_buf(compiler, 1 + 3);
        !          2599:                        FAIL_IF(!buf);
        !          2600:                        INC_SIZE(3);
        !          2601: 
        !          2602:                        *buf++ = 0x0f;
        !          2603:                        *buf++ = cond_set;
        !          2604:                        *buf++ = 0xC0 | reg_map[dst];
        !          2605:                }
        !          2606:                else {
        !          2607:                        EMIT_MOV(compiler, TMP_REGISTER, 0, SLJIT_TEMPORARY_REG1, 0);
        !          2608: 
        !          2609:                        buf = (sljit_ub*)ensure_buf(compiler, 1 + 3 + 3 + 1);
        !          2610:                        FAIL_IF(!buf);
        !          2611:                        INC_SIZE(3 + 3 + 1);
        !          2612:                        /* Set al to conditional flag. */
        !          2613:                        *buf++ = 0x0f;
        !          2614:                        *buf++ = cond_set;
        !          2615:                        *buf++ = 0xC0;
        !          2616: 
        !          2617:                        *buf++ = 0x0f;
        !          2618:                        *buf++ = 0xb6;
        !          2619:                        *buf++ = 0xC0;
        !          2620: 
        !          2621:                        *buf++ = 0x90 + reg_map[TMP_REGISTER];
        !          2622:                }
        !          2623: #if (defined SLJIT_VERBOSE && SLJIT_VERBOSE) || (defined SLJIT_DEBUG && SLJIT_DEBUG)
        !          2624:                compiler->skip_checks = 1;
        !          2625: #endif
        !          2626:                return sljit_emit_op2(compiler, op, dst, dstw, dst, dstw, TMP_REGISTER, 0);
        !          2627:        }
        !          2628: #endif
        !          2629: 
        !          2630:        return SLJIT_SUCCESS;
        !          2631: }
        !          2632: 
        !          2633: SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, int dst, sljit_w dstw, sljit_w init_value)
        !          2634: {
        !          2635:        sljit_ub *buf;
        !          2636:        struct sljit_const *const_;
        !          2637: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2638:        int reg;
        !          2639: #endif
        !          2640: 
        !          2641:        CHECK_ERROR_PTR();
        !          2642:        check_sljit_emit_const(compiler, dst, dstw, init_value);
        !          2643: 
        !          2644:        CHECK_EXTRA_REGS(dst, dstw, (void)0);
        !          2645: 
        !          2646:        const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));
        !          2647:        PTR_FAIL_IF(!const_);
        !          2648:        set_const(const_, compiler);
        !          2649: 
        !          2650: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2651:        compiler->mode32 = 0;
        !          2652:        reg = (dst >= SLJIT_TEMPORARY_REG1 && dst <= SLJIT_NO_REGISTERS) ? dst : TMP_REGISTER;
        !          2653: 
        !          2654:        if (emit_load_imm64(compiler, reg, init_value))
        !          2655:                return NULL;
        !          2656: #else
        !          2657:        if (dst == SLJIT_UNUSED)
        !          2658:                dst = TMP_REGISTER;
        !          2659: 
        !          2660:        if (emit_mov(compiler, dst, dstw, SLJIT_IMM, init_value))
        !          2661:                return NULL;
        !          2662: #endif
        !          2663: 
        !          2664:        buf = (sljit_ub*)ensure_buf(compiler, 2);
        !          2665:        PTR_FAIL_IF(!buf);
        !          2666: 
        !          2667:        *buf++ = 0;
        !          2668:        *buf++ = 1;
        !          2669: 
        !          2670: #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
        !          2671:        if (reg == TMP_REGISTER && dst != SLJIT_UNUSED)
        !          2672:                if (emit_mov(compiler, dst, dstw, TMP_REGISTER, 0))
        !          2673:                        return NULL;
        !          2674: #endif
        !          2675: 
        !          2676:        return const_;
        !          2677: }
        !          2678: 
        !          2679: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_addr)
        !          2680: {
        !          2681: #if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
        !          2682:        *(sljit_w*)addr = new_addr - (addr + 4);
        !          2683: #else
        !          2684:        *(sljit_uw*)addr = new_addr;
        !          2685: #endif
        !          2686: }
        !          2687: 
        !          2688: SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_w new_constant)
        !          2689: {
        !          2690:        *(sljit_w*)addr = new_constant;
        !          2691: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>