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