mono/arch/x86/x86-codegen.h

   1 /*
   2  * x86-codegen.h: Macros for generating x86 code
   3  *
   4  * Authors:
   5  *   Paolo Molaro (lupus@ximian.com)
   6  *   Intel Corporation (ORP Project)
   7  *   Sergey Chaban (serge@wildwestsoftware.com)
   8  *   Dietmar Maurer (dietmar@ximian.com)
   9  *   Patrik Torstensson
  10  *
  11  * Copyright (C)  2000 Intel Corporation.  All rights reserved.
  12  * Copyright (C)  2001, 2002 Ximian, Inc.
  13  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  14  */
  15
  16 #ifndef X86_H
  17 #define X86_H
  18 #include <assert.h>
  19
  20 #ifdef __native_client_codegen__
  21 extern gint8 nacl_align_byte;
  22 #endif /* __native_client_codegen__ */
  23
  24
  25 #if defined( __native_client_codegen__ ) && defined( TARGET_X86 )
  26 #define x86_codegen_pre(inst_ptr_ptr, inst_len) do { mono_nacl_align_inst(inst_ptr_ptr, inst_len); } while (0)
  27 #define x86_call_sequence_pre_val(inst) guint8* _code_start = (inst);
  28 #define x86_call_sequence_post_val(inst) \
  29   (mono_nacl_align_call(&_code_start, &(inst)), _code_start);
  30 #define x86_call_sequence_pre(inst) x86_call_sequence_pre_val((inst))
  31 #define x86_call_sequence_post(inst) x86_call_sequence_post_val((inst))
  32 #else
  33 #define x86_codegen_pre(inst_ptr_ptr, inst_len) do {} while (0)
  34 /* Two variants are needed to avoid warnings */
  35 #define x86_call_sequence_pre_val(inst) guint8* _code_start = (inst);
  36 #define x86_call_sequence_post_val(inst) _code_start
  37 #define x86_call_sequence_pre(inst)
  38 #define x86_call_sequence_post(inst)
  39 #endif  /* __native_client_codegen__ */
  40
  41
  42 /*
  43 // x86 register numbers
  44 */
  45 typedef enum {
  46         X86_EAX = 0,
  47         X86_ECX = 1,
  48         X86_EDX = 2,
  49         X86_EBX = 3,
  50         X86_ESP = 4,
  51         X86_EBP = 5,
  52         X86_ESI = 6,
  53         X86_EDI = 7,
  54         X86_NREG
  55 } X86_Reg_No;
  56
  57 typedef enum {
  58         X86_XMM0,
  59         X86_XMM1,
  60         X86_XMM2,
  61         X86_XMM3,
  62         X86_XMM4,
  63         X86_XMM5,
  64         X86_XMM6,
  65         X86_XMM7,
  66         X86_XMM_NREG
  67 } X86_XMM_Reg_No;
  68
  69 /*
  70 // opcodes for alu instructions
  71 */
  72 typedef enum {
  73         X86_ADD = 0,
  74         X86_OR  = 1,
  75         X86_ADC = 2,
  76         X86_SBB = 3,
  77         X86_AND = 4,
  78         X86_SUB = 5,
  79         X86_XOR = 6,
  80         X86_CMP = 7,
  81         X86_NALU
  82 } X86_ALU_Opcode;
  83 /*
  84 // opcodes for shift instructions
  85 */
  86 typedef enum {
  87         X86_SHLD,
  88         X86_SHLR,
  89         X86_ROL = 0,
  90         X86_ROR = 1,
  91         X86_RCL = 2,
  92         X86_RCR = 3,
  93         X86_SHL = 4,
  94         X86_SHR = 5,
  95         X86_SAR = 7,
  96         X86_NSHIFT = 8
  97 } X86_Shift_Opcode;
  98 /*
  99 // opcodes for floating-point instructions
 100 */
 101 typedef enum {
 102         X86_FADD  = 0,
 103         X86_FMUL  = 1,
 104         X86_FCOM  = 2,
 105         X86_FCOMP = 3,
 106         X86_FSUB  = 4,
 107         X86_FSUBR = 5,
 108         X86_FDIV  = 6,
 109         X86_FDIVR = 7,
 110         X86_NFP   = 8
 111 } X86_FP_Opcode;
 112 /*
 113 // integer conditions codes
 114 */
 115 typedef enum {
 116         X86_CC_EQ = 0, X86_CC_E = 0, X86_CC_Z = 0,
 117         X86_CC_NE = 1, X86_CC_NZ = 1,
 118         X86_CC_LT = 2, X86_CC_B = 2, X86_CC_C = 2, X86_CC_NAE = 2,
 119         X86_CC_LE = 3, X86_CC_BE = 3, X86_CC_NA = 3,
 120         X86_CC_GT = 4, X86_CC_A = 4, X86_CC_NBE = 4,
 121         X86_CC_GE = 5, X86_CC_AE = 5, X86_CC_NB = 5, X86_CC_NC = 5,
 122         X86_CC_LZ = 6, X86_CC_S = 6,
 123         X86_CC_GEZ = 7, X86_CC_NS = 7,
 124         X86_CC_P = 8, X86_CC_PE = 8,
 125         X86_CC_NP = 9, X86_CC_PO = 9,
 126         X86_CC_O = 10,
 127         X86_CC_NO = 11,
 128         X86_NCC
 129 } X86_CC;
 130
 131 /* FP status */
 132 enum {
 133         X86_FP_C0 = 0x100,
 134         X86_FP_C1 = 0x200,
 135         X86_FP_C2 = 0x400,
 136         X86_FP_C3 = 0x4000,
 137         X86_FP_CC_MASK = 0x4500
 138 };
 139
 140 /* FP control word */
 141 enum {
 142         X86_FPCW_INVOPEX_MASK = 0x1,
 143         X86_FPCW_DENOPEX_MASK = 0x2,
 144         X86_FPCW_ZERODIV_MASK = 0x4,
 145         X86_FPCW_OVFEX_MASK   = 0x8,
 146         X86_FPCW_UNDFEX_MASK  = 0x10,
 147         X86_FPCW_PRECEX_MASK  = 0x20,
 148         X86_FPCW_PRECC_MASK   = 0x300,
 149         X86_FPCW_ROUNDC_MASK  = 0xc00,
 150
 151         /* values for precision control */
 152         X86_FPCW_PREC_SINGLE    = 0,
 153         X86_FPCW_PREC_DOUBLE    = 0x200,
 154         X86_FPCW_PREC_EXTENDED  = 0x300,
 155
 156         /* values for rounding control */
 157         X86_FPCW_ROUND_NEAREST  = 0,
 158         X86_FPCW_ROUND_DOWN     = 0x400,
 159         X86_FPCW_ROUND_UP       = 0x800,
 160         X86_FPCW_ROUND_TOZERO   = 0xc00
 161 };
 162
 163 /*
 164 // prefix code
 165 */
 166 typedef enum {
 167         X86_LOCK_PREFIX = 0xF0,
 168         X86_REPNZ_PREFIX = 0xF2,
 169         X86_REPZ_PREFIX = 0xF3,
 170         X86_REP_PREFIX = 0xF3,
 171         X86_CS_PREFIX = 0x2E,
 172         X86_SS_PREFIX = 0x36,
 173         X86_DS_PREFIX = 0x3E,
 174         X86_ES_PREFIX = 0x26,
 175         X86_FS_PREFIX = 0x64,
 176         X86_GS_PREFIX = 0x65,
 177         X86_UNLIKELY_PREFIX = 0x2E,
 178         X86_LIKELY_PREFIX = 0x3E,
 179         X86_OPERAND_PREFIX = 0x66,
 180         X86_ADDRESS_PREFIX = 0x67
 181 } X86_Prefix;
 182
 183 static const unsigned char
 184 x86_cc_unsigned_map [X86_NCC] = {
 185         0x74, /* eq  */
 186         0x75, /* ne  */
 187         0x72, /* lt  */
 188         0x76, /* le  */
 189         0x77, /* gt  */
 190         0x73, /* ge  */
 191         0x78, /* lz  */
 192         0x79, /* gez */
 193         0x7a, /* p   */
 194         0x7b, /* np  */
 195         0x70, /* o  */
 196         0x71, /* no  */
 197 };
 198
 199 static const unsigned char
 200 x86_cc_signed_map [X86_NCC] = {
 201         0x74, /* eq  */
 202         0x75, /* ne  */
 203         0x7c, /* lt  */
 204         0x7e, /* le  */
 205         0x7f, /* gt  */
 206         0x7d, /* ge  */
 207         0x78, /* lz  */
 208         0x79, /* gez */
 209         0x7a, /* p   */
 210         0x7b, /* np  */
 211         0x70, /* o  */
 212         0x71, /* no  */
 213 };
 214
 215 typedef union {
 216         int val;
 217         unsigned char b [4];
 218 } x86_imm_buf;
 219
 220 #define X86_NOBASEREG (-1)
 221
 222 /*
 223 // bitvector mask for callee-saved registers
 224 */
 225 #define X86_ESI_MASK (1<<X86_ESI)
 226 #define X86_EDI_MASK (1<<X86_EDI)
 227 #define X86_EBX_MASK (1<<X86_EBX)
 228 #define X86_EBP_MASK (1<<X86_EBP)
 229
 230 #define X86_CALLEE_REGS ((1<<X86_EAX) | (1<<X86_ECX) | (1<<X86_EDX))
 231 #define X86_CALLER_REGS ((1<<X86_EBX) | (1<<X86_EBP) | (1<<X86_ESI) | (1<<X86_EDI))
 232 #define X86_BYTE_REGS   ((1<<X86_EAX) | (1<<X86_ECX) | (1<<X86_EDX) | (1<<X86_EBX))
 233
 234 #define X86_IS_SCRATCH(reg) (X86_CALLER_REGS & (1 << (reg))) /* X86_EAX, X86_ECX, or X86_EDX */
 235 #define X86_IS_CALLEE(reg)  (X86_CALLEE_REGS & (1 << (reg)))    /* X86_ESI, X86_EDI, X86_EBX, or X86_EBP */
 236
 237 #define X86_IS_BYTE_REG(reg) ((reg) < 4)
 238
 239 /*
 240 // Frame structure:
 241 //
 242 //      +--------------------------------+
 243 //      | in_arg[0]       = var[0]           |
 244 //      | in_arg[1]           = var[1]       |
 245 //      |             . . .                              |
 246 //      | in_arg[n_arg-1] = var[n_arg-1] |
 247 //      +--------------------------------+
 248 //      |       return IP                |
 249 //      +--------------------------------+
 250 //      |       saved EBP                | <-- frame pointer (EBP)
 251 //      +--------------------------------+
 252 //      |            ...                 |  n_extra
 253 //      +--------------------------------+
 254 //      |           var[n_arg]               |
 255 //      |           var[n_arg+1]             |  local variables area
 256 //      |          . . .                 |
 257 //      |           var[n_var-1]             |
 258 //      +--------------------------------+
 259 //      |                                            |
 260 //      |                                            |
 261 //      |               spill area               | area for spilling mimic stack
 262 //      |                                            |
 263 //      +--------------------------------|
 264 //      |          ebx                   |
 265 //      |          ebp [ESP_Frame only]  |
 266 //      |              esi                   |  0..3 callee-saved regs
 267 //      |          edi                   | <-- stack pointer (ESP)
 268 //      +--------------------------------+
 269 //      |       stk0                         |
 270 //      |       stk1                         |  operand stack area/
 271 //      |       . . .                        |  out args
 272 //      |       stkn-1                       |
 273 //      +--------------------------------|
 274 //
 275 //
 276 */
 277
 278
 279 /*
 280  * useful building blocks
 281  */
 282 #define x86_modrm_mod(modrm) ((modrm) >> 6)
 283 #define x86_modrm_reg(modrm) (((modrm) >> 3) & 0x7)
 284 #define x86_modrm_rm(modrm) ((modrm) & 0x7)
 285
 286 #define x86_address_byte(inst,m,o,r) do { *(inst)++ = ((((m)&0x03)<<6)|(((o)&0x07)<<3)|(((r)&0x07))); } while (0)
 287 #define x86_imm_emit32(inst,imm)     \
 288         do {    \
 289                         x86_imm_buf imb; imb.val = (int) (imm); \
 290                         *(inst)++ = imb.b [0];  \
 291                         *(inst)++ = imb.b [1];  \
 292                         *(inst)++ = imb.b [2];  \
 293                         *(inst)++ = imb.b [3];  \
 294         } while (0)
 295 #define x86_imm_emit16(inst,imm)     do { *(short*)(inst) = (imm); (inst) += 2; } while (0)
 296 #define x86_imm_emit8(inst,imm)      do { *(inst) = (unsigned char)((imm) & 0xff); ++(inst); } while (0)
 297 #define x86_is_imm8(imm)             (((int)(imm) >= -128 && (int)(imm) <= 127))
 298 #define x86_is_imm16(imm)            (((int)(imm) >= -(1<<16) && (int)(imm) <= ((1<<16)-1)))
 299
 300 #define x86_reg_emit(inst,r,regno)   do { x86_address_byte ((inst), 3, (r), (regno)); } while (0)
 301 #define x86_reg8_emit(inst,r,regno,is_rh,is_rnoh)   do {x86_address_byte ((inst), 3, (is_rh)?((r)|4):(r), (is_rnoh)?((regno)|4):(regno));} while (0)
 302 #define x86_regp_emit(inst,r,regno)  do { x86_address_byte ((inst), 0, (r), (regno)); } while (0)
 303 #define x86_mem_emit(inst,r,disp)    do { x86_address_byte ((inst), 0, (r), 5); x86_imm_emit32((inst), (disp)); } while (0)
 304
 305 #define kMaxMembaseEmitPadding 6
 306
 307 #define x86_membase_emit_body(inst,r,basereg,disp)      do {\
 308         if ((basereg) == X86_ESP) {     \
 309                 if ((disp) == 0) {      \
 310                         x86_address_byte ((inst), 0, (r), X86_ESP);     \
 311                         x86_address_byte ((inst), 0, X86_ESP, X86_ESP); \
 312                 } else if (x86_is_imm8((disp))) {       \
 313                         x86_address_byte ((inst), 1, (r), X86_ESP);     \
 314                         x86_address_byte ((inst), 0, X86_ESP, X86_ESP); \
 315                         x86_imm_emit8 ((inst), (disp)); \
 316                 } else {        \
 317                         x86_address_byte ((inst), 2, (r), X86_ESP);     \
 318                         x86_address_byte ((inst), 0, X86_ESP, X86_ESP); \
 319                         x86_imm_emit32 ((inst), (disp));        \
 320                 }       \
 321                 break;  \
 322         }       \
 323         if ((disp) == 0 && (basereg) != X86_EBP) {      \
 324                 x86_address_byte ((inst), 0, (r), (basereg));   \
 325                 break;  \
 326         }       \
 327         if (x86_is_imm8((disp))) {      \
 328                 x86_address_byte ((inst), 1, (r), (basereg));   \
 329                 x86_imm_emit8 ((inst), (disp)); \
 330         } else {        \
 331                 x86_address_byte ((inst), 2, (r), (basereg));   \
 332                 x86_imm_emit32 ((inst), (disp));        \
 333         }       \
 334         } while (0)
 335
 336 #if defined(__native_client_codegen__) && defined(TARGET_AMD64)
 337 #define x86_membase_emit(inst,r,basereg,disp) \
 338         do { \
 339                 amd64_nacl_membase_handler(&(inst), (basereg), (disp), (r)) ; \
 340         } while (0)
 341 #else /* __default_codegen__ || 32-bit NaCl codegen */
 342 #define x86_membase_emit(inst,r,basereg,disp) \
 343         do { \
 344                 x86_membase_emit_body((inst),(r),(basereg),(disp)); \
 345         } while (0)
 346 #endif
 347
 348 #define kMaxMemindexEmitPadding 6
 349
 350 #define x86_memindex_emit(inst,r,basereg,disp,indexreg,shift)   \
 351         do {    \
 352                 if ((basereg) == X86_NOBASEREG) {       \
 353                         x86_address_byte ((inst), 0, (r), 4);   \
 354                         x86_address_byte ((inst), (shift), (indexreg), 5);      \
 355                         x86_imm_emit32 ((inst), (disp));        \
 356                 } else if ((disp) == 0 && (basereg) != X86_EBP) {       \
 357                         x86_address_byte ((inst), 0, (r), 4);   \
 358                         x86_address_byte ((inst), (shift), (indexreg), (basereg));      \
 359                 } else if (x86_is_imm8((disp))) {       \
 360                         x86_address_byte ((inst), 1, (r), 4);   \
 361                         x86_address_byte ((inst), (shift), (indexreg), (basereg));      \
 362                         x86_imm_emit8 ((inst), (disp)); \
 363                 } else {        \
 364                         x86_address_byte ((inst), 2, (r), 4);   \
 365                         x86_address_byte ((inst), (shift), (indexreg), (basereg));      \
 366                         x86_imm_emit32 ((inst), (disp));        \
 367                 }       \
 368         } while (0)
 369
 370 /*
 371  * target is the position in the code where to jump to:
 372  * target = code;
 373  * .. output loop code...
 374  * x86_mov_reg_imm (code, X86_EAX, 0);
 375  * loop = code;
 376  * x86_loop (code, -1);
 377  * ... finish method
 378  *
 379  * patch displacement
 380  * x86_patch (loop, target);
 381  *
 382  * ins should point at the start of the instruction that encodes a target.
 383  * the instruction is inspected for validity and the correct displacement
 384  * is inserted.
 385  */
 386 #define x86_do_patch(ins,target)        \
 387         do {    \
 388                 unsigned char* pos = (ins) + 1; \
 389                 int disp, size = 0;     \
 390                 switch (*(unsigned char*)(ins)) {       \
 391                 case 0xe8: case 0xe9: ++size; break; /* call, jump32 */ \
 392                 case 0x0f: if (!(*pos >= 0x70 && *pos <= 0x8f)) assert (0);     \
 393                    ++size; ++pos; break; /* prefix for 32-bit disp */   \
 394                 case 0xe0: case 0xe1: case 0xe2: /* loop */     \
 395                 case 0xeb: /* jump8 */  \
 396                 /* conditional jump opcodes */  \
 397                 case 0x70: case 0x71: case 0x72: case 0x73:     \
 398                 case 0x74: case 0x75: case 0x76: case 0x77:     \
 399                 case 0x78: case 0x79: case 0x7a: case 0x7b:     \
 400                 case 0x7c: case 0x7d: case 0x7e: case 0x7f:     \
 401                         break;  \
 402                 default: assert (0);    \
 403                 }       \
 404                 disp = (target) - pos;  \
 405                 if (size) x86_imm_emit32 (pos, disp - 4);       \
 406                 else if (x86_is_imm8 (disp - 1)) x86_imm_emit8 (pos, disp - 1); \
 407                 else assert (0);        \
 408         } while (0)
 409
 410 #if defined( __native_client_codegen__ ) && defined(TARGET_X86)
 411
 412 #define x86_skip_nops(inst) \
 413   do {    \
 414     int in_nop = 0; \
 415     do { \
 416       in_nop = 0; \
 417       if (inst[0] == 0x90) { \
 418         in_nop = 1; \
 419         inst += 1; \
 420       } \
 421       if (inst[0] == 0x8b && inst[1] == 0xc0) { \
 422         in_nop = 1; \
 423         inst += 2; \
 424       } \
 425       if (inst[0] == 0x8d && inst[1] == 0x6d \
 426        && inst[2] == 0x00) { \
 427         in_nop = 1; \
 428         inst += 3; \
 429       } \
 430       if (inst[0] == 0x8d && inst[1] == 0x64 \
 431        && inst[2] == 0x24 && inst[3] == 0x00) { \
 432         in_nop = 1; \
 433         inst += 4; \
 434       } \
 435       /* skip inst+=5 case because it's the 4-byte + 1-byte case */ \
 436       if (inst[0] == 0x8d && inst[1] == 0xad \
 437        && inst[2] == 0x00 && inst[3] == 0x00 \
 438        && inst[4] == 0x00 && inst[5] == 0x00) { \
 439         in_nop = 1; \
 440         inst += 6; \
 441       } \
 442       if (inst[0] == 0x8d && inst[1] == 0xa4 \
 443        && inst[2] == 0x24 && inst[3] == 0x00 \
 444        && inst[4] == 0x00 && inst[5] == 0x00 \
 445        && inst[6] == 0x00 ) { \
 446         in_nop = 1; \
 447         inst += 7; \
 448       } \
 449     } while ( in_nop );  \
 450   } while (0)
 451
 452 #if defined(__native_client__)
 453 #define x86_patch(ins,target) \
 454   do { \
 455     unsigned char* inst = (ins); \
 456     guint8* new_target = nacl_modify_patch_target((target)); \
 457     x86_skip_nops((inst)); \
 458     x86_do_patch((inst), new_target); \
 459   } while (0)
 460 #else /* __native_client__ */
 461 #define x86_patch(ins,target) \
 462   do { \
 463     unsigned char* inst = (ins); \
 464     guint8* new_target = (target); \
 465     x86_skip_nops((inst)); \
 466     x86_do_patch((inst), new_target); \
 467   } while (0)
 468 #endif /* __native_client__ */
 469
 470 #else
 471 #define x86_patch(ins,target) do { x86_do_patch((ins), (target)); } while (0)
 472 #endif /* __native_client_codegen__ */
 473
 474 #ifdef __native_client_codegen__
 475 /* The breakpoint instruction is illegal in Native Client, although the HALT   */
 476 /* instruction is allowed. The breakpoint is used several places in mini-x86.c */
 477 /* and exceptions-x86.c.                                                       */
 478 #define x86_breakpoint(inst) \
 479         do {    \
 480                 *(inst)++ = 0xf4;       \
 481         } while (0)
 482 #else
 483 #define x86_breakpoint(inst) \
 484         do {    \
 485                 *(inst)++ = 0xcc;       \
 486         } while (0)
 487 #endif
 488
 489 #define x86_cld(inst) do { *(inst)++ =(unsigned char)0xfc; } while (0)
 490 #define x86_stosb(inst) do { *(inst)++ =(unsigned char)0xaa; } while (0)
 491 #define x86_stosl(inst) do { *(inst)++ =(unsigned char)0xab; } while (0)
 492 #define x86_stosd(inst) x86_stosl((inst))
 493 #define x86_movsb(inst) do { *(inst)++ =(unsigned char)0xa4; } while (0)
 494 #define x86_movsl(inst) do { *(inst)++ =(unsigned char)0xa5; } while (0)
 495 #define x86_movsd(inst) x86_movsl((inst))
 496
 497 #if defined(__default_codegen__)
 498 #define x86_prefix(inst,p) \
 499         do { \
 500                 *(inst)++ =(unsigned char) (p); \
 501         } while (0)
 502 #elif defined(__native_client_codegen__)
 503 #if defined(TARGET_X86)
 504 /* kNaClAlignment - 1 is the max value we can pass into x86_codegen_pre. */
 505 /* This keeps us from having to call x86_codegen_pre with specific       */
 506 /* knowledge of the size of the instruction that follows it, and         */
 507 /* localizes the alignment requirement to this spot.                     */
 508 #define x86_prefix(inst,p) \
 509         do { \
 510                 x86_codegen_pre(&(inst), kNaClAlignment - 1); \
 511                 *(inst)++ =(unsigned char) (p); \
 512         } while (0)
 513 #elif defined(TARGET_AMD64)
 514 /* We need to tag any prefixes so we can perform proper membase sandboxing */
 515 /* See: mini-amd64.c:amd64_nacl_membase_handler for verbose details        */
 516 #define x86_prefix(inst,p) \
 517         do { \
 518                 amd64_nacl_tag_legacy_prefix((inst)); \
 519                 *(inst)++ =(unsigned char) (p); \
 520         } while (0)
 521
 522 #endif /* TARGET_AMD64 */
 523
 524 #endif /* __native_client_codegen__ */
 525
 526 #define x86_mfence(inst) \
 527         do {    \
 528                 x86_codegen_pre(&(inst), 3); \
 529                 *(inst)++ = 0x0f;       \
 530                 *(inst)++ = 0xae;       \
 531                 *(inst)++ = 0xf0;       \
 532         } while (0)
 533
 534 #define x86_rdtsc(inst) \
 535         do {    \
 536                 x86_codegen_pre(&(inst), 2); \
 537                 *(inst)++ = 0x0f;       \
 538                 *(inst)++ = 0x31;       \
 539         } while (0)
 540
 541 #define x86_cmpxchg_reg_reg(inst,dreg,reg)      \
 542         do {    \
 543                 x86_codegen_pre(&(inst), 3); \
 544                 *(inst)++ = (unsigned char)0x0f;        \
 545                 *(inst)++ = (unsigned char)0xb1;        \
 546                 x86_reg_emit ((inst), (reg), (dreg));   \
 547         } while (0)
 548
 549 #define x86_cmpxchg_mem_reg(inst,mem,reg)       \
 550         do {    \
 551                 x86_codegen_pre(&(inst), 7); \
 552                 *(inst)++ = (unsigned char)0x0f;        \
 553                 *(inst)++ = (unsigned char)0xb1;        \
 554                 x86_mem_emit ((inst), (reg), (mem));    \
 555         } while (0)
 556
 557 #define x86_cmpxchg_membase_reg(inst,basereg,disp,reg)  \
 558         do {    \
 559                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
 560                 *(inst)++ = (unsigned char)0x0f;        \
 561                 *(inst)++ = (unsigned char)0xb1;        \
 562                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 563         } while (0)
 564
 565 #define x86_xchg_reg_reg(inst,dreg,reg,size)    \
 566         do {    \
 567                 x86_codegen_pre(&(inst), 2); \
 568                 if ((size) == 1)        \
 569                         *(inst)++ = (unsigned char)0x86;        \
 570                 else    \
 571                         *(inst)++ = (unsigned char)0x87;        \
 572                 x86_reg_emit ((inst), (reg), (dreg));   \
 573         } while (0)
 574
 575 #define x86_xchg_mem_reg(inst,mem,reg,size)     \
 576         do {    \
 577                 x86_codegen_pre(&(inst), 6); \
 578                 if ((size) == 1)        \
 579                         *(inst)++ = (unsigned char)0x86;        \
 580                 else    \
 581                         *(inst)++ = (unsigned char)0x87;        \
 582                 x86_mem_emit ((inst), (reg), (mem));    \
 583         } while (0)
 584
 585 #define x86_xchg_membase_reg(inst,basereg,disp,reg,size)        \
 586         do {    \
 587                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 588                 if ((size) == 1)        \
 589                         *(inst)++ = (unsigned char)0x86;        \
 590                 else    \
 591                         *(inst)++ = (unsigned char)0x87;        \
 592                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 593         } while (0)
 594
 595 #define x86_xadd_reg_reg(inst,dreg,reg,size)    \
 596         do {    \
 597                 x86_codegen_pre(&(inst), 3); \
 598                 *(inst)++ = (unsigned char)0x0F;     \
 599                 if ((size) == 1)        \
 600                         *(inst)++ = (unsigned char)0xC0;        \
 601                 else    \
 602                         *(inst)++ = (unsigned char)0xC1;        \
 603                 x86_reg_emit ((inst), (reg), (dreg));   \
 604         } while (0)
 605
 606 #define x86_xadd_mem_reg(inst,mem,reg,size)     \
 607         do {    \
 608                 x86_codegen_pre(&(inst), 7); \
 609                 *(inst)++ = (unsigned char)0x0F;     \
 610                 if ((size) == 1)        \
 611                         *(inst)++ = (unsigned char)0xC0;        \
 612                 else    \
 613                         *(inst)++ = (unsigned char)0xC1;        \
 614                 x86_mem_emit ((inst), (reg), (mem));    \
 615         } while (0)
 616
 617 #define x86_xadd_membase_reg(inst,basereg,disp,reg,size)        \
 618         do {    \
 619                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
 620                 *(inst)++ = (unsigned char)0x0F;     \
 621                 if ((size) == 1)        \
 622                         *(inst)++ = (unsigned char)0xC0;        \
 623                 else    \
 624                         *(inst)++ = (unsigned char)0xC1;        \
 625                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 626         } while (0)
 627
 628 #define x86_inc_mem(inst,mem)   \
 629         do {    \
 630                 x86_codegen_pre(&(inst), 6); \
 631                 *(inst)++ = (unsigned char)0xff;        \
 632                 x86_mem_emit ((inst), 0, (mem));        \
 633         } while (0)
 634
 635 #define x86_inc_membase(inst,basereg,disp)      \
 636         do {    \
 637                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 638                 *(inst)++ = (unsigned char)0xff;        \
 639                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
 640         } while (0)
 641
 642 #define x86_inc_reg(inst,reg) do { *(inst)++ = (unsigned char)0x40 + (reg); } while (0)
 643
 644 #define x86_dec_mem(inst,mem)   \
 645         do {    \
 646                 x86_codegen_pre(&(inst), 6); \
 647                 *(inst)++ = (unsigned char)0xff;        \
 648                 x86_mem_emit ((inst), 1, (mem));        \
 649         } while (0)
 650
 651 #define x86_dec_membase(inst,basereg,disp)      \
 652         do {    \
 653                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 654                 *(inst)++ = (unsigned char)0xff;        \
 655                 x86_membase_emit ((inst), 1, (basereg), (disp));        \
 656         } while (0)
 657
 658 #define x86_dec_reg(inst,reg) do { *(inst)++ = (unsigned char)0x48 + (reg); } while (0)
 659
 660 #define x86_not_mem(inst,mem)   \
 661         do {    \
 662                 x86_codegen_pre(&(inst), 6); \
 663                 *(inst)++ = (unsigned char)0xf7;        \
 664                 x86_mem_emit ((inst), 2, (mem));        \
 665         } while (0)
 666
 667 #define x86_not_membase(inst,basereg,disp)      \
 668         do {    \
 669                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 670                 *(inst)++ = (unsigned char)0xf7;        \
 671                 x86_membase_emit ((inst), 2, (basereg), (disp));        \
 672         } while (0)
 673
 674 #define x86_not_reg(inst,reg)   \
 675         do {    \
 676                 x86_codegen_pre(&(inst), 2); \
 677                 *(inst)++ = (unsigned char)0xf7;        \
 678                 x86_reg_emit ((inst), 2, (reg));        \
 679         } while (0)
 680
 681 #define x86_neg_mem(inst,mem)   \
 682         do {    \
 683                 x86_codegen_pre(&(inst), 6); \
 684                 *(inst)++ = (unsigned char)0xf7;        \
 685                 x86_mem_emit ((inst), 3, (mem));        \
 686         } while (0)
 687
 688 #define x86_neg_membase(inst,basereg,disp)      \
 689         do {    \
 690                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 691                 *(inst)++ = (unsigned char)0xf7;        \
 692                 x86_membase_emit ((inst), 3, (basereg), (disp));        \
 693         } while (0)
 694
 695 #define x86_neg_reg(inst,reg)   \
 696         do {    \
 697                 x86_codegen_pre(&(inst), 2); \
 698                 *(inst)++ = (unsigned char)0xf7;        \
 699                 x86_reg_emit ((inst), 3, (reg));        \
 700         } while (0)
 701
 702 #define x86_nop(inst) do { *(inst)++ = (unsigned char)0x90; } while (0)
 703
 704 #define x86_alu_reg_imm(inst,opc,reg,imm)       \
 705         do {    \
 706                 if ((reg) == X86_EAX) { \
 707                         x86_codegen_pre(&(inst), 5); \
 708                         *(inst)++ = (((unsigned char)(opc)) << 3) + 5;  \
 709                         x86_imm_emit32 ((inst), (imm)); \
 710                         break;  \
 711                 }       \
 712                 if (x86_is_imm8((imm))) {       \
 713                         x86_codegen_pre(&(inst), 3); \
 714                         *(inst)++ = (unsigned char)0x83;        \
 715                         x86_reg_emit ((inst), (opc), (reg));    \
 716                         x86_imm_emit8 ((inst), (imm));  \
 717                 } else {        \
 718                         x86_codegen_pre(&(inst), 6); \
 719                         *(inst)++ = (unsigned char)0x81;        \
 720                         x86_reg_emit ((inst), (opc), (reg));    \
 721                         x86_imm_emit32 ((inst), (imm)); \
 722                 }       \
 723         } while (0)
 724
 725 #define x86_alu_mem_imm(inst,opc,mem,imm)       \
 726         do {    \
 727                 if (x86_is_imm8((imm))) {       \
 728                         x86_codegen_pre(&(inst), 7); \
 729                         *(inst)++ = (unsigned char)0x83;        \
 730                         x86_mem_emit ((inst), (opc), (mem));    \
 731                         x86_imm_emit8 ((inst), (imm));  \
 732                 } else {        \
 733                         x86_codegen_pre(&(inst), 10); \
 734                         *(inst)++ = (unsigned char)0x81;        \
 735                         x86_mem_emit ((inst), (opc), (mem));    \
 736                         x86_imm_emit32 ((inst), (imm)); \
 737                 }       \
 738         } while (0)
 739
 740 #define x86_alu_membase_imm(inst,opc,basereg,disp,imm)  \
 741         do {    \
 742                 if (x86_is_imm8((imm))) {       \
 743                         x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
 744                         *(inst)++ = (unsigned char)0x83;        \
 745                         x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 746                         x86_imm_emit8 ((inst), (imm));  \
 747                 } else {        \
 748                         x86_codegen_pre(&(inst), 5 + kMaxMembaseEmitPadding); \
 749                         *(inst)++ = (unsigned char)0x81;        \
 750                         x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 751                         x86_imm_emit32 ((inst), (imm)); \
 752                 }       \
 753         } while (0)
 754
 755 #define x86_alu_membase8_imm(inst,opc,basereg,disp,imm)         \
 756         do {    \
 757                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
 758                 *(inst)++ = (unsigned char)0x80;        \
 759                 x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 760                 x86_imm_emit8 ((inst), (imm)); \
 761         } while (0)
 762
 763 #define x86_alu_mem_reg(inst,opc,mem,reg)       \
 764         do {    \
 765                 x86_codegen_pre(&(inst), 6); \
 766                 *(inst)++ = (((unsigned char)(opc)) << 3) + 1;  \
 767                 x86_mem_emit ((inst), (reg), (mem));    \
 768         } while (0)
 769
 770 #define x86_alu_membase_reg(inst,opc,basereg,disp,reg)  \
 771         do {    \
 772                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 773                 *(inst)++ = (((unsigned char)(opc)) << 3) + 1;  \
 774                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 775         } while (0)
 776
 777 #define x86_alu_reg_reg(inst,opc,dreg,reg)      \
 778         do {    \
 779                 x86_codegen_pre(&(inst), 2); \
 780                 *(inst)++ = (((unsigned char)(opc)) << 3) + 3;  \
 781                 x86_reg_emit ((inst), (dreg), (reg));   \
 782         } while (0)
 783
 784 /**
 785  * @x86_alu_reg8_reg8:
 786  * Supports ALU operations between two 8-bit registers.
 787  * dreg := dreg opc reg
 788  * X86_Reg_No enum is used to specify the registers.
 789  * Additionally is_*_h flags are used to specify what part
 790  * of a given 32-bit register is used - high (TRUE) or low (FALSE).
 791  * For example: dreg = X86_EAX, is_dreg_h = TRUE -> use AH
 792  */
 793 #define x86_alu_reg8_reg8(inst,opc,dreg,reg,is_dreg_h,is_reg_h) \
 794         do {    \
 795                 x86_codegen_pre(&(inst), 2); \
 796                 *(inst)++ = (((unsigned char)(opc)) << 3) + 2;  \
 797                 x86_reg8_emit ((inst), (dreg), (reg), (is_dreg_h), (is_reg_h)); \
 798         } while (0)
 799
 800 #define x86_alu_reg_mem(inst,opc,reg,mem)       \
 801         do {    \
 802                 x86_codegen_pre(&(inst), 6); \
 803                 *(inst)++ = (((unsigned char)(opc)) << 3) + 3;  \
 804                 x86_mem_emit ((inst), (reg), (mem));    \
 805         } while (0)
 806
 807 #define x86_alu_reg_membase(inst,opc,reg,basereg,disp)  \
 808         do {    \
 809                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 810                 *(inst)++ = (((unsigned char)(opc)) << 3) + 3;  \
 811                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 812         } while (0)
 813
 814 #define x86_test_reg_imm(inst,reg,imm)  \
 815         do {    \
 816                 x86_codegen_pre(&(inst), 6); \
 817                 if ((reg) == X86_EAX) { \
 818                         *(inst)++ = (unsigned char)0xa9;        \
 819                 } else {        \
 820                         *(inst)++ = (unsigned char)0xf7;        \
 821                         x86_reg_emit ((inst), 0, (reg));        \
 822                 }       \
 823                 x86_imm_emit32 ((inst), (imm)); \
 824         } while (0)
 825
 826 #define x86_test_mem_imm8(inst,mem,imm) \
 827         do {    \
 828                 x86_codegen_pre(&(inst), 7); \
 829                 *(inst)++ = (unsigned char)0xf6;        \
 830                 x86_mem_emit ((inst), 0, (mem));        \
 831                 x86_imm_emit8 ((inst), (imm));  \
 832         } while (0)
 833
 834 #define x86_test_mem_imm(inst,mem,imm)  \
 835         do {    \
 836                 x86_codegen_pre(&(inst), 10); \
 837                 *(inst)++ = (unsigned char)0xf7;        \
 838                 x86_mem_emit ((inst), 0, (mem));        \
 839                 x86_imm_emit32 ((inst), (imm)); \
 840         } while (0)
 841
 842 #define x86_test_membase_imm(inst,basereg,disp,imm)     \
 843         do {    \
 844                 x86_codegen_pre(&(inst), 5 + kMaxMembaseEmitPadding); \
 845                 *(inst)++ = (unsigned char)0xf7;        \
 846                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
 847                 x86_imm_emit32 ((inst), (imm)); \
 848         } while (0)
 849
 850 #define x86_test_reg_reg(inst,dreg,reg) \
 851         do {    \
 852                 x86_codegen_pre(&(inst), 2); \
 853                 *(inst)++ = (unsigned char)0x85;        \
 854                 x86_reg_emit ((inst), (reg), (dreg));   \
 855         } while (0)
 856
 857 #define x86_test_mem_reg(inst,mem,reg)  \
 858         do {    \
 859                 x86_codegen_pre(&(inst), 6); \
 860                 *(inst)++ = (unsigned char)0x85;        \
 861                 x86_mem_emit ((inst), (reg), (mem));    \
 862         } while (0)
 863
 864 #define x86_test_membase_reg(inst,basereg,disp,reg)     \
 865         do {    \
 866                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 867                 *(inst)++ = (unsigned char)0x85;        \
 868                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 869         } while (0)
 870
 871 #define x86_shift_reg_imm(inst,opc,reg,imm)     \
 872         do {    \
 873                 if ((imm) == 1) {       \
 874                         x86_codegen_pre(&(inst), 2); \
 875                         *(inst)++ = (unsigned char)0xd1;        \
 876                         x86_reg_emit ((inst), (opc), (reg));    \
 877                 } else {        \
 878                         x86_codegen_pre(&(inst), 3); \
 879                         *(inst)++ = (unsigned char)0xc1;        \
 880                         x86_reg_emit ((inst), (opc), (reg));    \
 881                         x86_imm_emit8 ((inst), (imm));  \
 882                 }       \
 883         } while (0)
 884
 885 #define x86_shift_mem_imm(inst,opc,mem,imm)     \
 886         do {    \
 887                 if ((imm) == 1) {       \
 888                         x86_codegen_pre(&(inst), 6); \
 889                         *(inst)++ = (unsigned char)0xd1;        \
 890                         x86_mem_emit ((inst), (opc), (mem));    \
 891                 } else {        \
 892                         x86_codegen_pre(&(inst), 7); \
 893                         *(inst)++ = (unsigned char)0xc1;        \
 894                         x86_mem_emit ((inst), (opc), (mem));    \
 895                         x86_imm_emit8 ((inst), (imm));  \
 896                 }       \
 897         } while (0)
 898
 899 #define x86_shift_membase_imm(inst,opc,basereg,disp,imm)        \
 900         do {    \
 901                 if ((imm) == 1) {       \
 902                         x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 903                         *(inst)++ = (unsigned char)0xd1;        \
 904                         x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 905                 } else {        \
 906                         x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
 907                         *(inst)++ = (unsigned char)0xc1;        \
 908                         x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 909                         x86_imm_emit8 ((inst), (imm));  \
 910                 }       \
 911         } while (0)
 912
 913 #define x86_shift_reg(inst,opc,reg)     \
 914         do {    \
 915                 x86_codegen_pre(&(inst), 2); \
 916                 *(inst)++ = (unsigned char)0xd3;        \
 917                 x86_reg_emit ((inst), (opc), (reg));    \
 918         } while (0)
 919
 920 #define x86_shift_mem(inst,opc,mem)     \
 921         do {    \
 922                 x86_codegen_pre(&(inst), 6); \
 923                 *(inst)++ = (unsigned char)0xd3;        \
 924                 x86_mem_emit ((inst), (opc), (mem));    \
 925         } while (0)
 926
 927 #define x86_shift_membase(inst,opc,basereg,disp)        \
 928         do {    \
 929                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 930                 *(inst)++ = (unsigned char)0xd3;        \
 931                 x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 932         } while (0)
 933
 934 /*
 935  * Multi op shift missing.
 936  */
 937
 938 #define x86_shrd_reg(inst,dreg,reg)                     \
 939         do {                                            \
 940                 x86_codegen_pre(&(inst), 3); \
 941                 *(inst)++ = (unsigned char)0x0f;        \
 942                 *(inst)++ = (unsigned char)0xad;        \
 943                 x86_reg_emit ((inst), (reg), (dreg));   \
 944         } while (0)
 945
 946 #define x86_shrd_reg_imm(inst,dreg,reg,shamt)           \
 947         do {                                            \
 948                 x86_codegen_pre(&(inst), 4); \
 949                 *(inst)++ = (unsigned char)0x0f;        \
 950                 *(inst)++ = (unsigned char)0xac;        \
 951                 x86_reg_emit ((inst), (reg), (dreg));   \
 952                 x86_imm_emit8 ((inst), (shamt));        \
 953         } while (0)
 954
 955 #define x86_shld_reg(inst,dreg,reg)                     \
 956         do {                                            \
 957                 x86_codegen_pre(&(inst), 3); \
 958                 *(inst)++ = (unsigned char)0x0f;        \
 959                 *(inst)++ = (unsigned char)0xa5;        \
 960                 x86_reg_emit ((inst), (reg), (dreg));   \
 961         } while (0)
 962
 963 #define x86_shld_reg_imm(inst,dreg,reg,shamt)           \
 964         do {                                            \
 965                 x86_codegen_pre(&(inst), 4); \
 966                 *(inst)++ = (unsigned char)0x0f;        \
 967                 *(inst)++ = (unsigned char)0xa4;        \
 968                 x86_reg_emit ((inst), (reg), (dreg));   \
 969                 x86_imm_emit8 ((inst), (shamt));        \
 970         } while (0)
 971
 972 /*
 973  * EDX:EAX = EAX * rm
 974  */
 975 #define x86_mul_reg(inst,reg,is_signed) \
 976         do {    \
 977                 x86_codegen_pre(&(inst), 2); \
 978                 *(inst)++ = (unsigned char)0xf7;        \
 979                 x86_reg_emit ((inst), 4 + ((is_signed) ? 1 : 0), (reg));        \
 980         } while (0)
 981
 982 #define x86_mul_mem(inst,mem,is_signed) \
 983         do {    \
 984                 x86_codegen_pre(&(inst), 6); \
 985                 *(inst)++ = (unsigned char)0xf7;        \
 986                 x86_mem_emit ((inst), 4 + ((is_signed) ? 1 : 0), (mem));        \
 987         } while (0)
 988
 989 #define x86_mul_membase(inst,basereg,disp,is_signed)    \
 990         do {    \
 991                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
 992                 *(inst)++ = (unsigned char)0xf7;        \
 993                 x86_membase_emit ((inst), 4 + ((is_signed) ? 1 : 0), (basereg), (disp));        \
 994         } while (0)
 995
 996 /*
 997  * r *= rm
 998  */
 999 #define x86_imul_reg_reg(inst,dreg,reg) \
1000         do {    \
1001                 x86_codegen_pre(&(inst), 3); \
1002                 *(inst)++ = (unsigned char)0x0f;        \
1003                 *(inst)++ = (unsigned char)0xaf;        \
1004                 x86_reg_emit ((inst), (dreg), (reg));   \
1005         } while (0)
1006
1007 #define x86_imul_reg_mem(inst,reg,mem)  \
1008         do {    \
1009                 x86_codegen_pre(&(inst), 7); \
1010                 *(inst)++ = (unsigned char)0x0f;        \
1011                 *(inst)++ = (unsigned char)0xaf;        \
1012                 x86_mem_emit ((inst), (reg), (mem));    \
1013         } while (0)
1014
1015 #define x86_imul_reg_membase(inst,reg,basereg,disp)     \
1016         do {    \
1017                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
1018                 *(inst)++ = (unsigned char)0x0f;        \
1019                 *(inst)++ = (unsigned char)0xaf;        \
1020                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
1021         } while (0)
1022
1023 /*
1024  * dreg = rm * imm
1025  */
1026 #define x86_imul_reg_reg_imm(inst,dreg,reg,imm) \
1027         do {    \
1028                 if (x86_is_imm8 ((imm))) {      \
1029                         x86_codegen_pre(&(inst), 3); \
1030                         *(inst)++ = (unsigned char)0x6b;        \
1031                         x86_reg_emit ((inst), (dreg), (reg));   \
1032                         x86_imm_emit8 ((inst), (imm));  \
1033                 } else {        \
1034                         x86_codegen_pre(&(inst), 6); \
1035                         *(inst)++ = (unsigned char)0x69;        \
1036                         x86_reg_emit ((inst), (dreg), (reg));   \
1037                         x86_imm_emit32 ((inst), (imm)); \
1038                 }       \
1039         } while (0)
1040
1041 #define x86_imul_reg_mem_imm(inst,reg,mem,imm)  \
1042         do {    \
1043                 if (x86_is_imm8 ((imm))) {      \
1044                         x86_codegen_pre(&(inst), 7); \
1045                         *(inst)++ = (unsigned char)0x6b;        \
1046                         x86_mem_emit ((inst), (reg), (mem));    \
1047                         x86_imm_emit8 ((inst), (imm));  \
1048                 } else {        \
1049                         x86_codegen_pre(&(inst), 6); \
1050                         *(inst)++ = (unsigned char)0x69;        \
1051                         x86_mem_emit ((inst), (reg), (mem));    \
1052                         x86_imm_emit32 ((inst), (imm)); \
1053                 }       \
1054         } while (0)
1055
1056 #define x86_imul_reg_membase_imm(inst,reg,basereg,disp,imm)     \
1057         do {    \
1058                 if (x86_is_imm8 ((imm))) {      \
1059                         x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
1060                         *(inst)++ = (unsigned char)0x6b;        \
1061                         x86_membase_emit ((inst), (reg), (basereg), (disp));    \
1062                         x86_imm_emit8 ((inst), (imm));  \
1063                 } else {        \
1064                         x86_codegen_pre(&(inst), 5 + kMaxMembaseEmitPadding); \
1065                         *(inst)++ = (unsigned char)0x69;        \
1066                         x86_membase_emit ((inst), (reg), (basereg), (disp));    \
1067                         x86_imm_emit32 ((inst), (imm)); \
1068                 }       \
1069         } while (0)
1070
1071 /*
1072  * divide EDX:EAX by rm;
1073  * eax = quotient, edx = remainder
1074  */
1075
1076 #define x86_div_reg(inst,reg,is_signed) \
1077         do {    \
1078                 x86_codegen_pre(&(inst), 2); \
1079                 *(inst)++ = (unsigned char)0xf7;        \
1080                 x86_reg_emit ((inst), 6 + ((is_signed) ? 1 : 0), (reg));        \
1081         } while (0)
1082
1083 #define x86_div_mem(inst,mem,is_signed) \
1084         do {    \
1085                 x86_codegen_pre(&(inst), 6); \
1086                 *(inst)++ = (unsigned char)0xf7;        \
1087                 x86_mem_emit ((inst), 6 + ((is_signed) ? 1 : 0), (mem));        \
1088         } while (0)
1089
1090 #define x86_div_membase(inst,basereg,disp,is_signed)    \
1091         do {    \
1092                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1093                 *(inst)++ = (unsigned char)0xf7;        \
1094                 x86_membase_emit ((inst), 6 + ((is_signed) ? 1 : 0), (basereg), (disp));        \
1095         } while (0)
1096
1097 #define x86_mov_mem_reg(inst,mem,reg,size)      \
1098         do {    \
1099                 x86_codegen_pre(&(inst), 7); \
1100                 switch ((size)) {       \
1101                 case 1: *(inst)++ = (unsigned char)0x88; break; \
1102                 case 2: x86_prefix((inst), X86_OPERAND_PREFIX); /* fall through */      \
1103                 case 4: *(inst)++ = (unsigned char)0x89; break; \
1104                 default: assert (0);    \
1105                 }       \
1106                 x86_mem_emit ((inst), (reg), (mem));    \
1107         } while (0)
1108
1109 #define x86_mov_regp_reg(inst,regp,reg,size)    \
1110         do {    \
1111                 x86_codegen_pre(&(inst), 3); \
1112                 switch ((size)) {       \
1113                 case 1: *(inst)++ = (unsigned char)0x88; break; \
1114                 case 2: x86_prefix((inst), X86_OPERAND_PREFIX); /* fall through */      \
1115                 case 4: *(inst)++ = (unsigned char)0x89; break; \
1116                 default: assert (0);    \
1117                 }       \
1118                 x86_regp_emit ((inst), (reg), (regp));  \
1119         } while (0)
1120
1121 #define x86_mov_membase_reg(inst,basereg,disp,reg,size) \
1122         do {    \
1123                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
1124                 switch ((size)) {       \
1125                 case 1: *(inst)++ = (unsigned char)0x88; break; \
1126                 case 2: x86_prefix((inst), X86_OPERAND_PREFIX); /* fall through */      \
1127                 case 4: *(inst)++ = (unsigned char)0x89; break; \
1128                 default: assert (0);    \
1129                 }       \
1130                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
1131         } while (0)
1132
1133 #define x86_mov_memindex_reg(inst,basereg,disp,indexreg,shift,reg,size) \
1134         do {    \
1135                 x86_codegen_pre(&(inst), 2 + kMaxMemindexEmitPadding); \
1136                 switch ((size)) {       \
1137                 case 1: *(inst)++ = (unsigned char)0x88; break; \
1138                 case 2: x86_prefix((inst), X86_OPERAND_PREFIX); /* fall through */      \
1139                 case 4: *(inst)++ = (unsigned char)0x89; break; \
1140                 default: assert (0);    \
1141                 }       \
1142                 x86_memindex_emit ((inst), (reg), (basereg), (disp), (indexreg), (shift));      \
1143         } while (0)
1144
1145 #define x86_mov_reg_reg(inst,dreg,reg,size)     \
1146         do {    \
1147                 x86_codegen_pre(&(inst), 3); \
1148                 switch ((size)) {       \
1149                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
1150                 case 2: x86_prefix((inst), X86_OPERAND_PREFIX); /* fall through */      \
1151                 case 4: *(inst)++ = (unsigned char)0x8b; break; \
1152                 default: assert (0);    \
1153                 }       \
1154                 x86_reg_emit ((inst), (dreg), (reg));   \
1155         } while (0)
1156
1157 #define x86_mov_reg_mem(inst,reg,mem,size)      \
1158         do {    \
1159                 x86_codegen_pre(&(inst), 7); \
1160                 switch ((size)) {       \
1161                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
1162                 case 2: x86_prefix((inst), X86_OPERAND_PREFIX); /* fall through */      \
1163                 case 4: *(inst)++ = (unsigned char)0x8b; break; \
1164                 default: assert (0);    \
1165                 }       \
1166                 x86_mem_emit ((inst), (reg), (mem));    \
1167         } while (0)
1168
1169 #define kMovRegMembasePadding (2 + kMaxMembaseEmitPadding)
1170
1171 #define x86_mov_reg_membase(inst,reg,basereg,disp,size) \
1172         do {    \
1173                 x86_codegen_pre(&(inst), kMovRegMembasePadding); \
1174                 switch ((size)) {       \
1175                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
1176                 case 2: x86_prefix((inst), X86_OPERAND_PREFIX); /* fall through */      \
1177                 case 4: *(inst)++ = (unsigned char)0x8b; break; \
1178                 default: assert (0);    \
1179                 }       \
1180                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
1181         } while (0)
1182
1183 #define x86_mov_reg_memindex(inst,reg,basereg,disp,indexreg,shift,size) \
1184         do {    \
1185                 x86_codegen_pre(&(inst), 2 + kMaxMemindexEmitPadding); \
1186                 switch ((size)) {       \
1187                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
1188                 case 2: x86_prefix((inst), X86_OPERAND_PREFIX); /* fall through */      \
1189                 case 4: *(inst)++ = (unsigned char)0x8b; break; \
1190                 default: assert (0);    \
1191                 }       \
1192                 x86_memindex_emit ((inst), (reg), (basereg), (disp), (indexreg), (shift));      \
1193         } while (0)
1194
1195 /*
1196  * Note: x86_clear_reg () chacnges the condition code!
1197  */
1198 #define x86_clear_reg(inst,reg) x86_alu_reg_reg((inst), X86_XOR, (reg), (reg))
1199
1200 #define x86_mov_reg_imm(inst,reg,imm)   \
1201         do {    \
1202                 x86_codegen_pre(&(inst), 5); \
1203                 *(inst)++ = (unsigned char)0xb8 + (reg);        \
1204                 x86_imm_emit32 ((inst), (imm)); \
1205         } while (0)
1206
1207 #define x86_mov_mem_imm(inst,mem,imm,size)      \
1208         do {    \
1209                 if ((size) == 1) {      \
1210                         x86_codegen_pre(&(inst), 7); \
1211                         *(inst)++ = (unsigned char)0xc6;        \
1212                         x86_mem_emit ((inst), 0, (mem));        \
1213                         x86_imm_emit8 ((inst), (imm));  \
1214                 } else if ((size) == 2) {       \
1215                         x86_codegen_pre(&(inst), 9); \
1216                         x86_prefix((inst), X86_OPERAND_PREFIX); \
1217                         *(inst)++ = (unsigned char)0xc7;        \
1218                         x86_mem_emit ((inst), 0, (mem));        \
1219                         x86_imm_emit16 ((inst), (imm)); \
1220                 } else {        \
1221                         x86_codegen_pre(&(inst), 10); \
1222                         *(inst)++ = (unsigned char)0xc7;        \
1223                         x86_mem_emit ((inst), 0, (mem));        \
1224                         x86_imm_emit32 ((inst), (imm)); \
1225                 }       \
1226         } while (0)
1227
1228 #define x86_mov_membase_imm(inst,basereg,disp,imm,size) \
1229         do {    \
1230                 if ((size) == 1) {      \
1231                         x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
1232                         *(inst)++ = (unsigned char)0xc6;        \
1233                         x86_membase_emit ((inst), 0, (basereg), (disp));        \
1234                         x86_imm_emit8 ((inst), (imm));  \
1235                 } else if ((size) == 2) {       \
1236                         x86_codegen_pre(&(inst), 4 + kMaxMembaseEmitPadding); \
1237                         x86_prefix((inst), X86_OPERAND_PREFIX); \
1238                         *(inst)++ = (unsigned char)0xc7;        \
1239                         x86_membase_emit ((inst), 0, (basereg), (disp));        \
1240                         x86_imm_emit16 ((inst), (imm)); \
1241                 } else {        \
1242                         x86_codegen_pre(&(inst), 5 + kMaxMembaseEmitPadding); \
1243                         *(inst)++ = (unsigned char)0xc7;        \
1244                         x86_membase_emit ((inst), 0, (basereg), (disp));        \
1245                         x86_imm_emit32 ((inst), (imm)); \
1246                 }       \
1247         } while (0)
1248
1249 #define x86_mov_memindex_imm(inst,basereg,disp,indexreg,shift,imm,size) \
1250         do {    \
1251                 if ((size) == 1) {      \
1252                         x86_codegen_pre(&(inst), 2 + kMaxMemindexEmitPadding); \
1253                         *(inst)++ = (unsigned char)0xc6;        \
1254                         x86_memindex_emit ((inst), 0, (basereg), (disp), (indexreg), (shift));  \
1255                         x86_imm_emit8 ((inst), (imm));  \
1256                 } else if ((size) == 2) {       \
1257                         x86_codegen_pre(&(inst), 4 + kMaxMemindexEmitPadding); \
1258                         x86_prefix((inst), X86_OPERAND_PREFIX); \
1259                         *(inst)++ = (unsigned char)0xc7;        \
1260                         x86_memindex_emit ((inst), 0, (basereg), (disp), (indexreg), (shift));  \
1261                         x86_imm_emit16 ((inst), (imm)); \
1262                 } else {        \
1263                         x86_codegen_pre(&(inst), 5 + kMaxMemindexEmitPadding); \
1264                         *(inst)++ = (unsigned char)0xc7;        \
1265                         x86_memindex_emit ((inst), 0, (basereg), (disp), (indexreg), (shift));  \
1266                         x86_imm_emit32 ((inst), (imm)); \
1267                 }       \
1268         } while (0)
1269
1270 #define x86_lea_mem(inst,reg,mem)       \
1271         do {    \
1272                 x86_codegen_pre(&(inst), 5); \
1273                 *(inst)++ = (unsigned char)0x8d;        \
1274                 x86_mem_emit ((inst), (reg), (mem));    \
1275         } while (0)
1276
1277 #define x86_lea_membase(inst,reg,basereg,disp)  \
1278         do {    \
1279                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1280                 *(inst)++ = (unsigned char)0x8d;        \
1281                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
1282         } while (0)
1283
1284 #define x86_lea_memindex(inst,reg,basereg,disp,indexreg,shift)  \
1285         do {    \
1286                 x86_codegen_pre(&(inst), 1 + kMaxMemindexEmitPadding); \
1287                 *(inst)++ = (unsigned char)0x8d;        \
1288                 x86_memindex_emit ((inst), (reg), (basereg), (disp), (indexreg), (shift));      \
1289         } while (0)
1290
1291 #define x86_widen_reg(inst,dreg,reg,is_signed,is_half)  \
1292         do {    \
1293                 unsigned char op = 0xb6;        \
1294                 g_assert (is_half ||  X86_IS_BYTE_REG (reg)); \
1295                 x86_codegen_pre(&(inst), 3); \
1296                 *(inst)++ = (unsigned char)0x0f;        \
1297                 if ((is_signed)) op += 0x08;    \
1298                 if ((is_half)) op += 0x01;      \
1299                 *(inst)++ = op; \
1300                 x86_reg_emit ((inst), (dreg), (reg));   \
1301         } while (0)
1302
1303 #define x86_widen_mem(inst,dreg,mem,is_signed,is_half)  \
1304         do {    \
1305                 unsigned char op = 0xb6;        \
1306                 x86_codegen_pre(&(inst), 7); \
1307                 *(inst)++ = (unsigned char)0x0f;        \
1308                 if ((is_signed)) op += 0x08;    \
1309                 if ((is_half)) op += 0x01;      \
1310                 *(inst)++ = op; \
1311                 x86_mem_emit ((inst), (dreg), (mem));   \
1312         } while (0)
1313
1314 #define x86_widen_membase(inst,dreg,basereg,disp,is_signed,is_half)     \
1315         do {    \
1316                 unsigned char op = 0xb6;        \
1317                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
1318                 *(inst)++ = (unsigned char)0x0f;        \
1319                 if ((is_signed)) op += 0x08;    \
1320                 if ((is_half)) op += 0x01;      \
1321                 *(inst)++ = op; \
1322                 x86_membase_emit ((inst), (dreg), (basereg), (disp));   \
1323         } while (0)
1324
1325 #define x86_widen_memindex(inst,dreg,basereg,disp,indexreg,shift,is_signed,is_half)     \
1326         do {    \
1327                 unsigned char op = 0xb6;        \
1328                 x86_codegen_pre(&(inst), 2 + kMaxMemindexEmitPadding); \
1329                 *(inst)++ = (unsigned char)0x0f;        \
1330                 if ((is_signed)) op += 0x08;    \
1331                 if ((is_half)) op += 0x01;      \
1332                 *(inst)++ = op; \
1333                 x86_memindex_emit ((inst), (dreg), (basereg), (disp), (indexreg), (shift));     \
1334         } while (0)
1335
1336 #define x86_cdq(inst)  do { *(inst)++ = (unsigned char)0x99; } while (0)
1337 #define x86_wait(inst) do { *(inst)++ = (unsigned char)0x9b; } while (0)
1338
1339 #define x86_fp_op_mem(inst,opc,mem,is_double)   \
1340         do {    \
1341                 x86_codegen_pre(&(inst), 6); \
1342                 *(inst)++ = (is_double) ? (unsigned char)0xdc : (unsigned char)0xd8;    \
1343                 x86_mem_emit ((inst), (opc), (mem));    \
1344         } while (0)
1345
1346 #define x86_fp_op_membase(inst,opc,basereg,disp,is_double)      \
1347         do {    \
1348                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1349                 *(inst)++ = (is_double) ? (unsigned char)0xdc : (unsigned char)0xd8;    \
1350                 x86_membase_emit ((inst), (opc), (basereg), (disp));    \
1351         } while (0)
1352
1353 #define x86_fp_op(inst,opc,index)       \
1354         do {    \
1355                 x86_codegen_pre(&(inst), 2); \
1356                 *(inst)++ = (unsigned char)0xd8;        \
1357                 *(inst)++ = (unsigned char)0xc0+((opc)<<3)+((index)&0x07);      \
1358         } while (0)
1359
1360 #define x86_fp_op_reg(inst,opc,index,pop_stack) \
1361         do {    \
1362                 static const unsigned char map[] = { 0, 1, 2, 3, 5, 4, 7, 6, 8};        \
1363                 x86_codegen_pre(&(inst), 2); \
1364                 *(inst)++ = (pop_stack) ? (unsigned char)0xde : (unsigned char)0xdc;    \
1365                 *(inst)++ = (unsigned char)0xc0+(map[(opc)]<<3)+((index)&0x07); \
1366         } while (0)
1367
1368 /**
1369  * @x86_fp_int_op_membase
1370  * Supports FPU operations between ST(0) and integer operand in memory.
1371  * Operation encoded using X86_FP_Opcode enum.
1372  * Operand is addressed by [basereg + disp].
1373  * is_int specifies whether operand is int32 (TRUE) or int16 (FALSE).
1374  */
1375 #define x86_fp_int_op_membase(inst,opc,basereg,disp,is_int)     \
1376         do {    \
1377                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1378                 *(inst)++ = (is_int) ? (unsigned char)0xda : (unsigned char)0xde;       \
1379                 x86_membase_emit ((inst), opc, (basereg), (disp));      \
1380         } while (0)
1381
1382 #define x86_fstp(inst,index)    \
1383         do {    \
1384                 x86_codegen_pre(&(inst), 2); \
1385                 *(inst)++ = (unsigned char)0xdd;        \
1386                 *(inst)++ = (unsigned char)0xd8+(index);        \
1387         } while (0)
1388
1389 #define x86_fcompp(inst)        \
1390         do {    \
1391                 x86_codegen_pre(&(inst), 2); \
1392                 *(inst)++ = (unsigned char)0xde;        \
1393                 *(inst)++ = (unsigned char)0xd9;        \
1394         } while (0)
1395
1396 #define x86_fucompp(inst)       \
1397         do {    \
1398                 x86_codegen_pre(&(inst), 2); \
1399                 *(inst)++ = (unsigned char)0xda;        \
1400                 *(inst)++ = (unsigned char)0xe9;        \
1401         } while (0)
1402
1403 #define x86_fnstsw(inst)        \
1404         do {    \
1405                 x86_codegen_pre(&(inst), 2); \
1406                 *(inst)++ = (unsigned char)0xdf;        \
1407                 *(inst)++ = (unsigned char)0xe0;        \
1408         } while (0)
1409
1410 #define x86_fnstcw(inst,mem)    \
1411         do {    \
1412                 x86_codegen_pre(&(inst), 6); \
1413                 *(inst)++ = (unsigned char)0xd9;        \
1414                 x86_mem_emit ((inst), 7, (mem));        \
1415         } while (0)
1416
1417 #define x86_fnstcw_membase(inst,basereg,disp)   \
1418         do {    \
1419                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1420                 *(inst)++ = (unsigned char)0xd9;        \
1421                 x86_membase_emit ((inst), 7, (basereg), (disp));        \
1422         } while (0)
1423
1424 #define x86_fldcw(inst,mem)     \
1425         do {    \
1426                 x86_codegen_pre(&(inst), 6); \
1427                 *(inst)++ = (unsigned char)0xd9;        \
1428                 x86_mem_emit ((inst), 5, (mem));        \
1429         } while (0)
1430
1431 #define x86_fldcw_membase(inst,basereg,disp)    \
1432         do {    \
1433                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1434                 *(inst)++ = (unsigned char)0xd9;        \
1435                 x86_membase_emit ((inst), 5, (basereg), (disp));        \
1436         } while (0)
1437
1438 #define x86_fchs(inst)  \
1439         do {    \
1440                 x86_codegen_pre(&(inst), 2); \
1441                 *(inst)++ = (unsigned char)0xd9;        \
1442                 *(inst)++ = (unsigned char)0xe0;        \
1443         } while (0)
1444
1445 #define x86_frem(inst)  \
1446         do {    \
1447                 x86_codegen_pre(&(inst), 2); \
1448                 *(inst)++ = (unsigned char)0xd9;        \
1449                 *(inst)++ = (unsigned char)0xf8;        \
1450         } while (0)
1451
1452 #define x86_fxch(inst,index)    \
1453         do {    \
1454                 x86_codegen_pre(&(inst), 2); \
1455                 *(inst)++ = (unsigned char)0xd9;        \
1456                 *(inst)++ = (unsigned char)0xc8 + ((index) & 0x07);     \
1457         } while (0)
1458
1459 #define x86_fcomi(inst,index)   \
1460         do {    \
1461                 x86_codegen_pre(&(inst), 2); \
1462                 *(inst)++ = (unsigned char)0xdb;        \
1463                 *(inst)++ = (unsigned char)0xf0 + ((index) & 0x07);     \
1464         } while (0)
1465
1466 #define x86_fcomip(inst,index)  \
1467         do {    \
1468                 x86_codegen_pre(&(inst), 2); \
1469                 *(inst)++ = (unsigned char)0xdf;        \
1470                 *(inst)++ = (unsigned char)0xf0 + ((index) & 0x07);     \
1471         } while (0)
1472
1473 #define x86_fucomi(inst,index)  \
1474         do {    \
1475                 x86_codegen_pre(&(inst), 2); \
1476                 *(inst)++ = (unsigned char)0xdb;        \
1477                 *(inst)++ = (unsigned char)0xe8 + ((index) & 0x07);     \
1478         } while (0)
1479
1480 #define x86_fucomip(inst,index) \
1481         do {    \
1482                 x86_codegen_pre(&(inst), 2); \
1483                 *(inst)++ = (unsigned char)0xdf;        \
1484                 *(inst)++ = (unsigned char)0xe8 + ((index) & 0x07);     \
1485         } while (0)
1486
1487 #define x86_fld(inst,mem,is_double)     \
1488         do {    \
1489                 x86_codegen_pre(&(inst), 6); \
1490                 *(inst)++ = (is_double) ? (unsigned char)0xdd : (unsigned char)0xd9;    \
1491                 x86_mem_emit ((inst), 0, (mem));        \
1492         } while (0)
1493
1494 #define x86_fld_membase(inst,basereg,disp,is_double)    \
1495         do {    \
1496                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1497                 *(inst)++ = (is_double) ? (unsigned char)0xdd : (unsigned char)0xd9;    \
1498                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
1499         } while (0)
1500
1501 #define x86_fld80_mem(inst,mem) \
1502         do {    \
1503                 x86_codegen_pre(&(inst), 6); \
1504                 *(inst)++ = (unsigned char)0xdb;        \
1505                 x86_mem_emit ((inst), 5, (mem));        \
1506         } while (0)
1507
1508 #define x86_fld80_membase(inst,basereg,disp)    \
1509         do {    \
1510                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1511                 *(inst)++ = (unsigned char)0xdb;        \
1512                 x86_membase_emit ((inst), 5, (basereg), (disp));        \
1513         } while (0)
1514
1515 #define x86_fild(inst,mem,is_long)      \
1516         do {    \
1517                 x86_codegen_pre(&(inst), 6); \
1518                 if ((is_long)) {        \
1519                         *(inst)++ = (unsigned char)0xdf;        \
1520                         x86_mem_emit ((inst), 5, (mem));        \
1521                 } else {        \
1522                         *(inst)++ = (unsigned char)0xdb;        \
1523                         x86_mem_emit ((inst), 0, (mem));        \
1524                 }       \
1525         } while (0)
1526
1527 #define x86_fild_membase(inst,basereg,disp,is_long)     \
1528         do {    \
1529                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1530                 if ((is_long)) {        \
1531                         *(inst)++ = (unsigned char)0xdf;        \
1532                         x86_membase_emit ((inst), 5, (basereg), (disp));        \
1533                 } else {        \
1534                         *(inst)++ = (unsigned char)0xdb;        \
1535                         x86_membase_emit ((inst), 0, (basereg), (disp));        \
1536                 }       \
1537         } while (0)
1538
1539 #define x86_fld_reg(inst,index) \
1540         do {    \
1541                 x86_codegen_pre(&(inst), 2); \
1542                 *(inst)++ = (unsigned char)0xd9;        \
1543                 *(inst)++ = (unsigned char)0xc0 + ((index) & 0x07);     \
1544         } while (0)
1545
1546 #define x86_fldz(inst)  \
1547         do {    \
1548                 x86_codegen_pre(&(inst), 2); \
1549                 *(inst)++ = (unsigned char)0xd9;        \
1550                 *(inst)++ = (unsigned char)0xee;        \
1551         } while (0)
1552
1553 #define x86_fld1(inst)  \
1554         do {    \
1555                 x86_codegen_pre(&(inst), 2); \
1556                 *(inst)++ = (unsigned char)0xd9;        \
1557                 *(inst)++ = (unsigned char)0xe8;        \
1558         } while (0)
1559
1560 #define x86_fldpi(inst) \
1561         do {    \
1562                 x86_codegen_pre(&(inst), 2); \
1563                 *(inst)++ = (unsigned char)0xd9;        \
1564                 *(inst)++ = (unsigned char)0xeb;        \
1565         } while (0)
1566
1567 #define x86_fst(inst,mem,is_double,pop_stack)   \
1568         do {    \
1569                 x86_codegen_pre(&(inst), 6); \
1570                 *(inst)++ = (is_double) ? (unsigned char)0xdd: (unsigned char)0xd9;     \
1571                 x86_mem_emit ((inst), 2 + ((pop_stack) ? 1 : 0), (mem));        \
1572         } while (0)
1573
1574 #define x86_fst_membase(inst,basereg,disp,is_double,pop_stack)  \
1575         do {    \
1576                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1577                 *(inst)++ = (is_double) ? (unsigned char)0xdd: (unsigned char)0xd9;     \
1578                 x86_membase_emit ((inst), 2 + ((pop_stack) ? 1 : 0), (basereg), (disp));        \
1579         } while (0)
1580
1581 #define x86_fst80_mem(inst,mem) \
1582         do {    \
1583                 x86_codegen_pre(&(inst), 6); \
1584                 *(inst)++ = (unsigned char)0xdb;        \
1585                 x86_mem_emit ((inst), 7, (mem));        \
1586         } while (0)
1587
1588
1589 #define x86_fst80_membase(inst,basereg,disp)    \
1590         do {    \
1591                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1592                 *(inst)++ = (unsigned char)0xdb;        \
1593                 x86_membase_emit ((inst), 7, (basereg), (disp));        \
1594         } while (0)
1595
1596
1597 #define x86_fist_pop(inst,mem,is_long)  \
1598         do {    \
1599                 x86_codegen_pre(&(inst), 6); \
1600                 if ((is_long)) {        \
1601                         *(inst)++ = (unsigned char)0xdf;        \
1602                         x86_mem_emit ((inst), 7, (mem));        \
1603                 } else {        \
1604                         *(inst)++ = (unsigned char)0xdb;        \
1605                         x86_mem_emit ((inst), 3, (mem));        \
1606                 }       \
1607         } while (0)
1608
1609 #define x86_fist_pop_membase(inst,basereg,disp,is_long) \
1610         do {    \
1611                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1612                 if ((is_long)) {        \
1613                         *(inst)++ = (unsigned char)0xdf;        \
1614                         x86_membase_emit ((inst), 7, (basereg), (disp));        \
1615                 } else {        \
1616                         *(inst)++ = (unsigned char)0xdb;        \
1617                         x86_membase_emit ((inst), 3, (basereg), (disp));        \
1618                 }       \
1619         } while (0)
1620
1621 #define x86_fstsw(inst) \
1622         do {    \
1623                         x86_codegen_pre(&(inst), 3); \
1624                         *(inst)++ = (unsigned char)0x9b;        \
1625                         *(inst)++ = (unsigned char)0xdf;        \
1626                         *(inst)++ = (unsigned char)0xe0;        \
1627         } while (0)
1628
1629 /**
1630  * @x86_fist_membase
1631  * Converts content of ST(0) to integer and stores it at memory location
1632  * addressed by [basereg + disp].
1633  * is_int specifies whether destination is int32 (TRUE) or int16 (FALSE).
1634  */
1635 #define x86_fist_membase(inst,basereg,disp,is_int)      \
1636         do {    \
1637                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1638                 if ((is_int)) { \
1639                         *(inst)++ = (unsigned char)0xdb;        \
1640                         x86_membase_emit ((inst), 2, (basereg), (disp));        \
1641                 } else {        \
1642                         *(inst)++ = (unsigned char)0xdf;        \
1643                         x86_membase_emit ((inst), 2, (basereg), (disp));        \
1644                 }       \
1645         } while (0)
1646
1647
1648 #define x86_push_reg(inst,reg)  \
1649         do {    \
1650                 *(inst)++ = (unsigned char)0x50 + (reg);        \
1651         } while (0)
1652
1653 #define x86_push_regp(inst,reg) \
1654         do {    \
1655                 x86_codegen_pre(&(inst), 2); \
1656                 *(inst)++ = (unsigned char)0xff;        \
1657                 x86_regp_emit ((inst), 6, (reg));       \
1658         } while (0)
1659
1660 #define x86_push_mem(inst,mem)  \
1661         do {    \
1662                 x86_codegen_pre(&(inst), 6); \
1663                 *(inst)++ = (unsigned char)0xff;        \
1664                 x86_mem_emit ((inst), 6, (mem));        \
1665         } while (0)
1666
1667 #define x86_push_membase(inst,basereg,disp)     \
1668         do {    \
1669                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1670                 *(inst)++ = (unsigned char)0xff;        \
1671                 x86_membase_emit ((inst), 6, (basereg), (disp));        \
1672         } while (0)
1673
1674 #define x86_push_memindex(inst,basereg,disp,indexreg,shift)     \
1675         do {    \
1676                 x86_codegen_pre(&(inst), 1 + kMaxMemindexEmitPadding); \
1677                 *(inst)++ = (unsigned char)0xff;        \
1678                 x86_memindex_emit ((inst), 6, (basereg), (disp), (indexreg), (shift));  \
1679         } while (0)
1680
1681 #define x86_push_imm_template(inst) x86_push_imm (inst, 0xf0f0f0f0)
1682
1683 #define x86_push_imm(inst,imm)  \
1684         do {    \
1685                 int _imm = (int) (imm); \
1686                 if (x86_is_imm8 (_imm)) {       \
1687                         x86_codegen_pre(&(inst), 2); \
1688                         *(inst)++ = (unsigned char)0x6A;        \
1689                         x86_imm_emit8 ((inst), (_imm)); \
1690                 } else {        \
1691                         x86_codegen_pre(&(inst), 5); \
1692                         *(inst)++ = (unsigned char)0x68;        \
1693                         x86_imm_emit32 ((inst), (_imm));        \
1694                 }       \
1695         } while (0)
1696
1697 #define x86_pop_reg(inst,reg)   \
1698         do {    \
1699                 *(inst)++ = (unsigned char)0x58 + (reg);        \
1700         } while (0)
1701
1702 #define x86_pop_mem(inst,mem)   \
1703         do {    \
1704                 x86_codegen_pre(&(inst), 6); \
1705                 *(inst)++ = (unsigned char)0x87;        \
1706                 x86_mem_emit ((inst), 0, (mem));        \
1707         } while (0)
1708
1709 #define x86_pop_membase(inst,basereg,disp)      \
1710         do {    \
1711                 x86_codegen_pre(&(inst), 1 + kMaxMembaseEmitPadding); \
1712                 *(inst)++ = (unsigned char)0x87;        \
1713                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
1714         } while (0)
1715
1716 #define x86_pushad(inst) do { *(inst)++ = (unsigned char)0x60; } while (0)
1717 #define x86_pushfd(inst) do { *(inst)++ = (unsigned char)0x9c; } while (0)
1718 #define x86_popad(inst)  do { *(inst)++ = (unsigned char)0x61; } while (0)
1719 #define x86_popfd(inst)  do { *(inst)++ = (unsigned char)0x9d; } while (0)
1720
1721 #define x86_loop(inst,imm)      \
1722         do {    \
1723                 x86_codegen_pre(&(inst), 2); \
1724                 *(inst)++ = (unsigned char)0xe2;        \
1725                 x86_imm_emit8 ((inst), (imm));  \
1726         } while (0)
1727
1728 #define x86_loope(inst,imm)     \
1729         do {    \
1730                 x86_codegen_pre(&(inst), 2); \
1731                 *(inst)++ = (unsigned char)0xe1;        \
1732                 x86_imm_emit8 ((inst), (imm));  \
1733         } while (0)
1734
1735 #define x86_loopne(inst,imm)    \
1736         do {    \
1737                 x86_codegen_pre(&(inst), 2); \
1738                 *(inst)++ = (unsigned char)0xe0;        \
1739                 x86_imm_emit8 ((inst), (imm));  \
1740         } while (0)
1741
1742 #if defined(TARGET_X86)
1743 #define x86_jump32(inst,imm)    \
1744         do {    \
1745                 x86_codegen_pre(&(inst), 5); \
1746                 *(inst)++ = (unsigned char)0xe9;        \
1747                 x86_imm_emit32 ((inst), (imm)); \
1748         } while (0)
1749
1750 #define x86_jump8(inst,imm)     \
1751         do {    \
1752                 x86_codegen_pre(&(inst), 2); \
1753                 *(inst)++ = (unsigned char)0xeb;        \
1754                 x86_imm_emit8 ((inst), (imm));  \
1755         } while (0)
1756 #elif defined(TARGET_AMD64)
1757 /* These macros are used directly from mini-amd64.c and other      */
1758 /* amd64 specific files, so they need to be instrumented directly. */
1759 #define x86_jump32(inst,imm)    \
1760         do {    \
1761                 amd64_codegen_pre(inst); \
1762                 *(inst)++ = (unsigned char)0xe9;        \
1763                 x86_imm_emit32 ((inst), (imm)); \
1764                 amd64_codegen_post(inst); \
1765         } while (0)
1766
1767 #define x86_jump8(inst,imm)     \
1768         do {    \
1769                 amd64_codegen_pre(inst); \
1770                 *(inst)++ = (unsigned char)0xeb;        \
1771                 x86_imm_emit8 ((inst), (imm));  \
1772                 amd64_codegen_post(inst); \
1773         } while (0)
1774 #endif
1775
1776 #if defined( __native_client_codegen__ ) && defined( TARGET_X86 )
1777 #define x86_jump_reg(inst,reg)  do {    \
1778     x86_codegen_pre(&(inst), 5);                        \
1779     *(inst)++ = (unsigned char)0x83;  /* and */         \
1780     x86_reg_emit ((inst), 4, (reg));  /* reg */         \
1781     *(inst)++ = (unsigned char)nacl_align_byte;         \
1782     *(inst)++ = (unsigned char)0xff;                    \
1783     x86_reg_emit ((inst), 4, (reg));                    \
1784   } while (0)
1785
1786 /* Let's hope ECX is available for these... */
1787 #define x86_jump_mem(inst,mem)  do {    \
1788     x86_mov_reg_mem(inst, (X86_ECX), (mem), 4);         \
1789     x86_jump_reg(inst, (X86_ECX));                      \
1790   } while (0)
1791
1792 #define x86_jump_membase(inst,basereg,disp) do {        \
1793     x86_mov_reg_membase(inst, (X86_ECX), basereg, disp, 4);     \
1794     x86_jump_reg(inst, (X86_ECX));                              \
1795   } while (0)
1796
1797 /* like x86_jump_membase, but force a 32-bit displacement  */
1798 #define x86_jump_membase32(inst,basereg,disp) do {      \
1799     x86_codegen_pre(&(inst), 6); \
1800     *(inst)++ = (unsigned char)0x8b;                    \
1801     x86_address_byte ((inst), 2, X86_ECX, (basereg));   \
1802     x86_imm_emit32 ((inst), (disp));                    \
1803     x86_jump_reg(inst, (X86_ECX));                      \
1804   } while (0)
1805 #else  /* __native_client_codegen__ */
1806 #define x86_jump_reg(inst,reg)  \
1807         do {    \
1808                 *(inst)++ = (unsigned char)0xff;        \
1809                 x86_reg_emit ((inst), 4, (reg));        \
1810         } while (0)
1811
1812 #define x86_jump_mem(inst,mem)  \
1813         do {    \
1814                 *(inst)++ = (unsigned char)0xff;        \
1815                 x86_mem_emit ((inst), 4, (mem));        \
1816         } while (0)
1817
1818 #define x86_jump_membase(inst,basereg,disp)     \
1819         do {    \
1820                 *(inst)++ = (unsigned char)0xff;        \
1821                 x86_membase_emit ((inst), 4, (basereg), (disp));        \
1822         } while (0)
1823 #endif  /* __native_client_codegen__ */
1824 /*
1825  * target is a pointer in our buffer.
1826  */
1827 #define x86_jump_code_body(inst,target) \
1828         do {    \
1829                 int t; \
1830                 x86_codegen_pre(&(inst), 2); \
1831                 t = (unsigned char*)(target) - (inst) - 2;      \
1832                 if (x86_is_imm8(t)) {   \
1833                         x86_jump8 ((inst), t);  \
1834                 } else {        \
1835                         x86_codegen_pre(&(inst), 5); \
1836                         t = (unsigned char*)(target) - (inst) - 5;      \
1837                         x86_jump32 ((inst), t); \
1838                 }       \
1839         } while (0)
1840
1841 #if defined(__default_codegen__)
1842 #define x86_jump_code(inst,target) \
1843         do { \
1844                 x86_jump_code_body((inst),(target)); \
1845         } while (0)
1846 #elif defined(__native_client_codegen__) && defined(TARGET_X86)
1847 #define x86_jump_code(inst,target) \
1848         do { \
1849                 guint8* jump_start = (inst); \
1850                 x86_jump_code_body((inst),(target)); \
1851                 x86_patch(jump_start, (target)); \
1852         } while (0)
1853 #elif defined(__native_client_codegen__) && defined(TARGET_AMD64)
1854 #define x86_jump_code(inst,target) \
1855         do { \
1856                 /* jump_code_body is used twice because there are offsets */ \
1857                 /* calculated based on the IP, which can change after the */ \
1858                 /* call to amd64_codegen_post                             */ \
1859                 amd64_codegen_pre(inst); \
1860                 x86_jump_code_body((inst),(target)); \
1861                 inst = amd64_codegen_post(inst); \
1862                 x86_jump_code_body((inst),(target)); \
1863         } while (0)
1864 #endif /* __native_client_codegen__ */
1865
1866 #define x86_jump_disp(inst,disp)        \
1867         do {    \
1868                 int t = (disp) - 2;     \
1869                 if (x86_is_imm8(t)) {   \
1870                         x86_jump8 ((inst), t);  \
1871                 } else {        \
1872                         t -= 3; \
1873                         x86_jump32 ((inst), t); \
1874                 }       \
1875         } while (0)
1876
1877 #if defined(TARGET_X86)
1878 #define x86_branch8(inst,cond,imm,is_signed)    \
1879         do {    \
1880                 x86_codegen_pre(&(inst), 2); \
1881                 if ((is_signed))        \
1882                         *(inst)++ = x86_cc_signed_map [(cond)]; \
1883                 else    \
1884                         *(inst)++ = x86_cc_unsigned_map [(cond)];       \
1885                 x86_imm_emit8 ((inst), (imm));  \
1886         } while (0)
1887
1888 #define x86_branch32(inst,cond,imm,is_signed)   \
1889         do {    \
1890                 x86_codegen_pre(&(inst), 6); \
1891                 *(inst)++ = (unsigned char)0x0f;        \
1892                 if ((is_signed))        \
1893                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x10;  \
1894                 else    \
1895                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x10;        \
1896                 x86_imm_emit32 ((inst), (imm)); \
1897         } while (0)
1898 #elif defined(TARGET_AMD64)
1899 /* These macros are used directly from mini-amd64.c and other      */
1900 /* amd64 specific files, so they need to be instrumented directly. */
1901 #define x86_branch8(inst,cond,imm,is_signed)    \
1902         do {    \
1903                 amd64_codegen_pre(inst); \
1904                 if ((is_signed))        \
1905                         *(inst)++ = x86_cc_signed_map [(cond)]; \
1906                 else    \
1907                         *(inst)++ = x86_cc_unsigned_map [(cond)];       \
1908                 x86_imm_emit8 ((inst), (imm));  \
1909                 amd64_codegen_post(inst); \
1910         } while (0)
1911 #define x86_branch32(inst,cond,imm,is_signed)   \
1912         do {    \
1913                 amd64_codegen_pre(inst); \
1914                 *(inst)++ = (unsigned char)0x0f;        \
1915                 if ((is_signed))        \
1916                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x10;  \
1917                 else    \
1918                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x10;        \
1919                 x86_imm_emit32 ((inst), (imm)); \
1920                 amd64_codegen_post(inst); \
1921         } while (0)
1922 #endif
1923
1924 #if defined(TARGET_X86)
1925 #define x86_branch(inst,cond,target,is_signed)  \
1926         do {    \
1927                 int offset;                                      \
1928                 guint8* branch_start; \
1929                 x86_codegen_pre(&(inst), 2); \
1930                 offset = (target) - (inst) - 2; \
1931                 branch_start = (inst); \
1932                 if (x86_is_imm8 ((offset)))     \
1933                         x86_branch8 ((inst), (cond), offset, (is_signed));      \
1934                 else {  \
1935                         x86_codegen_pre(&(inst), 6); \
1936                         offset = (target) - (inst) - 6; \
1937                         x86_branch32 ((inst), (cond), offset, (is_signed));     \
1938                 }       \
1939                 x86_patch(branch_start, (target)); \
1940         } while (0)
1941 #elif defined(TARGET_AMD64)
1942 /* This macro is used directly from mini-amd64.c and other        */
1943 /* amd64 specific files, so it needs to be instrumented directly. */
1944
1945 #define x86_branch_body(inst,cond,target,is_signed)     \
1946         do {    \
1947                 int offset = (target) - (inst) - 2;     \
1948                 if (x86_is_imm8 ((offset)))     \
1949                         x86_branch8 ((inst), (cond), offset, (is_signed));      \
1950                 else {  \
1951                         offset = (target) - (inst) - 6; \
1952                         x86_branch32 ((inst), (cond), offset, (is_signed));     \
1953                 }       \
1954         } while (0)
1955
1956 #if defined(__default_codegen__)
1957 #define x86_branch(inst,cond,target,is_signed)  \
1958         do { \
1959                 x86_branch_body((inst),(cond),(target),(is_signed)); \
1960         } while (0)
1961 #elif defined(__native_client_codegen__)
1962 #define x86_branch(inst,cond,target,is_signed)  \
1963         do {    \
1964                 /* branch_body is used twice because there are offsets */ \
1965                 /* calculated based on the IP, which can change after  */ \
1966                 /* the call to amd64_codegen_post                      */ \
1967                 amd64_codegen_pre(inst); \
1968                 x86_branch_body((inst),(cond),(target),(is_signed)); \
1969                 inst = amd64_codegen_post(inst); \
1970                 x86_branch_body((inst),(cond),(target),(is_signed)); \
1971         } while (0)
1972 #endif /* __native_client_codegen__ */
1973
1974 #endif /* TARGET_AMD64 */
1975
1976 #define x86_branch_disp(inst,cond,disp,is_signed)       \
1977         do {    \
1978                 int offset = (disp) - 2;        \
1979                 if (x86_is_imm8 ((offset)))     \
1980                         x86_branch8 ((inst), (cond), offset, (is_signed));      \
1981                 else {  \
1982                         offset -= 4;    \
1983                         x86_branch32 ((inst), (cond), offset, (is_signed));     \
1984                 }       \
1985         } while (0)
1986
1987 #define x86_set_reg(inst,cond,reg,is_signed)    \
1988         do {    \
1989                 g_assert (X86_IS_BYTE_REG (reg)); \
1990                 x86_codegen_pre(&(inst), 3); \
1991                 *(inst)++ = (unsigned char)0x0f;        \
1992                 if ((is_signed))        \
1993                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x20;  \
1994                 else    \
1995                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x20;        \
1996                 x86_reg_emit ((inst), 0, (reg));        \
1997         } while (0)
1998
1999 #define x86_set_mem(inst,cond,mem,is_signed)    \
2000         do {    \
2001                 x86_codegen_pre(&(inst), 7); \
2002                 *(inst)++ = (unsigned char)0x0f;        \
2003                 if ((is_signed))        \
2004                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x20;  \
2005                 else    \
2006                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x20;        \
2007                 x86_mem_emit ((inst), 0, (mem));        \
2008         } while (0)
2009
2010 #define x86_set_membase(inst,cond,basereg,disp,is_signed)       \
2011         do {    \
2012                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
2013                 *(inst)++ = (unsigned char)0x0f;        \
2014                 if ((is_signed))        \
2015                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x20;  \
2016                 else    \
2017                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x20;        \
2018                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
2019         } while (0)
2020
2021 #define x86_call_imm_body(inst,disp) \
2022         do {    \
2023                 *(inst)++ = (unsigned char)0xe8;        \
2024                 x86_imm_emit32 ((inst), (int)(disp));   \
2025         } while (0)
2026
2027 #define x86_call_imm(inst,disp) \
2028         do {    \
2029                 x86_call_sequence_pre((inst)); \
2030                 x86_call_imm_body((inst), (disp)); \
2031                 x86_call_sequence_post((inst)); \
2032         } while (0)
2033
2034
2035 #if defined( __native_client_codegen__ ) && defined( TARGET_X86 )
2036 #define x86_call_reg_internal(inst,reg) \
2037   do {                                                  \
2038     *(inst)++ = (unsigned char)0x83;  /* and */         \
2039     x86_reg_emit ((inst), 4, (reg));  /* reg */         \
2040     *(inst)++ = (unsigned char)nacl_align_byte;         \
2041     *(inst)++ = (unsigned char)0xff;  /* call */        \
2042     x86_reg_emit ((inst), 2, (reg));  /* reg */         \
2043   } while (0)
2044
2045 #define x86_call_reg(inst, reg) do {            \
2046     x86_call_sequence_pre((inst));              \
2047     x86_call_reg_internal(inst, reg);           \
2048     x86_call_sequence_post((inst));             \
2049   } while (0)
2050
2051
2052 /* It appears that x86_call_mem() is never used, so I'm leaving it out. */
2053 #define x86_call_membase(inst,basereg,disp)  do {               \
2054     x86_call_sequence_pre((inst));                              \
2055     /* x86_mov_reg_membase() inlined so its fixed size */       \
2056     *(inst)++ = (unsigned char)0x8b;                            \
2057     x86_address_byte ((inst), 2, (X86_ECX), (basereg));         \
2058     x86_imm_emit32 ((inst), (disp));                            \
2059     x86_call_reg_internal(inst, X86_ECX);                       \
2060     x86_call_sequence_post((inst));                             \
2061   } while (0)
2062 #else  /* __native_client_codegen__ */
2063 #define x86_call_reg(inst,reg)  \
2064         do {    \
2065                 *(inst)++ = (unsigned char)0xff;        \
2066                 x86_reg_emit ((inst), 2, (reg));        \
2067         } while (0)
2068
2069 #define x86_call_mem(inst,mem)  \
2070         do {    \
2071                 *(inst)++ = (unsigned char)0xff;        \
2072                 x86_mem_emit ((inst), 2, (mem));        \
2073         } while (0)
2074
2075 #define x86_call_membase(inst,basereg,disp)     \
2076         do {    \
2077                 *(inst)++ = (unsigned char)0xff;        \
2078                 x86_membase_emit ((inst), 2, (basereg), (disp));        \
2079         } while (0)
2080 #endif  /* __native_client_codegen__ */
2081
2082
2083 #if defined( __native_client_codegen__ ) && defined( TARGET_X86 )
2084
2085 #define x86_call_code(inst,target)      \
2086         do {    \
2087                 int _x86_offset; \
2088                 guint8* call_start; \
2089                 guint8* _aligned_start; \
2090                 x86_call_sequence_pre_val((inst)); \
2091                 _x86_offset = (unsigned char*)(target) - (inst);        \
2092                 _x86_offset -= 5;       \
2093                 x86_call_imm_body ((inst), _x86_offset);        \
2094                 _aligned_start = x86_call_sequence_post_val((inst)); \
2095                 call_start = _aligned_start; \
2096                 _x86_offset = (unsigned char*)(target) - (_aligned_start);      \
2097                 _x86_offset -= 5;       \
2098                 x86_call_imm_body ((_aligned_start), _x86_offset);      \
2099                 x86_patch(call_start, (target)); \
2100         } while (0)
2101
2102 #define SIZE_OF_RET 6
2103 #define x86_ret(inst) do { \
2104     *(inst)++ = (unsigned char)0x59;  /* pop ecx */             \
2105     x86_codegen_pre(&(inst), 5); \
2106     *(inst)++ = (unsigned char)0x83;  /* and 0xffffffff, ecx */ \
2107     *(inst)++ = (unsigned char)0xe1;                            \
2108     *(inst)++ = (unsigned char)nacl_align_byte;                 \
2109     *(inst)++ = (unsigned char)0xff;  /* jmp ecx */             \
2110     *(inst)++ = (unsigned char)0xe1;                            \
2111   } while (0)
2112
2113 /* pop return address */
2114 /* pop imm bytes from stack */
2115 /* return */
2116 #define x86_ret_imm(inst,imm)   do {    \
2117     *(inst)++ = (unsigned char)0x59;  /* pop ecx */             \
2118     x86_alu_reg_imm ((inst), X86_ADD, X86_ESP, imm);            \
2119     x86_codegen_pre(&(inst), 5); \
2120     *(inst)++ = (unsigned char)0x83;  /* and 0xffffffff, ecx */ \
2121     *(inst)++ = (unsigned char)0xe1;                            \
2122     *(inst)++ = (unsigned char)nacl_align_byte;                 \
2123     *(inst)++ = (unsigned char)0xff;  /* jmp ecx */             \
2124     *(inst)++ = (unsigned char)0xe1;                            \
2125 } while (0)
2126 #else  /* __native_client_codegen__ */
2127
2128 #define x86_call_code(inst,target)      \
2129         do {    \
2130                 int _x86_offset; \
2131                 _x86_offset = (unsigned char*)(target) - (inst);        \
2132                 _x86_offset -= 5;       \
2133                 x86_call_imm_body ((inst), _x86_offset);        \
2134         } while (0)
2135
2136 #define x86_ret(inst) do { *(inst)++ = (unsigned char)0xc3; } while (0)
2137
2138 #define x86_ret_imm(inst,imm)   \
2139         do {    \
2140                 if ((imm) == 0) {       \
2141                         x86_ret ((inst));       \
2142                 } else {        \
2143                         x86_codegen_pre(&(inst), 3); \
2144                         *(inst)++ = (unsigned char)0xc2;        \
2145                         x86_imm_emit16 ((inst), (imm)); \
2146                 }       \
2147         } while (0)
2148 #endif  /* __native_client_codegen__ */
2149
2150 #define x86_cmov_reg(inst,cond,is_signed,dreg,reg)      \
2151         do {    \
2152                 x86_codegen_pre(&(inst), 3); \
2153                 *(inst)++ = (unsigned char) 0x0f;       \
2154                 if ((is_signed))        \
2155                         *(inst)++ = x86_cc_signed_map [(cond)] - 0x30;  \
2156                 else    \
2157                         *(inst)++ = x86_cc_unsigned_map [(cond)] - 0x30;        \
2158                 x86_reg_emit ((inst), (dreg), (reg));   \
2159         } while (0)
2160
2161 #define x86_cmov_mem(inst,cond,is_signed,reg,mem)       \
2162         do {    \
2163                 x86_codegen_pre(&(inst), 7); \
2164                 *(inst)++ = (unsigned char) 0x0f;       \
2165                 if ((is_signed))        \
2166                         *(inst)++ = x86_cc_signed_map [(cond)] - 0x30;  \
2167                 else    \
2168                         *(inst)++ = x86_cc_unsigned_map [(cond)] - 0x30;        \
2169                 x86_mem_emit ((inst), (reg), (mem));    \
2170         } while (0)
2171
2172 #define x86_cmov_membase(inst,cond,is_signed,reg,basereg,disp)  \
2173         do {    \
2174                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
2175                 *(inst)++ = (unsigned char) 0x0f;       \
2176                 if ((is_signed))        \
2177                         *(inst)++ = x86_cc_signed_map [(cond)] - 0x30;  \
2178                 else    \
2179                         *(inst)++ = x86_cc_unsigned_map [(cond)] - 0x30;        \
2180                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
2181         } while (0)
2182
2183 #define x86_enter(inst,framesize)       \
2184         do {    \
2185                 x86_codegen_pre(&(inst), 4); \
2186                 *(inst)++ = (unsigned char)0xc8;        \
2187                 x86_imm_emit16 ((inst), (framesize));   \
2188                 *(inst)++ = 0;  \
2189         } while (0)
2190
2191 #define x86_leave(inst) do { *(inst)++ = (unsigned char)0xc9; } while (0)
2192 #define x86_sahf(inst)  do { *(inst)++ = (unsigned char)0x9e; } while (0)
2193
2194 #define x86_fsin(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xfe; } while (0)
2195 #define x86_fcos(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xff; } while (0)
2196 #define x86_fabs(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xe1; } while (0)
2197 #define x86_ftst(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xe4; } while (0)
2198 #define x86_fxam(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xe5; } while (0)
2199 #define x86_fpatan(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xf3; } while (0)
2200 #define x86_fprem(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xf8; } while (0)
2201 #define x86_fprem1(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xf5; } while (0)
2202 #define x86_frndint(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xfc; } while (0)
2203 #define x86_fsqrt(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xfa; } while (0)
2204 #define x86_fptan(inst) do { x86_codegen_pre(&(inst), 2); *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xf2; } while (0)
2205
2206 #define x86_padding(inst,size)  \
2207         do {    \
2208                 switch ((size)) {       \
2209                 case 1: x86_nop ((inst)); break;        \
2210                 case 2: *(inst)++ = 0x8b;       \
2211                         *(inst)++ = 0xc0; break;        \
2212                 case 3: *(inst)++ = 0x8d; *(inst)++ = 0x6d;     \
2213                         *(inst)++ = 0x00; break;        \
2214                 case 4: *(inst)++ = 0x8d; *(inst)++ = 0x64;     \
2215                         *(inst)++ = 0x24; *(inst)++ = 0x00;     \
2216                         break;  \
2217                 case 5: *(inst)++ = 0x8d; *(inst)++ = 0x64;     \
2218                         *(inst)++ = 0x24; *(inst)++ = 0x00;     \
2219                         x86_nop ((inst)); break;        \
2220                 case 6: *(inst)++ = 0x8d; *(inst)++ = 0xad;     \
2221                         *(inst)++ = 0x00; *(inst)++ = 0x00;     \
2222                         *(inst)++ = 0x00; *(inst)++ = 0x00;     \
2223                         break;  \
2224                 case 7: *(inst)++ = 0x8d; *(inst)++ = 0xa4;     \
2225                         *(inst)++ = 0x24; *(inst)++ = 0x00;     \
2226                         *(inst)++ = 0x00; *(inst)++ = 0x00;     \
2227                         *(inst)++ = 0x00; break;        \
2228                 default: assert (0);    \
2229                 }       \
2230         } while (0)
2231
2232 #ifdef __native_client_codegen__
2233
2234 #define kx86NaClLengthOfCallReg 5
2235 #define kx86NaClLengthOfCallImm 5
2236 #define kx86NaClLengthOfCallMembase (kx86NaClLengthOfCallReg + 6)
2237
2238 #endif  /* __native_client_codegen__ */
2239
2240 #define x86_prolog(inst,frame_size,reg_mask)    \
2241         do {    \
2242                 unsigned i, m = 1;      \
2243                 x86_enter ((inst), (frame_size));       \
2244                 for (i = 0; i < X86_NREG; ++i, m <<= 1) {       \
2245                         if ((reg_mask) & m)     \
2246                                 x86_push_reg ((inst), i);       \
2247                 }       \
2248         } while (0)
2249
2250 #define x86_epilog(inst,reg_mask)       \
2251         do {    \
2252                 unsigned i, m = 1 << X86_EDI;   \
2253                 for (i = X86_EDI; m != 0; i--, m=m>>1) {        \
2254                         if ((reg_mask) & m)     \
2255                                 x86_pop_reg ((inst), i);        \
2256                 }       \
2257                 x86_leave ((inst));     \
2258                 x86_ret ((inst));       \
2259         } while (0)
2260
2261
2262 typedef enum {
2263         X86_SSE_SQRT = 0x51,
2264         X86_SSE_RSQRT = 0x52,
2265         X86_SSE_RCP = 0x53,
2266         X86_SSE_ADD = 0x58,
2267         X86_SSE_DIV = 0x5E,
2268         X86_SSE_MUL = 0x59,
2269         X86_SSE_SUB = 0x5C,
2270         X86_SSE_MIN = 0x5D,
2271         X86_SSE_MAX = 0x5F,
2272         X86_SSE_COMP = 0xC2,
2273         X86_SSE_AND = 0x54,
2274         X86_SSE_ANDN = 0x55,
2275         X86_SSE_OR = 0x56,
2276         X86_SSE_XOR = 0x57,
2277         X86_SSE_UNPCKL = 0x14,
2278         X86_SSE_UNPCKH = 0x15,
2279
2280         X86_SSE_ADDSUB = 0xD0,
2281         X86_SSE_HADD = 0x7C,
2282         X86_SSE_HSUB = 0x7D,
2283         X86_SSE_MOVSHDUP = 0x16,
2284         X86_SSE_MOVSLDUP = 0x12,
2285         X86_SSE_MOVDDUP = 0x12,
2286
2287         X86_SSE_PAND = 0xDB,
2288         X86_SSE_POR = 0xEB,
2289         X86_SSE_PXOR = 0xEF,
2290
2291         X86_SSE_PADDB = 0xFC,
2292         X86_SSE_PADDW = 0xFD,
2293         X86_SSE_PADDD = 0xFE,
2294         X86_SSE_PADDQ = 0xD4,
2295
2296         X86_SSE_PSUBB = 0xF8,
2297         X86_SSE_PSUBW = 0xF9,
2298         X86_SSE_PSUBD = 0xFA,
2299         X86_SSE_PSUBQ = 0xFB,
2300
2301         X86_SSE_PMAXSB = 0x3C, /*sse41*/
2302         X86_SSE_PMAXSW = 0xEE,
2303         X86_SSE_PMAXSD = 0x3D, /*sse41*/
2304
2305         X86_SSE_PMAXUB = 0xDE,
2306         X86_SSE_PMAXUW = 0x3E, /*sse41*/
2307         X86_SSE_PMAXUD = 0x3F, /*sse41*/
2308
2309         X86_SSE_PMINSB = 0x38, /*sse41*/
2310         X86_SSE_PMINSW = 0xEA,
2311         X86_SSE_PMINSD = 0x39,/*sse41*/
2312
2313         X86_SSE_PMINUB = 0xDA,
2314         X86_SSE_PMINUW = 0x3A, /*sse41*/
2315         X86_SSE_PMINUD = 0x3B, /*sse41*/
2316
2317         X86_SSE_PAVGB = 0xE0,
2318         X86_SSE_PAVGW = 0xE3,
2319
2320         X86_SSE_PCMPEQB = 0x74,
2321         X86_SSE_PCMPEQW = 0x75,
2322         X86_SSE_PCMPEQD = 0x76,
2323         X86_SSE_PCMPEQQ = 0x29, /*sse41*/
2324
2325         X86_SSE_PCMPGTB = 0x64,
2326         X86_SSE_PCMPGTW = 0x65,
2327         X86_SSE_PCMPGTD = 0x66,
2328         X86_SSE_PCMPGTQ = 0x37, /*sse42*/
2329
2330         X86_SSE_PSADBW = 0xf6,
2331
2332         X86_SSE_PSHUFD = 0x70,
2333
2334         X86_SSE_PUNPCKLBW = 0x60,
2335         X86_SSE_PUNPCKLWD = 0x61,
2336         X86_SSE_PUNPCKLDQ = 0x62,
2337         X86_SSE_PUNPCKLQDQ = 0x6C,
2338
2339         X86_SSE_PUNPCKHBW = 0x68,
2340         X86_SSE_PUNPCKHWD = 0x69,
2341         X86_SSE_PUNPCKHDQ = 0x6A,
2342         X86_SSE_PUNPCKHQDQ = 0x6D,
2343
2344         X86_SSE_PACKSSWB = 0x63,
2345         X86_SSE_PACKSSDW = 0x6B,
2346
2347         X86_SSE_PACKUSWB = 0x67,
2348         X86_SSE_PACKUSDW = 0x2B,/*sse41*/
2349
2350         X86_SSE_PADDUSB = 0xDC,
2351         X86_SSE_PADDUSW = 0xDD,
2352         X86_SSE_PSUBUSB = 0xD8,
2353         X86_SSE_PSUBUSW = 0xD9,
2354
2355         X86_SSE_PADDSB = 0xEC,
2356         X86_SSE_PADDSW = 0xED,
2357         X86_SSE_PSUBSB = 0xE8,
2358         X86_SSE_PSUBSW = 0xE9,
2359
2360         X86_SSE_PMULLW = 0xD5,
2361         X86_SSE_PMULLD = 0x40,/*sse41*/
2362         X86_SSE_PMULHUW = 0xE4,
2363         X86_SSE_PMULHW = 0xE5,
2364         X86_SSE_PMULUDQ = 0xF4,
2365
2366         X86_SSE_PMOVMSKB = 0xD7,
2367
2368         X86_SSE_PSHIFTW = 0x71,
2369         X86_SSE_PSHIFTD = 0x72,
2370         X86_SSE_PSHIFTQ = 0x73,
2371         X86_SSE_SHR = 2,
2372         X86_SSE_SAR = 4,
2373         X86_SSE_SHL = 6,
2374
2375         X86_SSE_PSRLW_REG = 0xD1,
2376         X86_SSE_PSRAW_REG = 0xE1,
2377         X86_SSE_PSLLW_REG = 0xF1,
2378
2379         X86_SSE_PSRLD_REG = 0xD2,
2380         X86_SSE_PSRAD_REG = 0xE2,
2381         X86_SSE_PSLLD_REG = 0xF2,
2382
2383         X86_SSE_PSRLQ_REG = 0xD3,
2384         X86_SSE_PSLLQ_REG = 0xF3,
2385
2386         X86_SSE_PREFETCH = 0x18,
2387         X86_SSE_MOVNTPS = 0x2B,
2388         X86_SSE_MOVHPD_REG_MEMBASE = 0x16,
2389         X86_SSE_MOVHPD_MEMBASE_REG = 0x17,
2390
2391         X86_SSE_MOVSD_REG_MEMBASE = 0x10,
2392         X86_SSE_MOVSD_MEMBASE_REG = 0x11,
2393
2394         X86_SSE_PINSRB = 0x20,/*sse41*/
2395         X86_SSE_PINSRW = 0xC4,
2396         X86_SSE_PINSRD = 0x22,/*sse41*/
2397
2398         X86_SSE_PEXTRB = 0x14,/*sse41*/
2399         X86_SSE_PEXTRW = 0xC5,
2400         X86_SSE_PEXTRD = 0x16,/*sse41*/
2401
2402         X86_SSE_SHUFP = 0xC6,
2403
2404         X86_SSE_CVTDQ2PD = 0xE6,
2405         X86_SSE_CVTDQ2PS = 0x5B,
2406         X86_SSE_CVTPD2DQ = 0xE6,
2407         X86_SSE_CVTPD2PS = 0x5A,
2408         X86_SSE_CVTPS2DQ = 0x5B,
2409         X86_SSE_CVTPS2PD = 0x5A,
2410         X86_SSE_CVTTPD2DQ = 0xE6,
2411         X86_SSE_CVTTPS2DQ = 0x5B,
2412 } X86_SSE_Opcode;
2413
2414
2415 /* minimal SSE* support */
2416 #define x86_movsd_reg_membase(inst,dreg,basereg,disp)   \
2417         do {    \
2418                 x86_codegen_pre(&(inst), 3 + kMaxMembaseEmitPadding); \
2419                 *(inst)++ = (unsigned char)0xf2;        \
2420                 *(inst)++ = (unsigned char)0x0f;        \
2421                 *(inst)++ = (unsigned char)0x10;        \
2422                 x86_membase_emit ((inst), (dreg), (basereg), (disp));   \
2423         } while (0)
2424
2425 #define x86_cvttsd2si(inst,dreg,reg)    \
2426         do {    \
2427                 x86_codegen_pre(&(inst), 4); \
2428                 *(inst)++ = (unsigned char)0xf2;        \
2429                 *(inst)++ = (unsigned char)0x0f;        \
2430                 *(inst)++ = (unsigned char)0x2c;        \
2431                 x86_reg_emit ((inst), (dreg), (reg));   \
2432         } while (0)
2433
2434 #define x86_sse_alu_reg_reg(inst,opc,dreg,reg)  \
2435         do {    \
2436                 x86_codegen_pre(&(inst), 3); \
2437                 *(inst)++ = (unsigned char)0x0F;        \
2438                 *(inst)++ = (unsigned char)(opc);       \
2439                 x86_reg_emit ((inst), (dreg), (reg));   \
2440         } while (0)
2441
2442 #define x86_sse_alu_reg_membase(inst,opc,sreg,basereg,disp)     \
2443                 do {    \
2444                         x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
2445                         *(inst)++ = (unsigned char)0x0f;        \
2446                         *(inst)++ = (unsigned char)(opc);       \
2447                         x86_membase_emit ((inst), (sreg), (basereg), (disp));   \
2448                 } while (0)
2449
2450 #define x86_sse_alu_membase_reg(inst,opc,basereg,disp,reg)      \
2451         do {    \
2452                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
2453                 *(inst)++ = (unsigned char)0x0F;        \
2454                 *(inst)++ = (unsigned char)(opc);       \
2455                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
2456         } while (0)
2457
2458 #define x86_sse_alu_reg_reg_imm8(inst,opc,dreg,reg, imm8)       \
2459         do {    \
2460                 x86_codegen_pre(&(inst), 4); \
2461                 *(inst)++ = (unsigned char)0x0F;        \
2462                 *(inst)++ = (unsigned char)(opc);       \
2463                 x86_reg_emit ((inst), (dreg), (reg));   \
2464                 *(inst)++ = (unsigned char)(imm8);      \
2465         } while (0)
2466
2467 #define x86_sse_alu_pd_reg_reg_imm8(inst,opc,dreg,reg, imm8)       \
2468         do {    \
2469                 x86_codegen_pre(&(inst), 5); \
2470                 *(inst)++ = (unsigned char)0x66;        \
2471                 x86_sse_alu_reg_reg_imm8 ((inst), (opc), (dreg), (reg), (imm8)); \
2472         } while (0)
2473
2474 #define x86_sse_alu_pd_reg_reg(inst,opc,dreg,reg)       \
2475         do {    \
2476                 x86_codegen_pre(&(inst), 4); \
2477                 *(inst)++ = (unsigned char)0x66;        \
2478                 x86_sse_alu_reg_reg ((inst), (opc), (dreg), (reg)); \
2479         } while (0)
2480
2481 #define x86_sse_alu_pd_membase_reg(inst,opc,basereg,disp,reg)   \
2482         do {    \
2483                 x86_codegen_pre(&(inst), 3 + kMaxMembaseEmitPadding); \
2484                 *(inst)++ = (unsigned char)0x66;        \
2485                 x86_sse_alu_membase_reg ((inst), (opc), (basereg), (disp), (reg)); \
2486         } while (0)
2487
2488 #define x86_sse_alu_pd_reg_membase(inst,opc,dreg,basereg,disp)  \
2489         do {    \
2490                 x86_codegen_pre(&(inst), 3 + kMaxMembaseEmitPadding); \
2491                 *(inst)++ = (unsigned char)0x66;        \
2492                 x86_sse_alu_reg_membase ((inst), (opc), (dreg),(basereg), (disp)); \
2493         } while (0)
2494
2495 #define x86_sse_alu_pd_reg_reg_imm(inst,opc,dreg,reg,imm)       \
2496         do {    \
2497                 x86_codegen_pre(&(inst), 5); \
2498                 x86_sse_alu_pd_reg_reg ((inst), (opc), (dreg), (reg)); \
2499                 *(inst)++ = (unsigned char)(imm);       \
2500         } while (0)
2501
2502 #define x86_sse_alu_pd_reg_membase_imm(inst,opc,dreg,basereg,disp,imm)  \
2503         do {    \
2504                 x86_codegen_pre(&(inst), 4 + kMaxMembaseEmitPadding); \
2505                 x86_sse_alu_pd_reg_membase ((inst), (opc), (dreg),(basereg), (disp)); \
2506                 *(inst)++ = (unsigned char)(imm);       \
2507         } while (0)
2508
2509
2510 #define x86_sse_alu_ps_reg_reg(inst,opc,dreg,reg)       \
2511         do {    \
2512                 x86_sse_alu_reg_reg ((inst), (opc), (dreg), (reg)); \
2513         } while (0)
2514
2515 #define x86_sse_alu_ps_reg_reg_imm(inst,opc,dreg,reg, imm)      \
2516         do {    \
2517                 x86_codegen_pre(&(inst), 4); \
2518                 x86_sse_alu_reg_reg ((inst), (opc), (dreg), (reg)); \
2519                 *(inst)++ = (unsigned char)imm; \
2520         } while (0)
2521
2522
2523 #define x86_sse_alu_sd_reg_reg(inst,opc,dreg,reg)       \
2524         do {    \
2525                 x86_codegen_pre(&(inst), 4); \
2526                 *(inst)++ = (unsigned char)0xF2;        \
2527                 x86_sse_alu_reg_reg ((inst), (opc), (dreg), (reg)); \
2528         } while (0)
2529
2530 #define x86_sse_alu_sd_membase_reg(inst,opc,basereg,disp,reg)   \
2531         do {    \
2532                 x86_codegen_pre(&(inst), 3 + kMaxMembaseEmitPadding); \
2533                 *(inst)++ = (unsigned char)0xF2;        \
2534                 x86_sse_alu_membase_reg ((inst), (opc), (basereg), (disp), (reg));      \
2535         } while (0)
2536
2537
2538 #define x86_sse_alu_ss_reg_reg(inst,opc,dreg,reg)       \
2539         do {    \
2540                 x86_codegen_pre(&(inst), 4); \
2541                 *(inst)++ = (unsigned char)0xF3;        \
2542                 x86_sse_alu_reg_reg ((inst), (opc), (dreg), (reg)); \
2543         } while (0)
2544
2545 #define x86_sse_alu_ss_membase_reg(inst,opc,basereg,disp,reg)       \
2546         do {    \
2547                 x86_codegen_pre(&(inst), 3 + kMaxMembaseEmitPadding); \
2548                 *(inst)++ = (unsigned char)0xF3;        \
2549                 x86_sse_alu_membase_reg ((inst), (opc), (basereg), (disp), (reg));      \
2550         } while (0)
2551
2552
2553
2554 #define x86_sse_alu_sse41_reg_reg(inst,opc,dreg,reg)       \
2555         do {    \
2556                 x86_codegen_pre(&(inst), 5); \
2557                 *(inst)++ = (unsigned char)0x66;        \
2558                 *(inst)++ = (unsigned char)0x0F;        \
2559                 *(inst)++ = (unsigned char)0x38;        \
2560                 *(inst)++ = (unsigned char)(opc);       \
2561                 x86_reg_emit ((inst), (dreg), (reg));   \
2562         } while (0)
2563
2564 #define x86_movups_reg_membase(inst,sreg,basereg,disp)  \
2565         do {    \
2566                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
2567                 *(inst)++ = (unsigned char)0x0f;        \
2568                 *(inst)++ = (unsigned char)0x10;        \
2569                 x86_membase_emit ((inst), (sreg), (basereg), (disp));   \
2570         } while (0)
2571
2572 #define x86_movups_membase_reg(inst,basereg,disp,reg)   \
2573         do {    \
2574                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
2575                 *(inst)++ = (unsigned char)0x0f;        \
2576                 *(inst)++ = (unsigned char)0x11;        \
2577                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
2578         } while (0)
2579
2580 #define x86_movaps_reg_membase(inst,sreg,basereg,disp)  \
2581         do {    \
2582                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
2583                 *(inst)++ = (unsigned char)0x0f;        \
2584                 *(inst)++ = (unsigned char)0x28;        \
2585                 x86_membase_emit ((inst), (sreg), (basereg), (disp));   \
2586         } while (0)
2587
2588 #define x86_movaps_membase_reg(inst,basereg,disp,reg)   \
2589         do {    \
2590                 x86_codegen_pre(&(inst), 2 + kMaxMembaseEmitPadding); \
2591                 *(inst)++ = (unsigned char)0x0f;        \
2592                 *(inst)++ = (unsigned char)0x29;        \
2593                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
2594         } while (0)
2595
2596 #define x86_movaps_reg_reg(inst,dreg,sreg)      \
2597         do {    \
2598                 x86_codegen_pre(&(inst), 3); \
2599                 *(inst)++ = (unsigned char)0x0f;        \
2600                 *(inst)++ = (unsigned char)0x28;        \
2601                 x86_reg_emit ((inst), (dreg), (sreg));  \
2602         } while (0)
2603
2604
2605 #define x86_movd_reg_xreg(inst,dreg,sreg)       \
2606         do {    \
2607                 x86_codegen_pre(&(inst), 4); \
2608                 *(inst)++ = (unsigned char)0x66;        \
2609                 *(inst)++ = (unsigned char)0x0f;        \
2610                 *(inst)++ = (unsigned char)0x7e;        \
2611                 x86_reg_emit ((inst), (sreg), (dreg));  \
2612         } while (0)
2613
2614 #define x86_movd_xreg_reg(inst,dreg,sreg)       \
2615         do {    \
2616                 x86_codegen_pre(&(inst), 4); \
2617                 *(inst)++ = (unsigned char)0x66;        \
2618                 *(inst)++ = (unsigned char)0x0f;        \
2619                 *(inst)++ = (unsigned char)0x6e;        \
2620                 x86_reg_emit ((inst), (dreg), (sreg));  \
2621         } while (0)
2622
2623 #define x86_movd_xreg_membase(inst,sreg,basereg,disp)   \
2624         do {    \
2625                 x86_codegen_pre(&(inst), 3 + kMaxMembaseEmitPadding); \
2626                 *(inst)++ = (unsigned char)0x66;        \
2627                 *(inst)++ = (unsigned char)0x0f;        \
2628                 *(inst)++ = (unsigned char)0x6e;        \
2629                 x86_membase_emit ((inst), (sreg), (basereg), (disp));   \
2630         } while (0)
2631
2632 #define x86_pshufw_reg_reg(inst,dreg,sreg,mask,high_words)      \
2633         do {    \
2634                 x86_codegen_pre(&(inst), 5); \
2635                 *(inst)++ = (unsigned char)(high_words) ? 0xF3 : 0xF2;  \
2636                 *(inst)++ = (unsigned char)0x0f;        \
2637                 *(inst)++ = (unsigned char)0x70;        \
2638                 x86_reg_emit ((inst), (dreg), (sreg));  \
2639                 *(inst)++ = (unsigned char)mask;        \
2640         } while (0)
2641
2642 #define x86_sse_shift_reg_imm(inst,opc,mode, dreg,imm)  \
2643         do {    \
2644                 x86_codegen_pre(&(inst), 5); \
2645                 x86_sse_alu_pd_reg_reg (inst, opc, mode, dreg); \
2646                 x86_imm_emit8 ((inst), (imm));  \
2647         } while (0)
2648
2649 #define x86_sse_shift_reg_reg(inst,opc,dreg,sreg)       \
2650         do {    \
2651                 x86_sse_alu_pd_reg_reg (inst, opc, dreg, sreg); \
2652         } while (0)
2653
2654
2655
2656 #endif // X86_H
2657